// Copyright © 2019 - 2020 Oscar Campos <oscar.campos@thepimpam.com>
// Copyright © 2017 - William Edwards
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "gdnative.gen.h"
#include <gdnative/aabb.h>
#include <gdnative/array.h>
#include <gdnative/basis.h>
#include <gdnative/color.h>
#include <gdnative/dictionary.h>
#include <gdnative/gdnative.h>
#include <gdnative/node_path.h>
#include <gdnative/plane.h>
#include <gdnative/pool_arrays.h>
#include <gdnative/quat.h>
#include <gdnative/rect2.h>
#include <gdnative/rid.h>
#include <gdnative/string.h>
#include <gdnative/string_name.h>
#include <gdnative/transform.h>
#include <gdnative/transform2d.h>
#include <gdnative/variant.h>
#include <gdnative/vector2.h>
#include <gdnative/vector3.h>
#include <gdnative_api_struct.gen.h>

/*------------------------------------------------------------------------------
//   This file was autogenerated by PimPam GDNative-Go binding tools
//   Please do not modify this file, any change will be lost
//----------------------------------------------------------------------------*/


/* GDNative CORE 1.0 */
void go_godot_color_new_rgba(godot_gdnative_core_api_struct * p_api, godot_color * r_dest, const godot_real p_r, const godot_real p_g, const godot_real p_b, const godot_real p_a) {
	p_api->godot_color_new_rgba(r_dest, p_r, p_g, p_b, p_a);
}

void go_godot_color_new_rgb(godot_gdnative_core_api_struct * p_api, godot_color * r_dest, const godot_real p_r, const godot_real p_g, const godot_real p_b) {
	p_api->godot_color_new_rgb(r_dest, p_r, p_g, p_b);
}

godot_real go_godot_color_get_r(godot_gdnative_core_api_struct * p_api, const godot_color * p_self) {
	return p_api->godot_color_get_r(p_self);
}

void go_godot_color_set_r(godot_gdnative_core_api_struct * p_api, godot_color * p_self, const godot_real r) {
	p_api->godot_color_set_r(p_self, r);
}

godot_real go_godot_color_get_g(godot_gdnative_core_api_struct * p_api, const godot_color * p_self) {
	return p_api->godot_color_get_g(p_self);
}

void go_godot_color_set_g(godot_gdnative_core_api_struct * p_api, godot_color * p_self, const godot_real g) {
	p_api->godot_color_set_g(p_self, g);
}

godot_real go_godot_color_get_b(godot_gdnative_core_api_struct * p_api, const godot_color * p_self) {
	return p_api->godot_color_get_b(p_self);
}

void go_godot_color_set_b(godot_gdnative_core_api_struct * p_api, godot_color * p_self, const godot_real b) {
	p_api->godot_color_set_b(p_self, b);
}

godot_real go_godot_color_get_a(godot_gdnative_core_api_struct * p_api, const godot_color * p_self) {
	return p_api->godot_color_get_a(p_self);
}

void go_godot_color_set_a(godot_gdnative_core_api_struct * p_api, godot_color * p_self, const godot_real a) {
	p_api->godot_color_set_a(p_self, a);
}

godot_real go_godot_color_get_h(godot_gdnative_core_api_struct * p_api, const godot_color * p_self) {
	return p_api->godot_color_get_h(p_self);
}

godot_real go_godot_color_get_s(godot_gdnative_core_api_struct * p_api, const godot_color * p_self) {
	return p_api->godot_color_get_s(p_self);
}

godot_real go_godot_color_get_v(godot_gdnative_core_api_struct * p_api, const godot_color * p_self) {
	return p_api->godot_color_get_v(p_self);
}

godot_string go_godot_color_as_string(godot_gdnative_core_api_struct * p_api, const godot_color * p_self) {
	return p_api->godot_color_as_string(p_self);
}

godot_int go_godot_color_to_rgba32(godot_gdnative_core_api_struct * p_api, const godot_color * p_self) {
	return p_api->godot_color_to_rgba32(p_self);
}

godot_int go_godot_color_to_argb32(godot_gdnative_core_api_struct * p_api, const godot_color * p_self) {
	return p_api->godot_color_to_argb32(p_self);
}

godot_real go_godot_color_gray(godot_gdnative_core_api_struct * p_api, const godot_color * p_self) {
	return p_api->godot_color_gray(p_self);
}

godot_color go_godot_color_inverted(godot_gdnative_core_api_struct * p_api, const godot_color * p_self) {
	return p_api->godot_color_inverted(p_self);
}

godot_color go_godot_color_contrasted(godot_gdnative_core_api_struct * p_api, const godot_color * p_self) {
	return p_api->godot_color_contrasted(p_self);
}

godot_color go_godot_color_linear_interpolate(godot_gdnative_core_api_struct * p_api, const godot_color * p_self, const godot_color * p_b, const godot_real p_t) {
	return p_api->godot_color_linear_interpolate(p_self, p_b, p_t);
}

godot_color go_godot_color_blend(godot_gdnative_core_api_struct * p_api, const godot_color * p_self, const godot_color * p_over) {
	return p_api->godot_color_blend(p_self, p_over);
}

godot_string go_godot_color_to_html(godot_gdnative_core_api_struct * p_api, const godot_color * p_self, const godot_bool p_with_alpha) {
	return p_api->godot_color_to_html(p_self, p_with_alpha);
}

godot_bool go_godot_color_operator_equal(godot_gdnative_core_api_struct * p_api, const godot_color * p_self, const godot_color * p_b) {
	return p_api->godot_color_operator_equal(p_self, p_b);
}

godot_bool go_godot_color_operator_less(godot_gdnative_core_api_struct * p_api, const godot_color * p_self, const godot_color * p_b) {
	return p_api->godot_color_operator_less(p_self, p_b);
}

void go_godot_vector2_new(godot_gdnative_core_api_struct * p_api, godot_vector2 * r_dest, const godot_real p_x, const godot_real p_y) {
	p_api->godot_vector2_new(r_dest, p_x, p_y);
}

godot_string go_godot_vector2_as_string(godot_gdnative_core_api_struct * p_api, const godot_vector2 * p_self) {
	return p_api->godot_vector2_as_string(p_self);
}

godot_vector2 go_godot_vector2_normalized(godot_gdnative_core_api_struct * p_api, const godot_vector2 * p_self) {
	return p_api->godot_vector2_normalized(p_self);
}

godot_real go_godot_vector2_length(godot_gdnative_core_api_struct * p_api, const godot_vector2 * p_self) {
	return p_api->godot_vector2_length(p_self);
}

godot_real go_godot_vector2_angle(godot_gdnative_core_api_struct * p_api, const godot_vector2 * p_self) {
	return p_api->godot_vector2_angle(p_self);
}

godot_real go_godot_vector2_length_squared(godot_gdnative_core_api_struct * p_api, const godot_vector2 * p_self) {
	return p_api->godot_vector2_length_squared(p_self);
}

godot_bool go_godot_vector2_is_normalized(godot_gdnative_core_api_struct * p_api, const godot_vector2 * p_self) {
	return p_api->godot_vector2_is_normalized(p_self);
}

godot_real go_godot_vector2_distance_to(godot_gdnative_core_api_struct * p_api, const godot_vector2 * p_self, const godot_vector2 * p_to) {
	return p_api->godot_vector2_distance_to(p_self, p_to);
}

godot_real go_godot_vector2_distance_squared_to(godot_gdnative_core_api_struct * p_api, const godot_vector2 * p_self, const godot_vector2 * p_to) {
	return p_api->godot_vector2_distance_squared_to(p_self, p_to);
}

godot_real go_godot_vector2_angle_to(godot_gdnative_core_api_struct * p_api, const godot_vector2 * p_self, const godot_vector2 * p_to) {
	return p_api->godot_vector2_angle_to(p_self, p_to);
}

godot_real go_godot_vector2_angle_to_point(godot_gdnative_core_api_struct * p_api, const godot_vector2 * p_self, const godot_vector2 * p_to) {
	return p_api->godot_vector2_angle_to_point(p_self, p_to);
}

godot_vector2 go_godot_vector2_linear_interpolate(godot_gdnative_core_api_struct * p_api, const godot_vector2 * p_self, const godot_vector2 * p_b, const godot_real p_t) {
	return p_api->godot_vector2_linear_interpolate(p_self, p_b, p_t);
}

godot_vector2 go_godot_vector2_cubic_interpolate(godot_gdnative_core_api_struct * p_api, const godot_vector2 * p_self, const godot_vector2 * p_b, const godot_vector2 * p_pre_a, const godot_vector2 * p_post_b, const godot_real p_t) {
	return p_api->godot_vector2_cubic_interpolate(p_self, p_b, p_pre_a, p_post_b, p_t);
}

godot_vector2 go_godot_vector2_rotated(godot_gdnative_core_api_struct * p_api, const godot_vector2 * p_self, const godot_real p_phi) {
	return p_api->godot_vector2_rotated(p_self, p_phi);
}

godot_vector2 go_godot_vector2_tangent(godot_gdnative_core_api_struct * p_api, const godot_vector2 * p_self) {
	return p_api->godot_vector2_tangent(p_self);
}

godot_vector2 go_godot_vector2_floor(godot_gdnative_core_api_struct * p_api, const godot_vector2 * p_self) {
	return p_api->godot_vector2_floor(p_self);
}

godot_vector2 go_godot_vector2_snapped(godot_gdnative_core_api_struct * p_api, const godot_vector2 * p_self, const godot_vector2 * p_by) {
	return p_api->godot_vector2_snapped(p_self, p_by);
}

godot_real go_godot_vector2_aspect(godot_gdnative_core_api_struct * p_api, const godot_vector2 * p_self) {
	return p_api->godot_vector2_aspect(p_self);
}

godot_real go_godot_vector2_dot(godot_gdnative_core_api_struct * p_api, const godot_vector2 * p_self, const godot_vector2 * p_with) {
	return p_api->godot_vector2_dot(p_self, p_with);
}

godot_vector2 go_godot_vector2_slide(godot_gdnative_core_api_struct * p_api, const godot_vector2 * p_self, const godot_vector2 * p_n) {
	return p_api->godot_vector2_slide(p_self, p_n);
}

godot_vector2 go_godot_vector2_bounce(godot_gdnative_core_api_struct * p_api, const godot_vector2 * p_self, const godot_vector2 * p_n) {
	return p_api->godot_vector2_bounce(p_self, p_n);
}

godot_vector2 go_godot_vector2_reflect(godot_gdnative_core_api_struct * p_api, const godot_vector2 * p_self, const godot_vector2 * p_n) {
	return p_api->godot_vector2_reflect(p_self, p_n);
}

godot_vector2 go_godot_vector2_abs(godot_gdnative_core_api_struct * p_api, const godot_vector2 * p_self) {
	return p_api->godot_vector2_abs(p_self);
}

godot_vector2 go_godot_vector2_clamped(godot_gdnative_core_api_struct * p_api, const godot_vector2 * p_self, const godot_real p_length) {
	return p_api->godot_vector2_clamped(p_self, p_length);
}

godot_vector2 go_godot_vector2_operator_add(godot_gdnative_core_api_struct * p_api, const godot_vector2 * p_self, const godot_vector2 * p_b) {
	return p_api->godot_vector2_operator_add(p_self, p_b);
}

godot_vector2 go_godot_vector2_operator_subtract(godot_gdnative_core_api_struct * p_api, const godot_vector2 * p_self, const godot_vector2 * p_b) {
	return p_api->godot_vector2_operator_subtract(p_self, p_b);
}

godot_vector2 go_godot_vector2_operator_multiply_vector(godot_gdnative_core_api_struct * p_api, const godot_vector2 * p_self, const godot_vector2 * p_b) {
	return p_api->godot_vector2_operator_multiply_vector(p_self, p_b);
}

godot_vector2 go_godot_vector2_operator_multiply_scalar(godot_gdnative_core_api_struct * p_api, const godot_vector2 * p_self, const godot_real p_b) {
	return p_api->godot_vector2_operator_multiply_scalar(p_self, p_b);
}

godot_vector2 go_godot_vector2_operator_divide_vector(godot_gdnative_core_api_struct * p_api, const godot_vector2 * p_self, const godot_vector2 * p_b) {
	return p_api->godot_vector2_operator_divide_vector(p_self, p_b);
}

godot_vector2 go_godot_vector2_operator_divide_scalar(godot_gdnative_core_api_struct * p_api, const godot_vector2 * p_self, const godot_real p_b) {
	return p_api->godot_vector2_operator_divide_scalar(p_self, p_b);
}

godot_bool go_godot_vector2_operator_equal(godot_gdnative_core_api_struct * p_api, const godot_vector2 * p_self, const godot_vector2 * p_b) {
	return p_api->godot_vector2_operator_equal(p_self, p_b);
}

godot_bool go_godot_vector2_operator_less(godot_gdnative_core_api_struct * p_api, const godot_vector2 * p_self, const godot_vector2 * p_b) {
	return p_api->godot_vector2_operator_less(p_self, p_b);
}

godot_vector2 go_godot_vector2_operator_neg(godot_gdnative_core_api_struct * p_api, const godot_vector2 * p_self) {
	return p_api->godot_vector2_operator_neg(p_self);
}

void go_godot_vector2_set_x(godot_gdnative_core_api_struct * p_api, godot_vector2 * p_self, const godot_real p_x) {
	p_api->godot_vector2_set_x(p_self, p_x);
}

void go_godot_vector2_set_y(godot_gdnative_core_api_struct * p_api, godot_vector2 * p_self, const godot_real p_y) {
	p_api->godot_vector2_set_y(p_self, p_y);
}

godot_real go_godot_vector2_get_x(godot_gdnative_core_api_struct * p_api, const godot_vector2 * p_self) {
	return p_api->godot_vector2_get_x(p_self);
}

godot_real go_godot_vector2_get_y(godot_gdnative_core_api_struct * p_api, const godot_vector2 * p_self) {
	return p_api->godot_vector2_get_y(p_self);
}

void go_godot_quat_new(godot_gdnative_core_api_struct * p_api, godot_quat * r_dest, const godot_real p_x, const godot_real p_y, const godot_real p_z, const godot_real p_w) {
	p_api->godot_quat_new(r_dest, p_x, p_y, p_z, p_w);
}

void go_godot_quat_new_with_axis_angle(godot_gdnative_core_api_struct * p_api, godot_quat * r_dest, const godot_vector3 * p_axis, const godot_real p_angle) {
	p_api->godot_quat_new_with_axis_angle(r_dest, p_axis, p_angle);
}

godot_real go_godot_quat_get_x(godot_gdnative_core_api_struct * p_api, const godot_quat * p_self) {
	return p_api->godot_quat_get_x(p_self);
}

void go_godot_quat_set_x(godot_gdnative_core_api_struct * p_api, godot_quat * p_self, const godot_real val) {
	p_api->godot_quat_set_x(p_self, val);
}

godot_real go_godot_quat_get_y(godot_gdnative_core_api_struct * p_api, const godot_quat * p_self) {
	return p_api->godot_quat_get_y(p_self);
}

void go_godot_quat_set_y(godot_gdnative_core_api_struct * p_api, godot_quat * p_self, const godot_real val) {
	p_api->godot_quat_set_y(p_self, val);
}

godot_real go_godot_quat_get_z(godot_gdnative_core_api_struct * p_api, const godot_quat * p_self) {
	return p_api->godot_quat_get_z(p_self);
}

void go_godot_quat_set_z(godot_gdnative_core_api_struct * p_api, godot_quat * p_self, const godot_real val) {
	p_api->godot_quat_set_z(p_self, val);
}

godot_real go_godot_quat_get_w(godot_gdnative_core_api_struct * p_api, const godot_quat * p_self) {
	return p_api->godot_quat_get_w(p_self);
}

void go_godot_quat_set_w(godot_gdnative_core_api_struct * p_api, godot_quat * p_self, const godot_real val) {
	p_api->godot_quat_set_w(p_self, val);
}

godot_string go_godot_quat_as_string(godot_gdnative_core_api_struct * p_api, const godot_quat * p_self) {
	return p_api->godot_quat_as_string(p_self);
}

godot_real go_godot_quat_length(godot_gdnative_core_api_struct * p_api, const godot_quat * p_self) {
	return p_api->godot_quat_length(p_self);
}

godot_real go_godot_quat_length_squared(godot_gdnative_core_api_struct * p_api, const godot_quat * p_self) {
	return p_api->godot_quat_length_squared(p_self);
}

godot_quat go_godot_quat_normalized(godot_gdnative_core_api_struct * p_api, const godot_quat * p_self) {
	return p_api->godot_quat_normalized(p_self);
}

godot_bool go_godot_quat_is_normalized(godot_gdnative_core_api_struct * p_api, const godot_quat * p_self) {
	return p_api->godot_quat_is_normalized(p_self);
}

godot_quat go_godot_quat_inverse(godot_gdnative_core_api_struct * p_api, const godot_quat * p_self) {
	return p_api->godot_quat_inverse(p_self);
}

godot_real go_godot_quat_dot(godot_gdnative_core_api_struct * p_api, const godot_quat * p_self, const godot_quat * p_b) {
	return p_api->godot_quat_dot(p_self, p_b);
}

godot_vector3 go_godot_quat_xform(godot_gdnative_core_api_struct * p_api, const godot_quat * p_self, const godot_vector3 * p_v) {
	return p_api->godot_quat_xform(p_self, p_v);
}

godot_quat go_godot_quat_slerp(godot_gdnative_core_api_struct * p_api, const godot_quat * p_self, const godot_quat * p_b, const godot_real p_t) {
	return p_api->godot_quat_slerp(p_self, p_b, p_t);
}

godot_quat go_godot_quat_slerpni(godot_gdnative_core_api_struct * p_api, const godot_quat * p_self, const godot_quat * p_b, const godot_real p_t) {
	return p_api->godot_quat_slerpni(p_self, p_b, p_t);
}

godot_quat go_godot_quat_cubic_slerp(godot_gdnative_core_api_struct * p_api, const godot_quat * p_self, const godot_quat * p_b, const godot_quat * p_pre_a, const godot_quat * p_post_b, const godot_real p_t) {
	return p_api->godot_quat_cubic_slerp(p_self, p_b, p_pre_a, p_post_b, p_t);
}

godot_quat go_godot_quat_operator_multiply(godot_gdnative_core_api_struct * p_api, const godot_quat * p_self, const godot_real p_b) {
	return p_api->godot_quat_operator_multiply(p_self, p_b);
}

godot_quat go_godot_quat_operator_add(godot_gdnative_core_api_struct * p_api, const godot_quat * p_self, const godot_quat * p_b) {
	return p_api->godot_quat_operator_add(p_self, p_b);
}

godot_quat go_godot_quat_operator_subtract(godot_gdnative_core_api_struct * p_api, const godot_quat * p_self, const godot_quat * p_b) {
	return p_api->godot_quat_operator_subtract(p_self, p_b);
}

godot_quat go_godot_quat_operator_divide(godot_gdnative_core_api_struct * p_api, const godot_quat * p_self, const godot_real p_b) {
	return p_api->godot_quat_operator_divide(p_self, p_b);
}

