@ringozz/godot 0.1.0

package/gen/classes/TwoBoneIK3D.ts

@@ -0,0 +1,173 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { IKModifier3D } from './IKModifier3D.ts';
+import type { NodePath } from '../heap-types/index.ts';
+import type { Vector3 } from '../value-types/index.ts';
+import type { BoneDirection, SecondaryDirection } from './SkeletonModifier3D.ts';
+
+/**
+ * This {@link IKModifier3D} requires a pole target. It provides deterministic results by constructing a plane from each joint and pole target and finding the intersection of two circles (disks in 3D).
+ * This IK can handle twist by setting the pole direction. If there are more than one bone between each set bone, their rotations are ignored, and the straight line connecting the root-middle and middle-end joints are treated as virtual bones.
+ * **Note:** All the methods in this class take an `index` parameter. This parameter specifies which setting list entry to return if the IK has multiple entries (e.g. `settings/<index>/root_bone_name`).
+ */
+export class TwoBoneIK3D extends IKModifier3D {
+    constructor(name = 814) { super(name); }
+
+    /**
+     * Sets the target node that the end bone is trying to reach.
+     */
+    setTargetNode(index: number, targetNode: NodePath): void { _C(this, 13005, index, targetNode); }
+
+    /**
+     * Returns the target node that the end bone is trying to reach.
+     */
+    getTargetNode(index: number): NodePath { return _C(this, 6701, index) as NodePath; }
+
+    /**
+     * Sets the pole target node that constructs a plane which the joints are all on and the pole is trying to direct.
+     */
+    setPoleNode(index: number, poleNode: NodePath): void { _C(this, 12372, index, poleNode); }
+
+    /**
+     * Returns the pole target node that constructs a plane which the joints are all on and the pole is trying to direct.
+     */
+    getPoleNode(index: number): NodePath { return _C(this, 5961, index) as NodePath; }
+
+    /**
+     * Sets the root bone name.
+     */
+    setRootBoneName(index: number, boneName: string): void { _C(this, 12567, index, boneName); }
+
+    /**
+     * Returns the root bone name.
+     */
+    getRootBoneName(index: number): string { return _C(this, 6190, index) as string; }
+
+    /**
+     * Sets the root bone index.
+     */
+    setRootBone(index: number, bone: number): void { _C(this, 12566, index, bone); }
+
+    /**
+     * Returns the root bone index.
+     */
+    getRootBone(index: number): number { return _C(this, 6189, index) as number; }
+
+    /**
+     * Sets the middle bone name.
+     * **Note:** The middle bone must be a child of the root bone.
+     */
+    setMiddleBoneName(index: number, boneName: string): void { _C(this, 12043, index, boneName); }
+
+    /**
+     * Returns the middle bone name.
+     */
+    getMiddleBoneName(index: number): string { return _C(this, 5533, index) as string; }
+
+    /**
+     * Sets the middle bone index.
+     */
+    setMiddleBone(index: number, bone: number): void { _C(this, 12042, index, bone); }
+
+    /**
+     * Returns the middle bone index.
+     */
+    getMiddleBone(index: number): number { return _C(this, 5532, index) as number; }
+
+    /**
+     * Sets the pole direction.
+     * The pole is on the middle bone and will direct to the pole target.
+     * The rotation axis is a vector that is orthogonal to this and the forward vector.
+     * **Note:** The pole direction and the forward vector shouldn't be colinear to avoid unintended rotation.
+     */
+    setPoleDirection(index: number, direction: SecondaryDirection): void { _C(this, 12370, index, direction); }
+
+    /**
+     * Returns the pole direction.
+     */
+    getPoleDirection(index: number): SecondaryDirection { return _C(this, 5959, index) as SecondaryDirection; }
+
+    /**
+     * Sets the pole direction vector.
+     * This vector is normalized by an internal process.
+     * If the vector length is `0`, it is considered synonymous with {@link SkeletonModifier3D.SECONDARY_DIRECTION_NONE}.
+     */
+    setPoleDirectionVector(index: number, vector: Vector3): void { _C(this, 12371, index, vector); }
+
+    /**
+     * Returns the pole direction vector.
+     * If {@link getPoleDirection} is {@link SkeletonModifier3D.SECONDARY_DIRECTION_NONE}, this method returns `Vector3(0, 0, 0)`.
+     */
+    getPoleDirectionVector(index: number): Vector3 { return _C(this, 5960, index) as Vector3; }
+
+    /**
+     * Sets the end bone name.
+     * **Note:** The end bone must be a child of the middle bone.
+     */
+    setEndBoneName(index: number, boneName: string): void { _C(this, 11292, index, boneName); }
+
+    /**
+     * Returns the end bone name.
+     */
+    getEndBoneName(index: number): string { return _C(this, 4664, index) as string; }
+
+    /**
+     * Sets the end bone index.
+     */
+    setEndBone(index: number, bone: number): void { _C(this, 11289, index, bone); }
+
+    /**
+     * Returns the end bone index.
+     */
+    getEndBone(index: number): number { return _C(this, 4661, index) as number; }
+
+    /**
+     * If `enabled` is `true`, the end bone is extended from the middle bone as a virtual bone.
+     */
+    setUseVirtualEnd(index: number, enabled: boolean): void { _C(this, 13246, index, enabled); }
+
+    /**
+     * Returns `true` if the end bone is extended from the middle bone as a virtual bone.
+     */
+    isUsingVirtualEnd(index: number): boolean { return _C(this, 8428, index) as boolean; }
+
+    /**
+     * If `enabled` is `true`, the end bone is extended to have a tail.
+     */
+    setExtendEndBone(index: number, enabled: boolean): void { _C(this, 11332, index, enabled); }
+
+    /**
+     * Returns `true` if the end bone is extended to have a tail.
+     */
+    isEndBoneExtended(index: number): boolean { return _C(this, 7936, index) as boolean; }
+
+    /**
+     * Sets the end bone tail direction when {@link isEndBoneExtended} is `true`.
+     */
+    setEndBoneDirection(index: number, boneDirection: BoneDirection): void { _C(this, 11290, index, boneDirection); }
+
+    /**
+     * Returns the end bone's tail direction when {@link isEndBoneExtended} is `true`.
+     */
+    getEndBoneDirection(index: number): BoneDirection { return _C(this, 4662, index) as BoneDirection; }
+
+    /**
+     * Sets the end bone tail length when {@link isEndBoneExtended} is `true`.
+     */
+    setEndBoneLength(index: number, length: number): void { _C(this, 11291, index, length); }
+
+    /**
+     * Returns the end bone tail length of the bone chain when {@link isEndBoneExtended} is `true`.
+     */
+    getEndBoneLength(index: number): number { return _C(this, 4663, index) as number; }
+
+    /**
+     * The number of settings.
+     */
+    get settingCount(): number { return _C(this, 6350) as number; }
+    set settingCount(v: number) { _C(this, 12700, v); }
+
+    static readonly name = _R(814, TwoBoneIK3D);
+}

