typescript-to-gdscript 0.1.0

package/typings/classes/NavigationPathQueryParameters2D.d.ts

@@ -0,0 +1,114 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Provides parameters for 2D navigation path queries. */
+declare class NavigationPathQueryParameters2D extends RefCounted {
+  /**
+   * The list of region {@link RID}s that will be excluded from the path query. Use {@link NavigationRegion2D.get_rid} to get the {@link RID} associated with a {@link NavigationRegion2D} node.
+   * **Note:** The returned array is copied and any changes to it will not update the original property value. To update the value you need to modify the returned array, and then set it to the property again.
+   */
+  excluded_regions: Array<RID>;
+  /**
+   * The list of region {@link RID}s that will be included by the path query. Use {@link NavigationRegion2D.get_rid} to get the {@link RID} associated with a {@link NavigationRegion2D} node. If left empty all regions are included. If a region ends up being both included and excluded at the same time it will be excluded.
+   * **Note:** The returned array is copied and any changes to it will not update the original property value. To update the value you need to modify the returned array, and then set it to the property again.
+   */
+  included_regions: Array<RID>;
+  /** The navigation map {@link RID} used in the path query. */
+  map: RID;
+  /** Additional information to include with the navigation path. */
+  metadata_flags: int;
+  /** The navigation layers the query will use (as a bitmask). */
+  navigation_layers: int;
+  /**
+   * The path postprocessing applied to the raw path corridor found by the {@link pathfinding_algorithm}.
+   */
+  path_postprocessing: int;
+  /**
+   * The maximum allowed length of the returned path in world units. A path will be clipped when going over this length. A value of `0` or below counts as disabled.
+   */
+  path_return_max_length: float;
+  /**
+   * The maximum allowed radius in world units that the returned path can be from the path start. The path will be clipped when going over this radius. A value of `0` or below counts as disabled.
+   * **Note:** This will perform a circle shaped clip operation on the path with the first path position being the circle's center position.
+   */
+  path_return_max_radius: float;
+  /**
+   * The maximum distance a searched polygon can be away from the start polygon before the pathfinding cancels the search for a path to the (possibly unreachable or very far away) target position polygon. In this case the pathfinding resets and builds a path from the start polygon to the polygon that was found closest to the target position so far. A value of `0` or below counts as unlimited. In case of unlimited the pathfinding will search all polygons connected with the start polygon until either the target position polygon is found or all available polygon search options are exhausted.
+   */
+  path_search_max_distance: float;
+  /**
+   * The maximum number of polygons that are searched before the pathfinding cancels the search for a path to the (possibly unreachable or very far away) target position polygon. In this case the pathfinding resets and builds a path from the start polygon to the polygon that was found closest to the target position so far. A value of `0` or below counts as unlimited. In case of unlimited the pathfinding will search all polygons connected with the start polygon until either the target position polygon is found or all available polygon search options are exhausted.
+   */
+  path_search_max_polygons: int;
+  /** The pathfinding algorithm used in the path query. */
+  pathfinding_algorithm: int;
+  /** The path simplification amount in worlds units. */
+  simplify_epsilon: float;
+  /**
+   * If `true` a simplified version of the path will be returned with less critical path points removed. The simplification amount is controlled by {@link simplify_epsilon}. The simplification uses a variant of Ramer-Douglas-Peucker algorithm for curve point decimation.
+   * Path simplification can be helpful to mitigate various path following issues that can arise with certain agent types and script behaviors. E.g. "steering" agents or avoidance in "open fields".
+   */
+  simplify_path: boolean;
+  /** The pathfinding start position in global coordinates. */
+  start_position: Vector2;
+  /** The pathfinding target position in global coordinates. */
+  target_position: Vector2;
+  set_excluded_regions(value: Array<RID>): void;
+  get_excluded_regions(): Array<RID>;
+  set_included_regions(value: Array<RID>): void;
+  get_included_regions(): Array<RID>;
+  set_map(value: RID): void;
+  get_map(): RID;
+  set_metadata_flags(value: int): void;
+  get_metadata_flags(): int;
+  set_navigation_layers(value: int): void;
+  get_navigation_layers(): int;
+  set_path_postprocessing(value: int): void;
+  get_path_postprocessing(): int;
+  set_path_return_max_length(value: float): void;
+  get_path_return_max_length(): float;
+  set_path_return_max_radius(value: float): void;
+  get_path_return_max_radius(): float;
+  set_path_search_max_distance(value: float): void;
+  get_path_search_max_distance(): float;
+  set_path_search_max_polygons(value: int): void;
+  get_path_search_max_polygons(): int;
+  set_pathfinding_algorithm(value: int): void;
+  get_pathfinding_algorithm(): int;
+  set_simplify_epsilon(value: float): void;
+  get_simplify_epsilon(): float;
+  set_simplify_path(value: boolean): void;
+  get_simplify_path(): boolean;
+  set_start_position(value: Vector2 | Vector2i): void;
+  get_start_position(): Vector2;
+  set_target_position(value: Vector2 | Vector2i): void;
+  get_target_position(): Vector2;
+
+  // enum PathfindingAlgorithm
+  /** The path query uses the default A* pathfinding algorithm. */
+  static readonly PATHFINDING_ALGORITHM_ASTAR: int;
+  // enum PathPostProcessing
+  /**
+   * Applies a funnel algorithm to the raw path corridor found by the pathfinding algorithm. This will result in the shortest path possible inside the path corridor. This postprocessing very much depends on the navigation mesh polygon layout and the created corridor. Especially tile- or gridbased layouts can face artificial corners with diagonal movement due to a jagged path corridor imposed by the cell shapes.
+   */
+  static readonly PATH_POSTPROCESSING_CORRIDORFUNNEL: int;
+  /**
+   * Centers every path position in the middle of the traveled navigation mesh polygon edge. This creates better paths for tile- or gridbased layouts that restrict the movement to the cells center.
+   */
+  static readonly PATH_POSTPROCESSING_EDGECENTERED: int;
+  /** Applies no postprocessing and returns the raw path corridor as found by the pathfinding algorithm. */
+  static readonly PATH_POSTPROCESSING_NONE: int;
+  // enum PathMetadataFlags
+  /** Don't include any additional metadata about the returned path. */
+  static readonly PATH_METADATA_INCLUDE_NONE: int;
+  /** Include the type of navigation primitive (region or link) that each point of the path goes through. */
+  static readonly PATH_METADATA_INCLUDE_TYPES: int;
+  /** Include the {@link RID}s of the regions and links that each point of the path goes through. */
+  static readonly PATH_METADATA_INCLUDE_RIDS: int;
+  /**
+   * Include the `ObjectID`s of the {@link Object}s which manage the regions and links each point of the path goes through.
+   */
+  static readonly PATH_METADATA_INCLUDE_OWNERS: int;
+  /** Include all available metadata about the returned path. */
+  static readonly PATH_METADATA_INCLUDE_ALL: int;
+}