godot_bool go_godot_quat_operator_equal(godot_gdnative_core_api_struct * p_api, const godot_quat * p_self, const godot_quat * p_b) {
	return p_api->godot_quat_operator_equal(p_self, p_b);
}

godot_quat go_godot_quat_operator_neg(godot_gdnative_core_api_struct * p_api, const godot_quat * p_self) {
	return p_api->godot_quat_operator_neg(p_self);
}

void go_godot_basis_new_with_rows(godot_gdnative_core_api_struct * p_api, godot_basis * r_dest, const godot_vector3 * p_x_axis, const godot_vector3 * p_y_axis, const godot_vector3 * p_z_axis) {
	p_api->godot_basis_new_with_rows(r_dest, p_x_axis, p_y_axis, p_z_axis);
}

void go_godot_basis_new_with_axis_and_angle(godot_gdnative_core_api_struct * p_api, godot_basis * r_dest, const godot_vector3 * p_axis, const godot_real p_phi) {
	p_api->godot_basis_new_with_axis_and_angle(r_dest, p_axis, p_phi);
}

void go_godot_basis_new_with_euler(godot_gdnative_core_api_struct * p_api, godot_basis * r_dest, const godot_vector3 * p_euler) {
	p_api->godot_basis_new_with_euler(r_dest, p_euler);
}

godot_string go_godot_basis_as_string(godot_gdnative_core_api_struct * p_api, const godot_basis * p_self) {
	return p_api->godot_basis_as_string(p_self);
}

godot_basis go_godot_basis_inverse(godot_gdnative_core_api_struct * p_api, const godot_basis * p_self) {
	return p_api->godot_basis_inverse(p_self);
}

godot_basis go_godot_basis_transposed(godot_gdnative_core_api_struct * p_api, const godot_basis * p_self) {
	return p_api->godot_basis_transposed(p_self);
}

godot_basis go_godot_basis_orthonormalized(godot_gdnative_core_api_struct * p_api, const godot_basis * p_self) {
	return p_api->godot_basis_orthonormalized(p_self);
}

godot_real go_godot_basis_determinant(godot_gdnative_core_api_struct * p_api, const godot_basis * p_self) {
	return p_api->godot_basis_determinant(p_self);
}

godot_basis go_godot_basis_rotated(godot_gdnative_core_api_struct * p_api, const godot_basis * p_self, const godot_vector3 * p_axis, const godot_real p_phi) {
	return p_api->godot_basis_rotated(p_self, p_axis, p_phi);
}

godot_basis go_godot_basis_scaled(godot_gdnative_core_api_struct * p_api, const godot_basis * p_self, const godot_vector3 * p_scale) {
	return p_api->godot_basis_scaled(p_self, p_scale);
}

godot_vector3 go_godot_basis_get_scale(godot_gdnative_core_api_struct * p_api, const godot_basis * p_self) {
	return p_api->godot_basis_get_scale(p_self);
}

godot_vector3 go_godot_basis_get_euler(godot_gdnative_core_api_struct * p_api, const godot_basis * p_self) {
	return p_api->godot_basis_get_euler(p_self);
}

godot_real go_godot_basis_tdotx(godot_gdnative_core_api_struct * p_api, const godot_basis * p_self, const godot_vector3 * p_with) {
	return p_api->godot_basis_tdotx(p_self, p_with);
}

godot_real go_godot_basis_tdoty(godot_gdnative_core_api_struct * p_api, const godot_basis * p_self, const godot_vector3 * p_with) {
	return p_api->godot_basis_tdoty(p_self, p_with);
}

godot_real go_godot_basis_tdotz(godot_gdnative_core_api_struct * p_api, const godot_basis * p_self, const godot_vector3 * p_with) {
	return p_api->godot_basis_tdotz(p_self, p_with);
}

godot_vector3 go_godot_basis_xform(godot_gdnative_core_api_struct * p_api, const godot_basis * p_self, const godot_vector3 * p_v) {
	return p_api->godot_basis_xform(p_self, p_v);
}

godot_vector3 go_godot_basis_xform_inv(godot_gdnative_core_api_struct * p_api, const godot_basis * p_self, const godot_vector3 * p_v) {
	return p_api->godot_basis_xform_inv(p_self, p_v);
}

godot_int go_godot_basis_get_orthogonal_index(godot_gdnative_core_api_struct * p_api, const godot_basis * p_self) {
	return p_api->godot_basis_get_orthogonal_index(p_self);
}

void go_godot_basis_new(godot_gdnative_core_api_struct * p_api, godot_basis * r_dest) {
	p_api->godot_basis_new(r_dest);
}

void go_godot_basis_new_with_euler_quat(godot_gdnative_core_api_struct * p_api, godot_basis * r_dest, const godot_quat * p_euler) {
	p_api->godot_basis_new_with_euler_quat(r_dest, p_euler);
}

void go_godot_basis_get_elements(godot_gdnative_core_api_struct * p_api, const godot_basis * p_self, godot_vector3 * p_elements) {
	p_api->godot_basis_get_elements(p_self, p_elements);
}

godot_vector3 go_godot_basis_get_axis(godot_gdnative_core_api_struct * p_api, const godot_basis * p_self, const godot_int p_axis) {
	return p_api->godot_basis_get_axis(p_self, p_axis);
}

void go_godot_basis_set_axis(godot_gdnative_core_api_struct * p_api, godot_basis * p_self, const godot_int p_axis, const godot_vector3 * p_value) {
	p_api->godot_basis_set_axis(p_self, p_axis, p_value);
}

godot_vector3 go_godot_basis_get_row(godot_gdnative_core_api_struct * p_api, const godot_basis * p_self, const godot_int p_row) {
	return p_api->godot_basis_get_row(p_self, p_row);
}

void go_godot_basis_set_row(godot_gdnative_core_api_struct * p_api, godot_basis * p_self, const godot_int p_row, const godot_vector3 * p_value) {
	p_api->godot_basis_set_row(p_self, p_row, p_value);
}

godot_bool go_godot_basis_operator_equal(godot_gdnative_core_api_struct * p_api, const godot_basis * p_self, const godot_basis * p_b) {
	return p_api->godot_basis_operator_equal(p_self, p_b);
}

godot_basis go_godot_basis_operator_add(godot_gdnative_core_api_struct * p_api, const godot_basis * p_self, const godot_basis * p_b) {
	return p_api->godot_basis_operator_add(p_self, p_b);
}

godot_basis go_godot_basis_operator_subtract(godot_gdnative_core_api_struct * p_api, const godot_basis * p_self, const godot_basis * p_b) {
	return p_api->godot_basis_operator_subtract(p_self, p_b);
}

godot_basis go_godot_basis_operator_multiply_vector(godot_gdnative_core_api_struct * p_api, const godot_basis * p_self, const godot_basis * p_b) {
	return p_api->godot_basis_operator_multiply_vector(p_self, p_b);
}

godot_basis go_godot_basis_operator_multiply_scalar(godot_gdnative_core_api_struct * p_api, const godot_basis * p_self, const godot_real p_b) {
	return p_api->godot_basis_operator_multiply_scalar(p_self, p_b);
}

void go_godot_vector3_new(godot_gdnative_core_api_struct * p_api, godot_vector3 * r_dest, const godot_real p_x, const godot_real p_y, const godot_real p_z) {
	p_api->godot_vector3_new(r_dest, p_x, p_y, p_z);
}

godot_string go_godot_vector3_as_string(godot_gdnative_core_api_struct * p_api, const godot_vector3 * p_self) {
	return p_api->godot_vector3_as_string(p_self);
}

godot_int go_godot_vector3_min_axis(godot_gdnative_core_api_struct * p_api, const godot_vector3 * p_self) {
	return p_api->godot_vector3_min_axis(p_self);
}

godot_int go_godot_vector3_max_axis(godot_gdnative_core_api_struct * p_api, const godot_vector3 * p_self) {
	return p_api->godot_vector3_max_axis(p_self);
}

godot_real go_godot_vector3_length(godot_gdnative_core_api_struct * p_api, const godot_vector3 * p_self) {
	return p_api->godot_vector3_length(p_self);
}

godot_real go_godot_vector3_length_squared(godot_gdnative_core_api_struct * p_api, const godot_vector3 * p_self) {
	return p_api->godot_vector3_length_squared(p_self);
}

godot_bool go_godot_vector3_is_normalized(godot_gdnative_core_api_struct * p_api, const godot_vector3 * p_self) {
	return p_api->godot_vector3_is_normalized(p_self);
}

godot_vector3 go_godot_vector3_normalized(godot_gdnative_core_api_struct * p_api, const godot_vector3 * p_self) {
	return p_api->godot_vector3_normalized(p_self);
}

godot_vector3 go_godot_vector3_inverse(godot_gdnative_core_api_struct * p_api, const godot_vector3 * p_self) {
	return p_api->godot_vector3_inverse(p_self);
}

godot_vector3 go_godot_vector3_snapped(godot_gdnative_core_api_struct * p_api, const godot_vector3 * p_self, const godot_vector3 * p_by) {
	return p_api->godot_vector3_snapped(p_self, p_by);
}

godot_vector3 go_godot_vector3_rotated(godot_gdnative_core_api_struct * p_api, const godot_vector3 * p_self, const godot_vector3 * p_axis, const godot_real p_phi) {
	return p_api->godot_vector3_rotated(p_self, p_axis, p_phi);
}

godot_vector3 go_godot_vector3_linear_interpolate(godot_gdnative_core_api_struct * p_api, const godot_vector3 * p_self, const godot_vector3 * p_b, const godot_real p_t) {
	return p_api->godot_vector3_linear_interpolate(p_self, p_b, p_t);
}

godot_vector3 go_godot_vector3_cubic_interpolate(godot_gdnative_core_api_struct * p_api, const godot_vector3 * p_self, const godot_vector3 * p_b, const godot_vector3 * p_pre_a, const godot_vector3 * p_post_b, const godot_real p_t) {
	return p_api->godot_vector3_cubic_interpolate(p_self, p_b, p_pre_a, p_post_b, p_t);
}

godot_real go_godot_vector3_dot(godot_gdnative_core_api_struct * p_api, const godot_vector3 * p_self, const godot_vector3 * p_b) {
	return p_api->godot_vector3_dot(p_self, p_b);
}

godot_vector3 go_godot_vector3_cross(godot_gdnative_core_api_struct * p_api, const godot_vector3 * p_self, const godot_vector3 * p_b) {
	return p_api->godot_vector3_cross(p_self, p_b);
}

godot_basis go_godot_vector3_outer(godot_gdnative_core_api_struct * p_api, const godot_vector3 * p_self, const godot_vector3 * p_b) {
	return p_api->godot_vector3_outer(p_self, p_b);
}

godot_basis go_godot_vector3_to_diagonal_matrix(godot_gdnative_core_api_struct * p_api, const godot_vector3 * p_self) {
	return p_api->godot_vector3_to_diagonal_matrix(p_self);
}

godot_vector3 go_godot_vector3_abs(godot_gdnative_core_api_struct * p_api, const godot_vector3 * p_self) {
	return p_api->godot_vector3_abs(p_self);
}

godot_vector3 go_godot_vector3_floor(godot_gdnative_core_api_struct * p_api, const godot_vector3 * p_self) {
	return p_api->godot_vector3_floor(p_self);
}

godot_vector3 go_godot_vector3_ceil(godot_gdnative_core_api_struct * p_api, const godot_vector3 * p_self) {
	return p_api->godot_vector3_ceil(p_self);
}

godot_real go_godot_vector3_distance_to(godot_gdnative_core_api_struct * p_api, const godot_vector3 * p_self, const godot_vector3 * p_b) {
	return p_api->godot_vector3_distance_to(p_self, p_b);
}

godot_real go_godot_vector3_distance_squared_to(godot_gdnative_core_api_struct * p_api, const godot_vector3 * p_self, const godot_vector3 * p_b) {
	return p_api->godot_vector3_distance_squared_to(p_self, p_b);
}

godot_real go_godot_vector3_angle_to(godot_gdnative_core_api_struct * p_api, const godot_vector3 * p_self, const godot_vector3 * p_to) {
	return p_api->godot_vector3_angle_to(p_self, p_to);
}

godot_vector3 go_godot_vector3_slide(godot_gdnative_core_api_struct * p_api, const godot_vector3 * p_self, const godot_vector3 * p_n) {
	return p_api->godot_vector3_slide(p_self, p_n);
}

godot_vector3 go_godot_vector3_bounce(godot_gdnative_core_api_struct * p_api, const godot_vector3 * p_self, const godot_vector3 * p_n) {
	return p_api->godot_vector3_bounce(p_self, p_n);
}

godot_vector3 go_godot_vector3_reflect(godot_gdnative_core_api_struct * p_api, const godot_vector3 * p_self, const godot_vector3 * p_n) {
	return p_api->godot_vector3_reflect(p_self, p_n);
}

godot_vector3 go_godot_vector3_operator_add(godot_gdnative_core_api_struct * p_api, const godot_vector3 * p_self, const godot_vector3 * p_b) {
	return p_api->godot_vector3_operator_add(p_self, p_b);
}

godot_vector3 go_godot_vector3_operator_subtract(godot_gdnative_core_api_struct * p_api, const godot_vector3 * p_self, const godot_vector3 * p_b) {
	return p_api->godot_vector3_operator_subtract(p_self, p_b);
}

godot_vector3 go_godot_vector3_operator_multiply_vector(godot_gdnative_core_api_struct * p_api, const godot_vector3 * p_self, const godot_vector3 * p_b) {
	return p_api->godot_vector3_operator_multiply_vector(p_self, p_b);
}

godot_vector3 go_godot_vector3_operator_multiply_scalar(godot_gdnative_core_api_struct * p_api, const godot_vector3 * p_self, const godot_real p_b) {
	return p_api->godot_vector3_operator_multiply_scalar(p_self, p_b);
}

godot_vector3 go_godot_vector3_operator_divide_vector(godot_gdnative_core_api_struct * p_api, const godot_vector3 * p_self, const godot_vector3 * p_b) {
	return p_api->godot_vector3_operator_divide_vector(p_self, p_b);
}

godot_vector3 go_godot_vector3_operator_divide_scalar(godot_gdnative_core_api_struct * p_api, const godot_vector3 * p_self, const godot_real p_b) {
	return p_api->godot_vector3_operator_divide_scalar(p_self, p_b);
}

godot_bool go_godot_vector3_operator_equal(godot_gdnative_core_api_struct * p_api, const godot_vector3 * p_self, const godot_vector3 * p_b) {
	return p_api->godot_vector3_operator_equal(p_self, p_b);
}

godot_bool go_godot_vector3_operator_less(godot_gdnative_core_api_struct * p_api, const godot_vector3 * p_self, const godot_vector3 * p_b) {
	return p_api->godot_vector3_operator_less(p_self, p_b);
}

godot_vector3 go_godot_vector3_operator_neg(godot_gdnative_core_api_struct * p_api, const godot_vector3 * p_self) {
	return p_api->godot_vector3_operator_neg(p_self);
}

void go_godot_vector3_set_axis(godot_gdnative_core_api_struct * p_api, godot_vector3 * p_self, const godot_vector3_axis p_axis, const godot_real p_val) {
	p_api->godot_vector3_set_axis(p_self, p_axis, p_val);
}

godot_real go_godot_vector3_get_axis(godot_gdnative_core_api_struct * p_api, const godot_vector3 * p_self, const godot_vector3_axis p_axis) {
	return p_api->godot_vector3_get_axis(p_self, p_axis);
}

void go_godot_pool_byte_array_new(godot_gdnative_core_api_struct * p_api, godot_pool_byte_array * r_dest) {
	p_api->godot_pool_byte_array_new(r_dest);
}

void go_godot_pool_byte_array_new_copy(godot_gdnative_core_api_struct * p_api, godot_pool_byte_array * r_dest, const godot_pool_byte_array * p_src) {
	p_api->godot_pool_byte_array_new_copy(r_dest, p_src);
}

void go_godot_pool_byte_array_new_with_array(godot_gdnative_core_api_struct * p_api, godot_pool_byte_array * r_dest, const godot_array * p_a) {
	p_api->godot_pool_byte_array_new_with_array(r_dest, p_a);
}

void go_godot_pool_byte_array_append(godot_gdnative_core_api_struct * p_api, godot_pool_byte_array * p_self, const uint8_t p_data) {
	p_api->godot_pool_byte_array_append(p_self, p_data);
}

void go_godot_pool_byte_array_append_array(godot_gdnative_core_api_struct * p_api, godot_pool_byte_array * p_self, const godot_pool_byte_array * p_array) {
	p_api->godot_pool_byte_array_append_array(p_self, p_array);
}

godot_error go_godot_pool_byte_array_insert(godot_gdnative_core_api_struct * p_api, godot_pool_byte_array * p_self, const godot_int p_idx, const uint8_t p_data) {
	return p_api->godot_pool_byte_array_insert(p_self, p_idx, p_data);
}

void go_godot_pool_byte_array_invert(godot_gdnative_core_api_struct * p_api, godot_pool_byte_array * p_self) {
	p_api->godot_pool_byte_array_invert(p_self);
}

void go_godot_pool_byte_array_push_back(godot_gdnative_core_api_struct * p_api, godot_pool_byte_array * p_self, const uint8_t p_data) {
	p_api->godot_pool_byte_array_push_back(p_self, p_data);
}

void go_godot_pool_byte_array_remove(godot_gdnative_core_api_struct * p_api, godot_pool_byte_array * p_self, const godot_int p_idx) {
	p_api->godot_pool_byte_array_remove(p_self, p_idx);
}

void go_godot_pool_byte_array_resize(godot_gdnative_core_api_struct * p_api, godot_pool_byte_array * p_self, const godot_int p_size) {
	p_api->godot_pool_byte_array_resize(p_self, p_size);
}

godot_pool_byte_array_read_access * go_godot_pool_byte_array_read(godot_gdnative_core_api_struct * p_api, const godot_pool_byte_array * p_self) {
	return p_api->godot_pool_byte_array_read(p_self);
}

godot_pool_byte_array_write_access * go_godot_pool_byte_array_write(godot_gdnative_core_api_struct * p_api, godot_pool_byte_array * p_self) {
	return p_api->godot_pool_byte_array_write(p_self);
}

void go_godot_pool_byte_array_set(godot_gdnative_core_api_struct * p_api, godot_pool_byte_array * p_self, const godot_int p_idx, const uint8_t p_data) {
	p_api->godot_pool_byte_array_set(p_self, p_idx, p_data);
}

uint8_t go_godot_pool_byte_array_get(godot_gdnative_core_api_struct * p_api, const godot_pool_byte_array * p_self, const godot_int p_idx) {
	return p_api->godot_pool_byte_array_get(p_self, p_idx);
}

godot_int go_godot_pool_byte_array_size(godot_gdnative_core_api_struct * p_api, const godot_pool_byte_array * p_self) {
	return p_api->godot_pool_byte_array_size(p_self);
}

void go_godot_pool_byte_array_destroy(godot_gdnative_core_api_struct * p_api, godot_pool_byte_array * p_self) {
	p_api->godot_pool_byte_array_destroy(p_self);
}

