@ringozz/godot 0.1.0

package/gen/classes/NavigationServer2D.ts

@@ -0,0 +1,799 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, GodotVar, _G } from '../../src/runtime.ts';
+import { Object } from './Object.ts';
+import type { Callable, GodotArray, PackedVector2Array, RID, Signal } from '../heap-types/index.ts';
+import type { Rect2, Transform2D, Vector2 } from '../value-types/index.ts';
+import type { NavigationMeshSourceGeometryData2D } from './NavigationMeshSourceGeometryData2D.ts';
+import type { NavigationPathQueryParameters2D } from './NavigationPathQueryParameters2D.ts';
+import type { NavigationPathQueryResult2D } from './NavigationPathQueryResult2D.ts';
+import type { NavigationPolygon } from './NavigationPolygon.ts';
+import type { Node } from './Node.ts';
+
+let _$: any;
+const $ = () => _$ ?? (_$ = _C(null, 40, 451));
+
+/**
+ * NavigationServer2D is the server that handles navigation maps, regions and agents. It does not handle A* navigation from {@link AStar2D} or {@link AStarGrid2D}.
+ * Maps are divided into regions, which are composed of navigation polygons. Together, they define the traversable areas in the 2D world.
+ * **Note:** Most {@link NavigationServer2D} changes take effect after the next physics frame and not immediately. This includes all changes made to maps, regions or agents by navigation-related nodes in the scene tree or made through scripts.
+ * For two regions to be connected to each other, they must share a similar edge. An edge is considered connected to another if both of its two vertices are at a distance less than `edge_connection_margin` to the respective other edge's vertex.
+ * You may assign navigation layers to regions with {@link NavigationServer2D.regionSetNavigationLayers}, which then can be checked upon when requesting a path with {@link NavigationServer2D.mapGetPath}. This can be used to allow or deny certain areas for some objects.
+ * To use the collision avoidance system, you may use agents. You can set an agent's target velocity, then the servers will emit a callback with a modified velocity.
+ * **Note:** The collision avoidance system ignores regions. Using the modified velocity directly may move an agent outside of the traversable area. This is a limitation of the collision avoidance system, any more complex situation may require the use of the physics engine.
+ * This server keeps tracks of any call and executes them during the sync phase. This means that you can request any change to the map, using any thread, without worrying.
+ */
+export class NavigationServer2D extends GodotVar {
+
+    /**
+     * Returns all created navigation map {@link RID}s on the NavigationServer. This returns both 2D and 3D created navigation maps as there is technically no distinction between them.
+     */
+    static getMaps(): GodotArray<RID> { return _C($(), 5440) as GodotArray<RID>; }
+
+    /**
+     * Create a new map.
+     */
+    static mapCreate(): RID { return _C($(), 8747) as RID; }
+
+    /**
+     * Sets the map active.
+     */
+    static mapSetActive(map: RID, active: boolean): void { _C($(), 8772, map, active); }
+
+    /**
+     * Returns `true` if the map is active.
+     */
+    static mapIsActive(map: RID): boolean { return _C($(), 8770, map) as boolean; }
+
+    /**
+     * Sets the map cell size used to rasterize the navigation mesh vertices. Must match with the cell size of the used navigation meshes.
+     */
+    static mapSetCellSize(map: RID, cellSize: number): void { _C($(), 8774, map, cellSize); }
+
+    /**
+     * Returns the map cell size used to rasterize the navigation mesh vertices.
+     */
+    static mapGetCellSize(map: RID): number { return _C($(), 8753, map) as number; }
+
+    /**
+     * Set the map's internal merge rasterizer cell scale used to control merging sensitivity.
+     */
+    static mapSetMergeRasterizerCellScale(map: RID, scale: number): void { _C($(), 8777, map, scale); }
+
+    /**
+     * Returns map's internal merge rasterizer cell scale.
+     */
+    static mapGetMergeRasterizerCellScale(map: RID): number { return _C($(), 8762, map) as number; }
+
+    /**
+     * Set the navigation `map` edge connection use. If `enabled` is `true`, the navigation map allows navigation regions to use edge connections to connect with other navigation regions within proximity of the navigation map edge connection margin.
+     */
+    static mapSetUseEdgeConnections(map: RID, enabled: boolean): void { _C($(), 8780, map, enabled); }
+
+    /**
+     * Returns whether the navigation `map` allows navigation regions to use edge connections to connect with other navigation regions within proximity of the navigation map edge connection margin.
+     */
+    static mapGetUseEdgeConnections(map: RID): boolean { return _C($(), 8769, map) as boolean; }
+
+    /**
+     * Set the map edge connection margin used to weld the compatible region edges.
+     */
+    static mapSetEdgeConnectionMargin(map: RID, margin: number): void { _C($(), 8775, map, margin); }
+
+    /**
+     * Returns the edge connection margin of the map. The edge connection margin is a distance used to connect two regions.
+     */
+    static mapGetEdgeConnectionMargin(map: RID): number { return _C($(), 8758, map) as number; }
+
+    /**
+     * Set the map's link connection radius used to connect links to navigation polygons.
+     */
+    static mapSetLinkConnectionRadius(map: RID, radius: number): void { _C($(), 8776, map, radius); }
+
+    /**
+     * Returns the link connection radius of the map. This distance is the maximum range any link will search for navigation mesh polygons to connect to.
+     */
+    static mapGetLinkConnectionRadius(map: RID): number { return _C($(), 8760, map) as number; }
+
+    /**
+     * Returns the navigation path to reach the destination from the origin. `navigationLayers` is a bitmask of all region navigation layers that are allowed to be in the path.
+     */
+    static mapGetPath(map: RID, origin: Vector2, destination: Vector2, optimize: boolean, navigationLayers?: number /* = 1,  uint32 */): PackedVector2Array { return _C($(), 8764, map, origin, destination, optimize, navigationLayers) as PackedVector2Array; }
+
+    /**
+     * Returns the navigation mesh surface point closest to the provided `toPoint` on the navigation `map`.
+     */
+    static mapGetClosestPoint(map: RID, toPoint: Vector2): Vector2 { return _C($(), 8754, map, toPoint) as Vector2; }
+
+    /**
+     * Returns the owner region RID for the navigation mesh surface point closest to the provided `toPoint` on the navigation `map`.
+     */
+    static mapGetClosestPointOwner(map: RID, toPoint: Vector2): RID { return _C($(), 8756, map, toPoint) as RID; }
+
+    /**
+     * Returns all navigation link {@link RID}s that are currently assigned to the requested navigation `map`.
+     */
+    static mapGetLinks(map: RID): GodotArray<RID> { return _C($(), 8761, map) as GodotArray<RID>; }
+
+    /**
+     * Returns all navigation regions {@link RID}s that are currently assigned to the requested navigation `map`.
+     */
+    static mapGetRegions(map: RID): GodotArray<RID> { return _C($(), 8766, map) as GodotArray<RID>; }
+
+    /**
+     * Returns all navigation agents {@link RID}s that are currently assigned to the requested navigation `map`.
+     */
+    static mapGetAgents(map: RID): GodotArray<RID> { return _C($(), 8751, map) as GodotArray<RID>; }
+
+    /**
+     * Returns all navigation obstacle {@link RID}s that are currently assigned to the requested navigation `map`.
+     */
+    static mapGetObstacles(map: RID): GodotArray<RID> { return _C($(), 8763, map) as GodotArray<RID>; }
+
+    /**
+     * This function immediately forces synchronization of the specified navigation `map` {@link RID}. By default navigation maps are only synchronized at the end of each physics frame. This function can be used to immediately (re)calculate all the navigation meshes and region connections of the navigation map. This makes it possible to query a navigation path for a changed map immediately and in the same frame (multiple times if needed).
+     * Due to technical restrictions the current NavigationServer command queue will be flushed. This means all already queued update commands for this physics frame will be executed, even those intended for other maps, regions and agents not part of the specified map. The expensive computation of the navigation meshes and region connections of a map will only be done for the specified map. Other maps will receive the normal synchronization at the end of the physics frame. Should the specified map receive changes after the forced update it will update again as well when the other maps receive their update.
+     * Avoidance processing and dispatch of the `safe_velocity` signals is unaffected by this function and continues to happen for all maps and agents at the end of the physics frame.
+     * **Note:** With great power comes great responsibility. This function should only be used by users that really know what they are doing and have a good reason for it. Forcing an immediate update of a navigation map requires locking the NavigationServer and flushing the entire NavigationServer command queue. Not only can this severely impact the performance of a game but it can also introduce bugs if used inappropriately without much foresight.
+     */
+    static mapForceUpdate(map: RID): void { _C($(), 8750, map); }
+
+    /**
+     * Returns the current iteration id of the navigation map. Every time the navigation map changes and synchronizes the iteration id increases. An iteration id of 0 means the navigation map has never synchronized.
+     * **Note:** The iteration id will wrap back to 1 after reaching its range limit.
+     */
+    static mapGetIterationId(map: RID): number { return _C($(), 8759, map) as number; }
+
+    /**
+     * If `enabled` is `true` the `map` synchronization uses an async process that runs on a background thread.
+     */
+    static mapSetUseAsyncIterations(map: RID, enabled: boolean): void { _C($(), 8779, map, enabled); }
+
+    /**
+     * Returns `true` if the `map` synchronization uses an async process that runs on a background thread.
+     */
+    static mapGetUseAsyncIterations(map: RID): boolean { return _C($(), 8768, map) as boolean; }
+
+    /**
+     * Returns a random position picked from all map region polygons with matching `navigationLayers`.
+     * If `uniformly` is `true`, all map regions, polygons, and faces are weighted by their surface area (slower).
+     * If `uniformly` is `false`, just a random region and a random polygon are picked (faster).
+     */
+    static mapGetRandomPoint(map: RID, navigationLayers: number /* uint32 */, uniformly: boolean): Vector2 { return _C($(), 8765, map, navigationLayers, uniformly) as Vector2; }
+
+    /**
+     * Queries a path in a given navigation map. Start and target position and other parameters are defined through {@link NavigationPathQueryParameters2D}. Updates the provided {@link NavigationPathQueryResult2D} result object with the path among other results requested by the query. After the process is finished the optional `callback` will be called.
+     */
+    static queryPath(parameters: NavigationPathQueryParameters2D, result: NavigationPathQueryResult2D, callback?: Callable /* = Callable() */): void { _C($(), 9689, parameters, result, callback); }
+
+    /**
+     * Creates a new region.
+     */
+    static regionCreate(): RID { return _C($(), 9805) as RID; }
+
+    /**
+     * Returns the current iteration ID of the navigation region. Every time the navigation region changes and synchronizes, the iteration ID increases. An iteration ID of `0` means the navigation region has never synchronized.
+     * **Note:** The iteration ID will wrap around to `1` after reaching its range limit.
+     */
+    static regionGetIterationId(region: RID): number { return _C($(), 9817, region) as number; }
+
+    /**
+     * If `enabled` is `true` the `region` uses an async synchronization process that runs on a background thread.
+     */
+    static regionSetUseAsyncIterations(region: RID, enabled: boolean): void { _C($(), 9839, region, enabled); }
+
+    /**
+     * Returns `true` if the `region` uses an async synchronization process that runs on a background thread.
+     */
+    static regionGetUseAsyncIterations(region: RID): boolean { return _C($(), 9824, region) as boolean; }
+
+    /**
+     * If `enabled` is `true` the specified `region` will contribute to its current navigation map.
+     */
+    static regionSetEnabled(region: RID, enabled: boolean): void { _C($(), 9830, region, enabled); }
+
+    /**
+     * Returns `true` if the specified `region` is enabled.
+     */
+    static regionGetEnabled(region: RID): boolean { return _C($(), 9815, region) as boolean; }
+
+    /**
+     * If `enabled` is `true`, the navigation `region` will use edge connections to connect with other navigation regions within proximity of the navigation map edge connection margin.
+     */
+    static regionSetUseEdgeConnections(region: RID, enabled: boolean): void { _C($(), 9840, region, enabled); }
+
+    /**
+     * Returns whether the navigation `region` is set to use edge connections to connect with other navigation regions within proximity of the navigation map edge connection margin.
+     */
+    static regionGetUseEdgeConnections(region: RID): boolean { return _C($(), 9825, region) as boolean; }
+
+    /**
+     * Sets the `enterCost` for this `region`.
+     */
+    static regionSetEnterCost(region: RID, enterCost: number): void { _C($(), 9831, region, enterCost); }
+
+    /**
+     * Returns the enter cost of this `region`.
+     */
+    static regionGetEnterCost(region: RID): number { return _C($(), 9816, region) as number; }
+
+    /**
+     * Sets the `travelCost` for this `region`.
+     */
+    static regionSetTravelCost(region: RID, travelCost: number): void { _C($(), 9838, region, travelCost); }
+
+    /**
+     * Returns the travel cost of this `region`.
+     */
+    static regionGetTravelCost(region: RID): number { return _C($(), 9823, region) as number; }
+
+    /**
+     * Set the `ObjectID` of the object which manages this region.
+     */
+    static regionSetOwnerId(region: RID, ownerId: number /* uint64 */): void { _C($(), 9836, region, ownerId); }
+
+    /**
+     * Returns the `ObjectID` of the object which manages this region.
+     */
+    static regionGetOwnerId(region: RID): number { return _C($(), 9820, region) as number; }
+
+    /**
+     * Returns `true` if the provided `point` in world space is currently owned by the provided navigation `region`. Owned in this context means that one of the region's navigation mesh polygon faces has a possible position at the closest distance to this point compared to all other navigation meshes from other navigation regions that are also registered on the navigation map of the provided region.
+     * If multiple navigation meshes have positions at equal distance the navigation region whose polygons are processed first wins the ownership. Polygons are processed in the same order that navigation regions were registered on the NavigationServer.
+     * **Note:** If navigation meshes from different navigation regions overlap (which should be avoided in general) the result might not be what is expected.
+     */
+    static regionOwnsPoint(region: RID, point: Vector2): boolean { return _C($(), 9828, region, point) as boolean; }
+
+    /**
+     * Sets the map for the region.
+     */
+    static regionSetMap(region: RID, map: RID): void { _C($(), 9832, region, map); }
+
+    /**
+     * Returns the navigation map {@link RID} the requested `region` is currently assigned to.
+     */
+    static regionGetMap(region: RID): RID { return _C($(), 9818, region) as RID; }
+
+    /**
+     * Set the region's navigation layers. This allows selecting regions from a path request (when using {@link NavigationServer2D.mapGetPath}).
+     */
+    static regionSetNavigationLayers(region: RID, navigationLayers: number /* uint32 */): void { _C($(), 9833, region, navigationLayers); }
+
+    /**
+     * Returns the region's navigation layers.
+     */
+    static regionGetNavigationLayers(region: RID): number { return _C($(), 9819, region) as number; }
+
+    /**
+     * Sets the global transformation for the region.
+     */
+    static regionSetTransform(region: RID, transform: Transform2D): void { _C($(), 9837, region, transform); }
+
+    /**
+     * Returns the global transformation of this `region`.
+     */
+    static regionGetTransform(region: RID): Transform2D { return _C($(), 9822, region) as Transform2D; }
+
+    /**
+     * Sets the `navigationPolygon` for the region.
+     */
+    static regionSetNavigationPolygon(region: RID, navigationPolygon: NavigationPolygon): void { _C($(), 9835, region, navigationPolygon); }
+
+    /**
+     * Returns how many connections this `region` has with other regions in the map.
+     */
+    static regionGetConnectionsCount(region: RID): number { return _C($(), 9814, region) as number; }
+
+    /**
+     * Returns the starting point of a connection door. `connection` is an index between 0 and the return value of {@link regionGetConnectionsCount}.
+     */
+    static regionGetConnectionPathwayStart(region: RID, connection: number): Vector2 { return _C($(), 9813, region, connection) as Vector2; }
+
+    /**
+     * Returns the ending point of a connection door. `connection` is an index between 0 and the return value of {@link regionGetConnectionsCount}.
+     */
+    static regionGetConnectionPathwayEnd(region: RID, connection: number): Vector2 { return _C($(), 9812, region, connection) as Vector2; }
+
+    /**
+     * Returns the navigation mesh surface point closest to the provided `toPoint` on the navigation `region`.
+     */
+    static regionGetClosestPoint(region: RID, toPoint: Vector2): Vector2 { return _C($(), 9809, region, toPoint) as Vector2; }
+
+    /**
+     * Returns a random position picked from all region polygons with matching `navigationLayers`.
+     * If `uniformly` is `true`, all region polygons and faces are weighted by their surface area (slower).
+     * If `uniformly` is `false`, just a random polygon and face is picked (faster).
+     */
+    static regionGetRandomPoint(region: RID, navigationLayers: number /* uint32 */, uniformly: boolean): Vector2 { return _C($(), 9821, region, navigationLayers, uniformly) as Vector2; }
+
+    /**
+     * Returns the axis-aligned rectangle for the `region`'s transformed navigation mesh.
+     */
+    static regionGetBounds(region: RID): Rect2 { return _C($(), 9808, region) as Rect2; }
+
+    /**
+     * Create a new link between two positions on a map.
+     */
+    static linkCreate(): RID { return _C($(), 8638) as RID; }
+
+    /**
+     * Returns the current iteration ID of the navigation link. Every time the navigation link changes and synchronizes, the iteration ID increases. An iteration ID of `0` means the navigation link has never synchronized.
+     * **Note:** The iteration ID will wrap around to `1` after reaching its range limit.
+     */
+    static linkGetIterationId(link: RID): number { return _C($(), 8642, link) as number; }
+
+    /**
+     * Sets the navigation map {@link RID} for the link.
+     */
+    static linkSetMap(link: RID, map: RID): void { _C($(), 8654, link, map); }
+
+    /**
+     * Returns the navigation map {@link RID} the requested `link` is currently assigned to.
+     */
+    static linkGetMap(link: RID): RID { return _C($(), 8643, link) as RID; }
+
+    /**
+     * If `enabled` is `true`, the specified `link` will contribute to its current navigation map.
+     */
+    static linkSetEnabled(link: RID, enabled: boolean): void { _C($(), 8651, link, enabled); }
+
+    /**
+     * Returns `true` if the specified `link` is enabled.
+     */
+    static linkGetEnabled(link: RID): boolean { return _C($(), 8639, link) as boolean; }
+
+    /**
+     * Sets whether this `link` can be travelled in both directions.
+     */
+    static linkSetBidirectional(link: RID, bidirectional: boolean): void { _C($(), 8650, link, bidirectional); }
+
+    /**
+     * Returns whether this `link` can be travelled in both directions.
+     */
+    static linkIsBidirectional(link: RID): boolean { return _C($(), 8648, link) as boolean; }
+
+    /**
+     * Set the links's navigation layers. This allows selecting links from a path request (when using {@link NavigationServer2D.mapGetPath}).
+     */
+    static linkSetNavigationLayers(link: RID, navigationLayers: number /* uint32 */): void { _C($(), 8655, link, navigationLayers); }
+
+    /**
+     * Returns the navigation layers for this `link`.
+     */
+    static linkGetNavigationLayers(link: RID): number { return _C($(), 8644, link) as number; }
+
+    /**
+     * Sets the entry position for this `link`.
+     */
+    static linkSetStartPosition(link: RID, position: Vector2): void { _C($(), 8657, link, position); }
+
+    /**
+     * Returns the starting position of this `link`.
+     */
+    static linkGetStartPosition(link: RID): Vector2 { return _C($(), 8646, link) as Vector2; }
+
+    /**
+     * Sets the exit position for the `link`.
+     */
+    static linkSetEndPosition(link: RID, position: Vector2): void { _C($(), 8652, link, position); }
+
+    /**
+     * Returns the ending position of this `link`.
+     */
+    static linkGetEndPosition(link: RID): Vector2 { return _C($(), 8640, link) as Vector2; }
+
+    /**
+     * Sets the `enterCost` for this `link`.
+     */
+    static linkSetEnterCost(link: RID, enterCost: number): void { _C($(), 8653, link, enterCost); }
+
+    /**
+     * Returns the enter cost of this `link`.
+     */
+    static linkGetEnterCost(link: RID): number { return _C($(), 8641, link) as number; }
+
+    /**
+     * Sets the `travelCost` for this `link`.
+     */
+    static linkSetTravelCost(link: RID, travelCost: number): void { _C($(), 8658, link, travelCost); }
+
+    /**
+     * Returns the travel cost of this `link`.
+     */
+    static linkGetTravelCost(link: RID): number { return _C($(), 8647, link) as number; }
+
+    /**
+     * Set the `ObjectID` of the object which manages this link.
+     */
+    static linkSetOwnerId(link: RID, ownerId: number /* uint64 */): void { _C($(), 8656, link, ownerId); }
+
+    /**
+     * Returns the `ObjectID` of the object which manages this link.
+     */
+    static linkGetOwnerId(link: RID): number { return _C($(), 8645, link) as number; }
+
+    /**
+     * Creates the agent.
+     */
+    static agentCreate(): RID { return _C($(), 1355) as RID; }
+
+    /**
+     * If `enabled` is `true`, the specified `agent` uses avoidance.
+     */
+    static agentSetAvoidanceEnabled(agent: RID, enabled: boolean): void { _C($(), 1379, agent, enabled); }
+
+    /**
+     * Return `true` if the specified `agent` uses avoidance.
+     */
+    static agentGetAvoidanceEnabled(agent: RID): boolean { return _C($(), 1356, agent) as boolean; }
+
+    /**
+     * Puts the agent in the map.
+     */
+    static agentSetMap(agent: RID, map: RID): void { _C($(), 1384, agent, map); }
+
+    /**
+     * Returns the navigation map {@link RID} the requested `agent` is currently assigned to.
+     */
+    static agentGetMap(agent: RID): RID { return _C($(), 1361, agent) as RID; }
+
+    /**
+     * If `paused` is `true` the specified `agent` will not be processed. For example, it will not calculate avoidance velocities or receive avoidance callbacks.
+     */
+    static agentSetPaused(agent: RID, paused: boolean): void { _C($(), 1388, agent, paused); }
+
+    /**
+     * Returns `true` if the specified `agent` is paused.
+     */
+    static agentGetPaused(agent: RID): boolean { return _C($(), 1365, agent) as boolean; }
+
+    /**
+     * Sets the maximum distance to other agents this agent takes into account in the navigation. The larger this number, the longer the running time of the simulation. If the number is too low, the simulation will not be safe.
+     */
+    static agentSetNeighborDistance(agent: RID, distance: number): void { _C($(), 1387, agent, distance); }
+
+    /**
+     * Returns the maximum distance to other agents the specified `agent` takes into account in the navigation.
+     */
+    static agentGetNeighborDistance(agent: RID): number { return _C($(), 1364, agent) as number; }
+
+    /**
+     * Sets the maximum number of other agents the agent takes into account in the navigation. The larger this number, the longer the running time of the simulation. If the number is too low, the simulation will not be safe.
+     */
+    static agentSetMaxNeighbors(agent: RID, count: number): void { _C($(), 1385, agent, count); }
+
+    /**
+     * Returns the maximum number of other agents the specified `agent` takes into account in the navigation.
+     */
+    static agentGetMaxNeighbors(agent: RID): number { return _C($(), 1362, agent) as number; }
+
+    /**
+     * The minimal amount of time for which the agent's velocities that are computed by the simulation are safe with respect to other agents. The larger this number, the sooner this agent will respond to the presence of other agents, but the less freedom this agent has in choosing its velocities. A too high value will slow down agents movement considerably. Must be positive.
+     */
+    static agentSetTimeHorizonAgents(agent: RID, timeHorizon: number): void { _C($(), 1391, agent, timeHorizon); }
+
+    /**
+     * Returns the minimal amount of time for which the specified `agent`'s velocities that are computed by the simulation are safe with respect to other agents.
+     */
+    static agentGetTimeHorizonAgents(agent: RID): number { return _C($(), 1368, agent) as number; }
+
+    /**
+     * The minimal amount of time for which the agent's velocities that are computed by the simulation are safe with respect to static avoidance obstacles. The larger this number, the sooner this agent will respond to the presence of static avoidance obstacles, but the less freedom this agent has in choosing its velocities. A too high value will slow down agents movement considerably. Must be positive.
+     */
+    static agentSetTimeHorizonObstacles(agent: RID, timeHorizon: number): void { _C($(), 1392, agent, timeHorizon); }
+
+    /**
+     * Returns the minimal amount of time for which the specified `agent`'s velocities that are computed by the simulation are safe with respect to static avoidance obstacles.
+     */
+    static agentGetTimeHorizonObstacles(agent: RID): number { return _C($(), 1369, agent) as number; }
+
+    /**
+     * Sets the radius of the agent.
+     */
+    static agentSetRadius(agent: RID, radius: number): void { _C($(), 1390, agent, radius); }
+
+    /**
+     * Returns the radius of the specified `agent`.
+     */
+    static agentGetRadius(agent: RID): number { return _C($(), 1367, agent) as number; }
+
+    /**
+     * Sets the maximum speed of the agent. Must be positive.
+     */
+    static agentSetMaxSpeed(agent: RID, maxSpeed: number): void { _C($(), 1386, agent, maxSpeed); }
+
+    /**
+     * Returns the maximum speed of the specified `agent`.
+     */
+    static agentGetMaxSpeed(agent: RID): number { return _C($(), 1363, agent) as number; }
+
+    /**
+     * Replaces the internal velocity in the collision avoidance simulation with `velocity` for the specified `agent`. When an agent is teleported to a new position far away this function should be used in the same frame. If called frequently this function can get agents stuck.
+     */
+    static agentSetVelocityForced(agent: RID, velocity: Vector2): void { _C($(), 1395, agent, velocity); }
+
+    /**
+     * Sets `velocity` as the new wanted velocity for the specified `agent`. The avoidance simulation will try to fulfill this velocity if possible but will modify it to avoid collision with other agent's and obstacles. When an agent is teleported to a new position far away use {@link agentSetVelocityForced} instead to reset the internal velocity state.
+     */
+    static agentSetVelocity(agent: RID, velocity: Vector2): void { _C($(), 1394, agent, velocity); }
+
+    /**
+     * Returns the velocity of the specified `agent`.
+     */
+    static agentGetVelocity(agent: RID): Vector2 { return _C($(), 1371, agent) as Vector2; }
+
+    /**
+     * Sets the position of the agent in world space.
+     */
+    static agentSetPosition(agent: RID, position: Vector2): void { _C($(), 1389, agent, position); }
+
+    /**
+     * Returns the position of the specified `agent` in world space.
+     */
+    static agentGetPosition(agent: RID): Vector2 { return _C($(), 1366, agent) as Vector2; }
+
+    /**
+     * Returns `true` if the map got changed the previous frame.
+     */
+    static agentIsMapChanged(agent: RID): boolean { return _C($(), 1374, agent) as boolean; }
+
+    /**
+     * Sets the callback {@link Callable} that gets called after each avoidance processing step for the `agent`. The calculated `safe_velocity` will be dispatched with a signal to the object just before the physics calculations.
+     * **Note:** Created callbacks are always processed independently of the SceneTree state as long as the agent is on a navigation map and not freed. To disable the dispatch of a callback from an agent use {@link agentSetAvoidanceCallback} again with an empty {@link Callable}.
+     */
+    static agentSetAvoidanceCallback(agent: RID, callback: Callable): void { _C($(), 1378, agent, callback); }
+
+    /**
+     * Return `true` if the specified `agent` has an avoidance callback.
+     */
+    static agentHasAvoidanceCallback(agent: RID): boolean { return _C($(), 1372, agent) as boolean; }
+
+    /**
+     * Set the agent's `avoidance_layers` bitmask.
+     */
+    static agentSetAvoidanceLayers(agent: RID, layers: number /* uint32 */): void { _C($(), 1380, agent, layers); }
+
+    /**
+     * Returns the `avoidance_layers` bitmask of the specified `agent`.
+     */
+    static agentGetAvoidanceLayers(agent: RID): number { return _C($(), 1357, agent) as number; }
+
+    /**
+     * Set the agent's `avoidance_mask` bitmask.
+     */
+    static agentSetAvoidanceMask(agent: RID, mask: number /* uint32 */): void { _C($(), 1381, agent, mask); }
+
+    /**
+     * Returns the `avoidance_mask` bitmask of the specified `agent`.
+     */
+    static agentGetAvoidanceMask(agent: RID): number { return _C($(), 1358, agent) as number; }
+
+    /**
+     * Set the agent's `avoidance_priority` with a `priority` between 0.0 (lowest priority) to 1.0 (highest priority).
+     * The specified `agent` does not adjust the velocity for other agents that would match the `avoidance_mask` but have a lower `avoidance_priority`. This in turn makes the other agents with lower priority adjust their velocities even more to avoid collision with this agent.
+     */
+    static agentSetAvoidancePriority(agent: RID, priority: number): void { _C($(), 1382, agent, priority); }
+
+    /**
+     * Returns the `avoidance_priority` of the specified `agent`.
+     */
+    static agentGetAvoidancePriority(agent: RID): number { return _C($(), 1359, agent) as number; }
+
+    /**
+     * Creates a new navigation obstacle.
+     */
+    static obstacleCreate(): RID { return _C($(), 9123) as RID; }
+
+    /**
+     * If `enabled` is `true`, the provided `obstacle` affects avoidance using agents.
+     */
+    static obstacleSetAvoidanceEnabled(obstacle: RID, enabled: boolean): void { _C($(), 9134, obstacle, enabled); }
+
+    /**
+     * Returns `true` if the provided `obstacle` has avoidance enabled.
+     */
+    static obstacleGetAvoidanceEnabled(obstacle: RID): boolean { return _C($(), 9124, obstacle) as boolean; }
+
+    /**
+     * Sets the navigation map {@link RID} for the obstacle.
+     */
+    static obstacleSetMap(obstacle: RID, map: RID): void { _C($(), 9137, obstacle, map); }
+
+    /**
+     * Returns the navigation map {@link RID} the requested `obstacle` is currently assigned to.
+     */
+    static obstacleGetMap(obstacle: RID): RID { return _C($(), 9127, obstacle) as RID; }
+
+    /**
+     * If `paused` is `true` the specified `obstacle` will not be processed. For example, it will no longer affect avoidance velocities.
+     */
+    static obstacleSetPaused(obstacle: RID, paused: boolean): void { _C($(), 9138, obstacle, paused); }
+
+    /**
+     * Returns `true` if the specified `obstacle` is paused.
+     */
+    static obstacleGetPaused(obstacle: RID): boolean { return _C($(), 9128, obstacle) as boolean; }
+
+    /**
+     * Sets the radius of the dynamic obstacle.
+     */
+    static obstacleSetRadius(obstacle: RID, radius: number): void { _C($(), 9140, obstacle, radius); }
+
+    /**
+     * Returns the radius of the specified dynamic `obstacle`.
+     */
+    static obstacleGetRadius(obstacle: RID): number { return _C($(), 9130, obstacle) as number; }
+
+    /**
+     * Sets `velocity` of the dynamic `obstacle`. Allows other agents to better predict the movement of the dynamic obstacle. Only works in combination with the radius of the obstacle.
+     */
+    static obstacleSetVelocity(obstacle: RID, velocity: Vector2): void { _C($(), 9142, obstacle, velocity); }
+
+    /**
+     * Returns the velocity of the specified dynamic `obstacle`.
+     */
+    static obstacleGetVelocity(obstacle: RID): Vector2 { return _C($(), 9132, obstacle) as Vector2; }
+
+    /**
+     * Sets the position of the obstacle in world space.
+     */
+    static obstacleSetPosition(obstacle: RID, position: Vector2): void { _C($(), 9139, obstacle, position); }
+
+    /**
+     * Returns the position of the specified `obstacle` in world space.
+     */
+    static obstacleGetPosition(obstacle: RID): Vector2 { return _C($(), 9129, obstacle) as Vector2; }
+
+    /**
+     * Sets the outline vertices for the obstacle. If the vertices are winded in clockwise order agents will be pushed in by the obstacle, else they will be pushed out.
+     */
+    static obstacleSetVertices(obstacle: RID, vertices: PackedVector2Array): void { _C($(), 9143, obstacle, vertices); }
+
+    /**
+     * Returns the outline vertices for the specified `obstacle`.
+     */
+    static obstacleGetVertices(obstacle: RID): PackedVector2Array { return _C($(), 9133, obstacle) as PackedVector2Array; }
+
+    /**
+     * Set the obstacles's `avoidance_layers` bitmask.
+     */
+    static obstacleSetAvoidanceLayers(obstacle: RID, layers: number /* uint32 */): void { _C($(), 9135, obstacle, layers); }
+
+    /**
+     * Returns the `avoidance_layers` bitmask of the specified `obstacle`.
+     */
+    static obstacleGetAvoidanceLayers(obstacle: RID): number { return _C($(), 9125, obstacle) as number; }
+
+    /**
+     * Parses the {@link SceneTree} for source geometry according to the properties of `navigationPolygon`. Updates the provided `sourceGeometryData` resource with the resulting data. The resource can then be used to bake a navigation mesh with {@link bakeFromSourceGeometryData}. After the process is finished the optional `callback` will be called.
+     * **Note:** This function needs to run on the main thread or with a deferred call as the SceneTree is not thread-safe.
+     * **Performance:** While convenient, reading data arrays from {@link Mesh} resources can affect the frame rate negatively. The data needs to be received from the GPU, stalling the {@link RenderingServer} in the process. For performance prefer the use of e.g. collision shapes or creating the data arrays entirely in code.
+     */
+    static parseSourceGeometryData(navigationPolygon: NavigationPolygon, sourceGeometryData: NavigationMeshSourceGeometryData2D, rootNode: Node, callback?: Callable /* = Callable() */): void { _C($(), 9282, navigationPolygon, sourceGeometryData, rootNode, callback); }
+
+    /**
+     * Bakes the provided `navigationPolygon` with the data from the provided `sourceGeometryData`. After the process is finished the optional `callback` will be called.
+     */
+    static bakeFromSourceGeometryData(navigationPolygon: NavigationPolygon, sourceGeometryData: NavigationMeshSourceGeometryData2D, callback?: Callable /* = Callable() */): void { _C($(), 1712, navigationPolygon, sourceGeometryData, callback); }
+
+    /**
+     * Bakes the provided `navigationPolygon` with the data from the provided `sourceGeometryData` as an async task running on a background thread. After the process is finished the optional `callback` will be called.
+     */
+    static bakeFromSourceGeometryDataAsync(navigationPolygon: NavigationPolygon, sourceGeometryData: NavigationMeshSourceGeometryData2D, callback?: Callable /* = Callable() */): void { _C($(), 1713, navigationPolygon, sourceGeometryData, callback); }
+
+    /**
+     * Returns `true` when the provided navigation polygon is being baked on a background thread.
+     */
+    static isBakingNavigationPolygon(navigationPolygon: NavigationPolygon): boolean { return _C($(), 7792, navigationPolygon) as boolean; }
+
+    /**
+     * Creates a new source geometry parser. If a {@link Callable} is set for the parser with {@link sourceGeometryParserSetCallback} the callback will be called for every single node that gets parsed whenever {@link parseSourceGeometryData} is used.
+     */
+    static sourceGeometryParserCreate(): RID { return _C($(), 13738) as RID; }
+
+    /**
+     * Sets the `callback` {@link Callable} for the specific source geometry `parser`. The {@link Callable} will receive a call with the following parameters:
+     * - `navigation_mesh` - The {@link NavigationPolygon} reference used to define the parse settings. Do NOT edit or add directly to the navigation mesh.
+     * - `source_geometry_data` - The {@link NavigationMeshSourceGeometryData2D} reference. Add custom source geometry for navigation mesh baking to this object.
+     * - `node` - The {@link Node} that is parsed.
+     */
+    static sourceGeometryParserSetCallback(parser: RID, callback: Callable): void { _C($(), 13739, parser, callback); }
+
+    /**
+     * Returns a simplified version of `path` with less critical path points removed. The simplification amount is in worlds units and controlled by `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".
+     */
+    static simplifyPath(path: PackedVector2Array, epsilon: number): PackedVector2Array { return _C($(), 13603, path, epsilon) as PackedVector2Array; }
+
+    /**
+     * Destroys the given RID.
+     */
+    static freeRid(rid: RID): void { _C($(), 3583, rid); }
+
+    /**
+     * Control activation of this server.
+     */
+    static setActive(active: boolean): void { _C($(), 10426, active); }
+
+    /**
+     * If `true` enables debug mode on the NavigationServer.
+     */
+    static setDebugEnabled(enabled: boolean): void { _C($(), 11043, enabled); }
+
+    /**
+     * Returns `true` when the NavigationServer has debug enabled.
+     */
+    static getDebugEnabled(): boolean { return _C($(), 4432) as boolean; }
+
+    /**
+     * Returns information about the current state of the NavigationServer.
+     */
+    static getProcessInfo(processInfo: ProcessInfo): number { return _C($(), 6024, processInfo) as number; }
+
+    /**
+     * Emitted when a navigation map is updated, when a region moves or is modified.
+     */
+    static get mapChanged(): Signal<(map: RID) => void> { return _G($(), 8746) as Signal<(map: RID) => void>; }
+    static set mapChanged(v: ((map: RID) => void) | null) { _G($(), 8746, v); }
+
+    /**
+     * Emitted when navigation debug settings are changed. Only available in debug builds.
+     */
+    static get navigationDebugChanged(): Signal<() => void> { return _G($(), 9051) as Signal<() => void>; }
+    static set navigationDebugChanged(v: (() => void) | null) { _G($(), 9051, v); }
+
+    /**
+     * Emitted when avoidance debug settings are changed. Only available in debug builds.
+     */
+    static get avoidanceDebugChanged(): Signal<() => void> { return _G($(), 1671) as Signal<() => void>; }
+    static set avoidanceDebugChanged(v: (() => void) | null) { _G($(), 1671, v); }
+
+    static readonly name = _R(451, NavigationServer2D);
+}
+
+export const ProcessInfo = {
+    /**
+     * Constant to get the number of active navigation maps.
+     */
+    INFO_ACTIVE_MAPS: 0,
+    /**
+     * Constant to get the number of active navigation regions.
+     */
+    INFO_REGION_COUNT: 1,
+    /**
+     * Constant to get the number of active navigation agents processing avoidance.
+     */
+    INFO_AGENT_COUNT: 2,
+    /**
+     * Constant to get the number of active navigation links.
+     */
+    INFO_LINK_COUNT: 3,
+    /**
+     * Constant to get the number of navigation mesh polygons.
+     */
+    INFO_POLYGON_COUNT: 4,
+    /**
+     * Constant to get the number of navigation mesh polygon edges.
+     */
+    INFO_EDGE_COUNT: 5,
+    /**
+     * Constant to get the number of navigation mesh polygon edges that were merged due to edge key overlap.
+     */
+    INFO_EDGE_MERGE_COUNT: 6,
+    /**
+     * Constant to get the number of navigation mesh polygon edges that are considered connected by edge proximity.
+     */
+    INFO_EDGE_CONNECTION_COUNT: 7,
+    /**
+     * Constant to get the number of navigation mesh polygon edges that could not be merged but may be still connected by edge proximity or with links.
+     */
+    INFO_EDGE_FREE_COUNT: 8,
+    /**
+     * Constant to get the number of active navigation obstacles.
+     */
+    INFO_OBSTACLE_COUNT: 9,
+} as const;
+
+export type ProcessInfo = (typeof ProcessInfo)[keyof typeof ProcessInfo];
+