package/typings/classes/NavigationPathQueryParameters3D.d.ts

@@ -0,0 +1,114 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Provides parameters for 3D navigation path queries. */
+declare class NavigationPathQueryParameters3D extends RefCounted {
+  /**
+   * The list of region {@link RID}s that will be excluded from the path query. Use {@link NavigationRegion3D.get_rid} to get the {@link RID} associated with a {@link NavigationRegion3D} node.
+   * **Note:** The returned array is copied and any changes to it will not update the original property value. To update the value you need to modify the returned array, and then set it to the property again.
+   */
+  excluded_regions: Array<RID>;
+  /**
+   * The list of region {@link RID}s that will be included by the path query. Use {@link NavigationRegion3D.get_rid} to get the {@link RID} associated with a {@link NavigationRegion3D} node. If left empty all regions are included. If a region ends up being both included and excluded at the same time it will be excluded.
+   * **Note:** The returned array is copied and any changes to it will not update the original property value. To update the value you need to modify the returned array, and then set it to the property again.
+   */
+  included_regions: Array<RID>;
+  /** The navigation map {@link RID} used in the path query. */
+  map: RID;
+  /** Additional information to include with the navigation path. */
+  metadata_flags: int;
+  /** The navigation layers the query will use (as a bitmask). */
+  navigation_layers: int;
+  /**
+   * The path postprocessing applied to the raw path corridor found by the {@link pathfinding_algorithm}.
+   */
+  path_postprocessing: int;
+  /**
+   * The maximum allowed length of the returned path in world units. A path will be clipped when going over this length. A value of `0` or below counts as disabled.
+   */
+  path_return_max_length: float;
+  /**
+   * The maximum allowed radius in world units that the returned path can be from the path start. The path will be clipped when going over this radius. A value of `0` or below counts as disabled.
+   * **Note:** This will perform a sphere shaped clip operation on the path with the first path position being the sphere's center position.
+   */
+  path_return_max_radius: float;
+  /**
+   * The maximum distance a searched polygon can be away from the start polygon before the pathfinding cancels the search for a path to the (possibly unreachable or very far away) target position polygon. In this case the pathfinding resets and builds a path from the start polygon to the polygon that was found closest to the target position so far. A value of `0` or below counts as unlimited. In case of unlimited the pathfinding will search all polygons connected with the start polygon until either the target position polygon is found or all available polygon search options are exhausted.
+   */
+  path_search_max_distance: float;
+  /**
+   * The maximum number of polygons that are searched before the pathfinding cancels the search for a path to the (possibly unreachable or very far away) target position polygon. In this case the pathfinding resets and builds a path from the start polygon to the polygon that was found closest to the target position so far. A value of `0` or below counts as unlimited. In case of unlimited the pathfinding will search all polygons connected with the start polygon until either the target position polygon is found or all available polygon search options are exhausted.
+   */
+  path_search_max_polygons: int;
+  /** The pathfinding algorithm used in the path query. */
+  pathfinding_algorithm: int;
+  /** The path simplification amount in worlds units. */
+  simplify_epsilon: float;
+  /**
+   * If `true` a simplified version of the path will be returned with less critical path points removed. The simplification amount is controlled by {@link simplify_epsilon}. The simplification uses a variant of Ramer-Douglas-Peucker algorithm for curve point decimation.
+   * Path simplification can be helpful to mitigate various path following issues that can arise with certain agent types and script behaviors. E.g. "steering" agents or avoidance in "open fields".
+   */
+  simplify_path: boolean;
+  /** The pathfinding start position in global coordinates. */
+  start_position: Vector3;
+  /** The pathfinding target position in global coordinates. */
+  target_position: Vector3;
+  set_excluded_regions(value: Array<RID>): void;
+  get_excluded_regions(): Array<RID>;
+  set_included_regions(value: Array<RID>): void;
+  get_included_regions(): Array<RID>;
+  set_map(value: RID): void;
+  get_map(): RID;
+  set_metadata_flags(value: int): void;
+  get_metadata_flags(): int;
+  set_navigation_layers(value: int): void;
+  get_navigation_layers(): int;
+  set_path_postprocessing(value: int): void;
+  get_path_postprocessing(): int;
+  set_path_return_max_length(value: float): void;
+  get_path_return_max_length(): float;
+  set_path_return_max_radius(value: float): void;
+  get_path_return_max_radius(): float;
+  set_path_search_max_distance(value: float): void;
+  get_path_search_max_distance(): float;
+  set_path_search_max_polygons(value: int): void;
+  get_path_search_max_polygons(): int;
+  set_pathfinding_algorithm(value: int): void;
+  get_pathfinding_algorithm(): int;
+  set_simplify_epsilon(value: float): void;
+  get_simplify_epsilon(): float;
+  set_simplify_path(value: boolean): void;
+  get_simplify_path(): boolean;
+  set_start_position(value: Vector3 | Vector3i): void;
+  get_start_position(): Vector3;
+  set_target_position(value: Vector3 | Vector3i): void;
+  get_target_position(): Vector3;
+
+  // enum PathfindingAlgorithm
+  /** The path query uses the default A* pathfinding algorithm. */
+  static readonly PATHFINDING_ALGORITHM_ASTAR: int;
+  // enum PathPostProcessing
+  /**
+   * Applies a funnel algorithm to the raw path corridor found by the pathfinding algorithm. This will result in the shortest path possible inside the path corridor. This postprocessing very much depends on the navigation mesh polygon layout and the created corridor. Especially tile- or gridbased layouts can face artificial corners with diagonal movement due to a jagged path corridor imposed by the cell shapes.
+   */
+  static readonly PATH_POSTPROCESSING_CORRIDORFUNNEL: int;
+  /**
+   * Centers every path position in the middle of the traveled navigation mesh polygon edge. This creates better paths for tile- or gridbased layouts that restrict the movement to the cells center.
+   */
+  static readonly PATH_POSTPROCESSING_EDGECENTERED: int;
+  /** Applies no postprocessing and returns the raw path corridor as found by the pathfinding algorithm. */
+  static readonly PATH_POSTPROCESSING_NONE: int;
+  // enum PathMetadataFlags
+  /** Don't include any additional metadata about the returned path. */
+  static readonly PATH_METADATA_INCLUDE_NONE: int;
+  /** Include the type of navigation primitive (region or link) that each point of the path goes through. */
+  static readonly PATH_METADATA_INCLUDE_TYPES: int;
+  /** Include the {@link RID}s of the regions and links that each point of the path goes through. */
+  static readonly PATH_METADATA_INCLUDE_RIDS: int;
+  /**
+   * Include the `ObjectID`s of the {@link Object}s which manage the regions and links each point of the path goes through.
+   */
+  static readonly PATH_METADATA_INCLUDE_OWNERS: int;
+  /** Include all available metadata about the returned path. */
+  static readonly PATH_METADATA_INCLUDE_ALL: int;
+}