void go_godot_pool_int_array_new(godot_gdnative_core_api_struct * p_api, godot_pool_int_array * r_dest) {
	p_api->godot_pool_int_array_new(r_dest);
}

void go_godot_pool_int_array_new_copy(godot_gdnative_core_api_struct * p_api, godot_pool_int_array * r_dest, const godot_pool_int_array * p_src) {
	p_api->godot_pool_int_array_new_copy(r_dest, p_src);
}

void go_godot_pool_int_array_new_with_array(godot_gdnative_core_api_struct * p_api, godot_pool_int_array * r_dest, const godot_array * p_a) {
	p_api->godot_pool_int_array_new_with_array(r_dest, p_a);
}

void go_godot_pool_int_array_append(godot_gdnative_core_api_struct * p_api, godot_pool_int_array * p_self, const godot_int p_data) {
	p_api->godot_pool_int_array_append(p_self, p_data);
}

void go_godot_pool_int_array_append_array(godot_gdnative_core_api_struct * p_api, godot_pool_int_array * p_self, const godot_pool_int_array * p_array) {
	p_api->godot_pool_int_array_append_array(p_self, p_array);
}

godot_error go_godot_pool_int_array_insert(godot_gdnative_core_api_struct * p_api, godot_pool_int_array * p_self, const godot_int p_idx, const godot_int p_data) {
	return p_api->godot_pool_int_array_insert(p_self, p_idx, p_data);
}

void go_godot_pool_int_array_invert(godot_gdnative_core_api_struct * p_api, godot_pool_int_array * p_self) {
	p_api->godot_pool_int_array_invert(p_self);
}

void go_godot_pool_int_array_push_back(godot_gdnative_core_api_struct * p_api, godot_pool_int_array * p_self, const godot_int p_data) {
	p_api->godot_pool_int_array_push_back(p_self, p_data);
}

void go_godot_pool_int_array_remove(godot_gdnative_core_api_struct * p_api, godot_pool_int_array * p_self, const godot_int p_idx) {
	p_api->godot_pool_int_array_remove(p_self, p_idx);
}

void go_godot_pool_int_array_resize(godot_gdnative_core_api_struct * p_api, godot_pool_int_array * p_self, const godot_int p_size) {
	p_api->godot_pool_int_array_resize(p_self, p_size);
}

godot_pool_int_array_read_access * go_godot_pool_int_array_read(godot_gdnative_core_api_struct * p_api, const godot_pool_int_array * p_self) {
	return p_api->godot_pool_int_array_read(p_self);
}

godot_pool_int_array_write_access * go_godot_pool_int_array_write(godot_gdnative_core_api_struct * p_api, godot_pool_int_array * p_self) {
	return p_api->godot_pool_int_array_write(p_self);
}

void go_godot_pool_int_array_set(godot_gdnative_core_api_struct * p_api, godot_pool_int_array * p_self, const godot_int p_idx, const godot_int p_data) {
	p_api->godot_pool_int_array_set(p_self, p_idx, p_data);
}

godot_int go_godot_pool_int_array_get(godot_gdnative_core_api_struct * p_api, const godot_pool_int_array * p_self, const godot_int p_idx) {
	return p_api->godot_pool_int_array_get(p_self, p_idx);
}

godot_int go_godot_pool_int_array_size(godot_gdnative_core_api_struct * p_api, const godot_pool_int_array * p_self) {
	return p_api->godot_pool_int_array_size(p_self);
}

void go_godot_pool_int_array_destroy(godot_gdnative_core_api_struct * p_api, godot_pool_int_array * p_self) {
	p_api->godot_pool_int_array_destroy(p_self);
}

void go_godot_pool_real_array_new(godot_gdnative_core_api_struct * p_api, godot_pool_real_array * r_dest) {
	p_api->godot_pool_real_array_new(r_dest);
}

void go_godot_pool_real_array_new_copy(godot_gdnative_core_api_struct * p_api, godot_pool_real_array * r_dest, const godot_pool_real_array * p_src) {
	p_api->godot_pool_real_array_new_copy(r_dest, p_src);
}

void go_godot_pool_real_array_new_with_array(godot_gdnative_core_api_struct * p_api, godot_pool_real_array * r_dest, const godot_array * p_a) {
	p_api->godot_pool_real_array_new_with_array(r_dest, p_a);
}

void go_godot_pool_real_array_append(godot_gdnative_core_api_struct * p_api, godot_pool_real_array * p_self, const godot_real p_data) {
	p_api->godot_pool_real_array_append(p_self, p_data);
}

void go_godot_pool_real_array_append_array(godot_gdnative_core_api_struct * p_api, godot_pool_real_array * p_self, const godot_pool_real_array * p_array) {
	p_api->godot_pool_real_array_append_array(p_self, p_array);
}

godot_error go_godot_pool_real_array_insert(godot_gdnative_core_api_struct * p_api, godot_pool_real_array * p_self, const godot_int p_idx, const godot_real p_data) {
	return p_api->godot_pool_real_array_insert(p_self, p_idx, p_data);
}

void go_godot_pool_real_array_invert(godot_gdnative_core_api_struct * p_api, godot_pool_real_array * p_self) {
	p_api->godot_pool_real_array_invert(p_self);
}

void go_godot_pool_real_array_push_back(godot_gdnative_core_api_struct * p_api, godot_pool_real_array * p_self, const godot_real p_data) {
	p_api->godot_pool_real_array_push_back(p_self, p_data);
}

void go_godot_pool_real_array_remove(godot_gdnative_core_api_struct * p_api, godot_pool_real_array * p_self, const godot_int p_idx) {
	p_api->godot_pool_real_array_remove(p_self, p_idx);
}

void go_godot_pool_real_array_resize(godot_gdnative_core_api_struct * p_api, godot_pool_real_array * p_self, const godot_int p_size) {
	p_api->godot_pool_real_array_resize(p_self, p_size);
}

godot_pool_real_array_read_access * go_godot_pool_real_array_read(godot_gdnative_core_api_struct * p_api, const godot_pool_real_array * p_self) {
	return p_api->godot_pool_real_array_read(p_self);
}

godot_pool_real_array_write_access * go_godot_pool_real_array_write(godot_gdnative_core_api_struct * p_api, godot_pool_real_array * p_self) {
	return p_api->godot_pool_real_array_write(p_self);
}

void go_godot_pool_real_array_set(godot_gdnative_core_api_struct * p_api, godot_pool_real_array * p_self, const godot_int p_idx, const godot_real p_data) {
	p_api->godot_pool_real_array_set(p_self, p_idx, p_data);
}

godot_real go_godot_pool_real_array_get(godot_gdnative_core_api_struct * p_api, const godot_pool_real_array * p_self, const godot_int p_idx) {
	return p_api->godot_pool_real_array_get(p_self, p_idx);
}

godot_int go_godot_pool_real_array_size(godot_gdnative_core_api_struct * p_api, const godot_pool_real_array * p_self) {
	return p_api->godot_pool_real_array_size(p_self);
}

void go_godot_pool_real_array_destroy(godot_gdnative_core_api_struct * p_api, godot_pool_real_array * p_self) {
	p_api->godot_pool_real_array_destroy(p_self);
}

void go_godot_pool_string_array_new(godot_gdnative_core_api_struct * p_api, godot_pool_string_array * r_dest) {
	p_api->godot_pool_string_array_new(r_dest);
}

void go_godot_pool_string_array_new_copy(godot_gdnative_core_api_struct * p_api, godot_pool_string_array * r_dest, const godot_pool_string_array * p_src) {
	p_api->godot_pool_string_array_new_copy(r_dest, p_src);
}

void go_godot_pool_string_array_new_with_array(godot_gdnative_core_api_struct * p_api, godot_pool_string_array * r_dest, const godot_array * p_a) {
	p_api->godot_pool_string_array_new_with_array(r_dest, p_a);
}

void go_godot_pool_string_array_append(godot_gdnative_core_api_struct * p_api, godot_pool_string_array * p_self, const godot_string * p_data) {
	p_api->godot_pool_string_array_append(p_self, p_data);
}

void go_godot_pool_string_array_append_array(godot_gdnative_core_api_struct * p_api, godot_pool_string_array * p_self, const godot_pool_string_array * p_array) {
	p_api->godot_pool_string_array_append_array(p_self, p_array);
}

godot_error go_godot_pool_string_array_insert(godot_gdnative_core_api_struct * p_api, godot_pool_string_array * p_self, const godot_int p_idx, const godot_string * p_data) {
	return p_api->godot_pool_string_array_insert(p_self, p_idx, p_data);
}

void go_godot_pool_string_array_invert(godot_gdnative_core_api_struct * p_api, godot_pool_string_array * p_self) {
	p_api->godot_pool_string_array_invert(p_self);
}

void go_godot_pool_string_array_push_back(godot_gdnative_core_api_struct * p_api, godot_pool_string_array * p_self, const godot_string * p_data) {
	p_api->godot_pool_string_array_push_back(p_self, p_data);
}

void go_godot_pool_string_array_remove(godot_gdnative_core_api_struct * p_api, godot_pool_string_array * p_self, const godot_int p_idx) {
	p_api->godot_pool_string_array_remove(p_self, p_idx);
}

void go_godot_pool_string_array_resize(godot_gdnative_core_api_struct * p_api, godot_pool_string_array * p_self, const godot_int p_size) {
	p_api->godot_pool_string_array_resize(p_self, p_size);
}

godot_pool_string_array_read_access * go_godot_pool_string_array_read(godot_gdnative_core_api_struct * p_api, const godot_pool_string_array * p_self) {
	return p_api->godot_pool_string_array_read(p_self);
}

godot_pool_string_array_write_access * go_godot_pool_string_array_write(godot_gdnative_core_api_struct * p_api, godot_pool_string_array * p_self) {
	return p_api->godot_pool_string_array_write(p_self);
}

void go_godot_pool_string_array_set(godot_gdnative_core_api_struct * p_api, godot_pool_string_array * p_self, const godot_int p_idx, const godot_string * p_data) {
	p_api->godot_pool_string_array_set(p_self, p_idx, p_data);
}

godot_string go_godot_pool_string_array_get(godot_gdnative_core_api_struct * p_api, const godot_pool_string_array * p_self, const godot_int p_idx) {
	return p_api->godot_pool_string_array_get(p_self, p_idx);
}

godot_int go_godot_pool_string_array_size(godot_gdnative_core_api_struct * p_api, const godot_pool_string_array * p_self) {
	return p_api->godot_pool_string_array_size(p_self);
}

void go_godot_pool_string_array_destroy(godot_gdnative_core_api_struct * p_api, godot_pool_string_array * p_self) {
	p_api->godot_pool_string_array_destroy(p_self);
}

void go_godot_pool_vector2_array_new(godot_gdnative_core_api_struct * p_api, godot_pool_vector2_array * r_dest) {
	p_api->godot_pool_vector2_array_new(r_dest);
}

void go_godot_pool_vector2_array_new_copy(godot_gdnative_core_api_struct * p_api, godot_pool_vector2_array * r_dest, const godot_pool_vector2_array * p_src) {
	p_api->godot_pool_vector2_array_new_copy(r_dest, p_src);
}

void go_godot_pool_vector2_array_new_with_array(godot_gdnative_core_api_struct * p_api, godot_pool_vector2_array * r_dest, const godot_array * p_a) {
	p_api->godot_pool_vector2_array_new_with_array(r_dest, p_a);
}

void go_godot_pool_vector2_array_append(godot_gdnative_core_api_struct * p_api, godot_pool_vector2_array * p_self, const godot_vector2 * p_data) {
	p_api->godot_pool_vector2_array_append(p_self, p_data);
}

void go_godot_pool_vector2_array_append_array(godot_gdnative_core_api_struct * p_api, godot_pool_vector2_array * p_self, const godot_pool_vector2_array * p_array) {
	p_api->godot_pool_vector2_array_append_array(p_self, p_array);
}

godot_error go_godot_pool_vector2_array_insert(godot_gdnative_core_api_struct * p_api, godot_pool_vector2_array * p_self, const godot_int p_idx, const godot_vector2 * p_data) {
	return p_api->godot_pool_vector2_array_insert(p_self, p_idx, p_data);
}

void go_godot_pool_vector2_array_invert(godot_gdnative_core_api_struct * p_api, godot_pool_vector2_array * p_self) {
	p_api->godot_pool_vector2_array_invert(p_self);
}

void go_godot_pool_vector2_array_push_back(godot_gdnative_core_api_struct * p_api, godot_pool_vector2_array * p_self, const godot_vector2 * p_data) {
	p_api->godot_pool_vector2_array_push_back(p_self, p_data);
}

void go_godot_pool_vector2_array_remove(godot_gdnative_core_api_struct * p_api, godot_pool_vector2_array * p_self, const godot_int p_idx) {
	p_api->godot_pool_vector2_array_remove(p_self, p_idx);
}

void go_godot_pool_vector2_array_resize(godot_gdnative_core_api_struct * p_api, godot_pool_vector2_array * p_self, const godot_int p_size) {
	p_api->godot_pool_vector2_array_resize(p_self, p_size);
}

godot_pool_vector2_array_read_access * go_godot_pool_vector2_array_read(godot_gdnative_core_api_struct * p_api, const godot_pool_vector2_array * p_self) {
	return p_api->godot_pool_vector2_array_read(p_self);
}

godot_pool_vector2_array_write_access * go_godot_pool_vector2_array_write(godot_gdnative_core_api_struct * p_api, godot_pool_vector2_array * p_self) {
	return p_api->godot_pool_vector2_array_write(p_self);
}

void go_godot_pool_vector2_array_set(godot_gdnative_core_api_struct * p_api, godot_pool_vector2_array * p_self, const godot_int p_idx, const godot_vector2 * p_data) {
	p_api->godot_pool_vector2_array_set(p_self, p_idx, p_data);
}

godot_vector2 go_godot_pool_vector2_array_get(godot_gdnative_core_api_struct * p_api, const godot_pool_vector2_array * p_self, const godot_int p_idx) {
	return p_api->godot_pool_vector2_array_get(p_self, p_idx);
}

godot_int go_godot_pool_vector2_array_size(godot_gdnative_core_api_struct * p_api, const godot_pool_vector2_array * p_self) {
	return p_api->godot_pool_vector2_array_size(p_self);
}

void go_godot_pool_vector2_array_destroy(godot_gdnative_core_api_struct * p_api, godot_pool_vector2_array * p_self) {
	p_api->godot_pool_vector2_array_destroy(p_self);
}

void go_godot_pool_vector3_array_new(godot_gdnative_core_api_struct * p_api, godot_pool_vector3_array * r_dest) {
	p_api->godot_pool_vector3_array_new(r_dest);
}

void go_godot_pool_vector3_array_new_copy(godot_gdnative_core_api_struct * p_api, godot_pool_vector3_array * r_dest, const godot_pool_vector3_array * p_src) {
	p_api->godot_pool_vector3_array_new_copy(r_dest, p_src);
}

void go_godot_pool_vector3_array_new_with_array(godot_gdnative_core_api_struct * p_api, godot_pool_vector3_array * r_dest, const godot_array * p_a) {
	p_api->godot_pool_vector3_array_new_with_array(r_dest, p_a);
}

void go_godot_pool_vector3_array_append(godot_gdnative_core_api_struct * p_api, godot_pool_vector3_array * p_self, const godot_vector3 * p_data) {
	p_api->godot_pool_vector3_array_append(p_self, p_data);
}

void go_godot_pool_vector3_array_append_array(godot_gdnative_core_api_struct * p_api, godot_pool_vector3_array * p_self, const godot_pool_vector3_array * p_array) {
	p_api->godot_pool_vector3_array_append_array(p_self, p_array);
}

godot_error go_godot_pool_vector3_array_insert(godot_gdnative_core_api_struct * p_api, godot_pool_vector3_array * p_self, const godot_int p_idx, const godot_vector3 * p_data) {
	return p_api->godot_pool_vector3_array_insert(p_self, p_idx, p_data);
}

void go_godot_pool_vector3_array_invert(godot_gdnative_core_api_struct * p_api, godot_pool_vector3_array * p_self) {
	p_api->godot_pool_vector3_array_invert(p_self);
}

void go_godot_pool_vector3_array_push_back(godot_gdnative_core_api_struct * p_api, godot_pool_vector3_array * p_self, const godot_vector3 * p_data) {
	p_api->godot_pool_vector3_array_push_back(p_self, p_data);
}

void go_godot_pool_vector3_array_remove(godot_gdnative_core_api_struct * p_api, godot_pool_vector3_array * p_self, const godot_int p_idx) {
	p_api->godot_pool_vector3_array_remove(p_self, p_idx);
}

void go_godot_pool_vector3_array_resize(godot_gdnative_core_api_struct * p_api, godot_pool_vector3_array * p_self, const godot_int p_size) {
	p_api->godot_pool_vector3_array_resize(p_self, p_size);
}

godot_pool_vector3_array_read_access * go_godot_pool_vector3_array_read(godot_gdnative_core_api_struct * p_api, const godot_pool_vector3_array * p_self) {
	return p_api->godot_pool_vector3_array_read(p_self);
}

godot_pool_vector3_array_write_access * go_godot_pool_vector3_array_write(godot_gdnative_core_api_struct * p_api, godot_pool_vector3_array * p_self) {
	return p_api->godot_pool_vector3_array_write(p_self);
}

void go_godot_pool_vector3_array_set(godot_gdnative_core_api_struct * p_api, godot_pool_vector3_array * p_self, const godot_int p_idx, const godot_vector3 * p_data) {
	p_api->godot_pool_vector3_array_set(p_self, p_idx, p_data);
}

godot_vector3 go_godot_pool_vector3_array_get(godot_gdnative_core_api_struct * p_api, const godot_pool_vector3_array * p_self, const godot_int p_idx) {
	return p_api->godot_pool_vector3_array_get(p_self, p_idx);
}

godot_int go_godot_pool_vector3_array_size(godot_gdnative_core_api_struct * p_api, const godot_pool_vector3_array * p_self) {
	return p_api->godot_pool_vector3_array_size(p_self);
}

void go_godot_pool_vector3_array_destroy(godot_gdnative_core_api_struct * p_api, godot_pool_vector3_array * p_self) {
	p_api->godot_pool_vector3_array_destroy(p_self);
}

void go_godot_pool_color_array_new(godot_gdnative_core_api_struct * p_api, godot_pool_color_array * r_dest) {
	p_api->godot_pool_color_array_new(r_dest);
}

void go_godot_pool_color_array_new_copy(godot_gdnative_core_api_struct * p_api, godot_pool_color_array * r_dest, const godot_pool_color_array * p_src) {
	p_api->godot_pool_color_array_new_copy(r_dest, p_src);
}

void go_godot_pool_color_array_new_with_array(godot_gdnative_core_api_struct * p_api, godot_pool_color_array * r_dest, const godot_array * p_a) {
	p_api->godot_pool_color_array_new_with_array(r_dest, p_a);
}

void go_godot_pool_color_array_append(godot_gdnative_core_api_struct * p_api, godot_pool_color_array * p_self, const godot_color * p_data) {
	p_api->godot_pool_color_array_append(p_self, p_data);
}

