--- This file was automatically generated by generate_lua_godot_api.py
--- @meta
--- @diagnostic disable: param-type-mismatch
--- @diagnostic disable: redundant-parameter

-----------------------------------------------------------
-- Builtin Classes (a.k.a. Variants)
-----------------------------------------------------------

--- @class Variant
--- @overload fun(): Variant
--- @overload fun(from: any): Variant
--- @operator concat(any): String
Variant = {}

--- @param self any
--- @return bool
function Variant.booleanize(self) end

--- @param self any
--- @return Variant
function Variant.duplicate(self) end

--- @param method string
--- @return Variant
function Variant:call(method, ...) end

--- @param method string
--- @return Variant
function Variant:pcall(method, ...) end

--- @param self any
--- @return Variant.Type
function Variant.get_type(self) end

--- @param self any
--- @return string
function Variant.get_type_name(self) end

--- @param self any
--- @return integer
function Variant.hash(self) end

--- @param self any
--- @param recursion_count integer
--- @return integer
function Variant.recursive_hash(self, recursion_count) end

--- @param other any
--- @return bool
function Variant.hash_compare(self, other) end

--- @param self any
--- @param type any
--- @return bool
function Variant.is(self, type) end


-----------------------------------------------------------
-- bool
-----------------------------------------------------------

--- @alias bool boolean
--- @return bool
function bool() end


-----------------------------------------------------------
-- int
-----------------------------------------------------------

--- @alias int integer
--- @return int
function int() end


-----------------------------------------------------------
-- float
-----------------------------------------------------------

--- @alias float number
--- @return float
function float() end


-----------------------------------------------------------
-- String
-----------------------------------------------------------

--- @alias String string
String = string

--- @param self string
--- @param to String
--- @return int
function string.casecmp_to(self, to) end

--- @param self string
--- @param to String
--- @return int
function string.nocasecmp_to(self, to) end

--- @param self string
--- @param to String
--- @return int
function string.naturalcasecmp_to(self, to) end

--- @param self string
--- @param to String
--- @return int
function string.naturalnocasecmp_to(self, to) end

--- @param self string
--- @param to String
--- @return int
function string.filecasecmp_to(self, to) end

--- @param self string
--- @param to String
--- @return int
function string.filenocasecmp_to(self, to) end

--- @param self string
--- @return int
function string.length(self) end

--- @param self string
--- @param from int
--- @param len int? Default: -1
--- @return String
function string.substr(self, from, len) end

--- @param self string
--- @param delimiter String
--- @param slice int
--- @return String
function string.get_slice(self, delimiter, slice) end

--- @param self string
--- @param delimiter int
--- @param slice int
--- @return String
function string.get_slicec(self, delimiter, slice) end

--- @param self string
--- @param delimiter String
--- @return int
function string.get_slice_count(self, delimiter) end

--- @param self string
--- @param what String
--- @param from int? Default: 0
--- @return int
function string.find(self, what, from) end

--- @param self string
--- @param what String
--- @param from int? Default: 0
--- @return int
function string.findn(self, what, from) end

--- @param self string
--- @param what String
--- @param from int? Default: 0
--- @param to int? Default: 0
--- @return int
function string.count(self, what, from, to) end

--- @param self string
--- @param what String
--- @param from int? Default: 0
--- @param to int? Default: 0
--- @return int
function string.countn(self, what, from, to) end

--- @param self string
--- @param what String
--- @param from int? Default: -1
--- @return int
function string.rfind(self, what, from) end

--- @param self string
--- @param what String
--- @param from int? Default: -1
--- @return int
function string.rfindn(self, what, from) end

--- @param self string
--- @param expr String
--- @return bool
function string.match(self, expr) end

--- @param self string
--- @param expr String
--- @return bool
function string.matchn(self, expr) end

--- @param self string
--- @param text String
--- @return bool
function string.begins_with(self, text) end

--- @param self string
--- @param text String
--- @return bool
function string.ends_with(self, text) end

--- @param self string
--- @param text String
--- @return bool
function string.is_subsequence_of(self, text) end

--- @param self string
--- @param text String
--- @return bool
function string.is_subsequence_ofn(self, text) end

--- @param self string
--- @return PackedStringArray
function string.bigrams(self) end

--- @param self string
--- @param text String
--- @return float
function string.similarity(self, text) end

--- @param self string
--- @param values any
--- @param placeholder String? Default: "{_}"
--- @return String
function string.format(self, values, placeholder) end

--- @param self string
--- @param what String
--- @param forwhat String
--- @return String
function string.replace(self, what, forwhat) end

--- @param self string
--- @param what String
--- @param forwhat String
--- @return String
function string.replacen(self, what, forwhat) end

--- @param self string
--- @param key int
--- @param with int
--- @return String
function string.replace_char(self, key, with) end

--- @param self string
--- @param keys String
--- @param with int
--- @return String
function string.replace_chars(self, keys, with) end

--- @param self string
--- @param what int
--- @return String
function string.remove_char(self, what) end

--- @param self string
--- @param chars String
--- @return String
function string.remove_chars(self, chars) end

--- @param self string
--- @return String
function string.reverse(self) end

--- @param self string
--- @param position int
--- @param what String
--- @return String
function string.insert(self, position, what) end

--- @param self string
--- @param position int
--- @param chars int? Default: 1
--- @return String
function string.erase(self, position, chars) end

--- @param self string
--- @return String
function string.capitalize(self) end

--- @param self string
--- @return String
function string.to_camel_case(self) end

--- @param self string
--- @return String
function string.to_pascal_case(self) end

--- @param self string
--- @return String
function string.to_snake_case(self) end

--- @param self string
--- @return String
function string.to_kebab_case(self) end

--- @param self string
--- @param delimiter String? Default: ""
--- @param allow_empty bool? Default: true
--- @param maxsplit int? Default: 0
--- @return PackedStringArray
function string.split(self, delimiter, allow_empty, maxsplit) end

--- @param self string
--- @param delimiter String? Default: ""
--- @param allow_empty bool? Default: true
--- @param maxsplit int? Default: 0
--- @return PackedStringArray
function string.rsplit(self, delimiter, allow_empty, maxsplit) end

--- @param self string
--- @param delimiter String
--- @param allow_empty bool? Default: true
--- @return PackedFloat64Array
function string.split_floats(self, delimiter, allow_empty) end

--- @param self string
--- @param parts PackedStringArray
--- @return String
function string.join(self, parts) end

--- @param self string
--- @return String
function string.to_upper(self) end

--- @param self string
--- @return String
function string.to_lower(self) end

--- @param self string
--- @param length int
--- @return String
function string.left(self, length) end

--- @param self string
--- @param length int
--- @return String
function string.right(self, length) end

--- @param self string
--- @param left bool? Default: true
--- @param right bool? Default: true
--- @return String
function string.strip_edges(self, left, right) end

--- @param self string
--- @return String
function string.strip_escapes(self) end

--- @param self string
--- @param chars String
--- @return String
function string.lstrip(self, chars) end

--- @param self string
--- @param chars String
--- @return String
function string.rstrip(self, chars) end

--- @param self string
--- @return String
function string.get_extension(self) end

--- @param self string
--- @return String
function string.get_basename(self) end

--- @param self string
--- @param path String
--- @return String
function string.path_join(self, path) end

--- @param self string
--- @param at int
--- @return int
function string.unicode_at(self, at) end

--- @param self string
--- @param prefix String
--- @return String
function string.indent(self, prefix) end

--- @param self string
--- @return String
function string.dedent(self) end

--- @param self string
--- @return int
function string.hash(self) end

--- @param self string
--- @return String
function string.md5_text(self) end

--- @param self string
--- @return String
function string.sha1_text(self) end

--- @param self string
--- @return String
function string.sha256_text(self) end

--- @param self string
--- @return PackedByteArray
function string.md5_buffer(self) end

--- @param self string
--- @return PackedByteArray
function string.sha1_buffer(self) end

--- @param self string
--- @return PackedByteArray
function string.sha256_buffer(self) end

--- @param self string
--- @return bool
function string.is_empty(self) end

--- @param self string
--- @param what String
--- @return bool
function string.contains(self, what) end

--- @param self string
--- @param what String
--- @return bool
function string.containsn(self, what) end

--- @param self string
--- @return bool
function string.is_absolute_path(self) end

--- @param self string
--- @return bool
function string.is_relative_path(self) end

--- @param self string
--- @return String
function string.simplify_path(self) end

--- @param self string
--- @return String
function string.get_base_dir(self) end

--- @param self string
--- @return String
function string.get_file(self) end

--- @param self string
--- @param escape_quotes bool? Default: false
--- @return String
function string.xml_escape(self, escape_quotes) end

--- @param self string
--- @return String
function string.xml_unescape(self) end

--- @param self string
--- @return String
function string.uri_encode(self) end

--- @param self string
--- @return String
function string.uri_decode(self) end

--- @param self string
--- @return String
function string.uri_file_decode(self) end

--- @param self string
--- @return String
function string.c_escape(self) end

--- @param self string
--- @return String
function string.c_unescape(self) end

--- @param self string
--- @return String
function string.json_escape(self) end

--- @param self string
--- @return String
function string.validate_node_name(self) end

--- @param self string
--- @return String
function string.validate_filename(self) end

--- @param self string
--- @return bool
function string.is_valid_ascii_identifier(self) end

--- @param self string
--- @return bool
function string.is_valid_unicode_identifier(self) end

--- @param self string
--- @return bool
function string.is_valid_identifier(self) end

--- @param self string
--- @return bool
function string.is_valid_int(self) end

--- @param self string
--- @return bool
function string.is_valid_float(self) end

--- @param self string
--- @param with_prefix bool? Default: false
--- @return bool
function string.is_valid_hex_number(self, with_prefix) end

--- @param self string
--- @return bool
function string.is_valid_html_color(self) end

--- @param self string
--- @return bool
function string.is_valid_ip_address(self) end

--- @param self string
--- @return bool
function string.is_valid_filename(self) end

--- @param self string
--- @return int
function string.to_int(self) end

--- @param self string
--- @return float
function string.to_float(self) end

--- @param self string
--- @return int
function string.hex_to_int(self) end

--- @param self string
--- @return int
function string.bin_to_int(self) end

--- @param self string
--- @param min_length int
--- @param character String? Default: " "
--- @return String
function string.lpad(self, min_length, character) end

--- @param self string
--- @param min_length int
--- @param character String? Default: " "
--- @return String
function string.rpad(self, min_length, character) end

--- @param self string
--- @param digits int
--- @return String
function string.pad_decimals(self, digits) end

--- @param self string
--- @param digits int
--- @return String
function string.pad_zeros(self, digits) end

--- @param self string
--- @param prefix String
--- @return String
function string.trim_prefix(self, prefix) end

--- @param self string
--- @param suffix String
--- @return String
function string.trim_suffix(self, suffix) end

--- @param self string
--- @return PackedByteArray
function string.to_ascii_buffer(self) end

--- @param self string
--- @return PackedByteArray
function string.to_utf8_buffer(self) end

--- @param self string
--- @return PackedByteArray
function string.to_utf16_buffer(self) end

--- @param self string
--- @return PackedByteArray
function string.to_utf32_buffer(self) end

--- @param self string
--- @return PackedByteArray
function string.to_wchar_buffer(self) end

--- @param self string
--- @param encoding String? Default: ""
--- @return PackedByteArray
function string.to_multibyte_char_buffer(self, encoding) end

--- @param self string
--- @return PackedByteArray
function string.hex_decode(self) end

--- static
--- @param self string
--- @param number float
--- @return String
function string.num_scientific(self, number) end

--- static
--- @param self string
--- @param number float
--- @param decimals int? Default: -1
--- @return String
function string.num(self, number, decimals) end

--- static
--- @param self string
--- @param number int
--- @param base int? Default: 10
--- @param capitalize_hex bool? Default: false
--- @return String
function string.num_int64(self, number, base, capitalize_hex) end

--- static
--- @param self string
--- @param number int
--- @param base int? Default: 10
--- @param capitalize_hex bool? Default: false
--- @return String
function string.num_uint64(self, number, base, capitalize_hex) end

--- static
--- @param self string
--- @param code int
--- @return String
function string.chr(self, code) end

--- static
--- @param self string
--- @param size int
--- @return String
function string.humanize_size(self, size) end


-----------------------------------------------------------
-- Vector2
-----------------------------------------------------------

--- @class Vector2: Variant, { [int]: float? }
--- @field x float
--- @field y float
--- @overload fun(): Vector2
--- @overload fun(from: Vector2): Vector2
--- @overload fun(from: Vector2i): Vector2
--- @overload fun(x: float, y: float): Vector2
--- @operator unm(): Vector2
--- @operator mul(int): Vector2
--- @operator div(int): Vector2
--- @operator mul(float): Vector2
--- @operator div(float): Vector2
--- @operator add(Vector2): Vector2
--- @operator sub(Vector2): Vector2
--- @operator mul(Vector2): Vector2
--- @operator div(Vector2): Vector2
--- @operator mul(Transform2D): Vector2
Vector2 = {}

Vector2.ZERO = Vector2(0, 0)
Vector2.ONE = Vector2(1, 1)
Vector2.INF = Vector2(math.huge, math.huge)
Vector2.LEFT = Vector2(-1, 0)
Vector2.RIGHT = Vector2(1, 0)
Vector2.UP = Vector2(0, -1)
Vector2.DOWN = Vector2(0, 1)

--- @enum Vector2.Axis
Vector2.Axis = {
	AXIS_X = 0,
	AXIS_Y = 1,
}

--- @return float
function Vector2:angle() end

--- @param to Vector2
--- @return float
function Vector2:angle_to(to) end

--- @param to Vector2
--- @return float
function Vector2:angle_to_point(to) end

--- @param to Vector2
--- @return Vector2
function Vector2:direction_to(to) end

--- @param to Vector2
--- @return float
function Vector2:distance_to(to) end

--- @param to Vector2
--- @return float
function Vector2:distance_squared_to(to) end

--- @return float
function Vector2:length() end