package/typings/classes/NavigationPathQueryResult2D.d.ts

@@ -0,0 +1,41 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Represents the result of a 2D pathfinding query. */
+declare class NavigationPathQueryResult2D extends RefCounted {
+  /**
+   * The resulting path array from the navigation query. All path array positions are in global coordinates. Without customized query parameters this is the same path as returned by {@link NavigationServer2D.map_get_path}.
+   */
+  path: PackedVector2Array;
+  /** Returns the length of the path. */
+  path_length: float;
+  /**
+   * The `ObjectID`s of the {@link Object}s which manage the regions and links each point of the path goes through.
+   */
+  path_owner_ids: PackedInt64Array;
+  /** The {@link RID}s of the regions and links that each point of the path goes through. */
+  path_rids: Array<RID>;
+  /** The type of navigation primitive (region or link) that each point of the path goes through. */
+  path_types: PackedInt32Array;
+  set_path(value: PackedVector2Array | Array<unknown>): void;
+  get_path(): PackedVector2Array;
+  set_path_length(value: float): void;
+  get_path_length(): float;
+  set_path_owner_ids(value: PackedInt64Array | Array<unknown>): void;
+  get_path_owner_ids(): PackedInt64Array;
+  set_path_rids(value: Array<RID>): void;
+  get_path_rids(): Array<RID>;
+  set_path_types(value: PackedInt32Array | Array<unknown>): void;
+  get_path_types(): PackedInt32Array;
+
+  /**
+   * Reset the result object to its initial state. This is useful to reuse the object across multiple queries.
+   */
+  reset(): void;
+
+  // enum PathSegmentType
+  /** This segment of the path goes through a region. */
+  static readonly PATH_SEGMENT_TYPE_REGION: int;
+  /** This segment of the path goes through a link. */
+  static readonly PATH_SEGMENT_TYPE_LINK: int;
+}