void go_godot_pool_color_array_append_array(godot_gdnative_core_api_struct * p_api, godot_pool_color_array * p_self, const godot_pool_color_array * p_array) {
	p_api->godot_pool_color_array_append_array(p_self, p_array);
}

godot_error go_godot_pool_color_array_insert(godot_gdnative_core_api_struct * p_api, godot_pool_color_array * p_self, const godot_int p_idx, const godot_color * p_data) {
	return p_api->godot_pool_color_array_insert(p_self, p_idx, p_data);
}

void go_godot_pool_color_array_invert(godot_gdnative_core_api_struct * p_api, godot_pool_color_array * p_self) {
	p_api->godot_pool_color_array_invert(p_self);
}

void go_godot_pool_color_array_push_back(godot_gdnative_core_api_struct * p_api, godot_pool_color_array * p_self, const godot_color * p_data) {
	p_api->godot_pool_color_array_push_back(p_self, p_data);
}

void go_godot_pool_color_array_remove(godot_gdnative_core_api_struct * p_api, godot_pool_color_array * p_self, const godot_int p_idx) {
	p_api->godot_pool_color_array_remove(p_self, p_idx);
}

void go_godot_pool_color_array_resize(godot_gdnative_core_api_struct * p_api, godot_pool_color_array * p_self, const godot_int p_size) {
	p_api->godot_pool_color_array_resize(p_self, p_size);
}

godot_pool_color_array_read_access * go_godot_pool_color_array_read(godot_gdnative_core_api_struct * p_api, const godot_pool_color_array * p_self) {
	return p_api->godot_pool_color_array_read(p_self);
}

godot_pool_color_array_write_access * go_godot_pool_color_array_write(godot_gdnative_core_api_struct * p_api, godot_pool_color_array * p_self) {
	return p_api->godot_pool_color_array_write(p_self);
}

void go_godot_pool_color_array_set(godot_gdnative_core_api_struct * p_api, godot_pool_color_array * p_self, const godot_int p_idx, const godot_color * p_data) {
	p_api->godot_pool_color_array_set(p_self, p_idx, p_data);
}

godot_color go_godot_pool_color_array_get(godot_gdnative_core_api_struct * p_api, const godot_pool_color_array * p_self, const godot_int p_idx) {
	return p_api->godot_pool_color_array_get(p_self, p_idx);
}

godot_int go_godot_pool_color_array_size(godot_gdnative_core_api_struct * p_api, const godot_pool_color_array * p_self) {
	return p_api->godot_pool_color_array_size(p_self);
}

void go_godot_pool_color_array_destroy(godot_gdnative_core_api_struct * p_api, godot_pool_color_array * p_self) {
	p_api->godot_pool_color_array_destroy(p_self);
}

godot_pool_byte_array_read_access * go_godot_pool_byte_array_read_access_copy(godot_gdnative_core_api_struct * p_api, const godot_pool_byte_array_read_access * p_read) {
	return p_api->godot_pool_byte_array_read_access_copy(p_read);
}

const uint8_t * go_godot_pool_byte_array_read_access_ptr(godot_gdnative_core_api_struct * p_api, const godot_pool_byte_array_read_access * p_read) {
	return p_api->godot_pool_byte_array_read_access_ptr(p_read);
}

void go_godot_pool_byte_array_read_access_operator_assign(godot_gdnative_core_api_struct * p_api, godot_pool_byte_array_read_access * p_read, godot_pool_byte_array_read_access * p_other) {
	p_api->godot_pool_byte_array_read_access_operator_assign(p_read, p_other);
}

void go_godot_pool_byte_array_read_access_destroy(godot_gdnative_core_api_struct * p_api, godot_pool_byte_array_read_access * p_read) {
	p_api->godot_pool_byte_array_read_access_destroy(p_read);
}

godot_pool_int_array_read_access * go_godot_pool_int_array_read_access_copy(godot_gdnative_core_api_struct * p_api, const godot_pool_int_array_read_access * p_read) {
	return p_api->godot_pool_int_array_read_access_copy(p_read);
}

const godot_int * go_godot_pool_int_array_read_access_ptr(godot_gdnative_core_api_struct * p_api, const godot_pool_int_array_read_access * p_read) {
	return p_api->godot_pool_int_array_read_access_ptr(p_read);
}

void go_godot_pool_int_array_read_access_operator_assign(godot_gdnative_core_api_struct * p_api, godot_pool_int_array_read_access * p_read, godot_pool_int_array_read_access * p_other) {
	p_api->godot_pool_int_array_read_access_operator_assign(p_read, p_other);
}

void go_godot_pool_int_array_read_access_destroy(godot_gdnative_core_api_struct * p_api, godot_pool_int_array_read_access * p_read) {
	p_api->godot_pool_int_array_read_access_destroy(p_read);
}

godot_pool_real_array_read_access * go_godot_pool_real_array_read_access_copy(godot_gdnative_core_api_struct * p_api, const godot_pool_real_array_read_access * p_read) {
	return p_api->godot_pool_real_array_read_access_copy(p_read);
}

const godot_real * go_godot_pool_real_array_read_access_ptr(godot_gdnative_core_api_struct * p_api, const godot_pool_real_array_read_access * p_read) {
	return p_api->godot_pool_real_array_read_access_ptr(p_read);
}

void go_godot_pool_real_array_read_access_operator_assign(godot_gdnative_core_api_struct * p_api, godot_pool_real_array_read_access * p_read, godot_pool_real_array_read_access * p_other) {
	p_api->godot_pool_real_array_read_access_operator_assign(p_read, p_other);
}

void go_godot_pool_real_array_read_access_destroy(godot_gdnative_core_api_struct * p_api, godot_pool_real_array_read_access * p_read) {
	p_api->godot_pool_real_array_read_access_destroy(p_read);
}

godot_pool_string_array_read_access * go_godot_pool_string_array_read_access_copy(godot_gdnative_core_api_struct * p_api, const godot_pool_string_array_read_access * p_read) {
	return p_api->godot_pool_string_array_read_access_copy(p_read);
}

const godot_string * go_godot_pool_string_array_read_access_ptr(godot_gdnative_core_api_struct * p_api, const godot_pool_string_array_read_access * p_read) {
	return p_api->godot_pool_string_array_read_access_ptr(p_read);
}

void go_godot_pool_string_array_read_access_operator_assign(godot_gdnative_core_api_struct * p_api, godot_pool_string_array_read_access * p_read, godot_pool_string_array_read_access * p_other) {
	p_api->godot_pool_string_array_read_access_operator_assign(p_read, p_other);
}

void go_godot_pool_string_array_read_access_destroy(godot_gdnative_core_api_struct * p_api, godot_pool_string_array_read_access * p_read) {
	p_api->godot_pool_string_array_read_access_destroy(p_read);
}

godot_pool_vector2_array_read_access * go_godot_pool_vector2_array_read_access_copy(godot_gdnative_core_api_struct * p_api, const godot_pool_vector2_array_read_access * p_read) {
	return p_api->godot_pool_vector2_array_read_access_copy(p_read);
}

const godot_vector2 * go_godot_pool_vector2_array_read_access_ptr(godot_gdnative_core_api_struct * p_api, const godot_pool_vector2_array_read_access * p_read) {
	return p_api->godot_pool_vector2_array_read_access_ptr(p_read);
}

void go_godot_pool_vector2_array_read_access_operator_assign(godot_gdnative_core_api_struct * p_api, godot_pool_vector2_array_read_access * p_read, godot_pool_vector2_array_read_access * p_other) {
	p_api->godot_pool_vector2_array_read_access_operator_assign(p_read, p_other);
}

void go_godot_pool_vector2_array_read_access_destroy(godot_gdnative_core_api_struct * p_api, godot_pool_vector2_array_read_access * p_read) {
	p_api->godot_pool_vector2_array_read_access_destroy(p_read);
}

godot_pool_vector3_array_read_access * go_godot_pool_vector3_array_read_access_copy(godot_gdnative_core_api_struct * p_api, const godot_pool_vector3_array_read_access * p_read) {
	return p_api->godot_pool_vector3_array_read_access_copy(p_read);
}

const godot_vector3 * go_godot_pool_vector3_array_read_access_ptr(godot_gdnative_core_api_struct * p_api, const godot_pool_vector3_array_read_access * p_read) {
	return p_api->godot_pool_vector3_array_read_access_ptr(p_read);
}

void go_godot_pool_vector3_array_read_access_operator_assign(godot_gdnative_core_api_struct * p_api, godot_pool_vector3_array_read_access * p_read, godot_pool_vector3_array_read_access * p_other) {
	p_api->godot_pool_vector3_array_read_access_operator_assign(p_read, p_other);
}

void go_godot_pool_vector3_array_read_access_destroy(godot_gdnative_core_api_struct * p_api, godot_pool_vector3_array_read_access * p_read) {
	p_api->godot_pool_vector3_array_read_access_destroy(p_read);
}

godot_pool_color_array_read_access * go_godot_pool_color_array_read_access_copy(godot_gdnative_core_api_struct * p_api, const godot_pool_color_array_read_access * p_read) {
	return p_api->godot_pool_color_array_read_access_copy(p_read);
}

const godot_color * go_godot_pool_color_array_read_access_ptr(godot_gdnative_core_api_struct * p_api, const godot_pool_color_array_read_access * p_read) {
	return p_api->godot_pool_color_array_read_access_ptr(p_read);
}

void go_godot_pool_color_array_read_access_operator_assign(godot_gdnative_core_api_struct * p_api, godot_pool_color_array_read_access * p_read, godot_pool_color_array_read_access * p_other) {
	p_api->godot_pool_color_array_read_access_operator_assign(p_read, p_other);
}

void go_godot_pool_color_array_read_access_destroy(godot_gdnative_core_api_struct * p_api, godot_pool_color_array_read_access * p_read) {
	p_api->godot_pool_color_array_read_access_destroy(p_read);
}

godot_pool_byte_array_write_access * go_godot_pool_byte_array_write_access_copy(godot_gdnative_core_api_struct * p_api, const godot_pool_byte_array_write_access * p_write) {
	return p_api->godot_pool_byte_array_write_access_copy(p_write);
}

uint8_t * go_godot_pool_byte_array_write_access_ptr(godot_gdnative_core_api_struct * p_api, const godot_pool_byte_array_write_access * p_write) {
	return p_api->godot_pool_byte_array_write_access_ptr(p_write);
}

void go_godot_pool_byte_array_write_access_operator_assign(godot_gdnative_core_api_struct * p_api, godot_pool_byte_array_write_access * p_write, godot_pool_byte_array_write_access * p_other) {
	p_api->godot_pool_byte_array_write_access_operator_assign(p_write, p_other);
}

void go_godot_pool_byte_array_write_access_destroy(godot_gdnative_core_api_struct * p_api, godot_pool_byte_array_write_access * p_write) {
	p_api->godot_pool_byte_array_write_access_destroy(p_write);
}

godot_pool_int_array_write_access * go_godot_pool_int_array_write_access_copy(godot_gdnative_core_api_struct * p_api, const godot_pool_int_array_write_access * p_write) {
	return p_api->godot_pool_int_array_write_access_copy(p_write);
}

godot_int * go_godot_pool_int_array_write_access_ptr(godot_gdnative_core_api_struct * p_api, const godot_pool_int_array_write_access * p_write) {
	return p_api->godot_pool_int_array_write_access_ptr(p_write);
}

void go_godot_pool_int_array_write_access_operator_assign(godot_gdnative_core_api_struct * p_api, godot_pool_int_array_write_access * p_write, godot_pool_int_array_write_access * p_other) {
	p_api->godot_pool_int_array_write_access_operator_assign(p_write, p_other);
}

void go_godot_pool_int_array_write_access_destroy(godot_gdnative_core_api_struct * p_api, godot_pool_int_array_write_access * p_write) {
	p_api->godot_pool_int_array_write_access_destroy(p_write);
}

godot_pool_real_array_write_access * go_godot_pool_real_array_write_access_copy(godot_gdnative_core_api_struct * p_api, const godot_pool_real_array_write_access * p_write) {
	return p_api->godot_pool_real_array_write_access_copy(p_write);
}

godot_real * go_godot_pool_real_array_write_access_ptr(godot_gdnative_core_api_struct * p_api, const godot_pool_real_array_write_access * p_write) {
	return p_api->godot_pool_real_array_write_access_ptr(p_write);
}

void go_godot_pool_real_array_write_access_operator_assign(godot_gdnative_core_api_struct * p_api, godot_pool_real_array_write_access * p_write, godot_pool_real_array_write_access * p_other) {
	p_api->godot_pool_real_array_write_access_operator_assign(p_write, p_other);
}

void go_godot_pool_real_array_write_access_destroy(godot_gdnative_core_api_struct * p_api, godot_pool_real_array_write_access * p_write) {
	p_api->godot_pool_real_array_write_access_destroy(p_write);
}

godot_pool_string_array_write_access * go_godot_pool_string_array_write_access_copy(godot_gdnative_core_api_struct * p_api, const godot_pool_string_array_write_access * p_write) {
	return p_api->godot_pool_string_array_write_access_copy(p_write);
}

godot_string * go_godot_pool_string_array_write_access_ptr(godot_gdnative_core_api_struct * p_api, const godot_pool_string_array_write_access * p_write) {
	return p_api->godot_pool_string_array_write_access_ptr(p_write);
}

void go_godot_pool_string_array_write_access_operator_assign(godot_gdnative_core_api_struct * p_api, godot_pool_string_array_write_access * p_write, godot_pool_string_array_write_access * p_other) {
	p_api->godot_pool_string_array_write_access_operator_assign(p_write, p_other);
}

void go_godot_pool_string_array_write_access_destroy(godot_gdnative_core_api_struct * p_api, godot_pool_string_array_write_access * p_write) {
	p_api->godot_pool_string_array_write_access_destroy(p_write);
}

godot_pool_vector2_array_write_access * go_godot_pool_vector2_array_write_access_copy(godot_gdnative_core_api_struct * p_api, const godot_pool_vector2_array_write_access * p_write) {
	return p_api->godot_pool_vector2_array_write_access_copy(p_write);
}

godot_vector2 * go_godot_pool_vector2_array_write_access_ptr(godot_gdnative_core_api_struct * p_api, const godot_pool_vector2_array_write_access * p_write) {
	return p_api->godot_pool_vector2_array_write_access_ptr(p_write);
}

void go_godot_pool_vector2_array_write_access_operator_assign(godot_gdnative_core_api_struct * p_api, godot_pool_vector2_array_write_access * p_write, godot_pool_vector2_array_write_access * p_other) {
	p_api->godot_pool_vector2_array_write_access_operator_assign(p_write, p_other);
}

void go_godot_pool_vector2_array_write_access_destroy(godot_gdnative_core_api_struct * p_api, godot_pool_vector2_array_write_access * p_write) {
	p_api->godot_pool_vector2_array_write_access_destroy(p_write);
}

godot_pool_vector3_array_write_access * go_godot_pool_vector3_array_write_access_copy(godot_gdnative_core_api_struct * p_api, const godot_pool_vector3_array_write_access * p_write) {
	return p_api->godot_pool_vector3_array_write_access_copy(p_write);
}

godot_vector3 * go_godot_pool_vector3_array_write_access_ptr(godot_gdnative_core_api_struct * p_api, const godot_pool_vector3_array_write_access * p_write) {
	return p_api->godot_pool_vector3_array_write_access_ptr(p_write);
}

void go_godot_pool_vector3_array_write_access_operator_assign(godot_gdnative_core_api_struct * p_api, godot_pool_vector3_array_write_access * p_write, godot_pool_vector3_array_write_access * p_other) {
	p_api->godot_pool_vector3_array_write_access_operator_assign(p_write, p_other);
}

void go_godot_pool_vector3_array_write_access_destroy(godot_gdnative_core_api_struct * p_api, godot_pool_vector3_array_write_access * p_write) {
	p_api->godot_pool_vector3_array_write_access_destroy(p_write);
}

godot_pool_color_array_write_access * go_godot_pool_color_array_write_access_copy(godot_gdnative_core_api_struct * p_api, const godot_pool_color_array_write_access * p_write) {
	return p_api->godot_pool_color_array_write_access_copy(p_write);
}

godot_color * go_godot_pool_color_array_write_access_ptr(godot_gdnative_core_api_struct * p_api, const godot_pool_color_array_write_access * p_write) {
	return p_api->godot_pool_color_array_write_access_ptr(p_write);
}

void go_godot_pool_color_array_write_access_operator_assign(godot_gdnative_core_api_struct * p_api, godot_pool_color_array_write_access * p_write, godot_pool_color_array_write_access * p_other) {
	p_api->godot_pool_color_array_write_access_operator_assign(p_write, p_other);
}

void go_godot_pool_color_array_write_access_destroy(godot_gdnative_core_api_struct * p_api, godot_pool_color_array_write_access * p_write) {
	p_api->godot_pool_color_array_write_access_destroy(p_write);
}

void go_godot_array_new(godot_gdnative_core_api_struct * p_api, godot_array * r_dest) {
	p_api->godot_array_new(r_dest);
}

void go_godot_array_new_copy(godot_gdnative_core_api_struct * p_api, godot_array * r_dest, const godot_array * p_src) {
	p_api->godot_array_new_copy(r_dest, p_src);
}

void go_godot_array_new_pool_color_array(godot_gdnative_core_api_struct * p_api, godot_array * r_dest, const godot_pool_color_array * p_pca) {
	p_api->godot_array_new_pool_color_array(r_dest, p_pca);
}

void go_godot_array_new_pool_vector3_array(godot_gdnative_core_api_struct * p_api, godot_array * r_dest, const godot_pool_vector3_array * p_pv3a) {
	p_api->godot_array_new_pool_vector3_array(r_dest, p_pv3a);
}

void go_godot_array_new_pool_vector2_array(godot_gdnative_core_api_struct * p_api, godot_array * r_dest, const godot_pool_vector2_array * p_pv2a) {
	p_api->godot_array_new_pool_vector2_array(r_dest, p_pv2a);
}

void go_godot_array_new_pool_string_array(godot_gdnative_core_api_struct * p_api, godot_array * r_dest, const godot_pool_string_array * p_psa) {
	p_api->godot_array_new_pool_string_array(r_dest, p_psa);
}

void go_godot_array_new_pool_real_array(godot_gdnative_core_api_struct * p_api, godot_array * r_dest, const godot_pool_real_array * p_pra) {
	p_api->godot_array_new_pool_real_array(r_dest, p_pra);
}

void go_godot_array_new_pool_int_array(godot_gdnative_core_api_struct * p_api, godot_array * r_dest, const godot_pool_int_array * p_pia) {
	p_api->godot_array_new_pool_int_array(r_dest, p_pia);
}

void go_godot_array_new_pool_byte_array(godot_gdnative_core_api_struct * p_api, godot_array * r_dest, const godot_pool_byte_array * p_pba) {
	p_api->godot_array_new_pool_byte_array(r_dest, p_pba);
}

void go_godot_array_set(godot_gdnative_core_api_struct * p_api, godot_array * p_self, const godot_int p_idx, const godot_variant * p_value) {
	p_api->godot_array_set(p_self, p_idx, p_value);
}