--- @return float
function Vector2:length_squared() end

--- @param length float? Default: 1.0
--- @return Vector2
function Vector2:limit_length(length) end

--- @return Vector2
function Vector2:normalized() end

--- @return bool
function Vector2:is_normalized() end

--- @param to Vector2
--- @return bool
function Vector2:is_equal_approx(to) end

--- @return bool
function Vector2:is_zero_approx() end

--- @return bool
function Vector2:is_finite() end

--- @param mod float
--- @return Vector2
function Vector2:posmod(mod) end

--- @param modv Vector2
--- @return Vector2
function Vector2:posmodv(modv) end

--- @param b Vector2
--- @return Vector2
function Vector2:project(b) end

--- @param to Vector2
--- @param weight float
--- @return Vector2
function Vector2:lerp(to, weight) end

--- @param to Vector2
--- @param weight float
--- @return Vector2
function Vector2:slerp(to, weight) end

--- @param b Vector2
--- @param pre_a Vector2
--- @param post_b Vector2
--- @param weight float
--- @return Vector2
function Vector2:cubic_interpolate(b, pre_a, post_b, weight) end

--- @param b Vector2
--- @param pre_a Vector2
--- @param post_b Vector2
--- @param weight float
--- @param b_t float
--- @param pre_a_t float
--- @param post_b_t float
--- @return Vector2
function Vector2:cubic_interpolate_in_time(b, pre_a, post_b, weight, b_t, pre_a_t, post_b_t) end

--- @param control_1 Vector2
--- @param control_2 Vector2
--- @param _end Vector2
--- @param t float
--- @return Vector2
function Vector2:bezier_interpolate(control_1, control_2, _end, t) end

--- @param control_1 Vector2
--- @param control_2 Vector2
--- @param _end Vector2
--- @param t float
--- @return Vector2
function Vector2:bezier_derivative(control_1, control_2, _end, t) end

--- @return int
function Vector2:max_axis_index() end

--- @return int
function Vector2:min_axis_index() end

--- @param to Vector2
--- @param delta float
--- @return Vector2
function Vector2:move_toward(to, delta) end

--- @param angle float
--- @return Vector2
function Vector2:rotated(angle) end

--- @return Vector2
function Vector2:orthogonal() end

--- @return Vector2
function Vector2:floor() end

--- @return Vector2
function Vector2:ceil() end

--- @return Vector2
function Vector2:round() end

--- @return float
function Vector2:aspect() end

--- @param with Vector2
--- @return float
function Vector2:dot(with) end

--- @param n Vector2
--- @return Vector2
function Vector2:slide(n) end

--- @param n Vector2
--- @return Vector2
function Vector2:bounce(n) end

--- @param line Vector2
--- @return Vector2
function Vector2:reflect(line) end

--- @param with Vector2
--- @return float
function Vector2:cross(with) end

--- @return Vector2
function Vector2:abs() end

--- @return Vector2
function Vector2:sign() end

--- @param min Vector2
--- @param max Vector2
--- @return Vector2
function Vector2:clamp(min, max) end

--- @param min float
--- @param max float
--- @return Vector2
function Vector2:clampf(min, max) end

--- @param step Vector2
--- @return Vector2
function Vector2:snapped(step) end

--- @param step float
--- @return Vector2
function Vector2:snappedf(step) end

--- @param with Vector2
--- @return Vector2
function Vector2:min(with) end

--- @param with float
--- @return Vector2
function Vector2:minf(with) end

--- @param with Vector2
--- @return Vector2
function Vector2:max(with) end

--- @param with float
--- @return Vector2
function Vector2:maxf(with) end

--- static
--- @param angle float
--- @return Vector2
function Vector2:from_angle(angle) end


-----------------------------------------------------------
-- Vector2i
-----------------------------------------------------------

--- @class Vector2i: Variant, { [int]: int? }
--- @field x int
--- @field y int
--- @overload fun(): Vector2i
--- @overload fun(from: Vector2i): Vector2i
--- @overload fun(from: Vector2): Vector2i
--- @overload fun(x: int, y: int): Vector2i
--- @operator unm(): Vector2i
--- @operator mul(int): Vector2i
--- @operator div(int): Vector2i
--- @operator mod(int): Vector2i
--- @operator mul(float): Vector2
--- @operator div(float): Vector2
--- @operator add(Vector2i): Vector2i
--- @operator sub(Vector2i): Vector2i
--- @operator mul(Vector2i): Vector2i
--- @operator div(Vector2i): Vector2i
--- @operator mod(Vector2i): Vector2i
Vector2i = {}

Vector2i.ZERO = Vector2i(0, 0)
Vector2i.ONE = Vector2i(1, 1)
Vector2i.MIN = Vector2i(-2147483648, -2147483648)
Vector2i.MAX = Vector2i(2147483647, 2147483647)
Vector2i.LEFT = Vector2i(-1, 0)
Vector2i.RIGHT = Vector2i(1, 0)
Vector2i.UP = Vector2i(0, -1)
Vector2i.DOWN = Vector2i(0, 1)

--- @enum Vector2i.Axis
Vector2i.Axis = {
	AXIS_X = 0,
	AXIS_Y = 1,
}

--- @return float
function Vector2i:aspect() end

--- @return int
function Vector2i:max_axis_index() end

--- @return int
function Vector2i:min_axis_index() end

--- @param to Vector2i
--- @return float
function Vector2i:distance_to(to) end

--- @param to Vector2i
--- @return int
function Vector2i:distance_squared_to(to) end

--- @return float
function Vector2i:length() end

--- @return int
function Vector2i:length_squared() end

--- @return Vector2i
function Vector2i:sign() end

--- @return Vector2i
function Vector2i:abs() end

--- @param min Vector2i
--- @param max Vector2i
--- @return Vector2i
function Vector2i:clamp(min, max) end

--- @param min int
--- @param max int
--- @return Vector2i
function Vector2i:clampi(min, max) end

--- @param step Vector2i
--- @return Vector2i
function Vector2i:snapped(step) end

--- @param step int
--- @return Vector2i
function Vector2i:snappedi(step) end

--- @param with Vector2i
--- @return Vector2i
function Vector2i:min(with) end

--- @param with int
--- @return Vector2i
function Vector2i:mini(with) end

--- @param with Vector2i
--- @return Vector2i
function Vector2i:max(with) end

--- @param with int
--- @return Vector2i
function Vector2i:maxi(with) end


-----------------------------------------------------------
-- Rect2
-----------------------------------------------------------

--- @class Rect2: Variant
--- @field position Vector2
--- @field size Vector2
--- @field end Vector2
--- @overload fun(): Rect2
--- @overload fun(from: Rect2): Rect2
--- @overload fun(from: Rect2i): Rect2
--- @overload fun(position: Vector2, size: Vector2): Rect2
--- @overload fun(x: float, y: float, width: float, height: float): Rect2
--- @operator mul(Transform2D): Rect2
Rect2 = {}

--- @return Vector2
function Rect2:get_center() end

--- @return float
function Rect2:get_area() end

--- @return bool
function Rect2:has_area() end

--- @param point Vector2
--- @return bool
function Rect2:has_point(point) end

--- @param rect Rect2
--- @return bool
function Rect2:is_equal_approx(rect) end

--- @return bool
function Rect2:is_finite() end

--- @param b Rect2
--- @param include_borders bool? Default: false
--- @return bool
function Rect2:intersects(b, include_borders) end

--- @param b Rect2
--- @return bool
function Rect2:encloses(b) end

--- @param b Rect2
--- @return Rect2
function Rect2:intersection(b) end

--- @param b Rect2
--- @return Rect2
function Rect2:merge(b) end

--- @param to Vector2
--- @return Rect2
function Rect2:expand(to) end

--- @param direction Vector2
--- @return Vector2
function Rect2:get_support(direction) end

--- @param amount float
--- @return Rect2
function Rect2:grow(amount) end

--- @param side int
--- @param amount float
--- @return Rect2
function Rect2:grow_side(side, amount) end

--- @param left float
--- @param top float
--- @param right float
--- @param bottom float
--- @return Rect2
function Rect2:grow_individual(left, top, right, bottom) end

--- @return Rect2
function Rect2:abs() end


-----------------------------------------------------------
-- Rect2i
-----------------------------------------------------------

--- @class Rect2i: Variant
--- @field position Vector2i
--- @field size Vector2i
--- @field end Vector2i
--- @overload fun(): Rect2i
--- @overload fun(from: Rect2i): Rect2i
--- @overload fun(from: Rect2): Rect2i
--- @overload fun(position: Vector2i, size: Vector2i): Rect2i
--- @overload fun(x: int, y: int, width: int, height: int): Rect2i
Rect2i = {}

--- @return Vector2i
function Rect2i:get_center() end

--- @return int
function Rect2i:get_area() end

--- @return bool
function Rect2i:has_area() end

--- @param point Vector2i
--- @return bool
function Rect2i:has_point(point) end

--- @param b Rect2i
--- @return bool
function Rect2i:intersects(b) end

--- @param b Rect2i
--- @return bool
function Rect2i:encloses(b) end

--- @param b Rect2i
--- @return Rect2i
function Rect2i:intersection(b) end

--- @param b Rect2i
--- @return Rect2i
function Rect2i:merge(b) end

--- @param to Vector2i
--- @return Rect2i
function Rect2i:expand(to) end

--- @param amount int
--- @return Rect2i
function Rect2i:grow(amount) end

--- @param side int
--- @param amount int
--- @return Rect2i
function Rect2i:grow_side(side, amount) end

--- @param left int
--- @param top int
--- @param right int
--- @param bottom int
--- @return Rect2i
function Rect2i:grow_individual(left, top, right, bottom) end

--- @return Rect2i
function Rect2i:abs() end


-----------------------------------------------------------
-- Vector3
-----------------------------------------------------------

--- @class Vector3: Variant, { [int]: float? }
--- @field x float
--- @field y float
--- @field z float
--- @overload fun(): Vector3
--- @overload fun(from: Vector3): Vector3
--- @overload fun(from: Vector3i): Vector3
--- @overload fun(x: float, y: float, z: float): Vector3
--- @operator unm(): Vector3
--- @operator mul(int): Vector3
--- @operator div(int): Vector3
--- @operator mul(float): Vector3
--- @operator div(float): Vector3
--- @operator add(Vector3): Vector3
--- @operator sub(Vector3): Vector3
--- @operator mul(Vector3): Vector3
--- @operator div(Vector3): Vector3
--- @operator mul(Quaternion): Vector3
--- @operator mul(Basis): Vector3
--- @operator mul(Transform3D): Vector3
Vector3 = {}

Vector3.ZERO = Vector3(0, 0, 0)
Vector3.ONE = Vector3(1, 1, 1)
Vector3.INF = Vector3(math.huge, math.huge, math.huge)
Vector3.LEFT = Vector3(-1, 0, 0)
Vector3.RIGHT = Vector3(1, 0, 0)
Vector3.UP = Vector3(0, 1, 0)
Vector3.DOWN = Vector3(0, -1, 0)
Vector3.FORWARD = Vector3(0, 0, -1)
Vector3.BACK = Vector3(0, 0, 1)
Vector3.MODEL_LEFT = Vector3(1, 0, 0)
Vector3.MODEL_RIGHT = Vector3(-1, 0, 0)
Vector3.MODEL_TOP = Vector3(0, 1, 0)
Vector3.MODEL_BOTTOM = Vector3(0, -1, 0)
Vector3.MODEL_FRONT = Vector3(0, 0, 1)
Vector3.MODEL_REAR = Vector3(0, 0, -1)

--- @enum Vector3.Axis
Vector3.Axis = {
	AXIS_X = 0,
	AXIS_Y = 1,
	AXIS_Z = 2,
}

--- @return int
function Vector3:min_axis_index() end

--- @return int
function Vector3:max_axis_index() end

--- @param to Vector3
--- @return float
function Vector3:angle_to(to) end

--- @param to Vector3
--- @param axis Vector3
--- @return float
function Vector3:signed_angle_to(to, axis) end

--- @param to Vector3
--- @return Vector3
function Vector3:direction_to(to) end

--- @param to Vector3
--- @return float
function Vector3:distance_to(to) end

--- @param to Vector3
--- @return float
function Vector3:distance_squared_to(to) end

--- @return float
function Vector3:length() end

--- @return float
function Vector3:length_squared() end

--- @param length float? Default: 1.0
--- @return Vector3
function Vector3:limit_length(length) end

--- @return Vector3
function Vector3:normalized() end

--- @return bool
function Vector3:is_normalized() end

--- @param to Vector3
--- @return bool
function Vector3:is_equal_approx(to) end

--- @return bool
function Vector3:is_zero_approx() end

--- @return bool
function Vector3:is_finite() end

--- @return Vector3
function Vector3:inverse() end

--- @param min Vector3
--- @param max Vector3
--- @return Vector3
function Vector3:clamp(min, max) end

--- @param min float
--- @param max float
--- @return Vector3
function Vector3:clampf(min, max) end

--- @param step Vector3
--- @return Vector3
function Vector3:snapped(step) end

--- @param step float
--- @return Vector3
function Vector3:snappedf(step) end

--- @param axis Vector3
--- @param angle float
--- @return Vector3
function Vector3:rotated(axis, angle) end

--- @param to Vector3
--- @param weight float
--- @return Vector3
function Vector3:lerp(to, weight) end

--- @param to Vector3
--- @param weight float
--- @return Vector3
function Vector3:slerp(to, weight) end

--- @param b Vector3
--- @param pre_a Vector3
--- @param post_b Vector3
--- @param weight float
--- @return Vector3
function Vector3:cubic_interpolate(b, pre_a, post_b, weight) end

--- @param b Vector3
--- @param pre_a Vector3
--- @param post_b Vector3
--- @param weight float
--- @param b_t float
--- @param pre_a_t float
--- @param post_b_t float
--- @return Vector3
function Vector3:cubic_interpolate_in_time(b, pre_a, post_b, weight, b_t, pre_a_t, post_b_t) end