package/gen/classes/UDPServer.ts

@@ -0,0 +1,115 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { RefCounted } from './RefCounted.ts';
+import type { Error } from '../global-enums.ts';
+import type { PacketPeerUDP } from './PacketPeerUDP.ts';
+
+/**
+ * A simple server that opens a UDP socket and returns connected {@link PacketPeerUDP} upon receiving new packets. See also {@link PacketPeerUDP.connectToHost}.
+ * After starting the server ({@link listen}), you will need to {@link poll} it at regular intervals (e.g. inside {@link Node.Process}) for it to process new packets, delivering them to the appropriate {@link PacketPeerUDP}, and taking new connections.
+ * Below a small example of how it can be used:
+ *
+ *
+ * ```gdscript
+ *
+ * # server_node.gd
+ * class_name ServerNode
+ * extends Node
+ *
+ * var server = UDPServer.new()
+ * var peers = []
+ *
+ * func _ready():
+ * 	server.listen(4242)
+ *
+ * func _process(delta):
+ * 	server.poll() # Important!
+ * 	if server.is_connection_available():
+ * 		var peer = server.take_connection()
+ * 		var packet = peer.get_packet()
+ * 		print("Accepted peer: %s:%s" % [peer.get_packet_ip(), peer.get_packet_port()])
+ * 		print("Received data: %s" % [packet.get_string_from_utf8()])
+ * 		# Reply so it knows we received the message.
+ * 		peer.put_packet(packet)
+ * 		# Keep a reference so we can keep contacting the remote peer.
+ * 		peers.append(peer)
+ *
+ * 	for i in range(0, peers.size()):
+ * 		pass # Do something with the connected peers.
+ *
+ * ```
+ *
+ *
+ *
+ *
+ *
+ * ```gdscript
+ *
+ * # client_node.gd
+ * class_name ClientNode
+ * extends Node
+ *
+ * var udp = PacketPeerUDP.new()
+ * var connected = false
+ *
+ * func _ready():
+ * 	udp.connect_to_host("127.0.0.1", 4242)
+ *
+ * func _process(delta):
+ * 	if !connected:
+ * 		# Try to contact server
+ * 		udp.put_packet("The answer is... 42!".to_utf8_buffer())
+ * 	if udp.get_available_packet_count() > 0:
+ * 		print("Connected: %s" % udp.get_packet().get_string_from_utf8())
+ * 		connected = true
+ *
+ * ```
+ */
+export class UDPServer extends RefCounted {
+    constructor(name = 815) { super(name); }
+
+    /**
+     * Starts the server by opening a UDP socket listening on the given `port`. You can optionally specify a `bindAddress` to only listen for packets sent to that address. See also {@link PacketPeerUDP.bind}.
+     */
+    listen(port: number /* uint16 */, bindAddress?: string /* = "*" */): Error { return _C(this, 8664, port, bindAddress) as Error; }
+
+    /**
+     * Call this method at regular intervals (e.g. inside {@link Node.Process}) to process new packets. Any packet from a known address/port pair will be delivered to the appropriate {@link PacketPeerUDP}, while any packet received from an unknown address/port pair will be added as a pending connection (see {@link isConnectionAvailable} and {@link takeConnection}). The maximum number of pending connections is defined via {@link maxPendingConnections}.
+     */
+    poll(): Error { return _C(this, 9471) as Error; }
+
+    /**
+     * Returns `true` if a packet with a new address/port combination was received on the socket.
+     */
+    isConnectionAvailable(): boolean { return _C(this, 7857) as boolean; }
+
+    /**
+     * Returns the local port this server is listening to.
+     */
+    getLocalPort(): number { return _C(this, 5398) as number; }
+
+    /**
+     * Returns `true` if the socket is open and listening on a port.
+     */
+    isListening(): boolean { return _C(this, 8086) as boolean; }
+
+    /**
+     * Returns the first pending connection (connected to the appropriate address/port). Will return `null` if no new connection is available. See also {@link isConnectionAvailable}, {@link PacketPeerUDP.connectToHost}.
+     */
+    takeConnection(): PacketPeerUDP { return _C(this, 14114) as PacketPeerUDP; }
+
+    /**
+     * Stops the server, closing the UDP socket if open. Will close all connected {@link PacketPeerUDP} accepted via {@link takeConnection} (remote peers will not be notified).
+     */
+    stop(): void { _C(this, 13866); }
+
+    /**
+     * Define the maximum number of pending connections, during {@link poll}, any new pending connection exceeding that value will be automatically dropped. Setting this value to `0` effectively prevents any new pending connection to be accepted (e.g. when all your players have connected).
+     */
+    get maxPendingConnections(): number { return _C(this, 5478) as number; }
+    set maxPendingConnections(v: number) { _C(this, 12001, v); }
+
+    static readonly name = _R(815, UDPServer);
+}