godot_variant go_godot_array_get(godot_gdnative_core_api_struct * p_api, const godot_array * p_self, const godot_int p_idx) {
	return p_api->godot_array_get(p_self, p_idx);
}

godot_variant * go_godot_array_operator_index(godot_gdnative_core_api_struct * p_api, godot_array * p_self, const godot_int p_idx) {
	return p_api->godot_array_operator_index(p_self, p_idx);
}

const godot_variant * go_godot_array_operator_index_const(godot_gdnative_core_api_struct * p_api, const godot_array * p_self, const godot_int p_idx) {
	return p_api->godot_array_operator_index_const(p_self, p_idx);
}

void go_godot_array_append(godot_gdnative_core_api_struct * p_api, godot_array * p_self, const godot_variant * p_value) {
	p_api->godot_array_append(p_self, p_value);
}

void go_godot_array_clear(godot_gdnative_core_api_struct * p_api, godot_array * p_self) {
	p_api->godot_array_clear(p_self);
}

godot_int go_godot_array_count(godot_gdnative_core_api_struct * p_api, const godot_array * p_self, const godot_variant * p_value) {
	return p_api->godot_array_count(p_self, p_value);
}

godot_bool go_godot_array_empty(godot_gdnative_core_api_struct * p_api, const godot_array * p_self) {
	return p_api->godot_array_empty(p_self);
}

void go_godot_array_erase(godot_gdnative_core_api_struct * p_api, godot_array * p_self, const godot_variant * p_value) {
	p_api->godot_array_erase(p_self, p_value);
}

godot_variant go_godot_array_front(godot_gdnative_core_api_struct * p_api, const godot_array * p_self) {
	return p_api->godot_array_front(p_self);
}

godot_variant go_godot_array_back(godot_gdnative_core_api_struct * p_api, const godot_array * p_self) {
	return p_api->godot_array_back(p_self);
}

godot_int go_godot_array_find(godot_gdnative_core_api_struct * p_api, const godot_array * p_self, const godot_variant * p_what, const godot_int p_from) {
	return p_api->godot_array_find(p_self, p_what, p_from);
}

godot_int go_godot_array_find_last(godot_gdnative_core_api_struct * p_api, const godot_array * p_self, const godot_variant * p_what) {
	return p_api->godot_array_find_last(p_self, p_what);
}

godot_bool go_godot_array_has(godot_gdnative_core_api_struct * p_api, const godot_array * p_self, const godot_variant * p_value) {
	return p_api->godot_array_has(p_self, p_value);
}

godot_int go_godot_array_hash(godot_gdnative_core_api_struct * p_api, const godot_array * p_self) {
	return p_api->godot_array_hash(p_self);
}

void go_godot_array_insert(godot_gdnative_core_api_struct * p_api, godot_array * p_self, const godot_int p_pos, const godot_variant * p_value) {
	p_api->godot_array_insert(p_self, p_pos, p_value);
}

void go_godot_array_invert(godot_gdnative_core_api_struct * p_api, godot_array * p_self) {
	p_api->godot_array_invert(p_self);
}

godot_variant go_godot_array_pop_back(godot_gdnative_core_api_struct * p_api, godot_array * p_self) {
	return p_api->godot_array_pop_back(p_self);
}

godot_variant go_godot_array_pop_front(godot_gdnative_core_api_struct * p_api, godot_array * p_self) {
	return p_api->godot_array_pop_front(p_self);
}

void go_godot_array_push_back(godot_gdnative_core_api_struct * p_api, godot_array * p_self, const godot_variant * p_value) {
	p_api->godot_array_push_back(p_self, p_value);
}

void go_godot_array_push_front(godot_gdnative_core_api_struct * p_api, godot_array * p_self, const godot_variant * p_value) {
	p_api->godot_array_push_front(p_self, p_value);
}

void go_godot_array_remove(godot_gdnative_core_api_struct * p_api, godot_array * p_self, const godot_int p_idx) {
	p_api->godot_array_remove(p_self, p_idx);
}

void go_godot_array_resize(godot_gdnative_core_api_struct * p_api, godot_array * p_self, const godot_int p_size) {
	p_api->godot_array_resize(p_self, p_size);
}

godot_int go_godot_array_rfind(godot_gdnative_core_api_struct * p_api, const godot_array * p_self, const godot_variant * p_what, const godot_int p_from) {
	return p_api->godot_array_rfind(p_self, p_what, p_from);
}

godot_int go_godot_array_size(godot_gdnative_core_api_struct * p_api, const godot_array * p_self) {
	return p_api->godot_array_size(p_self);
}

void go_godot_array_sort(godot_gdnative_core_api_struct * p_api, godot_array * p_self) {
	p_api->godot_array_sort(p_self);
}

void go_godot_array_sort_custom(godot_gdnative_core_api_struct * p_api, godot_array * p_self, godot_object * p_obj, const godot_string * p_func) {
	p_api->godot_array_sort_custom(p_self, p_obj, p_func);
}

godot_int go_godot_array_bsearch(godot_gdnative_core_api_struct * p_api, godot_array * p_self, const godot_variant * p_value, const godot_bool p_before) {
	return p_api->godot_array_bsearch(p_self, p_value, p_before);
}

godot_int go_godot_array_bsearch_custom(godot_gdnative_core_api_struct * p_api, godot_array * p_self, const godot_variant * p_value, godot_object * p_obj, const godot_string * p_func, const godot_bool p_before) {
	return p_api->godot_array_bsearch_custom(p_self, p_value, p_obj, p_func, p_before);
}

void go_godot_array_destroy(godot_gdnative_core_api_struct * p_api, godot_array * p_self) {
	p_api->godot_array_destroy(p_self);
}

void go_godot_dictionary_new(godot_gdnative_core_api_struct * p_api, godot_dictionary * r_dest) {
	p_api->godot_dictionary_new(r_dest);
}

void go_godot_dictionary_new_copy(godot_gdnative_core_api_struct * p_api, godot_dictionary * r_dest, const godot_dictionary * p_src) {
	p_api->godot_dictionary_new_copy(r_dest, p_src);
}

void go_godot_dictionary_destroy(godot_gdnative_core_api_struct * p_api, godot_dictionary * p_self) {
	p_api->godot_dictionary_destroy(p_self);
}

godot_int go_godot_dictionary_size(godot_gdnative_core_api_struct * p_api, const godot_dictionary * p_self) {
	return p_api->godot_dictionary_size(p_self);
}

godot_bool go_godot_dictionary_empty(godot_gdnative_core_api_struct * p_api, const godot_dictionary * p_self) {
	return p_api->godot_dictionary_empty(p_self);
}

void go_godot_dictionary_clear(godot_gdnative_core_api_struct * p_api, godot_dictionary * p_self) {
	p_api->godot_dictionary_clear(p_self);
}

godot_bool go_godot_dictionary_has(godot_gdnative_core_api_struct * p_api, const godot_dictionary * p_self, const godot_variant * p_key) {
	return p_api->godot_dictionary_has(p_self, p_key);
}

godot_bool go_godot_dictionary_has_all(godot_gdnative_core_api_struct * p_api, const godot_dictionary * p_self, const godot_array * p_keys) {
	return p_api->godot_dictionary_has_all(p_self, p_keys);
}

void go_godot_dictionary_erase(godot_gdnative_core_api_struct * p_api, godot_dictionary * p_self, const godot_variant * p_key) {
	p_api->godot_dictionary_erase(p_self, p_key);
}

godot_int go_godot_dictionary_hash(godot_gdnative_core_api_struct * p_api, const godot_dictionary * p_self) {
	return p_api->godot_dictionary_hash(p_self);
}

godot_array go_godot_dictionary_keys(godot_gdnative_core_api_struct * p_api, const godot_dictionary * p_self) {
	return p_api->godot_dictionary_keys(p_self);
}

godot_array go_godot_dictionary_values(godot_gdnative_core_api_struct * p_api, const godot_dictionary * p_self) {
	return p_api->godot_dictionary_values(p_self);
}

godot_variant go_godot_dictionary_get(godot_gdnative_core_api_struct * p_api, const godot_dictionary * p_self, const godot_variant * p_key) {
	return p_api->godot_dictionary_get(p_self, p_key);
}

void go_godot_dictionary_set(godot_gdnative_core_api_struct * p_api, godot_dictionary * p_self, const godot_variant * p_key, const godot_variant * p_value) {
	p_api->godot_dictionary_set(p_self, p_key, p_value);
}

godot_variant * go_godot_dictionary_operator_index(godot_gdnative_core_api_struct * p_api, godot_dictionary * p_self, const godot_variant * p_key) {
	return p_api->godot_dictionary_operator_index(p_self, p_key);
}

const godot_variant * go_godot_dictionary_operator_index_const(godot_gdnative_core_api_struct * p_api, const godot_dictionary * p_self, const godot_variant * p_key) {
	return p_api->godot_dictionary_operator_index_const(p_self, p_key);
}

godot_variant * go_godot_dictionary_next(godot_gdnative_core_api_struct * p_api, const godot_dictionary * p_self, const godot_variant * p_key) {
	return p_api->godot_dictionary_next(p_self, p_key);
}

godot_bool go_godot_dictionary_operator_equal(godot_gdnative_core_api_struct * p_api, const godot_dictionary * p_self, const godot_dictionary * p_b) {
	return p_api->godot_dictionary_operator_equal(p_self, p_b);
}

godot_string go_godot_dictionary_to_json(godot_gdnative_core_api_struct * p_api, const godot_dictionary * p_self) {
	return p_api->godot_dictionary_to_json(p_self);
}

void go_godot_node_path_new(godot_gdnative_core_api_struct * p_api, godot_node_path * r_dest, const godot_string * p_from) {
	p_api->godot_node_path_new(r_dest, p_from);
}

void go_godot_node_path_new_copy(godot_gdnative_core_api_struct * p_api, godot_node_path * r_dest, const godot_node_path * p_src) {
	p_api->godot_node_path_new_copy(r_dest, p_src);
}

void go_godot_node_path_destroy(godot_gdnative_core_api_struct * p_api, godot_node_path * p_self) {
	p_api->godot_node_path_destroy(p_self);
}

godot_string go_godot_node_path_as_string(godot_gdnative_core_api_struct * p_api, const godot_node_path * p_self) {
	return p_api->godot_node_path_as_string(p_self);
}

godot_bool go_godot_node_path_is_absolute(godot_gdnative_core_api_struct * p_api, const godot_node_path * p_self) {
	return p_api->godot_node_path_is_absolute(p_self);
}

godot_int go_godot_node_path_get_name_count(godot_gdnative_core_api_struct * p_api, const godot_node_path * p_self) {
	return p_api->godot_node_path_get_name_count(p_self);
}

godot_string go_godot_node_path_get_name(godot_gdnative_core_api_struct * p_api, const godot_node_path * p_self, const godot_int p_idx) {
	return p_api->godot_node_path_get_name(p_self, p_idx);
}

godot_int go_godot_node_path_get_subname_count(godot_gdnative_core_api_struct * p_api, const godot_node_path * p_self) {
	return p_api->godot_node_path_get_subname_count(p_self);
}

godot_string go_godot_node_path_get_subname(godot_gdnative_core_api_struct * p_api, const godot_node_path * p_self, const godot_int p_idx) {
	return p_api->godot_node_path_get_subname(p_self, p_idx);
}

godot_string go_godot_node_path_get_concatenated_subnames(godot_gdnative_core_api_struct * p_api, const godot_node_path * p_self) {
	return p_api->godot_node_path_get_concatenated_subnames(p_self);
}

godot_bool go_godot_node_path_is_empty(godot_gdnative_core_api_struct * p_api, const godot_node_path * p_self) {
	return p_api->godot_node_path_is_empty(p_self);
}

godot_bool go_godot_node_path_operator_equal(godot_gdnative_core_api_struct * p_api, const godot_node_path * p_self, const godot_node_path * p_b) {
	return p_api->godot_node_path_operator_equal(p_self, p_b);
}

void go_godot_plane_new_with_reals(godot_gdnative_core_api_struct * p_api, godot_plane * r_dest, const godot_real p_a, const godot_real p_b, const godot_real p_c, const godot_real p_d) {
	p_api->godot_plane_new_with_reals(r_dest, p_a, p_b, p_c, p_d);
}

void go_godot_plane_new_with_vectors(godot_gdnative_core_api_struct * p_api, godot_plane * r_dest, const godot_vector3 * p_v1, const godot_vector3 * p_v2, const godot_vector3 * p_v3) {
	p_api->godot_plane_new_with_vectors(r_dest, p_v1, p_v2, p_v3);
}

void go_godot_plane_new_with_normal(godot_gdnative_core_api_struct * p_api, godot_plane * r_dest, const godot_vector3 * p_normal, const godot_real p_d) {
	p_api->godot_plane_new_with_normal(r_dest, p_normal, p_d);
}

godot_string go_godot_plane_as_string(godot_gdnative_core_api_struct * p_api, const godot_plane * p_self) {
	return p_api->godot_plane_as_string(p_self);
}

godot_plane go_godot_plane_normalized(godot_gdnative_core_api_struct * p_api, const godot_plane * p_self) {
	return p_api->godot_plane_normalized(p_self);
}

godot_vector3 go_godot_plane_center(godot_gdnative_core_api_struct * p_api, const godot_plane * p_self) {
	return p_api->godot_plane_center(p_self);
}

godot_vector3 go_godot_plane_get_any_point(godot_gdnative_core_api_struct * p_api, const godot_plane * p_self) {
	return p_api->godot_plane_get_any_point(p_self);
}

godot_bool go_godot_plane_is_point_over(godot_gdnative_core_api_struct * p_api, const godot_plane * p_self, const godot_vector3 * p_point) {
	return p_api->godot_plane_is_point_over(p_self, p_point);
}

godot_real go_godot_plane_distance_to(godot_gdnative_core_api_struct * p_api, const godot_plane * p_self, const godot_vector3 * p_point) {
	return p_api->godot_plane_distance_to(p_self, p_point);
}

godot_bool go_godot_plane_has_point(godot_gdnative_core_api_struct * p_api, const godot_plane * p_self, const godot_vector3 * p_point, const godot_real p_epsilon) {
	return p_api->godot_plane_has_point(p_self, p_point, p_epsilon);
}

godot_vector3 go_godot_plane_project(godot_gdnative_core_api_struct * p_api, const godot_plane * p_self, const godot_vector3 * p_point) {
	return p_api->godot_plane_project(p_self, p_point);
}

godot_bool go_godot_plane_intersect_3(godot_gdnative_core_api_struct * p_api, const godot_plane * p_self, godot_vector3 * r_dest, const godot_plane * p_b, const godot_plane * p_c) {
	return p_api->godot_plane_intersect_3(p_self, r_dest, p_b, p_c);
}

godot_bool go_godot_plane_intersects_ray(godot_gdnative_core_api_struct * p_api, const godot_plane * p_self, godot_vector3 * r_dest, const godot_vector3 * p_from, const godot_vector3 * p_dir) {
	return p_api->godot_plane_intersects_ray(p_self, r_dest, p_from, p_dir);
}

godot_bool go_godot_plane_intersects_segment(godot_gdnative_core_api_struct * p_api, const godot_plane * p_self, godot_vector3 * r_dest, const godot_vector3 * p_begin, const godot_vector3 * p_end) {
	return p_api->godot_plane_intersects_segment(p_self, r_dest, p_begin, p_end);
}

godot_plane go_godot_plane_operator_neg(godot_gdnative_core_api_struct * p_api, const godot_plane * p_self) {
	return p_api->godot_plane_operator_neg(p_self);
}

godot_bool go_godot_plane_operator_equal(godot_gdnative_core_api_struct * p_api, const godot_plane * p_self, const godot_plane * p_b) {
	return p_api->godot_plane_operator_equal(p_self, p_b);
}

void go_godot_plane_set_normal(godot_gdnative_core_api_struct * p_api, godot_plane * p_self, const godot_vector3 * p_normal) {
	p_api->godot_plane_set_normal(p_self, p_normal);
}

godot_vector3 go_godot_plane_get_normal(godot_gdnative_core_api_struct * p_api, const godot_plane * p_self) {
	return p_api->godot_plane_get_normal(p_self);
}

godot_real go_godot_plane_get_d(godot_gdnative_core_api_struct * p_api, const godot_plane * p_self) {
	return p_api->godot_plane_get_d(p_self);
}

void go_godot_plane_set_d(godot_gdnative_core_api_struct * p_api, godot_plane * p_self, const godot_real p_d) {
	p_api->godot_plane_set_d(p_self, p_d);
}

void go_godot_rect2_new_with_position_and_size(godot_gdnative_core_api_struct * p_api, godot_rect2 * r_dest, const godot_vector2 * p_pos, const godot_vector2 * p_size) {
	p_api->godot_rect2_new_with_position_and_size(r_dest, p_pos, p_size);
}

void go_godot_rect2_new(godot_gdnative_core_api_struct * p_api, godot_rect2 * r_dest, const godot_real p_x, const godot_real p_y, const godot_real p_width, const godot_real p_height) {
	p_api->godot_rect2_new(r_dest, p_x, p_y, p_width, p_height);
}

godot_string go_godot_rect2_as_string(godot_gdnative_core_api_struct * p_api, const godot_rect2 * p_self) {
	return p_api->godot_rect2_as_string(p_self);
}

godot_real go_godot_rect2_get_area(godot_gdnative_core_api_struct * p_api, const godot_rect2 * p_self) {
	return p_api->godot_rect2_get_area(p_self);
}

godot_bool go_godot_rect2_intersects(godot_gdnative_core_api_struct * p_api, const godot_rect2 * p_self, const godot_rect2 * p_b) {
	return p_api->godot_rect2_intersects(p_self, p_b);
}

godot_bool go_godot_rect2_encloses(godot_gdnative_core_api_struct * p_api, const godot_rect2 * p_self, const godot_rect2 * p_b) {
	return p_api->godot_rect2_encloses(p_self, p_b);
}

godot_bool go_godot_rect2_has_no_area(godot_gdnative_core_api_struct * p_api, const godot_rect2 * p_self) {
	return p_api->godot_rect2_has_no_area(p_self);
}

godot_rect2 go_godot_rect2_clip(godot_gdnative_core_api_struct * p_api, const godot_rect2 * p_self, const godot_rect2 * p_b) {
	return p_api->godot_rect2_clip(p_self, p_b);
}

godot_rect2 go_godot_rect2_merge(godot_gdnative_core_api_struct * p_api, const godot_rect2 * p_self, const godot_rect2 * p_b) {
	return p_api->godot_rect2_merge(p_self, p_b);
}

godot_bool go_godot_rect2_has_point(godot_gdnative_core_api_struct * p_api, const godot_rect2 * p_self, const godot_vector2 * p_point) {
	return p_api->godot_rect2_has_point(p_self, p_point);
}

godot_rect2 go_godot_rect2_grow(godot_gdnative_core_api_struct * p_api, const godot_rect2 * p_self, const godot_real p_by) {
	return p_api->godot_rect2_grow(p_self, p_by);
}

godot_rect2 go_godot_rect2_expand(godot_gdnative_core_api_struct * p_api, const godot_rect2 * p_self, const godot_vector2 * p_to) {
	return p_api->godot_rect2_expand(p_self, p_to);
}