--- @param control_1 Vector3
--- @param control_2 Vector3
--- @param _end Vector3
--- @param t float
--- @return Vector3
function Vector3:bezier_interpolate(control_1, control_2, _end, t) end

--- @param control_1 Vector3
--- @param control_2 Vector3
--- @param _end Vector3
--- @param t float
--- @return Vector3
function Vector3:bezier_derivative(control_1, control_2, _end, t) end

--- @param to Vector3
--- @param delta float
--- @return Vector3
function Vector3:move_toward(to, delta) end

--- @param with Vector3
--- @return float
function Vector3:dot(with) end

--- @param with Vector3
--- @return Vector3
function Vector3:cross(with) end

--- @param with Vector3
--- @return Basis
function Vector3:outer(with) end

--- @return Vector3
function Vector3:abs() end

--- @return Vector3
function Vector3:floor() end

--- @return Vector3
function Vector3:ceil() end

--- @return Vector3
function Vector3:round() end

--- @param mod float
--- @return Vector3
function Vector3:posmod(mod) end

--- @param modv Vector3
--- @return Vector3
function Vector3:posmodv(modv) end

--- @param b Vector3
--- @return Vector3
function Vector3:project(b) end

--- @param n Vector3
--- @return Vector3
function Vector3:slide(n) end

--- @param n Vector3
--- @return Vector3
function Vector3:bounce(n) end

--- @param n Vector3
--- @return Vector3
function Vector3:reflect(n) end

--- @return Vector3
function Vector3:sign() end

--- @return Vector2
function Vector3:octahedron_encode() end

--- @param with Vector3
--- @return Vector3
function Vector3:min(with) end

--- @param with float
--- @return Vector3
function Vector3:minf(with) end

--- @param with Vector3
--- @return Vector3
function Vector3:max(with) end

--- @param with float
--- @return Vector3
function Vector3:maxf(with) end

--- static
--- @param uv Vector2
--- @return Vector3
function Vector3:octahedron_decode(uv) end


-----------------------------------------------------------
-- Vector3i
-----------------------------------------------------------

--- @class Vector3i: Variant, { [int]: int? }
--- @field x int
--- @field y int
--- @field z int
--- @overload fun(): Vector3i
--- @overload fun(from: Vector3i): Vector3i
--- @overload fun(from: Vector3): Vector3i
--- @overload fun(x: int, y: int, z: int): Vector3i
--- @operator unm(): Vector3i
--- @operator mul(int): Vector3i
--- @operator div(int): Vector3i
--- @operator mod(int): Vector3i
--- @operator mul(float): Vector3
--- @operator div(float): Vector3
--- @operator add(Vector3i): Vector3i
--- @operator sub(Vector3i): Vector3i
--- @operator mul(Vector3i): Vector3i
--- @operator div(Vector3i): Vector3i
--- @operator mod(Vector3i): Vector3i
Vector3i = {}

Vector3i.ZERO = Vector3i(0, 0, 0)
Vector3i.ONE = Vector3i(1, 1, 1)
Vector3i.MIN = Vector3i(-2147483648, -2147483648, -2147483648)
Vector3i.MAX = Vector3i(2147483647, 2147483647, 2147483647)
Vector3i.LEFT = Vector3i(-1, 0, 0)
Vector3i.RIGHT = Vector3i(1, 0, 0)
Vector3i.UP = Vector3i(0, 1, 0)
Vector3i.DOWN = Vector3i(0, -1, 0)
Vector3i.FORWARD = Vector3i(0, 0, -1)
Vector3i.BACK = Vector3i(0, 0, 1)

--- @enum Vector3i.Axis
Vector3i.Axis = {
	AXIS_X = 0,
	AXIS_Y = 1,
	AXIS_Z = 2,
}

--- @return int
function Vector3i:min_axis_index() end

--- @return int
function Vector3i:max_axis_index() end

--- @param to Vector3i
--- @return float
function Vector3i:distance_to(to) end

--- @param to Vector3i
--- @return int
function Vector3i:distance_squared_to(to) end

--- @return float
function Vector3i:length() end

--- @return int
function Vector3i:length_squared() end

--- @return Vector3i
function Vector3i:sign() end

--- @return Vector3i
function Vector3i:abs() end

--- @param min Vector3i
--- @param max Vector3i
--- @return Vector3i
function Vector3i:clamp(min, max) end

--- @param min int
--- @param max int
--- @return Vector3i
function Vector3i:clampi(min, max) end

--- @param step Vector3i
--- @return Vector3i
function Vector3i:snapped(step) end

--- @param step int
--- @return Vector3i
function Vector3i:snappedi(step) end

--- @param with Vector3i
--- @return Vector3i
function Vector3i:min(with) end

--- @param with int
--- @return Vector3i
function Vector3i:mini(with) end

--- @param with Vector3i
--- @return Vector3i
function Vector3i:max(with) end

--- @param with int
--- @return Vector3i
function Vector3i:maxi(with) end


-----------------------------------------------------------
-- Transform2D
-----------------------------------------------------------

--- @class Transform2D: Variant, { [int]: Vector2? }
--- @field x Vector2
--- @field y Vector2
--- @field origin Vector2
--- @overload fun(): Transform2D
--- @overload fun(from: Transform2D): Transform2D
--- @overload fun(rotation: float, position: Vector2): Transform2D
--- @overload fun(rotation: float, scale: Vector2, skew: float, position: Vector2): Transform2D
--- @overload fun(x_axis: Vector2, y_axis: Vector2, origin: Vector2): Transform2D
--- @operator mul(int): Transform2D
--- @operator div(int): Transform2D
--- @operator mul(float): Transform2D
--- @operator div(float): Transform2D
--- @operator mul(Vector2): Vector2
--- @operator mul(Rect2): Rect2
--- @operator mul(Transform2D): Transform2D
--- @operator mul(PackedVector2Array): PackedVector2Array
Transform2D = {}

Transform2D.IDENTITY = Transform2D(1, 0, 0, 1, 0, 0)
Transform2D.FLIP_X = Transform2D(-1, 0, 0, 1, 0, 0)
Transform2D.FLIP_Y = Transform2D(1, 0, 0, -1, 0, 0)

--- @return Transform2D
function Transform2D:inverse() end

--- @return Transform2D
function Transform2D:affine_inverse() end

--- @return float
function Transform2D:get_rotation() end

--- @return Vector2
function Transform2D:get_origin() end

--- @return Vector2
function Transform2D:get_scale() end

--- @return float
function Transform2D:get_skew() end

--- @return Transform2D
function Transform2D:orthonormalized() end

--- @param angle float
--- @return Transform2D
function Transform2D:rotated(angle) end

--- @param angle float
--- @return Transform2D
function Transform2D:rotated_local(angle) end

--- @param scale Vector2
--- @return Transform2D
function Transform2D:scaled(scale) end

--- @param scale Vector2
--- @return Transform2D
function Transform2D:scaled_local(scale) end

--- @param offset Vector2
--- @return Transform2D
function Transform2D:translated(offset) end

--- @param offset Vector2
--- @return Transform2D
function Transform2D:translated_local(offset) end

--- @return float
function Transform2D:determinant() end

--- @param v Vector2
--- @return Vector2
function Transform2D:basis_xform(v) end

--- @param v Vector2
--- @return Vector2
function Transform2D:basis_xform_inv(v) end

--- @param xform Transform2D
--- @param weight float
--- @return Transform2D
function Transform2D:interpolate_with(xform, weight) end

--- @return bool
function Transform2D:is_conformal() end

--- @param xform Transform2D
--- @return bool
function Transform2D:is_equal_approx(xform) end

--- @return bool
function Transform2D:is_finite() end

--- @param target Vector2? Default: Vector2(0, 0)
--- @return Transform2D
function Transform2D:looking_at(target) end


-----------------------------------------------------------
-- Vector4
-----------------------------------------------------------

--- @class Vector4: Variant, { [int]: float? }
--- @field x float
--- @field y float
--- @field z float
--- @field w float
--- @overload fun(): Vector4
--- @overload fun(from: Vector4): Vector4
--- @overload fun(from: Vector4i): Vector4
--- @overload fun(x: float, y: float, z: float, w: float): Vector4
--- @operator unm(): Vector4
--- @operator mul(int): Vector4
--- @operator div(int): Vector4
--- @operator mul(float): Vector4
--- @operator div(float): Vector4
--- @operator add(Vector4): Vector4
--- @operator sub(Vector4): Vector4
--- @operator mul(Vector4): Vector4
--- @operator div(Vector4): Vector4
--- @operator mul(Projection): Vector4
Vector4 = {}

Vector4.ZERO = Vector4(0, 0, 0, 0)
Vector4.ONE = Vector4(1, 1, 1, 1)
Vector4.INF = Vector4(math.huge, math.huge, math.huge, math.huge)

--- @enum Vector4.Axis
Vector4.Axis = {
	AXIS_X = 0,
	AXIS_Y = 1,
	AXIS_Z = 2,
	AXIS_W = 3,
}

--- @return int
function Vector4:min_axis_index() end

--- @return int
function Vector4:max_axis_index() end

--- @return float
function Vector4:length() end

--- @return float
function Vector4:length_squared() end

--- @return Vector4
function Vector4:abs() end

--- @return Vector4
function Vector4:sign() end

--- @return Vector4
function Vector4:floor() end

--- @return Vector4
function Vector4:ceil() end

--- @return Vector4
function Vector4:round() end

--- @param to Vector4
--- @param weight float
--- @return Vector4
function Vector4:lerp(to, weight) end

--- @param b Vector4
--- @param pre_a Vector4
--- @param post_b Vector4
--- @param weight float
--- @return Vector4
function Vector4:cubic_interpolate(b, pre_a, post_b, weight) end

--- @param b Vector4
--- @param pre_a Vector4
--- @param post_b Vector4
--- @param weight float
--- @param b_t float
--- @param pre_a_t float
--- @param post_b_t float
--- @return Vector4
function Vector4:cubic_interpolate_in_time(b, pre_a, post_b, weight, b_t, pre_a_t, post_b_t) end

--- @param mod float
--- @return Vector4
function Vector4:posmod(mod) end

--- @param modv Vector4
--- @return Vector4
function Vector4:posmodv(modv) end

--- @param step Vector4
--- @return Vector4
function Vector4:snapped(step) end

--- @param step float
--- @return Vector4
function Vector4:snappedf(step) end

--- @param min Vector4
--- @param max Vector4
--- @return Vector4
function Vector4:clamp(min, max) end

--- @param min float
--- @param max float
--- @return Vector4
function Vector4:clampf(min, max) end

--- @return Vector4
function Vector4:normalized() end

--- @return bool
function Vector4:is_normalized() end

--- @param to Vector4
--- @return Vector4
function Vector4:direction_to(to) end

--- @param to Vector4
--- @return float
function Vector4:distance_to(to) end

--- @param to Vector4
--- @return float
function Vector4:distance_squared_to(to) end

--- @param with Vector4
--- @return float
function Vector4:dot(with) end

--- @return Vector4
function Vector4:inverse() end

--- @param to Vector4
--- @return bool
function Vector4:is_equal_approx(to) end

--- @return bool
function Vector4:is_zero_approx() end

--- @return bool
function Vector4:is_finite() end

--- @param with Vector4
--- @return Vector4
function Vector4:min(with) end

--- @param with float
--- @return Vector4
function Vector4:minf(with) end

--- @param with Vector4
--- @return Vector4
function Vector4:max(with) end

--- @param with float
--- @return Vector4
function Vector4:maxf(with) end


-----------------------------------------------------------
-- Vector4i
-----------------------------------------------------------

--- @class Vector4i: Variant, { [int]: int? }
--- @field x int
--- @field y int
--- @field z int
--- @field w int
--- @overload fun(): Vector4i
--- @overload fun(from: Vector4i): Vector4i
--- @overload fun(from: Vector4): Vector4i
--- @overload fun(x: int, y: int, z: int, w: int): Vector4i
--- @operator unm(): Vector4i
--- @operator mul(int): Vector4i
--- @operator div(int): Vector4i
--- @operator mod(int): Vector4i
--- @operator mul(float): Vector4
--- @operator div(float): Vector4
--- @operator add(Vector4i): Vector4i
--- @operator sub(Vector4i): Vector4i
--- @operator mul(Vector4i): Vector4i
--- @operator div(Vector4i): Vector4i
--- @operator mod(Vector4i): Vector4i
Vector4i = {}

Vector4i.ZERO = Vector4i(0, 0, 0, 0)
Vector4i.ONE = Vector4i(1, 1, 1, 1)
Vector4i.MIN = Vector4i(-2147483648, -2147483648, -2147483648, -2147483648)
Vector4i.MAX = Vector4i(2147483647, 2147483647, 2147483647, 2147483647)

--- @enum Vector4i.Axis
Vector4i.Axis = {
	AXIS_X = 0,
	AXIS_Y = 1,
	AXIS_Z = 2,
	AXIS_W = 3,
}

--- @return int
function Vector4i:min_axis_index() end

--- @return int
function Vector4i:max_axis_index() end

--- @return float
function Vector4i:length() end

--- @return int
function Vector4i:length_squared() end

--- @return Vector4i
function Vector4i:sign() end

--- @return Vector4i
function Vector4i:abs() end

--- @param min Vector4i
--- @param max Vector4i
--- @return Vector4i
function Vector4i:clamp(min, max) end

--- @param min int
--- @param max int
--- @return Vector4i
function Vector4i:clampi(min, max) end

--- @param step Vector4i
--- @return Vector4i
function Vector4i:snapped(step) end

--- @param step int
--- @return Vector4i
function Vector4i:snappedi(step) end

--- @param with Vector4i
--- @return Vector4i
function Vector4i:min(with) end

--- @param with int
--- @return Vector4i
function Vector4i:mini(with) end

--- @param with Vector4i
--- @return Vector4i
function Vector4i:max(with) end

--- @param with int
--- @return Vector4i
function Vector4i:maxi(with) end

--- @param to Vector4i
--- @return float
function Vector4i:distance_to(to) end