package/typings/classes/NavigationPathQueryResult3D.d.ts

@@ -0,0 +1,41 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Represents the result of a 3D pathfinding query. */
+declare class NavigationPathQueryResult3D extends RefCounted {
+  /**
+   * The resulting path array from the navigation query. All path array positions are in global coordinates. Without customized query parameters this is the same path as returned by {@link NavigationServer3D.map_get_path}.
+   */
+  path: PackedVector3Array;
+  /** Returns the length of the path. */
+  path_length: float;
+  /**
+   * The `ObjectID`s of the {@link Object}s which manage the regions and links each point of the path goes through.
+   */
+  path_owner_ids: PackedInt64Array;
+  /** The {@link RID}s of the regions and links that each point of the path goes through. */
+  path_rids: Array<RID>;
+  /** The type of navigation primitive (region or link) that each point of the path goes through. */
+  path_types: PackedInt32Array;
+  set_path(value: PackedVector3Array | Array<unknown>): void;
+  get_path(): PackedVector3Array;
+  set_path_length(value: float): void;
+  get_path_length(): float;
+  set_path_owner_ids(value: PackedInt64Array | Array<unknown>): void;
+  get_path_owner_ids(): PackedInt64Array;
+  set_path_rids(value: Array<RID>): void;
+  get_path_rids(): Array<RID>;
+  set_path_types(value: PackedInt32Array | Array<unknown>): void;
+  get_path_types(): PackedInt32Array;
+
+  /**
+   * Reset the result object to its initial state. This is useful to reuse the object across multiple queries.
+   */
+  reset(): void;
+
+  // enum PathSegmentType
+  /** This segment of the path goes through a region. */
+  static readonly PATH_SEGMENT_TYPE_REGION: int;
+  /** This segment of the path goes through a link. */
+  static readonly PATH_SEGMENT_TYPE_LINK: int;
+}