package/gen/classes/UDSServer.ts

@@ -0,0 +1,28 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { SocketServer } from './SocketServer.ts';
+import type { Error } from '../global-enums.ts';
+import type { StreamPeerUDS } from './StreamPeerUDS.ts';
+
+/**
+ * A Unix Domain Socket (UDS) server. Listens to connections on a socket path and returns a {@link StreamPeerUDS} when it gets an incoming connection. Unix Domain Sockets provide inter-process communication on the same machine using the filesystem namespace.
+ * **Note:** Unix Domain Sockets are only available on Unix-like systems (Linux, macOS, etc.) and are not supported on Windows.
+ */
+export class UDSServer extends SocketServer {
+    constructor(name = 816) { super(name); }
+
+    /**
+     * Listens on the socket at `path`. The socket file will be created at the specified path.
+     * **Note:** The socket file must not already exist at the specified path. You may need to remove any existing socket file before calling this method.
+     */
+    listen(path: string): Error { return _C(this, 8664, path) as Error; }
+
+    /**
+     * If a connection is available, returns a StreamPeerUDS with the connection.
+     */
+    takeConnection(): StreamPeerUDS { return _C(this, 14114) as StreamPeerUDS; }
+
+    static readonly name = _R(816, UDSServer);
+}

package/gen/classes/UPNP.ts