--- @param to Vector4i
--- @return int
function Vector4i:distance_squared_to(to) end


-----------------------------------------------------------
-- Plane
-----------------------------------------------------------

--- @class Plane: Variant
--- @field x float
--- @field y float
--- @field z float
--- @field d float
--- @field normal Vector3
--- @overload fun(): Plane
--- @overload fun(from: Plane): Plane
--- @overload fun(normal: Vector3): Plane
--- @overload fun(normal: Vector3, d: float): Plane
--- @overload fun(normal: Vector3, point: Vector3): Plane
--- @overload fun(point1: Vector3, point2: Vector3, point3: Vector3): Plane
--- @overload fun(a: float, b: float, c: float, d: float): Plane
--- @operator unm(): Plane
--- @operator mul(Transform3D): Plane
Plane = {}

Plane.PLANE_YZ = Plane(1, 0, 0, 0)
Plane.PLANE_XZ = Plane(0, 1, 0, 0)
Plane.PLANE_XY = Plane(0, 0, 1, 0)

--- @return Plane
function Plane:normalized() end

--- @return Vector3
function Plane:get_center() end

--- @param to_plane Plane
--- @return bool
function Plane:is_equal_approx(to_plane) end

--- @return bool
function Plane:is_finite() end

--- @param point Vector3
--- @return bool
function Plane:is_point_over(point) end

--- @param point Vector3
--- @return float
function Plane:distance_to(point) end

--- @param point Vector3
--- @param tolerance float? Default: 1e-05
--- @return bool
function Plane:has_point(point, tolerance) end

--- @param point Vector3
--- @return Vector3
function Plane:project(point) end

--- @param b Plane
--- @param c Plane
--- @return any
function Plane:intersect_3(b, c) end

--- @param from Vector3
--- @param dir Vector3
--- @return any
function Plane:intersects_ray(from, dir) end

--- @param from Vector3
--- @param to Vector3
--- @return any
function Plane:intersects_segment(from, to) end


-----------------------------------------------------------
-- Quaternion
-----------------------------------------------------------

--- @class Quaternion: Variant, { [int]: float? }
--- @field x float
--- @field y float
--- @field z float
--- @field w float
--- @overload fun(): Quaternion
--- @overload fun(from: Quaternion): Quaternion
--- @overload fun(from: Basis): Quaternion
--- @overload fun(axis: Vector3, angle: float): Quaternion
--- @overload fun(arc_from: Vector3, arc_to: Vector3): Quaternion
--- @overload fun(x: float, y: float, z: float, w: float): Quaternion
--- @operator unm(): Quaternion
--- @operator mul(int): Quaternion
--- @operator div(int): Quaternion
--- @operator mul(float): Quaternion
--- @operator div(float): Quaternion
--- @operator mul(Vector3): Vector3
--- @operator add(Quaternion): Quaternion
--- @operator sub(Quaternion): Quaternion
--- @operator mul(Quaternion): Quaternion
Quaternion = {}

Quaternion.IDENTITY = Quaternion(0, 0, 0, 1)

--- @return float
function Quaternion:length() end

--- @return float
function Quaternion:length_squared() end

--- @return Quaternion
function Quaternion:normalized() end

--- @return bool
function Quaternion:is_normalized() end

--- @param to Quaternion
--- @return bool
function Quaternion:is_equal_approx(to) end

--- @return bool
function Quaternion:is_finite() end

--- @return Quaternion
function Quaternion:inverse() end

--- @return Quaternion
function Quaternion:log() end

--- @return Quaternion
function Quaternion:exp() end

--- @param to Quaternion
--- @return float
function Quaternion:angle_to(to) end

--- @param with Quaternion
--- @return float
function Quaternion:dot(with) end

--- @param to Quaternion
--- @param weight float
--- @return Quaternion
function Quaternion:slerp(to, weight) end

--- @param to Quaternion
--- @param weight float
--- @return Quaternion
function Quaternion:slerpni(to, weight) end

--- @param b Quaternion
--- @param pre_a Quaternion
--- @param post_b Quaternion
--- @param weight float
--- @return Quaternion
function Quaternion:spherical_cubic_interpolate(b, pre_a, post_b, weight) end

--- @param b Quaternion
--- @param pre_a Quaternion
--- @param post_b Quaternion
--- @param weight float
--- @param b_t float
--- @param pre_a_t float
--- @param post_b_t float
--- @return Quaternion
function Quaternion:spherical_cubic_interpolate_in_time(b, pre_a, post_b, weight, b_t, pre_a_t, post_b_t) end

--- @param order int? Default: 2
--- @return Vector3
function Quaternion:get_euler(order) end

--- static
--- @param euler Vector3
--- @return Quaternion
function Quaternion:from_euler(euler) end

--- @return Vector3
function Quaternion:get_axis() end

--- @return float
function Quaternion:get_angle() end


-----------------------------------------------------------
-- AABB
-----------------------------------------------------------

--- @class AABB: Variant
--- @field position Vector3
--- @field size Vector3
--- @field end Vector3
--- @overload fun(): AABB
--- @overload fun(from: AABB): AABB
--- @overload fun(position: Vector3, size: Vector3): AABB
--- @operator mul(Transform3D): AABB
AABB = {}

--- @return AABB
function AABB:abs() end

--- @return Vector3
function AABB:get_center() end

--- @return float
function AABB:get_volume() end

--- @return bool
function AABB:has_volume() end

--- @return bool
function AABB:has_surface() end

--- @param point Vector3
--- @return bool
function AABB:has_point(point) end

--- @param aabb AABB
--- @return bool
function AABB:is_equal_approx(aabb) end

--- @return bool
function AABB:is_finite() end

--- @param with AABB
--- @return bool
function AABB:intersects(with) end

--- @param with AABB
--- @return bool
function AABB:encloses(with) end

--- @param plane Plane
--- @return bool
function AABB:intersects_plane(plane) end

--- @param with AABB
--- @return AABB
function AABB:intersection(with) end

--- @param with AABB
--- @return AABB
function AABB:merge(with) end

--- @param to_point Vector3
--- @return AABB
function AABB:expand(to_point) end

--- @param by float
--- @return AABB
function AABB:grow(by) end

--- @param direction Vector3
--- @return Vector3
function AABB:get_support(direction) end

--- @return Vector3
function AABB:get_longest_axis() end

--- @return int
function AABB:get_longest_axis_index() end

--- @return float
function AABB:get_longest_axis_size() end

--- @return Vector3
function AABB:get_shortest_axis() end

--- @return int
function AABB:get_shortest_axis_index() end

--- @return float
function AABB:get_shortest_axis_size() end

--- @param idx int
--- @return Vector3
function AABB:get_endpoint(idx) end

--- @param from Vector3
--- @param to Vector3
--- @return any
function AABB:intersects_segment(from, to) end

--- @param from Vector3
--- @param dir Vector3
--- @return any
function AABB:intersects_ray(from, dir) end


-----------------------------------------------------------
-- Basis
-----------------------------------------------------------

--- @class Basis: Variant, { [int]: Vector3? }
--- @field x Vector3
--- @field y Vector3
--- @field z Vector3
--- @overload fun(): Basis
--- @overload fun(from: Basis): Basis
--- @overload fun(from: Quaternion): Basis
--- @overload fun(axis: Vector3, angle: float): Basis
--- @overload fun(x_axis: Vector3, y_axis: Vector3, z_axis: Vector3): Basis
--- @operator mul(int): Basis
--- @operator div(int): Basis
--- @operator mul(float): Basis
--- @operator div(float): Basis
--- @operator mul(Vector3): Vector3
--- @operator mul(Basis): Basis
Basis = {}

Basis.IDENTITY = Basis(1, 0, 0, 0, 1, 0, 0, 0, 1)
Basis.FLIP_X = Basis(-1, 0, 0, 0, 1, 0, 0, 0, 1)
Basis.FLIP_Y = Basis(1, 0, 0, 0, -1, 0, 0, 0, 1)
Basis.FLIP_Z = Basis(1, 0, 0, 0, 1, 0, 0, 0, -1)

--- @return Basis
function Basis:inverse() end

--- @return Basis
function Basis:transposed() end

--- @return Basis
function Basis:orthonormalized() end

--- @return float
function Basis:determinant() end

--- @param axis Vector3
--- @param angle float
--- @return Basis
function Basis:rotated(axis, angle) end

--- @param scale Vector3
--- @return Basis
function Basis:scaled(scale) end

--- @param scale Vector3
--- @return Basis
function Basis:scaled_local(scale) end

--- @return Vector3
function Basis:get_scale() end

--- @param order int? Default: 2
--- @return Vector3
function Basis:get_euler(order) end

--- @param with Vector3
--- @return float
function Basis:tdotx(with) end

--- @param with Vector3
--- @return float
function Basis:tdoty(with) end

--- @param with Vector3
--- @return float
function Basis:tdotz(with) end

--- @param to Basis
--- @param weight float
--- @return Basis
function Basis:slerp(to, weight) end

--- @return bool
function Basis:is_conformal() end

--- @param b Basis
--- @return bool
function Basis:is_equal_approx(b) end

--- @return bool
function Basis:is_finite() end

--- @return Quaternion
function Basis:get_rotation_quaternion() end

--- static
--- @param target Vector3
--- @param up Vector3? Default: Vector3(0, 1, 0)
--- @param use_model_front bool? Default: false
--- @return Basis
function Basis:looking_at(target, up, use_model_front) end

--- static
--- @param scale Vector3
--- @return Basis
function Basis:from_scale(scale) end

--- static
--- @param euler Vector3
--- @param order int? Default: 2
--- @return Basis
function Basis:from_euler(euler, order) end


-----------------------------------------------------------
-- Transform3D
-----------------------------------------------------------

--- @class Transform3D: Variant
--- @field basis Basis
--- @field origin Vector3
--- @overload fun(): Transform3D
--- @overload fun(from: Transform3D): Transform3D
--- @overload fun(basis: Basis, origin: Vector3): Transform3D
--- @overload fun(x_axis: Vector3, y_axis: Vector3, z_axis: Vector3, origin: Vector3): Transform3D
--- @overload fun(from: Projection): Transform3D
--- @operator mul(int): Transform3D
--- @operator div(int): Transform3D
--- @operator mul(float): Transform3D
--- @operator div(float): Transform3D
--- @operator mul(Vector3): Vector3
--- @operator mul(Plane): Plane
--- @operator mul(AABB): AABB
--- @operator mul(Transform3D): Transform3D
--- @operator mul(PackedVector3Array): PackedVector3Array
Transform3D = {}

Transform3D.IDENTITY = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0)
Transform3D.FLIP_X = Transform3D(-1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0)
Transform3D.FLIP_Y = Transform3D(1, 0, 0, 0, -1, 0, 0, 0, 1, 0, 0, 0)
Transform3D.FLIP_Z = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, -1, 0, 0, 0)

--- @return Transform3D
function Transform3D:inverse() end

--- @return Transform3D
function Transform3D:affine_inverse() end

--- @return Transform3D
function Transform3D:orthonormalized() end

--- @param axis Vector3
--- @param angle float
--- @return Transform3D
function Transform3D:rotated(axis, angle) end

--- @param axis Vector3
--- @param angle float
--- @return Transform3D
function Transform3D:rotated_local(axis, angle) end

--- @param scale Vector3
--- @return Transform3D
function Transform3D:scaled(scale) end

--- @param scale Vector3
--- @return Transform3D
function Transform3D:scaled_local(scale) end

--- @param offset Vector3
--- @return Transform3D
function Transform3D:translated(offset) end

--- @param offset Vector3
--- @return Transform3D
function Transform3D:translated_local(offset) end

--- @param target Vector3
--- @param up Vector3? Default: Vector3(0, 1, 0)
--- @param use_model_front bool? Default: false
--- @return Transform3D
function Transform3D:looking_at(target, up, use_model_front) end

--- @param xform Transform3D
--- @param weight float
--- @return Transform3D
function Transform3D:interpolate_with(xform, weight) end

--- @param xform Transform3D
--- @return bool
function Transform3D:is_equal_approx(xform) end

--- @return bool
function Transform3D:is_finite() end


-----------------------------------------------------------
-- Projection
-----------------------------------------------------------

--- @class Projection: Variant, { [int]: Vector4? }
--- @field x Vector4
--- @field y Vector4
--- @field z Vector4
--- @field w Vector4
--- @overload fun(): Projection
--- @overload fun(from: Projection): Projection
--- @overload fun(from: Transform3D): Projection
--- @overload fun(x_axis: Vector4, y_axis: Vector4, z_axis: Vector4, w_axis: Vector4): Projection
--- @operator mul(Vector4): Vector4
--- @operator mul(Projection): Projection
Projection = {}

Projection.IDENTITY = Projection(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)
Projection.ZERO = Projection(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)

--- @enum Projection.Planes
Projection.Planes = {
	PLANE_NEAR = 0,
	PLANE_FAR = 1,
	PLANE_LEFT = 2,
	PLANE_TOP = 3,
	PLANE_RIGHT = 4,
	PLANE_BOTTOM = 5,
}

--- static
--- @param flip_y bool
--- @return Projection
function Projection:create_depth_correction(flip_y) end

--- static
--- @param rect Rect2
--- @return Projection
function Projection:create_light_atlas_rect(rect) end

--- static
--- @param fovy float
--- @param aspect float
--- @param z_near float
--- @param z_far float
--- @param flip_fov bool? Default: false
--- @return Projection
function Projection:create_perspective(fovy, aspect, z_near, z_far, flip_fov) end

--- static
--- @param fovy float
--- @param aspect float
--- @param z_near float
--- @param z_far float
--- @param flip_fov bool
--- @param eye int
--- @param intraocular_dist float
--- @param convergence_dist float
--- @return Projection
function Projection:create_perspective_hmd(fovy, aspect, z_near, z_far, flip_fov, eye, intraocular_dist, convergence_dist) end