godot_bool go_godot_rect2_operator_equal(godot_gdnative_core_api_struct * p_api, const godot_rect2 * p_self, const godot_rect2 * p_b) {
	return p_api->godot_rect2_operator_equal(p_self, p_b);
}

godot_vector2 go_godot_rect2_get_position(godot_gdnative_core_api_struct * p_api, const godot_rect2 * p_self) {
	return p_api->godot_rect2_get_position(p_self);
}

godot_vector2 go_godot_rect2_get_size(godot_gdnative_core_api_struct * p_api, const godot_rect2 * p_self) {
	return p_api->godot_rect2_get_size(p_self);
}

void go_godot_rect2_set_position(godot_gdnative_core_api_struct * p_api, godot_rect2 * p_self, const godot_vector2 * p_pos) {
	p_api->godot_rect2_set_position(p_self, p_pos);
}

void go_godot_rect2_set_size(godot_gdnative_core_api_struct * p_api, godot_rect2 * p_self, const godot_vector2 * p_size) {
	p_api->godot_rect2_set_size(p_self, p_size);
}

void go_godot_aabb_new(godot_gdnative_core_api_struct * p_api, godot_aabb * r_dest, const godot_vector3 * p_pos, const godot_vector3 * p_size) {
	p_api->godot_aabb_new(r_dest, p_pos, p_size);
}

godot_vector3 go_godot_aabb_get_position(godot_gdnative_core_api_struct * p_api, const godot_aabb * p_self) {
	return p_api->godot_aabb_get_position(p_self);
}

void go_godot_aabb_set_position(godot_gdnative_core_api_struct * p_api, const godot_aabb * p_self, const godot_vector3 * p_v) {
	p_api->godot_aabb_set_position(p_self, p_v);
}

godot_vector3 go_godot_aabb_get_size(godot_gdnative_core_api_struct * p_api, const godot_aabb * p_self) {
	return p_api->godot_aabb_get_size(p_self);
}

void go_godot_aabb_set_size(godot_gdnative_core_api_struct * p_api, const godot_aabb * p_self, const godot_vector3 * p_v) {
	p_api->godot_aabb_set_size(p_self, p_v);
}

godot_string go_godot_aabb_as_string(godot_gdnative_core_api_struct * p_api, const godot_aabb * p_self) {
	return p_api->godot_aabb_as_string(p_self);
}

godot_real go_godot_aabb_get_area(godot_gdnative_core_api_struct * p_api, const godot_aabb * p_self) {
	return p_api->godot_aabb_get_area(p_self);
}

godot_bool go_godot_aabb_has_no_area(godot_gdnative_core_api_struct * p_api, const godot_aabb * p_self) {
	return p_api->godot_aabb_has_no_area(p_self);
}

godot_bool go_godot_aabb_has_no_surface(godot_gdnative_core_api_struct * p_api, const godot_aabb * p_self) {
	return p_api->godot_aabb_has_no_surface(p_self);
}

godot_bool go_godot_aabb_intersects(godot_gdnative_core_api_struct * p_api, const godot_aabb * p_self, const godot_aabb * p_with) {
	return p_api->godot_aabb_intersects(p_self, p_with);
}

godot_bool go_godot_aabb_encloses(godot_gdnative_core_api_struct * p_api, const godot_aabb * p_self, const godot_aabb * p_with) {
	return p_api->godot_aabb_encloses(p_self, p_with);
}

godot_aabb go_godot_aabb_merge(godot_gdnative_core_api_struct * p_api, const godot_aabb * p_self, const godot_aabb * p_with) {
	return p_api->godot_aabb_merge(p_self, p_with);
}

godot_aabb go_godot_aabb_intersection(godot_gdnative_core_api_struct * p_api, const godot_aabb * p_self, const godot_aabb * p_with) {
	return p_api->godot_aabb_intersection(p_self, p_with);
}

godot_bool go_godot_aabb_intersects_plane(godot_gdnative_core_api_struct * p_api, const godot_aabb * p_self, const godot_plane * p_plane) {
	return p_api->godot_aabb_intersects_plane(p_self, p_plane);
}

godot_bool go_godot_aabb_intersects_segment(godot_gdnative_core_api_struct * p_api, const godot_aabb * p_self, const godot_vector3 * p_from, const godot_vector3 * p_to) {
	return p_api->godot_aabb_intersects_segment(p_self, p_from, p_to);
}

godot_bool go_godot_aabb_has_point(godot_gdnative_core_api_struct * p_api, const godot_aabb * p_self, const godot_vector3 * p_point) {
	return p_api->godot_aabb_has_point(p_self, p_point);
}

godot_vector3 go_godot_aabb_get_support(godot_gdnative_core_api_struct * p_api, const godot_aabb * p_self, const godot_vector3 * p_dir) {
	return p_api->godot_aabb_get_support(p_self, p_dir);
}

godot_vector3 go_godot_aabb_get_longest_axis(godot_gdnative_core_api_struct * p_api, const godot_aabb * p_self) {
	return p_api->godot_aabb_get_longest_axis(p_self);
}

godot_int go_godot_aabb_get_longest_axis_index(godot_gdnative_core_api_struct * p_api, const godot_aabb * p_self) {
	return p_api->godot_aabb_get_longest_axis_index(p_self);
}

godot_real go_godot_aabb_get_longest_axis_size(godot_gdnative_core_api_struct * p_api, const godot_aabb * p_self) {
	return p_api->godot_aabb_get_longest_axis_size(p_self);
}

godot_vector3 go_godot_aabb_get_shortest_axis(godot_gdnative_core_api_struct * p_api, const godot_aabb * p_self) {
	return p_api->godot_aabb_get_shortest_axis(p_self);
}

godot_int go_godot_aabb_get_shortest_axis_index(godot_gdnative_core_api_struct * p_api, const godot_aabb * p_self) {
	return p_api->godot_aabb_get_shortest_axis_index(p_self);
}

godot_real go_godot_aabb_get_shortest_axis_size(godot_gdnative_core_api_struct * p_api, const godot_aabb * p_self) {
	return p_api->godot_aabb_get_shortest_axis_size(p_self);
}

godot_aabb go_godot_aabb_expand(godot_gdnative_core_api_struct * p_api, const godot_aabb * p_self, const godot_vector3 * p_to_point) {
	return p_api->godot_aabb_expand(p_self, p_to_point);
}

godot_aabb go_godot_aabb_grow(godot_gdnative_core_api_struct * p_api, const godot_aabb * p_self, const godot_real p_by) {
	return p_api->godot_aabb_grow(p_self, p_by);
}

godot_vector3 go_godot_aabb_get_endpoint(godot_gdnative_core_api_struct * p_api, const godot_aabb * p_self, const godot_int p_idx) {
	return p_api->godot_aabb_get_endpoint(p_self, p_idx);
}

godot_bool go_godot_aabb_operator_equal(godot_gdnative_core_api_struct * p_api, const godot_aabb * p_self, const godot_aabb * p_b) {
	return p_api->godot_aabb_operator_equal(p_self, p_b);
}

void go_godot_rid_new(godot_gdnative_core_api_struct * p_api, godot_rid * r_dest) {
	p_api->godot_rid_new(r_dest);
}

godot_int go_godot_rid_get_id(godot_gdnative_core_api_struct * p_api, const godot_rid * p_self) {
	return p_api->godot_rid_get_id(p_self);
}

void go_godot_rid_new_with_resource(godot_gdnative_core_api_struct * p_api, godot_rid * r_dest, const godot_object * p_from) {
	p_api->godot_rid_new_with_resource(r_dest, p_from);
}

godot_bool go_godot_rid_operator_equal(godot_gdnative_core_api_struct * p_api, const godot_rid * p_self, const godot_rid * p_b) {
	return p_api->godot_rid_operator_equal(p_self, p_b);
}

godot_bool go_godot_rid_operator_less(godot_gdnative_core_api_struct * p_api, const godot_rid * p_self, const godot_rid * p_b) {
	return p_api->godot_rid_operator_less(p_self, p_b);
}

void go_godot_transform_new_with_axis_origin(godot_gdnative_core_api_struct * p_api, godot_transform * r_dest, const godot_vector3 * p_x_axis, const godot_vector3 * p_y_axis, const godot_vector3 * p_z_axis, const godot_vector3 * p_origin) {
	p_api->godot_transform_new_with_axis_origin(r_dest, p_x_axis, p_y_axis, p_z_axis, p_origin);
}

void go_godot_transform_new(godot_gdnative_core_api_struct * p_api, godot_transform * r_dest, const godot_basis * p_basis, const godot_vector3 * p_origin) {
	p_api->godot_transform_new(r_dest, p_basis, p_origin);
}

godot_basis go_godot_transform_get_basis(godot_gdnative_core_api_struct * p_api, const godot_transform * p_self) {
	return p_api->godot_transform_get_basis(p_self);
}

void go_godot_transform_set_basis(godot_gdnative_core_api_struct * p_api, godot_transform * p_self, const godot_basis * p_v) {
	p_api->godot_transform_set_basis(p_self, p_v);
}

godot_vector3 go_godot_transform_get_origin(godot_gdnative_core_api_struct * p_api, const godot_transform * p_self) {
	return p_api->godot_transform_get_origin(p_self);
}

void go_godot_transform_set_origin(godot_gdnative_core_api_struct * p_api, godot_transform * p_self, const godot_vector3 * p_v) {
	p_api->godot_transform_set_origin(p_self, p_v);
}

godot_string go_godot_transform_as_string(godot_gdnative_core_api_struct * p_api, const godot_transform * p_self) {
	return p_api->godot_transform_as_string(p_self);
}

godot_transform go_godot_transform_inverse(godot_gdnative_core_api_struct * p_api, const godot_transform * p_self) {
	return p_api->godot_transform_inverse(p_self);
}

godot_transform go_godot_transform_affine_inverse(godot_gdnative_core_api_struct * p_api, const godot_transform * p_self) {
	return p_api->godot_transform_affine_inverse(p_self);
}

godot_transform go_godot_transform_orthonormalized(godot_gdnative_core_api_struct * p_api, const godot_transform * p_self) {
	return p_api->godot_transform_orthonormalized(p_self);
}

godot_transform go_godot_transform_rotated(godot_gdnative_core_api_struct * p_api, const godot_transform * p_self, const godot_vector3 * p_axis, const godot_real p_phi) {
	return p_api->godot_transform_rotated(p_self, p_axis, p_phi);
}

godot_transform go_godot_transform_scaled(godot_gdnative_core_api_struct * p_api, const godot_transform * p_self, const godot_vector3 * p_scale) {
	return p_api->godot_transform_scaled(p_self, p_scale);
}

godot_transform go_godot_transform_translated(godot_gdnative_core_api_struct * p_api, const godot_transform * p_self, const godot_vector3 * p_ofs) {
	return p_api->godot_transform_translated(p_self, p_ofs);
}

godot_transform go_godot_transform_looking_at(godot_gdnative_core_api_struct * p_api, const godot_transform * p_self, const godot_vector3 * p_target, const godot_vector3 * p_up) {
	return p_api->godot_transform_looking_at(p_self, p_target, p_up);
}

godot_plane go_godot_transform_xform_plane(godot_gdnative_core_api_struct * p_api, const godot_transform * p_self, const godot_plane * p_v) {
	return p_api->godot_transform_xform_plane(p_self, p_v);
}

godot_plane go_godot_transform_xform_inv_plane(godot_gdnative_core_api_struct * p_api, const godot_transform * p_self, const godot_plane * p_v) {
	return p_api->godot_transform_xform_inv_plane(p_self, p_v);
}

void go_godot_transform_new_identity(godot_gdnative_core_api_struct * p_api, godot_transform * r_dest) {
	p_api->godot_transform_new_identity(r_dest);
}

godot_bool go_godot_transform_operator_equal(godot_gdnative_core_api_struct * p_api, const godot_transform * p_self, const godot_transform * p_b) {
	return p_api->godot_transform_operator_equal(p_self, p_b);
}

godot_transform go_godot_transform_operator_multiply(godot_gdnative_core_api_struct * p_api, const godot_transform * p_self, const godot_transform * p_b) {
	return p_api->godot_transform_operator_multiply(p_self, p_b);
}

godot_vector3 go_godot_transform_xform_vector3(godot_gdnative_core_api_struct * p_api, const godot_transform * p_self, const godot_vector3 * p_v) {
	return p_api->godot_transform_xform_vector3(p_self, p_v);
}

godot_vector3 go_godot_transform_xform_inv_vector3(godot_gdnative_core_api_struct * p_api, const godot_transform * p_self, const godot_vector3 * p_v) {
	return p_api->godot_transform_xform_inv_vector3(p_self, p_v);
}

godot_aabb go_godot_transform_xform_aabb(godot_gdnative_core_api_struct * p_api, const godot_transform * p_self, const godot_aabb * p_v) {
	return p_api->godot_transform_xform_aabb(p_self, p_v);
}

godot_aabb go_godot_transform_xform_inv_aabb(godot_gdnative_core_api_struct * p_api, const godot_transform * p_self, const godot_aabb * p_v) {
	return p_api->godot_transform_xform_inv_aabb(p_self, p_v);
}

void go_godot_transform2d_new(godot_gdnative_core_api_struct * p_api, godot_transform2d * r_dest, const godot_real p_rot, const godot_vector2 * p_pos) {
	p_api->godot_transform2d_new(r_dest, p_rot, p_pos);
}

void go_godot_transform2d_new_axis_origin(godot_gdnative_core_api_struct * p_api, godot_transform2d * r_dest, const godot_vector2 * p_x_axis, const godot_vector2 * p_y_axis, const godot_vector2 * p_origin) {
	p_api->godot_transform2d_new_axis_origin(r_dest, p_x_axis, p_y_axis, p_origin);
}

godot_string go_godot_transform2d_as_string(godot_gdnative_core_api_struct * p_api, const godot_transform2d * p_self) {
	return p_api->godot_transform2d_as_string(p_self);
}

godot_transform2d go_godot_transform2d_inverse(godot_gdnative_core_api_struct * p_api, const godot_transform2d * p_self) {
	return p_api->godot_transform2d_inverse(p_self);
}

godot_transform2d go_godot_transform2d_affine_inverse(godot_gdnative_core_api_struct * p_api, const godot_transform2d * p_self) {
	return p_api->godot_transform2d_affine_inverse(p_self);
}

godot_real go_godot_transform2d_get_rotation(godot_gdnative_core_api_struct * p_api, const godot_transform2d * p_self) {
	return p_api->godot_transform2d_get_rotation(p_self);
}

godot_vector2 go_godot_transform2d_get_origin(godot_gdnative_core_api_struct * p_api, const godot_transform2d * p_self) {
	return p_api->godot_transform2d_get_origin(p_self);
}

godot_vector2 go_godot_transform2d_get_scale(godot_gdnative_core_api_struct * p_api, const godot_transform2d * p_self) {
	return p_api->godot_transform2d_get_scale(p_self);
}

godot_transform2d go_godot_transform2d_orthonormalized(godot_gdnative_core_api_struct * p_api, const godot_transform2d * p_self) {
	return p_api->godot_transform2d_orthonormalized(p_self);
}

godot_transform2d go_godot_transform2d_rotated(godot_gdnative_core_api_struct * p_api, const godot_transform2d * p_self, const godot_real p_phi) {
	return p_api->godot_transform2d_rotated(p_self, p_phi);
}

godot_transform2d go_godot_transform2d_scaled(godot_gdnative_core_api_struct * p_api, const godot_transform2d * p_self, const godot_vector2 * p_scale) {
	return p_api->godot_transform2d_scaled(p_self, p_scale);
}

godot_transform2d go_godot_transform2d_translated(godot_gdnative_core_api_struct * p_api, const godot_transform2d * p_self, const godot_vector2 * p_offset) {
	return p_api->godot_transform2d_translated(p_self, p_offset);
}

godot_vector2 go_godot_transform2d_xform_vector2(godot_gdnative_core_api_struct * p_api, const godot_transform2d * p_self, const godot_vector2 * p_v) {
	return p_api->godot_transform2d_xform_vector2(p_self, p_v);
}

godot_vector2 go_godot_transform2d_xform_inv_vector2(godot_gdnative_core_api_struct * p_api, const godot_transform2d * p_self, const godot_vector2 * p_v) {
	return p_api->godot_transform2d_xform_inv_vector2(p_self, p_v);
}

godot_vector2 go_godot_transform2d_basis_xform_vector2(godot_gdnative_core_api_struct * p_api, const godot_transform2d * p_self, const godot_vector2 * p_v) {
	return p_api->godot_transform2d_basis_xform_vector2(p_self, p_v);
}

godot_vector2 go_godot_transform2d_basis_xform_inv_vector2(godot_gdnative_core_api_struct * p_api, const godot_transform2d * p_self, const godot_vector2 * p_v) {
	return p_api->godot_transform2d_basis_xform_inv_vector2(p_self, p_v);
}

godot_transform2d go_godot_transform2d_interpolate_with(godot_gdnative_core_api_struct * p_api, const godot_transform2d * p_self, const godot_transform2d * p_m, const godot_real p_c) {
	return p_api->godot_transform2d_interpolate_with(p_self, p_m, p_c);
}

godot_bool go_godot_transform2d_operator_equal(godot_gdnative_core_api_struct * p_api, const godot_transform2d * p_self, const godot_transform2d * p_b) {
	return p_api->godot_transform2d_operator_equal(p_self, p_b);
}

godot_transform2d go_godot_transform2d_operator_multiply(godot_gdnative_core_api_struct * p_api, const godot_transform2d * p_self, const godot_transform2d * p_b) {
	return p_api->godot_transform2d_operator_multiply(p_self, p_b);
}

void go_godot_transform2d_new_identity(godot_gdnative_core_api_struct * p_api, godot_transform2d * r_dest) {
	p_api->godot_transform2d_new_identity(r_dest);
}

godot_rect2 go_godot_transform2d_xform_rect2(godot_gdnative_core_api_struct * p_api, const godot_transform2d * p_self, const godot_rect2 * p_v) {
	return p_api->godot_transform2d_xform_rect2(p_self, p_v);
}

godot_rect2 go_godot_transform2d_xform_inv_rect2(godot_gdnative_core_api_struct * p_api, const godot_transform2d * p_self, const godot_rect2 * p_v) {
	return p_api->godot_transform2d_xform_inv_rect2(p_self, p_v);
}

godot_variant_type go_godot_variant_get_type(godot_gdnative_core_api_struct * p_api, const godot_variant * p_v) {
	return p_api->godot_variant_get_type(p_v);
}

void go_godot_variant_new_copy(godot_gdnative_core_api_struct * p_api, godot_variant * r_dest, const godot_variant * p_src) {
	p_api->godot_variant_new_copy(r_dest, p_src);
}

void go_godot_variant_new_nil(godot_gdnative_core_api_struct * p_api, godot_variant * r_dest) {
	p_api->godot_variant_new_nil(r_dest);
}

void go_godot_variant_new_bool(godot_gdnative_core_api_struct * p_api, godot_variant * r_dest, const godot_bool p_b) {
	p_api->godot_variant_new_bool(r_dest, p_b);
}