@@ -0,0 +1,279 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { RefCounted } from './RefCounted.ts';
+import type { UPNPDevice } from './UPNPDevice.ts';
+
+/**
+ * This class can be used to discover compatible {@link UPNPDevice}s on the local network and execute commands on them, like managing port mappings (for port forwarding/NAT traversal) and querying the local and remote network IP address. Note that methods on this class are synchronous and block the calling thread.
+ * To forward a specific port (here `7777`, note both {@link discover} and {@link addPortMapping} can return errors that should be checked):
+ *
+ * ```text
+ *
+ * var upnp = UPNP.new()
+ * upnp.discover()
+ * upnp.add_port_mapping(7777)
+ *
+ * ```
+ *
+ * To close a specific port (e.g. after you have finished using it):
+ *
+ * ```text
+ *
+ * upnp.delete_port_mapping(port)
+ *
+ * ```
+ *
+ * **Note:** UPnP discovery blocks the current thread. To perform discovery without blocking the main thread, use {@link Thread}s like this:
+ *
+ * ```text
+ *
+ * # Emitted when UPnP port mapping setup is completed (regardless of success or failure).
+ * signal upnp_completed(error)
+ *
+ * # Replace this with your own server port number between 1024 and 65535.
+ * const SERVER_PORT = 3928
+ * var thread = null
+ *
+ * func _upnp_setup(server_port):
+ * 	# UPNP queries take some time.
+ * 	var upnp = UPNP.new()
+ * 	var err = upnp.discover()
+ *
+ * 	if err != UPNP.UPNP_RESULT_SUCCESS:
+ * 		push_error(str(err))
+ * 		upnp_completed.emit(err)
+ * 		return
+ *
+ * 	if upnp.get_gateway() and upnp.get_gateway().is_valid_gateway():
+ * 		upnp.add_port_mapping(server_port, server_port, ProjectSettings.get_setting("application/config/name"), "UDP")
+ * 		upnp.add_port_mapping(server_port, server_port, ProjectSettings.get_setting("application/config/name"), "TCP")
+ * 		upnp_completed.emit(UPNP.UPNP_RESULT_SUCCESS)
+ *
+ * func _ready():
+ * 	thread = Thread.new()
+ * 	thread.start(_upnp_setup.bind(SERVER_PORT))
+ *
+ * func _exit_tree():
+ * 	# Wait for thread finish here to handle game exit while the thread is running.
+ * 	thread.wait_to_finish()
+ *
+ * ```
+ *
+ * **Terminology:** In the context of UPnP networking, "gateway" (or "internet gateway device", short IGD) refers to network devices that allow computers in the local network to access the internet ("wide area network", WAN). These gateways are often also called "routers".
+ * **Pitfalls:**
+ * - As explained above, these calls are blocking and shouldn't be run on the main thread, especially as they can block for multiple seconds at a time. Use threading!
+ * - Networking is physical and messy. Packets get lost in transit or get filtered, addresses, free ports and assigned mappings change, and devices may leave or join the network at any time. Be mindful of this, be diligent when checking and handling errors, and handle these gracefully if you can: add clear error UI, timeouts and re-try handling.
+ * - Port mappings may change (and be removed) at any time, and the remote/external IP address of the gateway can change likewise. You should consider re-querying the external IP and try to update/refresh the port mapping periodically (for example, every 5 minutes and on networking failures).
+ * - Not all devices support UPnP, and some users disable UPnP support. You need to handle this (e.g. documenting and requiring the user to manually forward ports, or adding alternative methods of NAT traversal, like a relay/mirror server, or NAT hole punching, STUN/TURN, etc.).
+ * - Consider what happens on mapping conflicts. Maybe multiple users on the same network would like to play your game at the same time, or maybe another application uses the same port. Make the port configurable, and optimally choose a port automatically (re-trying with a different port on failure).
+ * **Further reading:** If you want to know more about UPnP (and the Internet Gateway Device (IGD) and Port Control Protocol (PCP) specifically), [Wikipedia](https://en.wikipedia.org/wiki/Universal_Plug_and_Play) is a good first stop, the specification can be found at the [Open Connectivity Foundation](https://openconnectivity.org/developer/specifications/upnp-resources/upnp/) and Godot's implementation is based on the [MiniUPnP client](https://github.com/miniupnp/miniupnp).
+ */
+export class UPNP extends RefCounted {
+    constructor(name = 817) { super(name); }
+
+    /**
+     * Returns the number of discovered {@link UPNPDevice}s.
+     */
+    getDeviceCount(): number { return _C(this, 4494) as number; }
+
+    /**
+     * Returns the {@link UPNPDevice} at the given `index`.
+     */
+    getDevice(index: number): UPNPDevice { return _C(this, 4491, index) as UPNPDevice; }
+
+    /**
+     * Adds the given {@link UPNPDevice} to the list of discovered devices.
+     */
+    addDevice(device: UPNPDevice): void { _C(this, 1207, device); }
+
+    /**
+     * Sets the device at `index` from the list of discovered devices to `device`.
+     */
+    setDevice(index: number, device: UPNPDevice): void { _C(this, 11106, index, device); }
+
+    /**
+     * Removes the device at `index` from the list of discovered devices.
+     */
+    removeDevice(index: number): void { _C(this, 9906, index); }
+
+    /**
+     * Clears the list of discovered devices.
+     */
+    clearDevices(): void { _C(this, 2260); }
+
+    /**
+     * Returns the default gateway. That is the first discovered {@link UPNPDevice} that is also a valid IGD (InternetGatewayDevice).
+     */
+    getGateway(): UPNPDevice { return _C(this, 4915) as UPNPDevice; }
+
+    /**
+     * Discovers local {@link UPNPDevice}s. Clears the list of previously discovered devices.
+     * Filters for IGD (InternetGatewayDevice) type devices by default, as those manage port forwarding. `timeout` is the time to wait for responses in milliseconds. `ttl` is the time-to-live; only touch this if you know what you're doing.
+     * See {@link UPNPResult} for possible return values.
+     */
+    discover(timeout?: number /* = 2000 */, ttl?: number /* = 2 */, deviceFilter?: string /* = "InternetGatewayDevice" */): number { return _C(this, 2830, timeout, ttl, deviceFilter) as number; }
+
+    /**
+     * Returns the external {@link IP} address of the default gateway (see {@link getGateway}) as string. Returns an empty string on error.
+     */
+    queryExternalAddress(): string { return _C(this, 9688) as string; }
+
+    /**
+     * Adds a mapping to forward the external `port` (between 1 and 65535, although recommended to use port 1024 or above) on the default gateway (see {@link getGateway}) to the `portInternal` on the local machine for the given protocol `proto` (either `"TCP"` or `"UDP"`, with UDP being the default). If a port mapping for the given port and protocol combination already exists on that gateway device, this method tries to overwrite it. If that is not desired, you can retrieve the gateway manually with {@link getGateway} and call {@link addPortMapping} on it, if any. Note that forwarding a well-known port (below 1024) with UPnP may fail depending on the device.
+     * Depending on the gateway device, if a mapping for that port already exists, it will either be updated or it will refuse this command due to that conflict, especially if the existing mapping for that port wasn't created via UPnP or points to a different network address (or device) than this one.
+     * If `portInternal` is `0` (the default), the same port number is used for both the external and the internal port (the `port` value).
+     * The description (`desc`) is shown in some routers management UIs and can be used to point out which application added the mapping.
+     * The mapping's lease `duration` can be limited by specifying a duration in seconds. The default of `0` means no duration, i.e. a permanent lease and notably some devices only support these permanent leases. Note that whether permanent or not, this is only a request and the gateway may still decide at any point to remove the mapping (which usually happens on a reboot of the gateway, when its external IP address changes, or on some models when it detects a port mapping has become inactive, i.e. had no traffic for multiple minutes). If not `0` (permanent), the allowed range according to spec is between `120` (2 minutes) and `86400` seconds (24 hours).
+     * See {@link UPNPResult} for possible return values.
+     */
+    addPortMapping(port: number, portInternal?: number /* = 0 */, desc?: string /* = "" */, proto?: string /* = "UDP" */, duration?: number /* = 0 */): number { return _C(this, 1274, port, portInternal, desc, proto, duration) as number; }
+
+    /**
+     * Deletes the port mapping for the given port and protocol combination on the default gateway (see {@link getGateway}) if one exists. `port` must be a valid port between 1 and 65535, `proto` can be either `"TCP"` or `"UDP"`. May be refused for mappings pointing to addresses other than this one, for well-known ports (below 1024), or for mappings not added via UPnP. See {@link UPNPResult} for possible return values.
+     */
+    deletePortMapping(port: number, proto?: string /* = "UDP" */): number { return _C(this, 2724, port, proto) as number; }
+
+    /**
+     * Multicast interface to use for discovery. Uses the default multicast interface if empty.
+     */
+    get discoverMulticastIf(): string { return _C(this, 4515) as string; }
+    set discoverMulticastIf(v: string) { _C(this, 11126, v); }
+
+    /**
+     * If `0`, the local port to use for discovery is chosen automatically by the system. If `1`, discovery will be done from the source port 1900 (same as destination port). Otherwise, the value will be used as the port.
+     */
+    get discoverLocalPort(): number { return _C(this, 4514) as number; }
+    set discoverLocalPort(v: number) { _C(this, 11125, v); }
+
+    /**
+     * If `true`, IPv6 is used for {@link UPNPDevice} discovery.
+     */
+    get discoverIpv6(): boolean { return _C(this, 7885) as boolean; }
+    set discoverIpv6(v: boolean) { _C(this, 11124, v); }
+
+    static readonly name = _R(817, UPNP);
+}
+
+export const UPNPResult = {
+    /**
+     * UPNP command or discovery was successful.
+     */
+    UPNP_RESULT_SUCCESS: 0,
+    /**
+     * Not authorized to use the command on the {@link UPNPDevice}. May be returned when the user disabled UPNP on their router.
+     */
+    UPNP_RESULT_NOT_AUTHORIZED: 1,
+    /**
+     * No port mapping was found for the given port, protocol combination on the given {@link UPNPDevice}.
+     */
+    UPNP_RESULT_PORT_MAPPING_NOT_FOUND: 2,
+    /**
+     * Inconsistent parameters.
+     */
+    UPNP_RESULT_INCONSISTENT_PARAMETERS: 3,
+    /**
+     * No such entry in array. May be returned if a given port, protocol combination is not found on a {@link UPNPDevice}.
+     */
+    UPNP_RESULT_NO_SUCH_ENTRY_IN_ARRAY: 4,
+    /**
+     * The action failed.
+     */
+    UPNP_RESULT_ACTION_FAILED: 5,
+    /**
+     * The {@link UPNPDevice} does not allow wildcard values for the source IP address.
+     */
+    UPNP_RESULT_SRC_IP_WILDCARD_NOT_PERMITTED: 6,
+    /**
+     * The {@link UPNPDevice} does not allow wildcard values for the external port.
+     */
+    UPNP_RESULT_EXT_PORT_WILDCARD_NOT_PERMITTED: 7,
+    /**
+     * The {@link UPNPDevice} does not allow wildcard values for the internal port.
+     */
+    UPNP_RESULT_INT_PORT_WILDCARD_NOT_PERMITTED: 8,
+    /**
+     * The remote host value must be a wildcard.
+     */
+    UPNP_RESULT_REMOTE_HOST_MUST_BE_WILDCARD: 9,
+    /**
+     * The external port value must be a wildcard.
+     */
+    UPNP_RESULT_EXT_PORT_MUST_BE_WILDCARD: 10,
+    /**
+     * No port maps are available. May also be returned if port mapping functionality is not available.
+     */
+    UPNP_RESULT_NO_PORT_MAPS_AVAILABLE: 11,
+    /**
+     * Conflict with other mechanism. May be returned instead of {@link UPNP_RESULT_CONFLICT_WITH_OTHER_MAPPING} if a port mapping conflicts with an existing one.
+     */
+    UPNP_RESULT_CONFLICT_WITH_OTHER_MECHANISM: 12,
+    /**
+     * Conflict with an existing port mapping.
+     */
+    UPNP_RESULT_CONFLICT_WITH_OTHER_MAPPING: 13,
+    /**
+     * External and internal port values must be the same.
+     */
+    UPNP_RESULT_SAME_PORT_VALUES_REQUIRED: 14,
+    /**
+     * Only permanent leases are supported. Do not use the `duration` parameter when adding port mappings.
+     */
+    UPNP_RESULT_ONLY_PERMANENT_LEASE_SUPPORTED: 15,
+    /**
+     * Invalid gateway.
+     */
+    UPNP_RESULT_INVALID_GATEWAY: 16,
+    /**
+     * Invalid port.
+     */
+    UPNP_RESULT_INVALID_PORT: 17,
+    /**
+     * Invalid protocol.
+     */
+    UPNP_RESULT_INVALID_PROTOCOL: 18,
+    /**
+     * Invalid duration.
+     */
+    UPNP_RESULT_INVALID_DURATION: 19,
+    /**
+     * Invalid arguments.
+     */
+    UPNP_RESULT_INVALID_ARGS: 20,
+    /**
+     * Invalid response.
+     */
+    UPNP_RESULT_INVALID_RESPONSE: 21,
+    /**
+     * Invalid parameter.
+     */
+    UPNP_RESULT_INVALID_PARAM: 22,
+    /**
+     * HTTP error.
+     */
+    UPNP_RESULT_HTTP_ERROR: 23,
+    /**
+     * Socket error.
+     */
+    UPNP_RESULT_SOCKET_ERROR: 24,
+    /**
+     * Error allocating memory.
+     */
+    UPNP_RESULT_MEM_ALLOC_ERROR: 25,
+    /**
+     * No gateway available. You may need to call {@link discover} first, or discovery didn't detect any valid IGDs (InternetGatewayDevices).
+     */
+    UPNP_RESULT_NO_GATEWAY: 26,
+    /**
+     * No devices available. You may need to call {@link discover} first, or discovery didn't detect any valid {@link UPNPDevice}s.
+     */
+    UPNP_RESULT_NO_DEVICES: 27,
+    /**
+     * Unknown error.
+     */
+    UPNP_RESULT_UNKNOWN_ERROR: 28,
+} as const;
+
+export type UPNPResult = (typeof UPNPResult)[keyof typeof UPNPResult];
+