--- static
--- @param eye int
--- @param aspect float
--- @param intraocular_dist float
--- @param display_width float
--- @param display_to_lens float
--- @param oversample float
--- @param z_near float
--- @param z_far float
--- @return Projection
function Projection:create_for_hmd(eye, aspect, intraocular_dist, display_width, display_to_lens, oversample, z_near, z_far) end

--- static
--- @param left float
--- @param right float
--- @param bottom float
--- @param top float
--- @param z_near float
--- @param z_far float
--- @return Projection
function Projection:create_orthogonal(left, right, bottom, top, z_near, z_far) end

--- static
--- @param size float
--- @param aspect float
--- @param z_near float
--- @param z_far float
--- @param flip_fov bool? Default: false
--- @return Projection
function Projection:create_orthogonal_aspect(size, aspect, z_near, z_far, flip_fov) end

--- static
--- @param left float
--- @param right float
--- @param bottom float
--- @param top float
--- @param z_near float
--- @param z_far float
--- @return Projection
function Projection:create_frustum(left, right, bottom, top, z_near, z_far) end

--- static
--- @param size float
--- @param aspect float
--- @param offset Vector2
--- @param z_near float
--- @param z_far float
--- @param flip_fov bool? Default: false
--- @return Projection
function Projection:create_frustum_aspect(size, aspect, offset, z_near, z_far, flip_fov) end

--- static
--- @param aabb AABB
--- @return Projection
function Projection:create_fit_aabb(aabb) end

--- @return float
function Projection:determinant() end

--- @param new_znear float
--- @return Projection
function Projection:perspective_znear_adjusted(new_znear) end

--- @param plane int
--- @return Plane
function Projection:get_projection_plane(plane) end

--- @return Projection
function Projection:flipped_y() end

--- @param offset Vector2
--- @return Projection
function Projection:jitter_offseted(offset) end

--- static
--- @param fovx float
--- @param aspect float
--- @return float
function Projection:get_fovy(fovx, aspect) end

--- @return float
function Projection:get_z_far() end

--- @return float
function Projection:get_z_near() end

--- @return float
function Projection:get_aspect() end

--- @return float
function Projection:get_fov() end

--- @return bool
function Projection:is_orthogonal() end

--- @return Vector2
function Projection:get_viewport_half_extents() end

--- @return Vector2
function Projection:get_far_plane_half_extents() end

--- @return Projection
function Projection:inverse() end

--- @param for_pixel_width int
--- @return int
function Projection:get_pixels_per_meter(for_pixel_width) end

--- @return float
function Projection:get_lod_multiplier() end


-----------------------------------------------------------
-- Color
-----------------------------------------------------------

--- @class Color: Variant, { [int]: float? }
--- @field r float
--- @field g float
--- @field b float
--- @field a float
--- @field r8 int
--- @field g8 int
--- @field b8 int
--- @field a8 int
--- @field h float
--- @field s float
--- @field v float
--- @field ok_hsl_h float
--- @field ok_hsl_s float
--- @field ok_hsl_l float
--- @overload fun(): Color
--- @overload fun(from: Color): Color
--- @overload fun(from: Color, alpha: float): Color
--- @overload fun(r: float, g: float, b: float): Color
--- @overload fun(r: float, g: float, b: float, a: float): Color
--- @overload fun(code: String): Color
--- @overload fun(code: String, alpha: float): Color
--- @operator unm(): Color
--- @operator mul(int): Color
--- @operator div(int): Color
--- @operator mul(float): Color
--- @operator div(float): Color
--- @operator add(Color): Color
--- @operator sub(Color): Color
--- @operator mul(Color): Color
--- @operator div(Color): Color
Color = {}

Color.ALICE_BLUE = Color(0.9411765, 0.972549, 1, 1)
Color.ANTIQUE_WHITE = Color(0.98039216, 0.92156863, 0.84313726, 1)
Color.AQUA = Color(0, 1, 1, 1)
Color.AQUAMARINE = Color(0.49803922, 1, 0.83137256, 1)
Color.AZURE = Color(0.9411765, 1, 1, 1)
Color.BEIGE = Color(0.9607843, 0.9607843, 0.8627451, 1)
Color.BISQUE = Color(1, 0.89411765, 0.76862746, 1)
Color.BLACK = Color(0, 0, 0, 1)
Color.BLANCHED_ALMOND = Color(1, 0.92156863, 0.8039216, 1)
Color.BLUE = Color(0, 0, 1, 1)
Color.BLUE_VIOLET = Color(0.5411765, 0.16862746, 0.8862745, 1)
Color.BROWN = Color(0.64705884, 0.16470589, 0.16470589, 1)
Color.BURLYWOOD = Color(0.87058824, 0.72156864, 0.5294118, 1)
Color.CADET_BLUE = Color(0.37254903, 0.61960787, 0.627451, 1)
Color.CHARTREUSE = Color(0.49803922, 1, 0, 1)
Color.CHOCOLATE = Color(0.8235294, 0.4117647, 0.11764706, 1)
Color.CORAL = Color(1, 0.49803922, 0.3137255, 1)
Color.CORNFLOWER_BLUE = Color(0.39215687, 0.58431375, 0.92941177, 1)
Color.CORNSILK = Color(1, 0.972549, 0.8627451, 1)
Color.CRIMSON = Color(0.8627451, 0.078431375, 0.23529412, 1)
Color.CYAN = Color(0, 1, 1, 1)
Color.DARK_BLUE = Color(0, 0, 0.54509807, 1)
Color.DARK_CYAN = Color(0, 0.54509807, 0.54509807, 1)
Color.DARK_GOLDENROD = Color(0.72156864, 0.5254902, 0.043137256, 1)
Color.DARK_GRAY = Color(0.6627451, 0.6627451, 0.6627451, 1)
Color.DARK_GREEN = Color(0, 0.39215687, 0, 1)
Color.DARK_KHAKI = Color(0.7411765, 0.7176471, 0.41960785, 1)
Color.DARK_MAGENTA = Color(0.54509807, 0, 0.54509807, 1)
Color.DARK_OLIVE_GREEN = Color(0.33333334, 0.41960785, 0.18431373, 1)
Color.DARK_ORANGE = Color(1, 0.54901963, 0, 1)
Color.DARK_ORCHID = Color(0.6, 0.19607843, 0.8, 1)
Color.DARK_RED = Color(0.54509807, 0, 0, 1)
Color.DARK_SALMON = Color(0.9137255, 0.5882353, 0.47843137, 1)
Color.DARK_SEA_GREEN = Color(0.56078434, 0.7372549, 0.56078434, 1)
Color.DARK_SLATE_BLUE = Color(0.28235295, 0.23921569, 0.54509807, 1)
Color.DARK_SLATE_GRAY = Color(0.18431373, 0.30980393, 0.30980393, 1)
Color.DARK_TURQUOISE = Color(0, 0.80784315, 0.81960785, 1)
Color.DARK_VIOLET = Color(0.5803922, 0, 0.827451, 1)
Color.DEEP_PINK = Color(1, 0.078431375, 0.5764706, 1)
Color.DEEP_SKY_BLUE = Color(0, 0.7490196, 1, 1)
Color.DIM_GRAY = Color(0.4117647, 0.4117647, 0.4117647, 1)
Color.DODGER_BLUE = Color(0.11764706, 0.5647059, 1, 1)
Color.FIREBRICK = Color(0.69803923, 0.13333334, 0.13333334, 1)
Color.FLORAL_WHITE = Color(1, 0.98039216, 0.9411765, 1)
Color.FOREST_GREEN = Color(0.13333334, 0.54509807, 0.13333334, 1)
Color.FUCHSIA = Color(1, 0, 1, 1)
Color.GAINSBORO = Color(0.8627451, 0.8627451, 0.8627451, 1)
Color.GHOST_WHITE = Color(0.972549, 0.972549, 1, 1)
Color.GOLD = Color(1, 0.84313726, 0, 1)
Color.GOLDENROD = Color(0.85490197, 0.64705884, 0.1254902, 1)
Color.GRAY = Color(0.74509805, 0.74509805, 0.74509805, 1)
Color.GREEN = Color(0, 1, 0, 1)
Color.GREEN_YELLOW = Color(0.6784314, 1, 0.18431373, 1)
Color.HONEYDEW = Color(0.9411765, 1, 0.9411765, 1)
Color.HOT_PINK = Color(1, 0.4117647, 0.7058824, 1)
Color.INDIAN_RED = Color(0.8039216, 0.36078432, 0.36078432, 1)
Color.INDIGO = Color(0.29411766, 0, 0.50980395, 1)
Color.IVORY = Color(1, 1, 0.9411765, 1)
Color.KHAKI = Color(0.9411765, 0.9019608, 0.54901963, 1)
Color.LAVENDER = Color(0.9019608, 0.9019608, 0.98039216, 1)
Color.LAVENDER_BLUSH = Color(1, 0.9411765, 0.9607843, 1)
Color.LAWN_GREEN = Color(0.4862745, 0.9882353, 0, 1)
Color.LEMON_CHIFFON = Color(1, 0.98039216, 0.8039216, 1)
Color.LIGHT_BLUE = Color(0.6784314, 0.84705883, 0.9019608, 1)
Color.LIGHT_CORAL = Color(0.9411765, 0.5019608, 0.5019608, 1)
Color.LIGHT_CYAN = Color(0.8784314, 1, 1, 1)
Color.LIGHT_GOLDENROD = Color(0.98039216, 0.98039216, 0.8235294, 1)
Color.LIGHT_GRAY = Color(0.827451, 0.827451, 0.827451, 1)
Color.LIGHT_GREEN = Color(0.5647059, 0.93333334, 0.5647059, 1)
Color.LIGHT_PINK = Color(1, 0.7137255, 0.75686276, 1)
Color.LIGHT_SALMON = Color(1, 0.627451, 0.47843137, 1)
Color.LIGHT_SEA_GREEN = Color(0.1254902, 0.69803923, 0.6666667, 1)
Color.LIGHT_SKY_BLUE = Color(0.5294118, 0.80784315, 0.98039216, 1)
Color.LIGHT_SLATE_GRAY = Color(0.46666667, 0.53333336, 0.6, 1)
Color.LIGHT_STEEL_BLUE = Color(0.6901961, 0.76862746, 0.87058824, 1)
Color.LIGHT_YELLOW = Color(1, 1, 0.8784314, 1)
Color.LIME = Color(0, 1, 0, 1)
Color.LIME_GREEN = Color(0.19607843, 0.8039216, 0.19607843, 1)
Color.LINEN = Color(0.98039216, 0.9411765, 0.9019608, 1)
Color.MAGENTA = Color(1, 0, 1, 1)
Color.MAROON = Color(0.6901961, 0.1882353, 0.3764706, 1)
Color.MEDIUM_AQUAMARINE = Color(0.4, 0.8039216, 0.6666667, 1)
Color.MEDIUM_BLUE = Color(0, 0, 0.8039216, 1)
Color.MEDIUM_ORCHID = Color(0.7294118, 0.33333334, 0.827451, 1)
Color.MEDIUM_PURPLE = Color(0.5764706, 0.4392157, 0.85882354, 1)
Color.MEDIUM_SEA_GREEN = Color(0.23529412, 0.7019608, 0.44313726, 1)
Color.MEDIUM_SLATE_BLUE = Color(0.48235294, 0.40784314, 0.93333334, 1)
Color.MEDIUM_SPRING_GREEN = Color(0, 0.98039216, 0.6039216, 1)
Color.MEDIUM_TURQUOISE = Color(0.28235295, 0.81960785, 0.8, 1)
Color.MEDIUM_VIOLET_RED = Color(0.78039217, 0.08235294, 0.52156866, 1)
Color.MIDNIGHT_BLUE = Color(0.09803922, 0.09803922, 0.4392157, 1)
Color.MINT_CREAM = Color(0.9607843, 1, 0.98039216, 1)
Color.MISTY_ROSE = Color(1, 0.89411765, 0.88235295, 1)
Color.MOCCASIN = Color(1, 0.89411765, 0.70980394, 1)
Color.NAVAJO_WHITE = Color(1, 0.87058824, 0.6784314, 1)
Color.NAVY_BLUE = Color(0, 0, 0.5019608, 1)
Color.OLD_LACE = Color(0.99215686, 0.9607843, 0.9019608, 1)
Color.OLIVE = Color(0.5019608, 0.5019608, 0, 1)
Color.OLIVE_DRAB = Color(0.41960785, 0.5568628, 0.13725491, 1)
Color.ORANGE = Color(1, 0.64705884, 0, 1)
Color.ORANGE_RED = Color(1, 0.27058825, 0, 1)
Color.ORCHID = Color(0.85490197, 0.4392157, 0.8392157, 1)
Color.PALE_GOLDENROD = Color(0.93333334, 0.9098039, 0.6666667, 1)
Color.PALE_GREEN = Color(0.59607846, 0.9843137, 0.59607846, 1)
Color.PALE_TURQUOISE = Color(0.6862745, 0.93333334, 0.93333334, 1)
Color.PALE_VIOLET_RED = Color(0.85882354, 0.4392157, 0.5764706, 1)
Color.PAPAYA_WHIP = Color(1, 0.9372549, 0.8352941, 1)
Color.PEACH_PUFF = Color(1, 0.85490197, 0.7254902, 1)
Color.PERU = Color(0.8039216, 0.52156866, 0.24705882, 1)
Color.PINK = Color(1, 0.7529412, 0.79607844, 1)
Color.PLUM = Color(0.8666667, 0.627451, 0.8666667, 1)
Color.POWDER_BLUE = Color(0.6901961, 0.8784314, 0.9019608, 1)
Color.PURPLE = Color(0.627451, 0.1254902, 0.9411765, 1)
Color.REBECCA_PURPLE = Color(0.4, 0.2, 0.6, 1)
Color.RED = Color(1, 0, 0, 1)
Color.ROSY_BROWN = Color(0.7372549, 0.56078434, 0.56078434, 1)
Color.ROYAL_BLUE = Color(0.25490198, 0.4117647, 0.88235295, 1)
Color.SADDLE_BROWN = Color(0.54509807, 0.27058825, 0.07450981, 1)
Color.SALMON = Color(0.98039216, 0.5019608, 0.44705883, 1)
Color.SANDY_BROWN = Color(0.95686275, 0.6431373, 0.3764706, 1)
Color.SEA_GREEN = Color(0.18039216, 0.54509807, 0.34117648, 1)
Color.SEASHELL = Color(1, 0.9607843, 0.93333334, 1)
Color.SIENNA = Color(0.627451, 0.32156864, 0.1764706, 1)
Color.SILVER = Color(0.7529412, 0.7529412, 0.7529412, 1)
Color.SKY_BLUE = Color(0.5294118, 0.80784315, 0.92156863, 1)
Color.SLATE_BLUE = Color(0.41568628, 0.3529412, 0.8039216, 1)
Color.SLATE_GRAY = Color(0.4392157, 0.5019608, 0.5647059, 1)
Color.SNOW = Color(1, 0.98039216, 0.98039216, 1)
Color.SPRING_GREEN = Color(0, 1, 0.49803922, 1)
Color.STEEL_BLUE = Color(0.27450982, 0.50980395, 0.7058824, 1)
Color.TAN = Color(0.8235294, 0.7058824, 0.54901963, 1)
Color.TEAL = Color(0, 0.5019608, 0.5019608, 1)
Color.THISTLE = Color(0.84705883, 0.7490196, 0.84705883, 1)
Color.TOMATO = Color(1, 0.3882353, 0.2784314, 1)
Color.TRANSPARENT = Color(1, 1, 1, 0)
Color.TURQUOISE = Color(0.2509804, 0.8784314, 0.8156863, 1)
Color.VIOLET = Color(0.93333334, 0.50980395, 0.93333334, 1)
Color.WEB_GRAY = Color(0.5019608, 0.5019608, 0.5019608, 1)
Color.WEB_GREEN = Color(0, 0.5019608, 0, 1)
Color.WEB_MAROON = Color(0.5019608, 0, 0, 1)
Color.WEB_PURPLE = Color(0.5019608, 0, 0.5019608, 1)
Color.WHEAT = Color(0.9607843, 0.87058824, 0.7019608, 1)
Color.WHITE = Color(1, 1, 1, 1)
Color.WHITE_SMOKE = Color(0.9607843, 0.9607843, 0.9607843, 1)
Color.YELLOW = Color(1, 1, 0, 1)
Color.YELLOW_GREEN = Color(0.6039216, 0.8039216, 0.19607843, 1)