void go_godot_variant_new_uint(godot_gdnative_core_api_struct * p_api, godot_variant * r_dest, const uint64_t p_i) {
	p_api->godot_variant_new_uint(r_dest, p_i);
}

void go_godot_variant_new_int(godot_gdnative_core_api_struct * p_api, godot_variant * r_dest, const int64_t p_i) {
	p_api->godot_variant_new_int(r_dest, p_i);
}

void go_godot_variant_new_real(godot_gdnative_core_api_struct * p_api, godot_variant * r_dest, const double p_r) {
	p_api->godot_variant_new_real(r_dest, p_r);
}

void go_godot_variant_new_string(godot_gdnative_core_api_struct * p_api, godot_variant * r_dest, const godot_string * p_s) {
	p_api->godot_variant_new_string(r_dest, p_s);
}

void go_godot_variant_new_vector2(godot_gdnative_core_api_struct * p_api, godot_variant * r_dest, const godot_vector2 * p_v2) {
	p_api->godot_variant_new_vector2(r_dest, p_v2);
}

void go_godot_variant_new_rect2(godot_gdnative_core_api_struct * p_api, godot_variant * r_dest, const godot_rect2 * p_rect2) {
	p_api->godot_variant_new_rect2(r_dest, p_rect2);
}

void go_godot_variant_new_vector3(godot_gdnative_core_api_struct * p_api, godot_variant * r_dest, const godot_vector3 * p_v3) {
	p_api->godot_variant_new_vector3(r_dest, p_v3);
}

void go_godot_variant_new_transform2d(godot_gdnative_core_api_struct * p_api, godot_variant * r_dest, const godot_transform2d * p_t2d) {
	p_api->godot_variant_new_transform2d(r_dest, p_t2d);
}

void go_godot_variant_new_plane(godot_gdnative_core_api_struct * p_api, godot_variant * r_dest, const godot_plane * p_plane) {
	p_api->godot_variant_new_plane(r_dest, p_plane);
}

void go_godot_variant_new_quat(godot_gdnative_core_api_struct * p_api, godot_variant * r_dest, const godot_quat * p_quat) {
	p_api->godot_variant_new_quat(r_dest, p_quat);
}

void go_godot_variant_new_aabb(godot_gdnative_core_api_struct * p_api, godot_variant * r_dest, const godot_aabb * p_aabb) {
	p_api->godot_variant_new_aabb(r_dest, p_aabb);
}

void go_godot_variant_new_basis(godot_gdnative_core_api_struct * p_api, godot_variant * r_dest, const godot_basis * p_basis) {
	p_api->godot_variant_new_basis(r_dest, p_basis);
}

void go_godot_variant_new_transform(godot_gdnative_core_api_struct * p_api, godot_variant * r_dest, const godot_transform * p_trans) {
	p_api->godot_variant_new_transform(r_dest, p_trans);
}

void go_godot_variant_new_color(godot_gdnative_core_api_struct * p_api, godot_variant * r_dest, const godot_color * p_color) {
	p_api->godot_variant_new_color(r_dest, p_color);
}

void go_godot_variant_new_node_path(godot_gdnative_core_api_struct * p_api, godot_variant * r_dest, const godot_node_path * p_np) {
	p_api->godot_variant_new_node_path(r_dest, p_np);
}

void go_godot_variant_new_rid(godot_gdnative_core_api_struct * p_api, godot_variant * r_dest, const godot_rid * p_rid) {
	p_api->godot_variant_new_rid(r_dest, p_rid);
}

void go_godot_variant_new_object(godot_gdnative_core_api_struct * p_api, godot_variant * r_dest, const godot_object * p_obj) {
	p_api->godot_variant_new_object(r_dest, p_obj);
}

void go_godot_variant_new_dictionary(godot_gdnative_core_api_struct * p_api, godot_variant * r_dest, const godot_dictionary * p_dict) {
	p_api->godot_variant_new_dictionary(r_dest, p_dict);
}

void go_godot_variant_new_array(godot_gdnative_core_api_struct * p_api, godot_variant * r_dest, const godot_array * p_arr) {
	p_api->godot_variant_new_array(r_dest, p_arr);
}

void go_godot_variant_new_pool_byte_array(godot_gdnative_core_api_struct * p_api, godot_variant * r_dest, const godot_pool_byte_array * p_pba) {
	p_api->godot_variant_new_pool_byte_array(r_dest, p_pba);
}

void go_godot_variant_new_pool_int_array(godot_gdnative_core_api_struct * p_api, godot_variant * r_dest, const godot_pool_int_array * p_pia) {
	p_api->godot_variant_new_pool_int_array(r_dest, p_pia);
}

void go_godot_variant_new_pool_real_array(godot_gdnative_core_api_struct * p_api, godot_variant * r_dest, const godot_pool_real_array * p_pra) {
	p_api->godot_variant_new_pool_real_array(r_dest, p_pra);
}

void go_godot_variant_new_pool_string_array(godot_gdnative_core_api_struct * p_api, godot_variant * r_dest, const godot_pool_string_array * p_psa) {
	p_api->godot_variant_new_pool_string_array(r_dest, p_psa);
}

void go_godot_variant_new_pool_vector2_array(godot_gdnative_core_api_struct * p_api, godot_variant * r_dest, const godot_pool_vector2_array * p_pv2a) {
	p_api->godot_variant_new_pool_vector2_array(r_dest, p_pv2a);
}

void go_godot_variant_new_pool_vector3_array(godot_gdnative_core_api_struct * p_api, godot_variant * r_dest, const godot_pool_vector3_array * p_pv3a) {
	p_api->godot_variant_new_pool_vector3_array(r_dest, p_pv3a);
}

void go_godot_variant_new_pool_color_array(godot_gdnative_core_api_struct * p_api, godot_variant * r_dest, const godot_pool_color_array * p_pca) {
	p_api->godot_variant_new_pool_color_array(r_dest, p_pca);
}

godot_bool go_godot_variant_as_bool(godot_gdnative_core_api_struct * p_api, const godot_variant * p_self) {
	return p_api->godot_variant_as_bool(p_self);
}

uint64_t go_godot_variant_as_uint(godot_gdnative_core_api_struct * p_api, const godot_variant * p_self) {
	return p_api->godot_variant_as_uint(p_self);
}

int64_t go_godot_variant_as_int(godot_gdnative_core_api_struct * p_api, const godot_variant * p_self) {
	return p_api->godot_variant_as_int(p_self);
}

double go_godot_variant_as_real(godot_gdnative_core_api_struct * p_api, const godot_variant * p_self) {
	return p_api->godot_variant_as_real(p_self);
}

godot_string go_godot_variant_as_string(godot_gdnative_core_api_struct * p_api, const godot_variant * p_self) {
	return p_api->godot_variant_as_string(p_self);
}

godot_vector2 go_godot_variant_as_vector2(godot_gdnative_core_api_struct * p_api, const godot_variant * p_self) {
	return p_api->godot_variant_as_vector2(p_self);
}

godot_rect2 go_godot_variant_as_rect2(godot_gdnative_core_api_struct * p_api, const godot_variant * p_self) {
	return p_api->godot_variant_as_rect2(p_self);
}

godot_vector3 go_godot_variant_as_vector3(godot_gdnative_core_api_struct * p_api, const godot_variant * p_self) {
	return p_api->godot_variant_as_vector3(p_self);
}

godot_transform2d go_godot_variant_as_transform2d(godot_gdnative_core_api_struct * p_api, const godot_variant * p_self) {
	return p_api->godot_variant_as_transform2d(p_self);
}

godot_plane go_godot_variant_as_plane(godot_gdnative_core_api_struct * p_api, const godot_variant * p_self) {
	return p_api->godot_variant_as_plane(p_self);
}

godot_quat go_godot_variant_as_quat(godot_gdnative_core_api_struct * p_api, const godot_variant * p_self) {
	return p_api->godot_variant_as_quat(p_self);
}

godot_aabb go_godot_variant_as_aabb(godot_gdnative_core_api_struct * p_api, const godot_variant * p_self) {
	return p_api->godot_variant_as_aabb(p_self);
}

godot_basis go_godot_variant_as_basis(godot_gdnative_core_api_struct * p_api, const godot_variant * p_self) {
	return p_api->godot_variant_as_basis(p_self);
}

godot_transform go_godot_variant_as_transform(godot_gdnative_core_api_struct * p_api, const godot_variant * p_self) {
	return p_api->godot_variant_as_transform(p_self);
}

godot_color go_godot_variant_as_color(godot_gdnative_core_api_struct * p_api, const godot_variant * p_self) {
	return p_api->godot_variant_as_color(p_self);
}

godot_node_path go_godot_variant_as_node_path(godot_gdnative_core_api_struct * p_api, const godot_variant * p_self) {
	return p_api->godot_variant_as_node_path(p_self);
}

godot_rid go_godot_variant_as_rid(godot_gdnative_core_api_struct * p_api, const godot_variant * p_self) {
	return p_api->godot_variant_as_rid(p_self);
}

godot_object * go_godot_variant_as_object(godot_gdnative_core_api_struct * p_api, const godot_variant * p_self) {
	return p_api->godot_variant_as_object(p_self);
}

godot_dictionary go_godot_variant_as_dictionary(godot_gdnative_core_api_struct * p_api, const godot_variant * p_self) {
	return p_api->godot_variant_as_dictionary(p_self);
}

godot_array go_godot_variant_as_array(godot_gdnative_core_api_struct * p_api, const godot_variant * p_self) {
	return p_api->godot_variant_as_array(p_self);
}

godot_pool_byte_array go_godot_variant_as_pool_byte_array(godot_gdnative_core_api_struct * p_api, const godot_variant * p_self) {
	return p_api->godot_variant_as_pool_byte_array(p_self);
}

godot_pool_int_array go_godot_variant_as_pool_int_array(godot_gdnative_core_api_struct * p_api, const godot_variant * p_self) {
	return p_api->godot_variant_as_pool_int_array(p_self);
}

godot_pool_real_array go_godot_variant_as_pool_real_array(godot_gdnative_core_api_struct * p_api, const godot_variant * p_self) {
	return p_api->godot_variant_as_pool_real_array(p_self);
}

godot_pool_string_array go_godot_variant_as_pool_string_array(godot_gdnative_core_api_struct * p_api, const godot_variant * p_self) {
	return p_api->godot_variant_as_pool_string_array(p_self);
}

godot_pool_vector2_array go_godot_variant_as_pool_vector2_array(godot_gdnative_core_api_struct * p_api, const godot_variant * p_self) {
	return p_api->godot_variant_as_pool_vector2_array(p_self);
}

godot_pool_vector3_array go_godot_variant_as_pool_vector3_array(godot_gdnative_core_api_struct * p_api, const godot_variant * p_self) {
	return p_api->godot_variant_as_pool_vector3_array(p_self);
}

godot_pool_color_array go_godot_variant_as_pool_color_array(godot_gdnative_core_api_struct * p_api, const godot_variant * p_self) {
	return p_api->godot_variant_as_pool_color_array(p_self);
}

godot_variant go_godot_variant_call(godot_gdnative_core_api_struct * p_api, godot_variant * p_self, const godot_string * p_method, const godot_variant ** p_args, const godot_int p_argcount, godot_variant_call_error * r_error) {
	return p_api->godot_variant_call(p_self, p_method, p_args, p_argcount, r_error);
}

godot_bool go_godot_variant_has_method(godot_gdnative_core_api_struct * p_api, const godot_variant * p_self, const godot_string * p_method) {
	return p_api->godot_variant_has_method(p_self, p_method);
}

godot_bool go_godot_variant_operator_equal(godot_gdnative_core_api_struct * p_api, const godot_variant * p_self, const godot_variant * p_other) {
	return p_api->godot_variant_operator_equal(p_self, p_other);
}

godot_bool go_godot_variant_operator_less(godot_gdnative_core_api_struct * p_api, const godot_variant * p_self, const godot_variant * p_other) {
	return p_api->godot_variant_operator_less(p_self, p_other);
}

godot_bool go_godot_variant_hash_compare(godot_gdnative_core_api_struct * p_api, const godot_variant * p_self, const godot_variant * p_other) {
	return p_api->godot_variant_hash_compare(p_self, p_other);
}

godot_bool go_godot_variant_booleanize(godot_gdnative_core_api_struct * p_api, const godot_variant * p_self) {
	return p_api->godot_variant_booleanize(p_self);
}

void go_godot_variant_destroy(godot_gdnative_core_api_struct * p_api, godot_variant * p_self) {
	p_api->godot_variant_destroy(p_self);
}

godot_int go_godot_char_string_length(godot_gdnative_core_api_struct * p_api, const godot_char_string * p_cs) {
	return p_api->godot_char_string_length(p_cs);
}

const char * go_godot_char_string_get_data(godot_gdnative_core_api_struct * p_api, const godot_char_string * p_cs) {
	return p_api->godot_char_string_get_data(p_cs);
}

void go_godot_char_string_destroy(godot_gdnative_core_api_struct * p_api, godot_char_string * p_cs) {
	p_api->godot_char_string_destroy(p_cs);
}

void go_godot_string_new(godot_gdnative_core_api_struct * p_api, godot_string * r_dest) {
	p_api->godot_string_new(r_dest);
}

void go_godot_string_new_copy(godot_gdnative_core_api_struct * p_api, godot_string * r_dest, const godot_string * p_src) {
	p_api->godot_string_new_copy(r_dest, p_src);
}

void go_godot_string_new_with_wide_string(godot_gdnative_core_api_struct * p_api, godot_string * r_dest, const wchar_t * p_contents, const int p_size) {
	p_api->godot_string_new_with_wide_string(r_dest, p_contents, p_size);
}

const wchar_t * go_godot_string_operator_index(godot_gdnative_core_api_struct * p_api, godot_string * p_self, const godot_int p_idx) {
	return p_api->godot_string_operator_index(p_self, p_idx);
}

wchar_t go_godot_string_operator_index_const(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, const godot_int p_idx) {
	return p_api->godot_string_operator_index_const(p_self, p_idx);
}

const wchar_t * go_godot_string_wide_str(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_wide_str(p_self);
}

godot_bool go_godot_string_operator_equal(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, const godot_string * p_b) {
	return p_api->godot_string_operator_equal(p_self, p_b);
}

godot_bool go_godot_string_operator_less(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, const godot_string * p_b) {
	return p_api->godot_string_operator_less(p_self, p_b);
}

godot_string go_godot_string_operator_plus(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, const godot_string * p_b) {
	return p_api->godot_string_operator_plus(p_self, p_b);
}

godot_int go_godot_string_length(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_length(p_self);
}

signed char go_godot_string_casecmp_to(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, const godot_string * p_str) {
	return p_api->godot_string_casecmp_to(p_self, p_str);
}

signed char go_godot_string_nocasecmp_to(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, const godot_string * p_str) {
	return p_api->godot_string_nocasecmp_to(p_self, p_str);
}

signed char go_godot_string_naturalnocasecmp_to(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, const godot_string * p_str) {
	return p_api->godot_string_naturalnocasecmp_to(p_self, p_str);
}

godot_bool go_godot_string_begins_with(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, const godot_string * p_string) {
	return p_api->godot_string_begins_with(p_self, p_string);
}

godot_bool go_godot_string_begins_with_char_array(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, const char * p_char_array) {
	return p_api->godot_string_begins_with_char_array(p_self, p_char_array);
}

godot_array go_godot_string_bigrams(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_bigrams(p_self);
}

godot_string go_godot_string_chr(godot_gdnative_core_api_struct * p_api, wchar_t p_character) {
	return p_api->godot_string_chr(p_character);
}

godot_bool go_godot_string_ends_with(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, const godot_string * p_string) {
	return p_api->godot_string_ends_with(p_self, p_string);
}

godot_int go_godot_string_find(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, godot_string p_what) {
	return p_api->godot_string_find(p_self, p_what);
}

godot_int go_godot_string_find_from(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, godot_string p_what, godot_int p_from) {
	return p_api->godot_string_find_from(p_self, p_what, p_from);
}

godot_int go_godot_string_findmk(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, const godot_array * p_keys) {
	return p_api->godot_string_findmk(p_self, p_keys);
}

godot_int go_godot_string_findmk_from(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, const godot_array * p_keys, godot_int p_from) {
	return p_api->godot_string_findmk_from(p_self, p_keys, p_from);
}

godot_int go_godot_string_findmk_from_in_place(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, const godot_array * p_keys, godot_int p_from, godot_int * r_key) {
	return p_api->godot_string_findmk_from_in_place(p_self, p_keys, p_from, r_key);
}

godot_int go_godot_string_findn(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, godot_string p_what) {
	return p_api->godot_string_findn(p_self, p_what);
}

godot_int go_godot_string_findn_from(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, godot_string p_what, godot_int p_from) {
	return p_api->godot_string_findn_from(p_self, p_what, p_from);
}

godot_int go_godot_string_find_last(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, godot_string p_what) {
	return p_api->godot_string_find_last(p_self, p_what);
}

godot_string go_godot_string_format(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, const godot_variant * p_values) {
	return p_api->godot_string_format(p_self, p_values);
}

godot_string go_godot_string_format_with_custom_placeholder(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, const godot_variant * p_values, const char * p_placeholder) {
	return p_api->godot_string_format_with_custom_placeholder(p_self, p_values, p_placeholder);
}

godot_string go_godot_string_hex_encode_buffer(godot_gdnative_core_api_struct * p_api, const uint8_t * p_buffer, godot_int p_len) {
	return p_api->godot_string_hex_encode_buffer(p_buffer, p_len);
}

godot_int go_godot_string_hex_to_int(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_hex_to_int(p_self);
}

godot_int go_godot_string_hex_to_int_without_prefix(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_hex_to_int_without_prefix(p_self);
}

godot_string go_godot_string_insert(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, godot_int p_at_pos, godot_string p_string) {
	return p_api->godot_string_insert(p_self, p_at_pos, p_string);
}

godot_bool go_godot_string_is_numeric(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_is_numeric(p_self);
}

godot_bool go_godot_string_is_subsequence_of(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, const godot_string * p_string) {
	return p_api->godot_string_is_subsequence_of(p_self, p_string);
}

godot_bool go_godot_string_is_subsequence_ofi(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, const godot_string * p_string) {
	return p_api->godot_string_is_subsequence_ofi(p_self, p_string);
}

godot_string go_godot_string_lpad(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, godot_int p_min_length) {
	return p_api->godot_string_lpad(p_self, p_min_length);
}

godot_string go_godot_string_lpad_with_custom_character(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, godot_int p_min_length, const godot_string * p_character) {
	return p_api->godot_string_lpad_with_custom_character(p_self, p_min_length, p_character);
}

godot_bool go_godot_string_match(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, const godot_string * p_wildcard) {
	return p_api->godot_string_match(p_self, p_wildcard);
}

godot_bool go_godot_string_matchn(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, const godot_string * p_wildcard) {
	return p_api->godot_string_matchn(p_self, p_wildcard);
}

godot_string go_godot_string_md5(godot_gdnative_core_api_struct * p_api, const uint8_t * p_md5) {
	return p_api->godot_string_md5(p_md5);
}