package/typings/classes/NavigationPolygon.d.ts

@@ -0,0 +1,150 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A 2D navigation mesh that describes a traversable surface for pathfinding. */
+declare class NavigationPolygon extends Resource {
+  /**
+   * The distance to erode/shrink the walkable surface when baking the navigation mesh.
+   * **Note:** The radius must be equal or higher than `0.0`. If the radius is `0.0`, it won't be possible to fix invalid outline overlaps and other precision errors during the baking process. As a result, some obstacles may be excluded incorrectly from the final navigation mesh, or may delete the navigation mesh's polygons.
+   */
+  agent_radius: float;
+  /**
+   * If the baking {@link Rect2} has an area the navigation mesh baking will be restricted to its enclosing area.
+   */
+  baking_rect: Rect2;
+  /** The position offset applied to the {@link baking_rect} {@link Rect2}. */
+  baking_rect_offset: Vector2;
+  /**
+   * The size of the non-navigable border around the bake bounding area defined by the {@link baking_rect} {@link Rect2}.
+   * In conjunction with the {@link baking_rect} the border size can be used to bake tile aligned navigation meshes without the tile edges being shrunk by {@link agent_radius}.
+   */
+  border_size: float;
+  /**
+   * The cell size used to rasterize the navigation mesh vertices. Must match with the cell size on the navigation map.
+   */
+  cell_size: float;
+  /**
+   * The physics layers to scan for static colliders.
+   * Only used when {@link parsed_geometry_type} is {@link PARSED_GEOMETRY_STATIC_COLLIDERS} or {@link PARSED_GEOMETRY_BOTH}.
+   */
+  parsed_collision_mask: int;
+  /** Determines which type of nodes will be parsed as geometry. */
+  parsed_geometry_type: int;
+  /** Partitioning algorithm for creating the navigation mesh polys. */
+  sample_partition_type: int;
+  /**
+   * The group name of nodes that should be parsed for baking source geometry.
+   * Only used when {@link source_geometry_mode} is {@link SOURCE_GEOMETRY_GROUPS_WITH_CHILDREN} or {@link SOURCE_GEOMETRY_GROUPS_EXPLICIT}.
+   */
+  source_geometry_group_name: string;
+  /** The source of the geometry used when baking. */
+  source_geometry_mode: int;
+  set_agent_radius(value: float): void;
+  get_agent_radius(): float;
+  set_baking_rect(value: Rect2 | Rect2i): void;
+  get_baking_rect(): Rect2;
+  set_baking_rect_offset(value: Vector2 | Vector2i): void;
+  get_baking_rect_offset(): Vector2;
+  set_border_size(value: float): void;
+  get_border_size(): float;
+  set_cell_size(value: float): void;
+  get_cell_size(): float;
+  set_parsed_collision_mask(value: int): void;
+  get_parsed_collision_mask(): int;
+  set_parsed_geometry_type(value: int): void;
+  get_parsed_geometry_type(): int;
+  set_sample_partition_type(value: int): void;
+  get_sample_partition_type(): int;
+  set_source_geometry_group_name(value: string): void;
+  get_source_geometry_group_name(): string;
+  set_source_geometry_mode(value: int): void;
+  get_source_geometry_mode(): int;
+
+  /**
+   * Appends a {@link PackedVector2Array} that contains the vertices of an outline to the internal array that contains all the outlines.
+   */
+  add_outline(outline: PackedVector2Array | Array<unknown>): void;
+  /**
+   * Adds a {@link PackedVector2Array} that contains the vertices of an outline to the internal array that contains all the outlines at a fixed position.
+   */
+  add_outline_at_index(outline: PackedVector2Array | Array<unknown>, index: int): void;
+  /** Adds a polygon using the indices of the vertices you get when calling {@link get_vertices}. */
+  add_polygon(polygon: PackedInt32Array | Array<unknown>): void;
+  /** Clears the internal arrays for vertices and polygon indices. */
+  clear(): void;
+  /**
+   * Clears the array of the outlines, but it doesn't clear the vertices and the polygons that were created by them.
+   */
+  clear_outlines(): void;
+  /** Clears the array of polygons, but it doesn't clear the array of outlines and vertices. */
+  clear_polygons(): void;
+  /**
+   * Returns the {@link NavigationMesh} resulting from this navigation polygon. This navigation mesh can be used to update the navigation mesh of a region with the {@link NavigationServer3D.region_set_navigation_mesh} API directly.
+   */
+  get_navigation_mesh(): NavigationMesh | null;
+  /**
+   * Returns a {@link PackedVector2Array} containing the vertices of an outline that was created in the editor or by script.
+   */
+  get_outline(idx: int): PackedVector2Array;
+  /** Returns the number of outlines that were created in the editor or by script. */
+  get_outline_count(): int;
+  /**
+   * Returns whether or not the specified layer of the {@link parsed_collision_mask} is enabled, given a `layer_number` between 1 and 32.
+   */
+  get_parsed_collision_mask_value(layer_number: int): boolean;
+  /** Returns a {@link PackedInt32Array} containing the indices of the vertices of a created polygon. */
+  get_polygon(idx: int): PackedInt32Array;
+  /** Returns the count of all polygons. */
+  get_polygon_count(): int;
+  /** Returns a {@link PackedVector2Array} containing all the vertices being used to create the polygons. */
+  get_vertices(): PackedVector2Array;
+  /** Creates polygons from the outlines added in the editor or by script. */
+  make_polygons_from_outlines(): void;
+  /**
+   * Removes an outline created in the editor or by script. You have to call {@link make_polygons_from_outlines} for the polygons to update.
+   */
+  remove_outline(idx: int): void;
+  /**
+   * Changes an outline created in the editor or by script. You have to call {@link make_polygons_from_outlines} for the polygons to update.
+   */
+  set_outline(idx: int, outline: PackedVector2Array | Array<unknown>): void;
+  /**
+   * Based on `value`, enables or disables the specified layer in the {@link parsed_collision_mask}, given a `layer_number` between 1 and 32.
+   */
+  set_parsed_collision_mask_value(layer_number: int, value: boolean): void;
+  /** Sets the vertices that can be then indexed to create polygons with the {@link add_polygon} method. */
+  set_vertices(vertices: PackedVector2Array | Array<unknown>): void;
+
+  // enum SamplePartitionType
+  /** Convex partitioning that results in a navigation mesh with convex polygons. */
+  static readonly SAMPLE_PARTITION_CONVEX_PARTITION: int;
+  /** Triangulation partitioning that results in a navigation mesh with triangle polygons. */
+  static readonly SAMPLE_PARTITION_TRIANGULATE: int;
+  /** Represents the size of the {@link SamplePartitionType} enum. */
+  static readonly SAMPLE_PARTITION_MAX: int;
+  // enum ParsedGeometryType
+  /**
+   * Parses mesh instances as obstruction geometry. This includes {@link Polygon2D}, {@link MeshInstance2D}, {@link MultiMeshInstance2D}, and {@link TileMap} nodes.
+   * Meshes are only parsed when they use a 2D vertices surface format.
+   */
+  static readonly PARSED_GEOMETRY_MESH_INSTANCES: int;
+  /**
+   * Parses {@link StaticBody2D} and {@link TileMap} colliders as obstruction geometry. The collider should be in any of the layers specified by {@link parsed_collision_mask}.
+   */
+  static readonly PARSED_GEOMETRY_STATIC_COLLIDERS: int;
+  /** Both {@link PARSED_GEOMETRY_MESH_INSTANCES} and {@link PARSED_GEOMETRY_STATIC_COLLIDERS}. */
+  static readonly PARSED_GEOMETRY_BOTH: int;
+  /** Represents the size of the {@link ParsedGeometryType} enum. */
+  static readonly PARSED_GEOMETRY_MAX: int;
+  // enum SourceGeometryMode
+  /** Scans the child nodes of the root node recursively for geometry. */
+  static readonly SOURCE_GEOMETRY_ROOT_NODE_CHILDREN: int;
+  /**
+   * Scans nodes in a group and their child nodes recursively for geometry. The group is specified by {@link source_geometry_group_name}.
+   */
+  static readonly SOURCE_GEOMETRY_GROUPS_WITH_CHILDREN: int;
+  /** Uses nodes in a group for geometry. The group is specified by {@link source_geometry_group_name}. */
+  static readonly SOURCE_GEOMETRY_GROUPS_EXPLICIT: int;
+  /** Represents the size of the {@link SourceGeometryMode} enum. */
+  static readonly SOURCE_GEOMETRY_MAX: int;
+}