--- @return int
function Color:to_argb32() end

--- @return int
function Color:to_abgr32() end

--- @return int
function Color:to_rgba32() end

--- @return int
function Color:to_argb64() end

--- @return int
function Color:to_abgr64() end

--- @return int
function Color:to_rgba64() end

--- @param with_alpha bool? Default: true
--- @return String
function Color:to_html(with_alpha) end

--- @param min Color? Default: Color(0, 0, 0, 0)
--- @param max Color? Default: Color(1, 1, 1, 1)
--- @return Color
function Color:clamp(min, max) end

--- @return Color
function Color:inverted() end

--- @param to Color
--- @param weight float
--- @return Color
function Color:lerp(to, weight) end

--- @param amount float
--- @return Color
function Color:lightened(amount) end

--- @param amount float
--- @return Color
function Color:darkened(amount) end

--- @param over Color
--- @return Color
function Color:blend(over) end

--- @return float
function Color:get_luminance() end

--- @return Color
function Color:srgb_to_linear() end

--- @return Color
function Color:linear_to_srgb() end

--- @param to Color
--- @return bool
function Color:is_equal_approx(to) end

--- static
--- @param hex int
--- @return Color
function Color:hex(hex) end

--- static
--- @param hex int
--- @return Color
function Color:hex64(hex) end

--- static
--- @param rgba String
--- @return Color
function Color:html(rgba) end

--- static
--- @param color String
--- @return bool
function Color:html_is_valid(color) end

--- static
--- @param str String
--- @param default Color
--- @return Color
function Color:from_string(str, default) end

--- static
--- @param h float
--- @param s float
--- @param v float
--- @param alpha float? Default: 1.0
--- @return Color
function Color:from_hsv(h, s, v, alpha) end

--- static
--- @param h float
--- @param s float
--- @param l float
--- @param alpha float? Default: 1.0
--- @return Color
function Color:from_ok_hsl(h, s, l, alpha) end

--- static
--- @param rgbe int
--- @return Color
function Color:from_rgbe9995(rgbe) end

--- static
--- @param r8 int
--- @param g8 int
--- @param b8 int
--- @param a8 int? Default: 255
--- @return Color
function Color:from_rgba8(r8, g8, b8, a8) end


-----------------------------------------------------------
-- StringName
-----------------------------------------------------------

--- @alias StringName string
StringName = string


-----------------------------------------------------------
-- NodePath
-----------------------------------------------------------

--- @class NodePath: Variant
--- @overload fun(): NodePath
--- @overload fun(from: NodePath): NodePath
--- @overload fun(from: String): NodePath
NodePath = {}

--- @return bool
function NodePath:is_absolute() end

--- @return int
function NodePath:get_name_count() end

--- @param idx int
--- @return StringName
function NodePath:get_name(idx) end

--- @return int
function NodePath:get_subname_count() end

--- @return int
function NodePath:hash() end

--- @param idx int
--- @return StringName
function NodePath:get_subname(idx) end

--- @return StringName
function NodePath:get_concatenated_names() end

--- @return StringName
function NodePath:get_concatenated_subnames() end

--- @param begin int
--- @param _end int? Default: 2147483647
--- @return NodePath
function NodePath:slice(begin, _end) end

--- @return NodePath
function NodePath:get_as_property_path() end

--- @return bool
function NodePath:is_empty() end


-----------------------------------------------------------
-- RID
-----------------------------------------------------------

--- @class RID: Variant
--- @overload fun(): RID
--- @overload fun(from: RID): RID
RID = {}

--- @return bool
function RID:is_valid() end

--- @return int
function RID:get_id() end


-----------------------------------------------------------
-- Callable
-----------------------------------------------------------

--- @class Callable: Variant
--- @overload fun(): Callable
--- @overload fun(from: Callable): Callable
--- @overload fun(object: Object, method: StringName): Callable
Callable = {}

--- static
--- @param variant any
--- @param method StringName
--- @return Callable
function Callable:create(variant, method) end

--- @param arguments Array
--- @return any
function Callable:callv(arguments) end

--- @return bool
function Callable:is_null() end

--- @return bool
function Callable:is_custom() end

--- @return bool
function Callable:is_standard() end

--- @return bool
function Callable:is_valid() end

--- @return Object
function Callable:get_object() end

--- @return int
function Callable:get_object_id() end

--- @return StringName
function Callable:get_method() end

--- @return int
function Callable:get_argument_count() end

--- @return int
function Callable:get_bound_arguments_count() end

--- @return Array
function Callable:get_bound_arguments() end

--- @return int
function Callable:get_unbound_arguments_count() end

--- @return int
function Callable:hash() end

--- @param arguments Array
--- @return Callable
function Callable:bindv(arguments) end

--- @param argcount int
--- @return Callable
function Callable:unbind(argcount) end

--- @return any
function Callable:call(...) end

function Callable:call_deferred(...) end

function Callable:rpc(...) end

--- @param peer_id int
function Callable:rpc_id(peer_id, ...) end

--- @return Callable
function Callable:bind(...) end


-----------------------------------------------------------
-- Signal
-----------------------------------------------------------

--- @class Signal: Variant
--- @overload fun(): Signal
--- @overload fun(from: Signal): Signal
--- @overload fun(object: Object, signal: StringName): Signal
Signal = {}

--- @return bool
function Signal:is_null() end

--- @return Object
function Signal:get_object() end

--- @return int
function Signal:get_object_id() end

--- @return StringName
function Signal:get_name() end

--- @param callable Callable
--- @param flags int? Default: 0
--- @return int
function Signal:connect(callable, flags) end

--- @param callable Callable
function Signal:disconnect(callable) end

--- @param callable Callable
--- @return bool
function Signal:is_connected(callable) end

--- @return Array
function Signal:get_connections() end

--- @return bool
function Signal:has_connections() end

function Signal:emit(...) end


-----------------------------------------------------------
-- Dictionary
-----------------------------------------------------------

--- @class Dictionary: Variant, { [any]: any }
--- @overload fun(from: table): Dictionary
--- @overload fun(): Dictionary
--- @overload fun(from: Dictionary): Dictionary
--- @overload fun(base: Dictionary, key_type: int, key_class_name: StringName, key_script: Variant, value_type: int, value_class_name: StringName, value_script: Variant): Dictionary
Dictionary = {}

--- @return int
function Dictionary:size() end

--- @return bool
function Dictionary:is_empty() end

function Dictionary:clear() end

--- @param dictionary Dictionary
function Dictionary:assign(dictionary) end

function Dictionary:sort() end

--- @param dictionary Dictionary
--- @param overwrite bool? Default: false
function Dictionary:merge(dictionary, overwrite) end

--- @param dictionary Dictionary
--- @param overwrite bool? Default: false
--- @return Dictionary
function Dictionary:merged(dictionary, overwrite) end

--- @param key any
--- @return bool
function Dictionary:has(key) end

--- @param keys Array
--- @return bool
function Dictionary:has_all(keys) end

--- @param value any
--- @return any
function Dictionary:find_key(value) end

--- @param key any
--- @return bool
function Dictionary:erase(key) end

--- @return int
function Dictionary:hash() end

--- @return Array
function Dictionary:keys() end

--- @return Array
function Dictionary:values() end

--- @param deep bool? Default: false
--- @return Dictionary
function Dictionary:duplicate(deep) end

--- @param deep_subresources_mode int? Default: 1
--- @return Dictionary
function Dictionary:duplicate_deep(deep_subresources_mode) end

--- @param key any
--- @param default any? Default: null
--- @return any
function Dictionary:get(key, default) end

--- @param key any
--- @param default any? Default: null
--- @return any
function Dictionary:get_or_add(key, default) end

--- @param key any
--- @param value any
--- @return bool
function Dictionary:set(key, value) end

--- @return bool
function Dictionary:is_typed() end

--- @return bool
function Dictionary:is_typed_key() end

--- @return bool
function Dictionary:is_typed_value() end

--- @param dictionary Dictionary
--- @return bool
function Dictionary:is_same_typed(dictionary) end

--- @param dictionary Dictionary
--- @return bool
function Dictionary:is_same_typed_key(dictionary) end

--- @param dictionary Dictionary
--- @return bool
function Dictionary:is_same_typed_value(dictionary) end

--- @return int
function Dictionary:get_typed_key_builtin() end

--- @return int
function Dictionary:get_typed_value_builtin() end

--- @return StringName
function Dictionary:get_typed_key_class_name() end

--- @return StringName
function Dictionary:get_typed_value_class_name() end

--- @return any
function Dictionary:get_typed_key_script() end

--- @return any
function Dictionary:get_typed_value_script() end

function Dictionary:make_read_only() end

--- @return bool
function Dictionary:is_read_only() end

--- @param dictionary Dictionary
--- @param recursion_count int
--- @return bool
function Dictionary:recursive_equal(dictionary, recursion_count) end


-----------------------------------------------------------
-- Array
-----------------------------------------------------------

--- @class Array: Variant, { [int]: any }
--- @overload fun(from: table): Array
--- @overload fun(): Array
--- @overload fun(from: Array): Array
--- @overload fun(base: Array, type: int, class_name: StringName, script: Variant): Array
--- @overload fun(from: PackedByteArray): Array
--- @overload fun(from: PackedInt32Array): Array
--- @overload fun(from: PackedInt64Array): Array
--- @overload fun(from: PackedFloat32Array): Array
--- @overload fun(from: PackedFloat64Array): Array
--- @overload fun(from: PackedStringArray): Array
--- @overload fun(from: PackedVector2Array): Array
--- @overload fun(from: PackedVector3Array): Array
--- @overload fun(from: PackedColorArray): Array
--- @overload fun(from: PackedVector4Array): Array
--- @operator add(Array): Array
Array = {}

--- @return int
function Array:size() end

--- @return bool
function Array:is_empty() end

function Array:clear() end

--- @return int
function Array:hash() end

--- @param array Array
function Array:assign(array) end

--- @param index int
--- @return any
function Array:get(index) end

--- @param index int
--- @param value any
function Array:set(index, value) end

--- @param value any
function Array:push_back(value) end

--- @param value any
function Array:push_front(value) end

--- @param value any
function Array:append(value) end

--- @param array Array
function Array:append_array(array) end

--- @param size int
--- @return int
function Array:resize(size) end

--- @param position int
--- @param value any
--- @return int
function Array:insert(position, value) end

--- @param position int
function Array:remove_at(position) end

--- @param value any
function Array:fill(value) end

--- @param value any
function Array:erase(value) end

--- @return any
function Array:front() end

--- @return any
function Array:back() end

--- @return any
function Array:pick_random() end

--- @param what any
--- @param from int? Default: 0
--- @return int
function Array:find(what, from) end

--- @param method Callable
--- @param from int? Default: 0
--- @return int
function Array:find_custom(method, from) end

--- @param what any
--- @param from int? Default: -1
--- @return int
function Array:rfind(what, from) end

--- @param method Callable
--- @param from int? Default: -1
--- @return int
function Array:rfind_custom(method, from) end

--- @param value any
--- @return int
function Array:count(value) end

--- @param value any
--- @return bool
function Array:has(value) end

--- @return any
function Array:pop_back() end

--- @return any
function Array:pop_front() end

--- @param position int
--- @return any
function Array:pop_at(position) end

function Array:sort() end

--- @param func Callable
function Array:sort_custom(func) end

function Array:shuffle() end

--- @param value any
--- @param before bool? Default: true
--- @return int
function Array:bsearch(value, before) end

--- @param value any
--- @param func Callable
--- @param before bool? Default: true
--- @return int
function Array:bsearch_custom(value, func, before) end

function Array:reverse() end