godot_string go_godot_string_num(godot_gdnative_core_api_struct * p_api, double p_num) {
	return p_api->godot_string_num(p_num);
}

godot_string go_godot_string_num_int64(godot_gdnative_core_api_struct * p_api, int64_t p_num, godot_int p_base) {
	return p_api->godot_string_num_int64(p_num, p_base);
}

godot_string go_godot_string_num_int64_capitalized(godot_gdnative_core_api_struct * p_api, int64_t p_num, godot_int p_base, godot_bool p_capitalize_hex) {
	return p_api->godot_string_num_int64_capitalized(p_num, p_base, p_capitalize_hex);
}

godot_string go_godot_string_num_real(godot_gdnative_core_api_struct * p_api, double p_num) {
	return p_api->godot_string_num_real(p_num);
}

godot_string go_godot_string_num_scientific(godot_gdnative_core_api_struct * p_api, double p_num) {
	return p_api->godot_string_num_scientific(p_num);
}

godot_string go_godot_string_num_with_decimals(godot_gdnative_core_api_struct * p_api, double p_num, godot_int p_decimals) {
	return p_api->godot_string_num_with_decimals(p_num, p_decimals);
}

godot_string go_godot_string_pad_decimals(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, godot_int p_digits) {
	return p_api->godot_string_pad_decimals(p_self, p_digits);
}

godot_string go_godot_string_pad_zeros(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, godot_int p_digits) {
	return p_api->godot_string_pad_zeros(p_self, p_digits);
}

godot_string go_godot_string_replace_first(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, godot_string p_key, godot_string p_with) {
	return p_api->godot_string_replace_first(p_self, p_key, p_with);
}

godot_string go_godot_string_replace(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, godot_string p_key, godot_string p_with) {
	return p_api->godot_string_replace(p_self, p_key, p_with);
}

godot_string go_godot_string_replacen(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, godot_string p_key, godot_string p_with) {
	return p_api->godot_string_replacen(p_self, p_key, p_with);
}

godot_int go_godot_string_rfind(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, godot_string p_what) {
	return p_api->godot_string_rfind(p_self, p_what);
}

godot_int go_godot_string_rfindn(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, godot_string p_what) {
	return p_api->godot_string_rfindn(p_self, p_what);
}

godot_int go_godot_string_rfind_from(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, godot_string p_what, godot_int p_from) {
	return p_api->godot_string_rfind_from(p_self, p_what, p_from);
}

godot_int go_godot_string_rfindn_from(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, godot_string p_what, godot_int p_from) {
	return p_api->godot_string_rfindn_from(p_self, p_what, p_from);
}

godot_string go_godot_string_rpad(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, godot_int p_min_length) {
	return p_api->godot_string_rpad(p_self, p_min_length);
}

godot_string go_godot_string_rpad_with_custom_character(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, godot_int p_min_length, const godot_string * p_character) {
	return p_api->godot_string_rpad_with_custom_character(p_self, p_min_length, p_character);
}

godot_real go_godot_string_similarity(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, const godot_string * p_string) {
	return p_api->godot_string_similarity(p_self, p_string);
}

godot_string go_godot_string_sprintf(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, const godot_array * p_values, godot_bool * p_error) {
	return p_api->godot_string_sprintf(p_self, p_values, p_error);
}

godot_string go_godot_string_substr(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, godot_int p_from, godot_int p_chars) {
	return p_api->godot_string_substr(p_self, p_from, p_chars);
}

double go_godot_string_to_double(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_to_double(p_self);
}

godot_real go_godot_string_to_float(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_to_float(p_self);
}

godot_int go_godot_string_to_int(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_to_int(p_self);
}

godot_string go_godot_string_camelcase_to_underscore(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_camelcase_to_underscore(p_self);
}

godot_string go_godot_string_camelcase_to_underscore_lowercased(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_camelcase_to_underscore_lowercased(p_self);
}

godot_string go_godot_string_capitalize(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_capitalize(p_self);
}

double go_godot_string_char_to_double(godot_gdnative_core_api_struct * p_api, const char * p_what) {
	return p_api->godot_string_char_to_double(p_what);
}

godot_int go_godot_string_char_to_int(godot_gdnative_core_api_struct * p_api, const char * p_what) {
	return p_api->godot_string_char_to_int(p_what);
}

int64_t go_godot_string_wchar_to_int(godot_gdnative_core_api_struct * p_api, const wchar_t * p_str) {
	return p_api->godot_string_wchar_to_int(p_str);
}

godot_int go_godot_string_char_to_int_with_len(godot_gdnative_core_api_struct * p_api, const char * p_what, godot_int p_len) {
	return p_api->godot_string_char_to_int_with_len(p_what, p_len);
}

int64_t go_godot_string_char_to_int64_with_len(godot_gdnative_core_api_struct * p_api, const wchar_t * p_str, int p_len) {
	return p_api->godot_string_char_to_int64_with_len(p_str, p_len);
}

int64_t go_godot_string_hex_to_int64(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_hex_to_int64(p_self);
}

int64_t go_godot_string_hex_to_int64_with_prefix(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_hex_to_int64_with_prefix(p_self);
}

int64_t go_godot_string_to_int64(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_to_int64(p_self);
}

double go_godot_string_unicode_char_to_double(godot_gdnative_core_api_struct * p_api, const wchar_t * p_str, const wchar_t ** r_end) {
	return p_api->godot_string_unicode_char_to_double(p_str, r_end);
}

godot_int go_godot_string_get_slice_count(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, godot_string p_splitter) {
	return p_api->godot_string_get_slice_count(p_self, p_splitter);
}

godot_string go_godot_string_get_slice(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, godot_string p_splitter, godot_int p_slice) {
	return p_api->godot_string_get_slice(p_self, p_splitter, p_slice);
}

godot_string go_godot_string_get_slicec(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, wchar_t p_splitter, godot_int p_slice) {
	return p_api->godot_string_get_slicec(p_self, p_splitter, p_slice);
}

godot_array go_godot_string_split(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, const godot_string * p_splitter) {
	return p_api->godot_string_split(p_self, p_splitter);
}

godot_array go_godot_string_split_allow_empty(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, const godot_string * p_splitter) {
	return p_api->godot_string_split_allow_empty(p_self, p_splitter);
}

godot_array go_godot_string_split_floats(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, const godot_string * p_splitter) {
	return p_api->godot_string_split_floats(p_self, p_splitter);
}

godot_array go_godot_string_split_floats_allows_empty(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, const godot_string * p_splitter) {
	return p_api->godot_string_split_floats_allows_empty(p_self, p_splitter);
}

godot_array go_godot_string_split_floats_mk(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, const godot_array * p_splitters) {
	return p_api->godot_string_split_floats_mk(p_self, p_splitters);
}

godot_array go_godot_string_split_floats_mk_allows_empty(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, const godot_array * p_splitters) {
	return p_api->godot_string_split_floats_mk_allows_empty(p_self, p_splitters);
}

godot_array go_godot_string_split_ints(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, const godot_string * p_splitter) {
	return p_api->godot_string_split_ints(p_self, p_splitter);
}

godot_array go_godot_string_split_ints_allows_empty(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, const godot_string * p_splitter) {
	return p_api->godot_string_split_ints_allows_empty(p_self, p_splitter);
}

godot_array go_godot_string_split_ints_mk(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, const godot_array * p_splitters) {
	return p_api->godot_string_split_ints_mk(p_self, p_splitters);
}

godot_array go_godot_string_split_ints_mk_allows_empty(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, const godot_array * p_splitters) {
	return p_api->godot_string_split_ints_mk_allows_empty(p_self, p_splitters);
}

godot_array go_godot_string_split_spaces(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_split_spaces(p_self);
}

wchar_t go_godot_string_char_lowercase(godot_gdnative_core_api_struct * p_api, wchar_t p_char) {
	return p_api->godot_string_char_lowercase(p_char);
}

wchar_t go_godot_string_char_uppercase(godot_gdnative_core_api_struct * p_api, wchar_t p_char) {
	return p_api->godot_string_char_uppercase(p_char);
}

godot_string go_godot_string_to_lower(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_to_lower(p_self);
}

godot_string go_godot_string_to_upper(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_to_upper(p_self);
}

godot_string go_godot_string_get_basename(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_get_basename(p_self);
}

godot_string go_godot_string_get_extension(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_get_extension(p_self);
}

godot_string go_godot_string_left(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, godot_int p_pos) {
	return p_api->godot_string_left(p_self, p_pos);
}

wchar_t go_godot_string_ord_at(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, godot_int p_idx) {
	return p_api->godot_string_ord_at(p_self, p_idx);
}

godot_string go_godot_string_plus_file(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, const godot_string * p_file) {
	return p_api->godot_string_plus_file(p_self, p_file);
}

godot_string go_godot_string_right(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, godot_int p_pos) {
	return p_api->godot_string_right(p_self, p_pos);
}

godot_string go_godot_string_strip_edges(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, godot_bool p_left, godot_bool p_right) {
	return p_api->godot_string_strip_edges(p_self, p_left, p_right);
}

godot_string go_godot_string_strip_escapes(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_strip_escapes(p_self);
}

void go_godot_string_erase(godot_gdnative_core_api_struct * p_api, godot_string * p_self, godot_int p_pos, godot_int p_chars) {
	p_api->godot_string_erase(p_self, p_pos, p_chars);
}

godot_char_string go_godot_string_ascii(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_ascii(p_self);
}

godot_char_string go_godot_string_ascii_extended(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_ascii_extended(p_self);
}

godot_char_string go_godot_string_utf8(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_utf8(p_self);
}

godot_bool go_godot_string_parse_utf8(godot_gdnative_core_api_struct * p_api, godot_string * p_self, const char * p_utf8) {
	return p_api->godot_string_parse_utf8(p_self, p_utf8);
}

godot_bool go_godot_string_parse_utf8_with_len(godot_gdnative_core_api_struct * p_api, godot_string * p_self, const char * p_utf8, godot_int p_len) {
	return p_api->godot_string_parse_utf8_with_len(p_self, p_utf8, p_len);
}

godot_string go_godot_string_chars_to_utf8(godot_gdnative_core_api_struct * p_api, const char * p_utf8) {
	return p_api->godot_string_chars_to_utf8(p_utf8);
}

godot_string go_godot_string_chars_to_utf8_with_len(godot_gdnative_core_api_struct * p_api, const char * p_utf8, godot_int p_len) {
	return p_api->godot_string_chars_to_utf8_with_len(p_utf8, p_len);
}

uint32_t go_godot_string_hash(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_hash(p_self);
}

uint64_t go_godot_string_hash64(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_hash64(p_self);
}

uint32_t go_godot_string_hash_chars(godot_gdnative_core_api_struct * p_api, const char * p_cstr) {
	return p_api->godot_string_hash_chars(p_cstr);
}

uint32_t go_godot_string_hash_chars_with_len(godot_gdnative_core_api_struct * p_api, const char * p_cstr, godot_int p_len) {
	return p_api->godot_string_hash_chars_with_len(p_cstr, p_len);
}

uint32_t go_godot_string_hash_utf8_chars(godot_gdnative_core_api_struct * p_api, const wchar_t * p_str) {
	return p_api->godot_string_hash_utf8_chars(p_str);
}

uint32_t go_godot_string_hash_utf8_chars_with_len(godot_gdnative_core_api_struct * p_api, const wchar_t * p_str, godot_int p_len) {
	return p_api->godot_string_hash_utf8_chars_with_len(p_str, p_len);
}

godot_pool_byte_array go_godot_string_md5_buffer(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_md5_buffer(p_self);
}

godot_string go_godot_string_md5_text(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_md5_text(p_self);
}

godot_pool_byte_array go_godot_string_sha256_buffer(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_sha256_buffer(p_self);
}

godot_string go_godot_string_sha256_text(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_sha256_text(p_self);
}

godot_bool go_godot_string_empty(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_empty(p_self);
}

godot_string go_godot_string_get_base_dir(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_get_base_dir(p_self);
}

godot_string go_godot_string_get_file(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_get_file(p_self);
}

godot_string go_godot_string_humanize_size(godot_gdnative_core_api_struct * p_api, uint64_t p_size) {
	return p_api->godot_string_humanize_size(p_size);
}

godot_bool go_godot_string_is_abs_path(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_is_abs_path(p_self);
}

godot_bool go_godot_string_is_rel_path(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_is_rel_path(p_self);
}

godot_bool go_godot_string_is_resource_file(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_is_resource_file(p_self);
}

godot_string go_godot_string_path_to(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, const godot_string * p_path) {
	return p_api->godot_string_path_to(p_self, p_path);
}

godot_string go_godot_string_path_to_file(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, const godot_string * p_path) {
	return p_api->godot_string_path_to_file(p_self, p_path);
}

godot_string go_godot_string_simplify_path(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_simplify_path(p_self);
}

godot_string go_godot_string_c_escape(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_c_escape(p_self);
}

godot_string go_godot_string_c_escape_multiline(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_c_escape_multiline(p_self);
}

godot_string go_godot_string_c_unescape(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_c_unescape(p_self);
}

godot_string go_godot_string_http_escape(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_http_escape(p_self);
}

godot_string go_godot_string_http_unescape(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_http_unescape(p_self);
}

godot_string go_godot_string_json_escape(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_json_escape(p_self);
}

godot_string go_godot_string_word_wrap(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, godot_int p_chars_per_line) {
	return p_api->godot_string_word_wrap(p_self, p_chars_per_line);
}

godot_string go_godot_string_xml_escape(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_xml_escape(p_self);
}

godot_string go_godot_string_xml_escape_with_quotes(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_xml_escape_with_quotes(p_self);
}

godot_string go_godot_string_xml_unescape(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_xml_unescape(p_self);
}

godot_string go_godot_string_percent_decode(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_percent_decode(p_self);
}

godot_string go_godot_string_percent_encode(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_percent_encode(p_self);
}

godot_bool go_godot_string_is_valid_float(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_is_valid_float(p_self);
}

godot_bool go_godot_string_is_valid_hex_number(godot_gdnative_core_api_struct * p_api, const godot_string * p_self, godot_bool p_with_prefix) {
	return p_api->godot_string_is_valid_hex_number(p_self, p_with_prefix);
}

godot_bool go_godot_string_is_valid_html_color(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_is_valid_html_color(p_self);
}

godot_bool go_godot_string_is_valid_identifier(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_is_valid_identifier(p_self);
}

godot_bool go_godot_string_is_valid_integer(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_is_valid_integer(p_self);
}

godot_bool go_godot_string_is_valid_ip_address(godot_gdnative_core_api_struct * p_api, const godot_string * p_self) {
	return p_api->godot_string_is_valid_ip_address(p_self);
}

void go_godot_string_destroy(godot_gdnative_core_api_struct * p_api, godot_string * p_self) {
	p_api->godot_string_destroy(p_self);
}

void go_godot_string_name_new(godot_gdnative_core_api_struct * p_api, godot_string_name * r_dest, const godot_string * p_name) {
	p_api->godot_string_name_new(r_dest, p_name);
}

void go_godot_string_name_new_data(godot_gdnative_core_api_struct * p_api, godot_string_name * r_dest, const char * p_name) {
	p_api->godot_string_name_new_data(r_dest, p_name);
}

godot_string go_godot_string_name_get_name(godot_gdnative_core_api_struct * p_api, const godot_string_name * p_self) {
	return p_api->godot_string_name_get_name(p_self);
}

uint32_t go_godot_string_name_get_hash(godot_gdnative_core_api_struct * p_api, const godot_string_name * p_self) {
	return p_api->godot_string_name_get_hash(p_self);
}

const void * go_godot_string_name_get_data_unique_pointer(godot_gdnative_core_api_struct * p_api, const godot_string_name * p_self) {
	return p_api->godot_string_name_get_data_unique_pointer(p_self);
}

godot_bool go_godot_string_name_operator_equal(godot_gdnative_core_api_struct * p_api, const godot_string_name * p_self, const godot_string_name * p_other) {
	return p_api->godot_string_name_operator_equal(p_self, p_other);
}

godot_bool go_godot_string_name_operator_less(godot_gdnative_core_api_struct * p_api, const godot_string_name * p_self, const godot_string_name * p_other) {
	return p_api->godot_string_name_operator_less(p_self, p_other);
}

void go_godot_string_name_destroy(godot_gdnative_core_api_struct * p_api, godot_string_name * p_self) {
	p_api->godot_string_name_destroy(p_self);
}

void go_godot_object_destroy(godot_gdnative_core_api_struct * p_api, godot_object * p_o) {
	p_api->godot_object_destroy(p_o);
}

godot_object * go_godot_global_get_singleton(godot_gdnative_core_api_struct * p_api, char * p_name) {
	return p_api->godot_global_get_singleton(p_name);
}

godot_method_bind * go_godot_method_bind_get_method(godot_gdnative_core_api_struct * p_api, const char * p_classname, const char * p_methodname) {
	return p_api->godot_method_bind_get_method(p_classname, p_methodname);
}

void go_godot_method_bind_ptrcall(godot_gdnative_core_api_struct * p_api, godot_method_bind * p_method_bind, godot_object * p_instance, const void ** p_args, void * p_ret) {
	p_api->godot_method_bind_ptrcall(p_method_bind, p_instance, p_args, p_ret);
}

godot_variant go_godot_method_bind_call(godot_gdnative_core_api_struct * p_api, godot_method_bind * p_method_bind, godot_object * p_instance, const godot_variant ** p_args, const int p_arg_count, godot_variant_call_error * p_call_error) {
	return p_api->godot_method_bind_call(p_method_bind, p_instance, p_args, p_arg_count, p_call_error);
}

godot_class_constructor go_godot_get_class_constructor(godot_gdnative_core_api_struct * p_api, const char * p_classname) {
	return p_api->godot_get_class_constructor(p_classname);
}

godot_dictionary go_godot_get_global_constants(godot_gdnative_core_api_struct * p_api) {
	return p_api->godot_get_global_constants();
}

void go_godot_register_native_call_type(godot_gdnative_core_api_struct * p_api, const char * call_type, native_call_cb p_callback) {
	p_api->godot_register_native_call_type(call_type, p_callback);
}

void * go_godot_alloc(godot_gdnative_core_api_struct * p_api, int p_bytes) {
	return p_api->godot_alloc(p_bytes);
}

void * go_godot_realloc(godot_gdnative_core_api_struct * p_api, void * p_ptr, int p_bytes) {
	return p_api->godot_realloc(p_ptr, p_bytes);
}

void go_godot_free(godot_gdnative_core_api_struct * p_api, void * p_ptr) {
	p_api->godot_free(p_ptr);
}

void go_godot_print_error(godot_gdnative_core_api_struct * p_api, const char * p_description, const char * p_function, const char * p_file, int p_line) {
	p_api->godot_print_error(p_description, p_function, p_file, p_line);
}

void go_godot_print_warning(godot_gdnative_core_api_struct * p_api, const char * p_description, const char * p_function, const char * p_file, int p_line) {
	p_api->godot_print_warning(p_description, p_function, p_file, p_line);
}

void go_godot_print(godot_gdnative_core_api_struct * p_api, const godot_string * p_message) {
	p_api->godot_print(p_message);
}