package/typings/classes/NavigationRegion2D.d.ts

@@ -0,0 +1,74 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A traversable 2D region that {@link NavigationAgent2D}s can use for pathfinding. */
+declare class NavigationRegion2D extends Node2D {
+  /** Determines if the {@link NavigationRegion2D} is enabled or disabled. */
+  enabled: boolean;
+  /**
+   * When pathfinding enters this region's navigation mesh from another regions navigation mesh the {@link enter_cost} value is added to the path distance for determining the shortest path.
+   */
+  enter_cost: float;
+  /**
+   * A bitfield determining all navigation layers the region belongs to. These navigation layers can be checked upon when requesting a path with {@link NavigationServer2D.map_get_path}.
+   */
+  navigation_layers: int;
+  /** The {@link NavigationPolygon} resource to use. */
+  navigation_polygon: NavigationPolygon | null;
+  /**
+   * When pathfinding moves inside this region's navigation mesh the traveled distances are multiplied with {@link travel_cost} for determining the shortest path.
+   */
+  travel_cost: float;
+  /**
+   * If enabled the navigation region will use edge connections to connect with other navigation regions within proximity of the navigation map edge connection margin.
+   */
+  use_edge_connections: boolean;
+  set_enabled(value: boolean): void;
+  is_enabled(): boolean;
+  set_enter_cost(value: float): void;
+  get_enter_cost(): float;
+  set_navigation_layers(value: int): void;
+  get_navigation_layers(): int;
+  set_navigation_polygon(value: NavigationPolygon | null): void;
+  get_navigation_polygon(): NavigationPolygon | null;
+  set_travel_cost(value: float): void;
+  get_travel_cost(): float;
+  set_use_edge_connections(value: boolean): void;
+  get_use_edge_connections(): boolean;
+
+  /**
+   * Bakes the {@link NavigationPolygon}. If `on_thread` is set to `true` (default), the baking is done on a separate thread.
+   */
+  bake_navigation_polygon(on_thread?: boolean): void;
+  /** Returns the axis-aligned rectangle for the region's transformed navigation mesh. */
+  get_bounds(): Rect2;
+  /**
+   * Returns whether or not the specified layer of the {@link navigation_layers} bitmask is enabled, given a `layer_number` between 1 and 32.
+   */
+  get_navigation_layer_value(layer_number: int): boolean;
+  /** Returns the current navigation map {@link RID} used by this region. */
+  get_navigation_map(): RID;
+  /** Returns the {@link RID} of this region on the {@link NavigationServer2D}. */
+  get_region_rid(): RID;
+  /**
+   * Returns the {@link RID} of this region on the {@link NavigationServer2D}. Combined with {@link NavigationServer2D.map_get_closest_point_owner} can be used to identify the {@link NavigationRegion2D} closest to a point on the merged navigation map.
+   */
+  get_rid(): RID;
+  /** Returns `true` when the {@link NavigationPolygon} is being baked on a background thread. */
+  is_baking(): boolean;
+  /**
+   * Based on `value`, enables or disables the specified layer in the {@link navigation_layers} bitmask, given a `layer_number` between 1 and 32.
+   */
+  set_navigation_layer_value(layer_number: int, value: boolean): void;
+  /**
+   * Sets the {@link RID} of the navigation map this region should use. By default the region will automatically join the {@link World2D} default navigation map so this function is only required to override the default map.
+   */
+  set_navigation_map(navigation_map: RID): void;
+
+  /** Emitted when a navigation polygon bake operation is completed. */
+  bake_finished: Signal<[]>;
+  /**
+   * Emitted when the used navigation polygon is replaced or changes to the internals of the current navigation polygon are committed.
+   */
+  navigation_polygon_changed: Signal<[]>;
+}