--- @param deep bool? Default: false
--- @return Array
function Array:duplicate(deep) end

--- @param deep_subresources_mode int? Default: 1
--- @return Array
function Array:duplicate_deep(deep_subresources_mode) end

--- @param begin int
--- @param _end int? Default: 2147483647
--- @param step int? Default: 1
--- @param deep bool? Default: false
--- @return Array
function Array:slice(begin, _end, step, deep) end

--- @param method Callable
--- @return Array
function Array:filter(method) end

--- @param method Callable
--- @return Array
function Array:map(method) end

--- @param method Callable
--- @param accum any? Default: null
--- @return any
function Array:reduce(method, accum) end

--- @param method Callable
--- @return bool
function Array:any(method) end

--- @param method Callable
--- @return bool
function Array:all(method) end

--- @return any
function Array:max() end

--- @return any
function Array:min() end

--- @return bool
function Array:is_typed() end

--- @param array Array
--- @return bool
function Array:is_same_typed(array) end

--- @return int
function Array:get_typed_builtin() end

--- @return StringName
function Array:get_typed_class_name() end

--- @return any
function Array:get_typed_script() end

function Array:make_read_only() end

--- @return bool
function Array:is_read_only() end


-----------------------------------------------------------
-- PackedByteArray
-----------------------------------------------------------

--- @class PackedByteArray: Variant, { [int]: int? }
--- @overload fun(): PackedByteArray
--- @overload fun(from: PackedByteArray): PackedByteArray
--- @overload fun(from: Array): PackedByteArray
--- @operator add(PackedByteArray): PackedByteArray
PackedByteArray = {}

--- @param index int
--- @return int
function PackedByteArray:get(index) end

--- @param index int
--- @param value int
function PackedByteArray:set(index, value) end

--- @return int
function PackedByteArray:size() end

--- @return bool
function PackedByteArray:is_empty() end

--- @param value int
--- @return bool
function PackedByteArray:push_back(value) end

--- @param value int
--- @return bool
function PackedByteArray:append(value) end

--- @param array PackedByteArray
function PackedByteArray:append_array(array) end

--- @param index int
function PackedByteArray:remove_at(index) end

--- @param at_index int
--- @param value int
--- @return int
function PackedByteArray:insert(at_index, value) end

--- @param value int
function PackedByteArray:fill(value) end

--- @param new_size int
--- @return int
function PackedByteArray:resize(new_size) end

function PackedByteArray:clear() end

--- @param value int
--- @return bool
function PackedByteArray:has(value) end

function PackedByteArray:reverse() end

--- @param begin int
--- @param _end int? Default: 2147483647
--- @return PackedByteArray
function PackedByteArray:slice(begin, _end) end

function PackedByteArray:sort() end

--- @param value int
--- @param before bool? Default: true
--- @return int
function PackedByteArray:bsearch(value, before) end

--- @return PackedByteArray
function PackedByteArray:duplicate() end

--- @param value int
--- @param from int? Default: 0
--- @return int
function PackedByteArray:find(value, from) end

--- @param value int
--- @param from int? Default: -1
--- @return int
function PackedByteArray:rfind(value, from) end

--- @param value int
--- @return int
function PackedByteArray:count(value) end

--- @param value int
--- @return bool
function PackedByteArray:erase(value) end

--- @return String
function PackedByteArray:get_string_from_ascii() end

--- @return String
function PackedByteArray:get_string_from_utf8() end

--- @return String
function PackedByteArray:get_string_from_utf16() end

--- @return String
function PackedByteArray:get_string_from_utf32() end

--- @return String
function PackedByteArray:get_string_from_wchar() end

--- @param encoding String? Default: ""
--- @return String
function PackedByteArray:get_string_from_multibyte_char(encoding) end

--- @return String
function PackedByteArray:hex_encode() end

--- @param compression_mode int? Default: 0
--- @return PackedByteArray
function PackedByteArray:compress(compression_mode) end

--- @param buffer_size int
--- @param compression_mode int? Default: 0
--- @return PackedByteArray
function PackedByteArray:decompress(buffer_size, compression_mode) end

--- @param max_output_size int
--- @param compression_mode int? Default: 0
--- @return PackedByteArray
function PackedByteArray:decompress_dynamic(max_output_size, compression_mode) end

--- @param byte_offset int
--- @return int
function PackedByteArray:decode_u8(byte_offset) end

--- @param byte_offset int
--- @return int
function PackedByteArray:decode_s8(byte_offset) end

--- @param byte_offset int
--- @return int
function PackedByteArray:decode_u16(byte_offset) end

--- @param byte_offset int
--- @return int
function PackedByteArray:decode_s16(byte_offset) end

--- @param byte_offset int
--- @return int
function PackedByteArray:decode_u32(byte_offset) end

--- @param byte_offset int
--- @return int
function PackedByteArray:decode_s32(byte_offset) end

--- @param byte_offset int
--- @return int
function PackedByteArray:decode_u64(byte_offset) end

--- @param byte_offset int
--- @return int
function PackedByteArray:decode_s64(byte_offset) end

--- @param byte_offset int
--- @return float
function PackedByteArray:decode_half(byte_offset) end

--- @param byte_offset int
--- @return float
function PackedByteArray:decode_float(byte_offset) end

--- @param byte_offset int
--- @return float
function PackedByteArray:decode_double(byte_offset) end

--- @param byte_offset int
--- @param allow_objects bool? Default: false
--- @return bool
function PackedByteArray:has_encoded_var(byte_offset, allow_objects) end

--- @param byte_offset int
--- @param allow_objects bool? Default: false
--- @return any
function PackedByteArray:decode_var(byte_offset, allow_objects) end

--- @param byte_offset int
--- @param allow_objects bool? Default: false
--- @return int
function PackedByteArray:decode_var_size(byte_offset, allow_objects) end

--- @return PackedInt32Array
function PackedByteArray:to_int32_array() end

--- @return PackedInt64Array
function PackedByteArray:to_int64_array() end

--- @return PackedFloat32Array
function PackedByteArray:to_float32_array() end

--- @return PackedFloat64Array
function PackedByteArray:to_float64_array() end

--- @return PackedVector2Array
function PackedByteArray:to_vector2_array() end

--- @return PackedVector3Array
function PackedByteArray:to_vector3_array() end

--- @return PackedVector4Array
function PackedByteArray:to_vector4_array() end

--- @return PackedColorArray
function PackedByteArray:to_color_array() end

--- @param offset int? Default: 0
--- @param count int? Default: -1
function PackedByteArray:bswap16(offset, count) end

--- @param offset int? Default: 0
--- @param count int? Default: -1
function PackedByteArray:bswap32(offset, count) end

--- @param offset int? Default: 0
--- @param count int? Default: -1
function PackedByteArray:bswap64(offset, count) end

--- @param byte_offset int
--- @param value int
function PackedByteArray:encode_u8(byte_offset, value) end

--- @param byte_offset int
--- @param value int
function PackedByteArray:encode_s8(byte_offset, value) end

--- @param byte_offset int
--- @param value int
function PackedByteArray:encode_u16(byte_offset, value) end

--- @param byte_offset int
--- @param value int
function PackedByteArray:encode_s16(byte_offset, value) end

--- @param byte_offset int
--- @param value int
function PackedByteArray:encode_u32(byte_offset, value) end

--- @param byte_offset int
--- @param value int
function PackedByteArray:encode_s32(byte_offset, value) end

--- @param byte_offset int
--- @param value int
function PackedByteArray:encode_u64(byte_offset, value) end

--- @param byte_offset int
--- @param value int
function PackedByteArray:encode_s64(byte_offset, value) end

--- @param byte_offset int
--- @param value float
function PackedByteArray:encode_half(byte_offset, value) end

--- @param byte_offset int
--- @param value float
function PackedByteArray:encode_float(byte_offset, value) end

--- @param byte_offset int
--- @param value float
function PackedByteArray:encode_double(byte_offset, value) end

--- @param byte_offset int
--- @param value any
--- @param allow_objects bool? Default: false
--- @return int
function PackedByteArray:encode_var(byte_offset, value, allow_objects) end


-----------------------------------------------------------
-- PackedInt32Array
-----------------------------------------------------------

--- @class PackedInt32Array: Variant, { [int]: int? }
--- @overload fun(): PackedInt32Array
--- @overload fun(from: PackedInt32Array): PackedInt32Array
--- @overload fun(from: Array): PackedInt32Array
--- @operator add(PackedInt32Array): PackedInt32Array
PackedInt32Array = {}

--- @param index int
--- @return int
function PackedInt32Array:get(index) end

--- @param index int
--- @param value int
function PackedInt32Array:set(index, value) end

--- @return int
function PackedInt32Array:size() end

--- @return bool
function PackedInt32Array:is_empty() end

--- @param value int
--- @return bool
function PackedInt32Array:push_back(value) end

--- @param value int
--- @return bool
function PackedInt32Array:append(value) end

--- @param array PackedInt32Array
function PackedInt32Array:append_array(array) end

--- @param index int
function PackedInt32Array:remove_at(index) end

--- @param at_index int
--- @param value int
--- @return int
function PackedInt32Array:insert(at_index, value) end

--- @param value int
function PackedInt32Array:fill(value) end

--- @param new_size int
--- @return int
function PackedInt32Array:resize(new_size) end

function PackedInt32Array:clear() end

--- @param value int
--- @return bool
function PackedInt32Array:has(value) end

function PackedInt32Array:reverse() end

--- @param begin int
--- @param _end int? Default: 2147483647
--- @return PackedInt32Array
function PackedInt32Array:slice(begin, _end) end

--- @return PackedByteArray
function PackedInt32Array:to_byte_array() end

function PackedInt32Array:sort() end

--- @param value int
--- @param before bool? Default: true
--- @return int
function PackedInt32Array:bsearch(value, before) end

--- @return PackedInt32Array
function PackedInt32Array:duplicate() end

--- @param value int
--- @param from int? Default: 0
--- @return int
function PackedInt32Array:find(value, from) end

--- @param value int
--- @param from int? Default: -1
--- @return int
function PackedInt32Array:rfind(value, from) end

--- @param value int
--- @return int
function PackedInt32Array:count(value) end

--- @param value int
--- @return bool
function PackedInt32Array:erase(value) end


-----------------------------------------------------------
-- PackedInt64Array
-----------------------------------------------------------

--- @class PackedInt64Array: Variant, { [int]: int? }
--- @overload fun(): PackedInt64Array
--- @overload fun(from: PackedInt64Array): PackedInt64Array
--- @overload fun(from: Array): PackedInt64Array
--- @operator add(PackedInt64Array): PackedInt64Array
PackedInt64Array = {}

--- @param index int
--- @return int
function PackedInt64Array:get(index) end

--- @param index int
--- @param value int
function PackedInt64Array:set(index, value) end

--- @return int
function PackedInt64Array:size() end

--- @return bool
function PackedInt64Array:is_empty() end

--- @param value int
--- @return bool
function PackedInt64Array:push_back(value) end

--- @param value int
--- @return bool
function PackedInt64Array:append(value) end

--- @param array PackedInt64Array
function PackedInt64Array:append_array(array) end

--- @param index int
function PackedInt64Array:remove_at(index) end

--- @param at_index int
--- @param value int
--- @return int
function PackedInt64Array:insert(at_index, value) end

--- @param value int
function PackedInt64Array:fill(value) end

--- @param new_size int
--- @return int
function PackedInt64Array:resize(new_size) end

function PackedInt64Array:clear() end

--- @param value int
--- @return bool
function PackedInt64Array:has(value) end

function PackedInt64Array:reverse() end

--- @param begin int
--- @param _end int? Default: 2147483647
--- @return PackedInt64Array
function PackedInt64Array:slice(begin, _end) end

--- @return PackedByteArray
function PackedInt64Array:to_byte_array() end

function PackedInt64Array:sort() end

--- @param value int
--- @param before bool? Default: true
--- @return int
function PackedInt64Array:bsearch(value, before) end

--- @return PackedInt64Array
function PackedInt64Array:duplicate() end

--- @param value int
--- @param from int? Default: 0
--- @return int
function PackedInt64Array:find(value, from) end

--- @param value int
--- @param from int? Default: -1
--- @return int
function PackedInt64Array:rfind(value, from) end

--- @param value int
--- @return int
function PackedInt64Array:count(value) end

--- @param value int
--- @return bool
function PackedInt64Array:erase(value) end


-----------------------------------------------------------
-- PackedFloat32Array
-----------------------------------------------------------

--- @class PackedFloat32Array: Variant, { [int]: float? }
--- @overload fun(): PackedFloat32Array
--- @overload fun(from: PackedFloat32Array): PackedFloat32Array
--- @overload fun(from: Array): PackedFloat32Array
--- @operator add(PackedFloat32Array): PackedFloat32Array
PackedFloat32Array = {}

--- @param index int
--- @return float
function PackedFloat32Array:get(index) end

--- @param index int
--- @param value float
function PackedFloat32Array:set(index, value) end

--- @return int
function PackedFloat32Array:size() end

--- @return bool
function PackedFloat32Array:is_empty() end

--- @param value float
--- @return bool
function PackedFloat32Array:push_back(value) end

--- @param value float
--- @return bool
function PackedFloat32Array:append(value) end

--- @param array PackedFloat32Array
function PackedFloat32Array:append_array(array) end

--- @param index int
function PackedFloat32Array:remove_at(index) end

--- @param at_index int
--- @param value float
--- @return int
function PackedFloat32Array:insert(at_index, value) end

--- @param value float
function PackedFloat32Array:fill(value) end

--- @param new_size int
--- @return int
function PackedFloat32Array:resize(new_size) end

function PackedFloat32Array:clear() end

--- @param value float
--- @return bool
function PackedFloat32Array:has(value) end

function PackedFloat32Array:reverse() end

--- @param begin int
--- @param _end int? Default: 2147483647
--- @return PackedFloat32Array
function PackedFloat32Array:slice(begin, _end) end

--- @return PackedByteArray
function PackedFloat32Array:to_byte_array() end

function PackedFloat32Array:sort() end

--- @param value float
--- @param before bool? Default: true
--- @return int
function PackedFloat32Array:bsearch(value, before) end

--- @return PackedFloat32Array
function PackedFloat32Array:duplicate() end

--- @param value float
--- @param from int? Default: 0
--- @return int
function PackedFloat32Array:find(value, from) end

--- @param value float
--- @param from int? Default: -1
--- @return int
function PackedFloat32Array:rfind(value, from) end

--- @param value float
--- @return int
function PackedFloat32Array:count(value) end

--- @param value float
--- @return bool
function PackedFloat32Array:erase(value) end


-----------------------------------------------------------
-- PackedFloat64Array
-----------------------------------------------------------

--- @class PackedFloat64Array: Variant, { [int]: float? }
--- @overload fun(): PackedFloat64Array
--- @overload fun(from: PackedFloat64Array): PackedFloat64Array
--- @overload fun(from: Array): PackedFloat64Array
--- @operator add(PackedFloat64Array): PackedFloat64Array
PackedFloat64Array = {}

--- @param index int
--- @return float
function PackedFloat64Array:get(index) end

--- @param index int
--- @param value float
function PackedFloat64Array:set(index, value) end

--- @return int
function PackedFloat64Array:size() end

--- @return bool
function PackedFloat64Array:is_empty() end

--- @param value float
--- @return bool
function PackedFloat64Array:push_back(value) end

--- @param value float
--- @return bool
function PackedFloat64Array:append(value) end

--- @param array PackedFloat64Array
function PackedFloat64Array:append_array(array) end

--- @param index int
function PackedFloat64Array:remove_at(index) end

--- @param at_index int
--- @param value float
--- @return int
function PackedFloat64Array:insert(at_index, value) end

--- @param value float
function PackedFloat64Array:fill(value) end

--- @param new_size int
--- @return int
function PackedFloat64Array:resize(new_size) end

function PackedFloat64Array:clear() end

--- @param value float
--- @return bool
function PackedFloat64Array:has(value) end

function PackedFloat64Array:reverse() end

--- @param begin int
--- @param _end int? Default: 2147483647
--- @return PackedFloat64Array
function PackedFloat64Array:slice(begin, _end) end

--- @return PackedByteArray
function PackedFloat64Array:to_byte_array() end

function PackedFloat64Array:sort() end

--- @param value float
--- @param before bool? Default: true
--- @return int
function PackedFloat64Array:bsearch(value, before) end

--- @return PackedFloat64Array
function PackedFloat64Array:duplicate() end

--- @param value float
--- @param from int? Default: 0
--- @return int
function PackedFloat64Array:find(value, from) end

--- @param value float
--- @param from int? Default: -1
--- @return int
function PackedFloat64Array:rfind(value, from) end

--- @param value float
--- @return int
function PackedFloat64Array:count(value) end

--- @param value float
--- @return bool
function PackedFloat64Array:erase(value) end


-----------------------------------------------------------
-- PackedStringArray
-----------------------------------------------------------

--- @class PackedStringArray: Variant, { [int]: String? }
--- @overload fun(): PackedStringArray
--- @overload fun(from: PackedStringArray): PackedStringArray
--- @overload fun(from: Array): PackedStringArray
--- @operator add(PackedStringArray): PackedStringArray
PackedStringArray = {}

--- @param index int
--- @return String
function PackedStringArray:get(index) end

--- @param index int
--- @param value String
function PackedStringArray:set(index, value) end

--- @return int
function PackedStringArray:size() end

--- @return bool
function PackedStringArray:is_empty() end

--- @param value String
--- @return bool
function PackedStringArray:push_back(value) end

--- @param value String
--- @return bool
function PackedStringArray:append(value) end

--- @param array PackedStringArray
function PackedStringArray:append_array(array) end

--- @param index int
function PackedStringArray:remove_at(index) end

--- @param at_index int
--- @param value String
--- @return int
function PackedStringArray:insert(at_index, value) end

--- @param value String
function PackedStringArray:fill(value) end

--- @param new_size int
--- @return int
function PackedStringArray:resize(new_size) end

function PackedStringArray:clear() end

--- @param value String
--- @return bool
function PackedStringArray:has(value) end

function PackedStringArray:reverse() end

--- @param begin int
--- @param _end int? Default: 2147483647
--- @return PackedStringArray
function PackedStringArray:slice(begin, _end) end

--- @return PackedByteArray
function PackedStringArray:to_byte_array() end

function PackedStringArray:sort() end

--- @param value String
--- @param before bool? Default: true
--- @return int
function PackedStringArray:bsearch(value, before) end

--- @return PackedStringArray
function PackedStringArray:duplicate() end

--- @param value String
--- @param from int? Default: 0
--- @return int
function PackedStringArray:find(value, from) end

--- @param value String
--- @param from int? Default: -1
--- @return int
function PackedStringArray:rfind(value, from) end

--- @param value String
--- @return int
function PackedStringArray:count(value) end

--- @param value String
--- @return bool
function PackedStringArray:erase(value) end


-----------------------------------------------------------
-- PackedVector2Array
-----------------------------------------------------------

--- @class PackedVector2Array: Variant, { [int]: Vector2? }
--- @overload fun(): PackedVector2Array
--- @overload fun(from: PackedVector2Array): PackedVector2Array
--- @overload fun(from: Array): PackedVector2Array
--- @operator mul(Transform2D): PackedVector2Array
--- @operator add(PackedVector2Array): PackedVector2Array
PackedVector2Array = {}

--- @param index int
--- @return Vector2
function PackedVector2Array:get(index) end

--- @param index int
--- @param value Vector2
function PackedVector2Array:set(index, value) end

--- @return int
function PackedVector2Array:size() end

--- @return bool
function PackedVector2Array:is_empty() end

--- @param value Vector2
--- @return bool
function PackedVector2Array:push_back(value) end

--- @param value Vector2
--- @return bool
function PackedVector2Array:append(value) end

--- @param array PackedVector2Array
function PackedVector2Array:append_array(array) end

--- @param index int
function PackedVector2Array:remove_at(index) end

--- @param at_index int
--- @param value Vector2
--- @return int
function PackedVector2Array:insert(at_index, value) end

--- @param value Vector2
function PackedVector2Array:fill(value) end

--- @param new_size int
--- @return int
function PackedVector2Array:resize(new_size) end

function PackedVector2Array:clear() end

--- @param value Vector2
--- @return bool
function PackedVector2Array:has(value) end

function PackedVector2Array:reverse() end

--- @param begin int
--- @param _end int? Default: 2147483647
--- @return PackedVector2Array
function PackedVector2Array:slice(begin, _end) end

--- @return PackedByteArray
function PackedVector2Array:to_byte_array() end

function PackedVector2Array:sort() end

--- @param value Vector2
--- @param before bool? Default: true
--- @return int
function PackedVector2Array:bsearch(value, before) end

--- @return PackedVector2Array
function PackedVector2Array:duplicate() end

--- @param value Vector2
--- @param from int? Default: 0
--- @return int
function PackedVector2Array:find(value, from) end

--- @param value Vector2
--- @param from int? Default: -1
--- @return int
function PackedVector2Array:rfind(value, from) end

--- @param value Vector2
--- @return int
function PackedVector2Array:count(value) end

--- @param value Vector2
--- @return bool
function PackedVector2Array:erase(value) end


-----------------------------------------------------------
-- PackedVector3Array
-----------------------------------------------------------

--- @class PackedVector3Array: Variant, { [int]: Vector3? }
--- @overload fun(): PackedVector3Array
--- @overload fun(from: PackedVector3Array): PackedVector3Array
--- @overload fun(from: Array): PackedVector3Array
--- @operator mul(Transform3D): PackedVector3Array
--- @operator add(PackedVector3Array): PackedVector3Array
PackedVector3Array = {}

--- @param index int
--- @return Vector3
function PackedVector3Array:get(index) end

--- @param index int
--- @param value Vector3
function PackedVector3Array:set(index, value) end

--- @return int
function PackedVector3Array:size() end

--- @return bool
function PackedVector3Array:is_empty() end

--- @param value Vector3
--- @return bool
function PackedVector3Array:push_back(value) end

--- @param value Vector3
--- @return bool
function PackedVector3Array:append(value) end

--- @param array PackedVector3Array
function PackedVector3Array:append_array(array) end

--- @param index int
function PackedVector3Array:remove_at(index) end

--- @param at_index int
--- @param value Vector3
--- @return int
function PackedVector3Array:insert(at_index, value) end

--- @param value Vector3
function PackedVector3Array:fill(value) end

--- @param new_size int
--- @return int
function PackedVector3Array:resize(new_size) end

function PackedVector3Array:clear() end

--- @param value Vector3
--- @return bool
function PackedVector3Array:has(value) end

function PackedVector3Array:reverse() end

--- @param begin int
--- @param _end int? Default: 2147483647
--- @return PackedVector3Array
function PackedVector3Array:slice(begin, _end) end

--- @return PackedByteArray
function PackedVector3Array:to_byte_array() end

function PackedVector3Array:sort() end

--- @param value Vector3
--- @param before bool? Default: true
--- @return int
function PackedVector3Array:bsearch(value, before) end

--- @return PackedVector3Array
function PackedVector3Array:duplicate() end

--- @param value Vector3
--- @param from int? Default: 0
--- @return int
function PackedVector3Array:find(value, from) end

--- @param value Vector3
--- @param from int? Default: -1
--- @return int
function PackedVector3Array:rfind(value, from) end

--- @param value Vector3
--- @return int
function PackedVector3Array:count(value) end

--- @param value Vector3
--- @return bool
function PackedVector3Array:erase(value) end


-----------------------------------------------------------
-- PackedColorArray
-----------------------------------------------------------

--- @class PackedColorArray: Variant, { [int]: Color? }
--- @overload fun(): PackedColorArray
--- @overload fun(from: PackedColorArray): PackedColorArray
--- @overload fun(from: Array): PackedColorArray
--- @operator add(PackedColorArray): PackedColorArray
PackedColorArray = {}

--- @param index int
--- @return Color
function PackedColorArray:get(index) end

--- @param index int
--- @param value Color
function PackedColorArray:set(index, value) end

--- @return int
function PackedColorArray:size() end

--- @return bool
function PackedColorArray:is_empty() end

--- @param value Color
--- @return bool
function PackedColorArray:push_back(value) end

--- @param value Color
--- @return bool
function PackedColorArray:append(value) end

--- @param array PackedColorArray
function PackedColorArray:append_array(array) end

--- @param index int
function PackedColorArray:remove_at(index) end

--- @param at_index int
--- @param value Color
--- @return int
function PackedColorArray:insert(at_index, value) end

--- @param value Color
function PackedColorArray:fill(value) end

--- @param new_size int
--- @return int
function PackedColorArray:resize(new_size) end

function PackedColorArray:clear() end

--- @param value Color
--- @return bool
function PackedColorArray:has(value) end

function PackedColorArray:reverse() end

--- @param begin int
--- @param _end int? Default: 2147483647
--- @return PackedColorArray
function PackedColorArray:slice(begin, _end) end

--- @return PackedByteArray
function PackedColorArray:to_byte_array() end

function PackedColorArray:sort() end

--- @param value Color
--- @param before bool? Default: true
--- @return int
function PackedColorArray:bsearch(value, before) end

--- @return PackedColorArray
function PackedColorArray:duplicate() end

--- @param value Color
--- @param from int? Default: 0
--- @return int
function PackedColorArray:find(value, from) end

--- @param value Color
--- @param from int? Default: -1
--- @return int
function PackedColorArray:rfind(value, from) end

--- @param value Color
--- @return int
function PackedColorArray:count(value) end

--- @param value Color
--- @return bool
function PackedColorArray:erase(value) end


-----------------------------------------------------------
-- PackedVector4Array
-----------------------------------------------------------

--- @class PackedVector4Array: Variant, { [int]: Vector4? }
--- @overload fun(): PackedVector4Array
--- @overload fun(from: PackedVector4Array): PackedVector4Array
--- @overload fun(from: Array): PackedVector4Array
--- @operator add(PackedVector4Array): PackedVector4Array
PackedVector4Array = {}

--- @param index int
--- @return Vector4
function PackedVector4Array:get(index) end

--- @param index int
--- @param value Vector4
function PackedVector4Array:set(index, value) end

--- @return int
function PackedVector4Array:size() end

--- @return bool
function PackedVector4Array:is_empty() end

--- @param value Vector4
--- @return bool
function PackedVector4Array:push_back(value) end

--- @param value Vector4
--- @return bool
function PackedVector4Array:append(value) end

--- @param array PackedVector4Array
function PackedVector4Array:append_array(array) end

--- @param index int
function PackedVector4Array:remove_at(index) end

--- @param at_index int
--- @param value Vector4
--- @return int
function PackedVector4Array:insert(at_index, value) end

--- @param value Vector4
function PackedVector4Array:fill(value) end

--- @param new_size int
--- @return int
function PackedVector4Array:resize(new_size) end

function PackedVector4Array:clear() end

--- @param value Vector4
--- @return bool
function PackedVector4Array:has(value) end

function PackedVector4Array:reverse() end

--- @param begin int
--- @param _end int? Default: 2147483647
--- @return PackedVector4Array
function PackedVector4Array:slice(begin, _end) end

--- @return PackedByteArray
function PackedVector4Array:to_byte_array() end

function PackedVector4Array:sort() end

--- @param value Vector4
--- @param before bool? Default: true
--- @return int
function PackedVector4Array:bsearch(value, before) end

--- @return PackedVector4Array
function PackedVector4Array:duplicate() end

--- @param value Vector4
--- @param from int? Default: 0
--- @return int
function PackedVector4Array:find(value, from) end

--- @param value Vector4
--- @param from int? Default: -1
--- @return int
function PackedVector4Array:rfind(value, from) end

--- @param value Vector4
--- @return int
function PackedVector4Array:count(value) end

--- @param value Vector4
--- @return bool
function PackedVector4Array:erase(value) end