package/typings/classes/NavigationRegion3D.d.ts

@@ -0,0 +1,72 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A traversable 3D region that {@link NavigationAgent3D}s can use for pathfinding. */
+declare class NavigationRegion3D extends Node3D {
+  /** Determines if the {@link NavigationRegion3D} is enabled or disabled. */
+  enabled: boolean;
+  /**
+   * When pathfinding enters this region's navigation mesh from another regions navigation mesh the {@link enter_cost} value is added to the path distance for determining the shortest path.
+   */
+  enter_cost: float;
+  /**
+   * A bitfield determining all navigation layers the region belongs to. These navigation layers can be checked upon when requesting a path with {@link NavigationServer3D.map_get_path}.
+   */
+  navigation_layers: int;
+  /** The {@link NavigationMesh} resource to use. */
+  navigation_mesh: NavigationMesh | null;
+  /**
+   * When pathfinding moves inside this region's navigation mesh the traveled distances are multiplied with {@link travel_cost} for determining the shortest path.
+   */
+  travel_cost: float;
+  /**
+   * If enabled the navigation region will use edge connections to connect with other navigation regions within proximity of the navigation map edge connection margin.
+   */
+  use_edge_connections: boolean;
+  set_enabled(value: boolean): void;
+  is_enabled(): boolean;
+  set_enter_cost(value: float): void;
+  get_enter_cost(): float;
+  set_navigation_layers(value: int): void;
+  get_navigation_layers(): int;
+  set_navigation_mesh(value: NavigationMesh | null): void;
+  get_navigation_mesh(): NavigationMesh | null;
+  set_travel_cost(value: float): void;
+  get_travel_cost(): float;
+  set_use_edge_connections(value: boolean): void;
+  get_use_edge_connections(): boolean;
+
+  /**
+   * Bakes the {@link NavigationMesh}. If `on_thread` is set to `true` (default), the baking is done on a separate thread. Baking on separate thread is useful because navigation baking is not a cheap operation. When it is completed, it automatically sets the new {@link NavigationMesh}. Please note that baking on separate thread may be very slow if geometry is parsed from meshes as async access to each mesh involves heavy synchronization. Also, please note that baking on a separate thread is automatically disabled on operating systems that cannot use threads (such as Web with threads disabled).
+   */
+  bake_navigation_mesh(on_thread?: boolean): void;
+  /** Returns the axis-aligned bounding box for the region's transformed navigation mesh. */
+  get_bounds(): AABB;
+  /**
+   * Returns whether or not the specified layer of the {@link navigation_layers} bitmask is enabled, given a `layer_number` between 1 and 32.
+   */
+  get_navigation_layer_value(layer_number: int): boolean;
+  /** Returns the current navigation map {@link RID} used by this region. */
+  get_navigation_map(): RID;
+  /** Returns the {@link RID} of this region on the {@link NavigationServer3D}. */
+  get_region_rid(): RID;
+  /**
+   * Returns the {@link RID} of this region on the {@link NavigationServer3D}. Combined with {@link NavigationServer3D.map_get_closest_point_owner} can be used to identify the {@link NavigationRegion3D} closest to a point on the merged navigation map.
+   */
+  get_rid(): RID;
+  /** Returns `true` when the {@link NavigationMesh} is being baked on a background thread. */
+  is_baking(): boolean;
+  /**
+   * Based on `value`, enables or disables the specified layer in the {@link navigation_layers} bitmask, given a `layer_number` between 1 and 32.
+   */
+  set_navigation_layer_value(layer_number: int, value: boolean): void;
+  /**
+   * Sets the {@link RID} of the navigation map this region should use. By default the region will automatically join the {@link World3D} default navigation map so this function is only required to override the default map.
+   */
+  set_navigation_map(navigation_map: RID): void;
+
+  /** Notifies when the navigation mesh bake operation is completed. */
+  bake_finished: Signal<[]>;
+  /** Notifies when the {@link NavigationMesh} has changed. */
+  navigation_mesh_changed: Signal<[]>;
+}