@ringozz/godot 0.1.0

package/gen/classes/WebSocketMultiplayerPeer.ts

@@ -0,0 +1,81 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { MultiplayerPeer } from './MultiplayerPeer.ts';
+import type { Error } from '../global-enums.ts';
+import type { PackedStringArray } from '../heap-types/index.ts';
+import type { TLSOptions } from './TLSOptions.ts';
+import type { WebSocketPeer } from './WebSocketPeer.ts';
+
+/**
+ * Base class for WebSocket server and client, allowing them to be used as multiplayer peer for the {@link MultiplayerAPI}.
+ * **Note:** When exporting to Android, make sure to enable the `INTERNET` permission in the Android export preset before exporting the project or using one-click deploy. Otherwise, network communication of any kind will be blocked by Android.
+ */
+export class WebSocketMultiplayerPeer extends MultiplayerPeer {
+    constructor(name = 961) { super(name); }
+
+    /**
+     * Starts a new multiplayer client connecting to the given `url`. TLS certificates will be verified against the hostname when connecting using the `wss://` protocol. You can pass the optional `tlsClientOptions` parameter to customize the trusted certification authorities, or disable the common name verification. See {@link TLSOptions.client} and {@link TLSOptions.clientUnsafe}.
+     * **Note:** It is recommended to specify the scheme part of the URL, i.e. the `url` should start with either `ws://` or `wss://`.
+     */
+    createClient(url: string, tlsClientOptions?: TLSOptions /* = null */): Error { return _C(this, 2512, url, tlsClientOptions) as Error; }
+
+    /**
+     * Starts a new multiplayer server listening on the given `port`. You can optionally specify a `bindAddress`, and provide valid `tlsServerOptions` to use TLS. See {@link TLSOptions.server}.
+     */
+    createServer(port: number, bindAddress?: string /* = "*" */, tlsServerOptions?: TLSOptions /* = null */): Error { return _C(this, 2568, port, bindAddress, tlsServerOptions) as Error; }
+
+    /**
+     * Returns the {@link WebSocketPeer} associated to the given `peerId`.
+     */
+    getPeer(peerId: number): WebSocketPeer { return _C(this, 5870, peerId) as WebSocketPeer; }
+
+    /**
+     * Returns the IP address of the given peer.
+     */
+    getPeerAddress(id: number): string { return _C(this, 5871, id) as string; }
+
+    /**
+     * Returns the remote port of the given peer.
+     */
+    getPeerPort(id: number): number { return _C(this, 5872, id) as number; }
+
+    /**
+     * The supported WebSocket sub-protocols. See {@link WebSocketPeer.supportedProtocols} for more details.
+     */
+    get supportedProtocols(): PackedStringArray { return _C(this, 6620) as PackedStringArray; }
+    set supportedProtocols(v: PackedStringArray) { _C(this, 12937, v); }
+
+    /**
+     * The extra headers to use during handshake. See {@link WebSocketPeer.handshakeHeaders} for more details.
+     */
+    get handshakeHeaders(): PackedStringArray { return _C(this, 5020) as PackedStringArray; }
+    set handshakeHeaders(v: PackedStringArray) { _C(this, 11603, v); }
+
+    /**
+     * The inbound buffer size for connected peers. See {@link WebSocketPeer.inboundBufferSize} for more details.
+     */
+    get inboundBufferSize(): number { return _C(this, 5078) as number; }
+    set inboundBufferSize(v: number) { _C(this, 11679, v); }
+
+    /**
+     * The outbound buffer size for connected peers. See {@link WebSocketPeer.outboundBufferSize} for more details.
+     */
+    get outboundBufferSize(): number { return _C(this, 5752) as number; }
+    set outboundBufferSize(v: number) { _C(this, 12211, v); }
+
+    /**
+     * The maximum time each peer can stay in a connecting state before being dropped.
+     */
+    get handshakeTimeout(): number { return _C(this, 5021) as number; }
+    set handshakeTimeout(v: number) { _C(this, 11604, v); }
+
+    /**
+     * The maximum number of queued packets for connected peers. See {@link WebSocketPeer.maxQueuedPackets} for more details.
+     */
+    get maxQueuedPackets(): number { return _C(this, 5481) as number; }
+    set maxQueuedPackets(v: number) { _C(this, 12004, v); }
+
+    static readonly name = _R(961, WebSocketMultiplayerPeer);
+}

package/gen/classes/WebSocketPeer.ts

@@ -0,0 +1,213 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { PacketPeer } from './PacketPeer.ts';
+import type { Error } from '../global-enums.ts';
+import type { PackedByteArray, PackedStringArray } from '../heap-types/index.ts';
+import type { StreamPeer } from './StreamPeer.ts';
+import type { TLSOptions } from './TLSOptions.ts';
+
+/**
+ * This class represents WebSocket connection, and can be used as a WebSocket client ([RFC 6455](https://datatracker.ietf.org/doc/html/rfc6455)-compliant) or as a remote peer of a WebSocket server.
+ * You can send WebSocket binary frames using {@link PacketPeer.putPacket}, and WebSocket text frames using {@link send} (prefer text frames when interacting with text-based API). You can check the frame type of the last packet via {@link wasStringPacket}.
+ * To start a WebSocket client, first call {@link connectToUrl}, then regularly call {@link poll} (e.g. during {@link Node} process). You can query the socket state via {@link getReadyState}, get the number of pending packets using {@link PacketPeer.getAvailablePacketCount}, and retrieve them via {@link PacketPeer.getPacket}.
+ *
+ *
+ * ```gdscript
+ *
+ * extends Node
+ *
+ * var socket = WebSocketPeer.new()
+ *
+ * func _ready():
+ * 	socket.connect_to_url("wss://example.com")
+ *
+ * func _process(delta):
+ * 	socket.poll()
+ * 	var state = socket.get_ready_state()
+ * 	if state == WebSocketPeer.STATE_OPEN:
+ * 		while socket.get_available_packet_count():
+ * 			print("Packet: ", socket.get_packet())
+ * 	elif state == WebSocketPeer.STATE_CLOSING:
+ * 		# Keep polling to achieve proper close.
+ * 		pass
+ * 	elif state == WebSocketPeer.STATE_CLOSED:
+ * 		var code = socket.get_close_code()
+ * 		var reason = socket.get_close_reason()
+ * 		print("WebSocket closed with code: %d, reason %s. Clean: %s" % [code,="-1" reason,="reason," code="code" !=""])
+ * 		set_process(false) # Stop processing.
+ *
+ * ```
+ *
+ *
+ * To use the peer as part of a WebSocket server refer to {@link acceptStream} and the online tutorial.
+ */
+export class WebSocketPeer extends PacketPeer {
+    constructor(name = 962) { super(name); }
+
+    /**
+     * Connects to the given URL. TLS certificates will be verified against the hostname when connecting using the `wss://` protocol. You can pass the optional `tlsClientOptions` parameter to customize the trusted certification authorities, or disable the common name verification. See {@link TLSOptions.client} and {@link TLSOptions.clientUnsafe}.
+     * **Note:** This method is non-blocking, and will return {@link OK} before the connection is established as long as the provided parameters are valid and the peer is not in an invalid state (e.g. already connected). Regularly call {@link poll} (e.g. during {@link Node} process) and check the result of {@link getReadyState} to know whether the connection succeeds or fails.
+     * **Note:** To avoid mixed content warnings or errors in Web, you may have to use a `url` that starts with `wss://` (secure) instead of `ws://`. When doing so, make sure to use the fully qualified domain name that matches the one defined in the server's TLS certificate. Do not connect directly via the IP address for `wss://` connections, as it won't match with the TLS certificate.
+     */
+    connectToUrl(url: string, tlsClientOptions?: TLSOptions /* = null */): Error { return _C(this, 2441, url, tlsClientOptions) as Error; }
+
+    /**
+     * Accepts a peer connection performing the HTTP handshake as a WebSocket server. The `stream` must be a valid TCP stream retrieved via {@link TCPServer.takeConnection}, or a TLS stream accepted via {@link StreamPeerTLS.acceptStream}.
+     * **Note:** Not supported in Web exports due to browsers' restrictions.
+     */
+    acceptStream(stream: StreamPeer): Error { return _C(this, 1059, stream) as Error; }
+
+    /**
+     * Sends the given `message` using the desired `writeMode`. When sending a {@link String}, prefer using {@link sendText}.
+     */
+    send(message: PackedByteArray, writeMode?: WriteMode /* = 1 */): Error { return _C(this, 10368, message, writeMode) as Error; }
+
+    /**
+     * Sends the given `message` using WebSocket text mode. Prefer this method over {@link PacketPeer.putPacket} when interacting with third-party text-based API (e.g. when using {@link JSON} formatted messages).
+     */
+    sendText(message: string): Error { return _C(this, 10372, message) as Error; }
+
+    /**
+     * Returns `true` if the last received packet was sent as a text payload. See {@link WriteMode}.
+     */
+    wasStringPacket(): boolean { return _C(this, 14841) as boolean; }
+
+    /**
+     * Updates the connection state and receive incoming packets. Call this function regularly to keep it in a clean state.
+     */
+    poll(): void { _C(this, 9471); }
+
+    /**
+     * Closes this WebSocket connection.
+     * `code` is the status code for the closure (see [RFC 6455 section 7.4](https://datatracker.ietf.org/doc/html/rfc6455#section-7.4.1) for a list of valid status codes). If `code` is negative, the connection will be closed immediately without notifying the remote peer.
+     * `reason` is the human-readable reason for closing the connection. It can be any UTF-8 string that's smaller than 123 bytes.
+     * **Note:** To achieve a clean closure, you will need to keep polling until {@link STATE_CLOSED} is reached.
+     * **Note:** The Web export might not support all status codes. Please refer to browser-specific documentation for more details.
+     */
+    close(code?: number /* = 1000 */, reason?: string /* = "" */): void { _C(this, 2331, code, reason); }
+
+    /**
+     * Returns the IP address of the connected peer.
+     * **Note:** Not available in the Web export.
+     */
+    getConnectedHost(): string { return _C(this, 4260) as string; }
+
+    /**
+     * Returns the remote port of the connected peer.
+     * **Note:** Not available in the Web export.
+     */
+    getConnectedPort(): number { return _C(this, 4264) as number; }
+
+    /**
+     * Returns the selected WebSocket sub-protocol for this connection or an empty string if the sub-protocol has not been selected yet.
+     */
+    getSelectedProtocol(): string { return _C(this, 6328) as string; }
+
+    /**
+     * Returns the URL requested by this peer. The URL is derived from the `url` passed to {@link connectToUrl} or from the HTTP headers when acting as server (i.e. when using {@link acceptStream}).
+     */
+    getRequestedUrl(): string { return _C(this, 6152) as string; }
+
+    /**
+     * Disable Nagle's algorithm on the underlying TCP socket (default). See {@link StreamPeerTCP.setNoDelay} for more information.
+     * **Note:** Not available in the Web export.
+     */
+    setNoDelay(enabled: boolean): void { _C(this, 12135, enabled); }
+
+    /**
+     * Returns the current amount of data in the outbound websocket buffer. **Note:** Web exports use WebSocket.bufferedAmount, while other platforms use an internal buffer.
+     */
+    getCurrentOutboundBufferedAmount(): number { return _C(this, 4360) as number; }
+
+    /**
+     * Returns the ready state of the connection.
+     */
+    getReadyState(): State { return _C(this, 6084) as State; }
+
+    /**
+     * Returns the received WebSocket close frame status code, or `-1` when the connection was not cleanly closed. Only call this method when {@link getReadyState} returns {@link STATE_CLOSED}.
+     */
+    getCloseCode(): number { return _C(this, 4165) as number; }
+
+    /**
+     * Returns the received WebSocket close frame status reason string. Only call this method when {@link getReadyState} returns {@link STATE_CLOSED}.
+     */
+    getCloseReason(): string { return _C(this, 4167) as string; }
+
+    /**
+     * The WebSocket sub-protocols allowed during the WebSocket handshake.
+     */
+    get supportedProtocols(): PackedStringArray { return _C(this, 6620) as PackedStringArray; }
+    set supportedProtocols(v: PackedStringArray) { _C(this, 12937, v); }
+
+    /**
+     * The extra HTTP headers to be sent during the WebSocket handshake.
+     * **Note:** Not supported in Web exports due to browsers' restrictions.
+     */
+    get handshakeHeaders(): PackedStringArray { return _C(this, 5020) as PackedStringArray; }
+    set handshakeHeaders(v: PackedStringArray) { _C(this, 11603, v); }
+
+    /**
+     * The size of the input buffer in bytes (roughly the maximum amount of memory that will be allocated for the inbound packets).
+     */
+    get inboundBufferSize(): number { return _C(this, 5078) as number; }
+    set inboundBufferSize(v: number) { _C(this, 11679, v); }
+
+    /**
+     * The size of the input buffer in bytes (roughly the maximum amount of memory that will be allocated for the outbound packets).
+     */
+    get outboundBufferSize(): number { return _C(this, 5752) as number; }
+    set outboundBufferSize(v: number) { _C(this, 12211, v); }
+
+    /**
+     * The maximum amount of packets that will be allowed in the queues (both inbound and outbound).
+     */
+    get maxQueuedPackets(): number { return _C(this, 5481) as number; }
+    set maxQueuedPackets(v: number) { _C(this, 12004, v); }
+
+    /**
+     * The interval (in seconds) at which the peer will automatically send WebSocket "ping" control frames. When set to `0`, no "ping" control frames will be sent.
+     * **Note:** Has no effect in Web exports due to browser restrictions.
+     */
+    get heartbeatInterval(): number { return _C(this, 5023) as number; }
+    set heartbeatInterval(v: number) { _C(this, 11608, v); }
+
+    static readonly name = _R(962, WebSocketPeer);
+}
+
+export const WriteMode = {
+    /**
+     * Specifies that WebSockets messages should be transferred as text payload (only valid UTF-8 is allowed).
+     */
+    WRITE_MODE_TEXT: 0,
+    /**
+     * Specifies that WebSockets messages should be transferred as binary payload (any byte combination is allowed).
+     */
+    WRITE_MODE_BINARY: 1,
+} as const;
+
+export type WriteMode = (typeof WriteMode)[keyof typeof WriteMode];
+
+export const State = {
+    /**
+     * Socket has been created. The connection is not yet open.
+     */
+    STATE_CONNECTING: 0,
+    /**
+     * The connection is open and ready to communicate.
+     */
+    STATE_OPEN: 1,
+    /**
+     * The connection is in the process of closing. This means a close request has been sent to the remote peer but confirmation has not been received.
+     */
+    STATE_CLOSING: 2,
+    /**
+     * The connection is closed or couldn't be opened.
+     */
+    STATE_CLOSED: 3,
+} as const;
+
+export type State = (typeof State)[keyof typeof State];
+

package/gen/classes/WebXRInterface.ts

@@ -0,0 +1,317 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { XRInterface } from './XRInterface.ts';
+import type { GodotArray, Signal } from '../heap-types/index.ts';
+import type { XRControllerTracker } from './XRControllerTracker.ts';
+
+/**
+ * WebXR is an open standard that allows creating VR and AR applications that run in the web browser.
+ * As such, this interface is only available when running in Web exports.
+ * WebXR supports a wide range of devices, from the very capable (like Valve Index, HTC Vive, Oculus Rift and Quest) down to the much less capable (like Google Cardboard, Oculus Go, GearVR, or plain smartphones).
+ * Since WebXR is based on JavaScript, it makes extensive use of callbacks, which means that {@link WebXRInterface} is forced to use signals, where other XR interfaces would instead use functions that return a result immediately. This makes {@link WebXRInterface} quite a bit more complicated to initialize than other XR interfaces.
+ * Here's the minimum code required to start an immersive VR session:
+ *
+ * ```text
+ *
+ * extends Node3D
+ *
+ * var webxr_interface
+ * var vr_supported = false
+ *
+ * func _ready():
+ * 	# We assume this node has a button as a child.
+ * 	# This button is for the user to consent to entering immersive VR mode.
+ * 	$Button.pressed.connect(self._on_button_pressed)
+ *
+ * 	webxr_interface = XRServer.find_interface("WebXR")
+ * 	if webxr_interface:
+ * 		# WebXR uses a lot of asynchronous callbacks, so we connect to various
+ * 		# signals in order to receive them.
+ * 		webxr_interface.session_supported.connect(self._webxr_session_supported)
+ * 		webxr_interface.session_started.connect(self._webxr_session_started)
+ * 		webxr_interface.session_ended.connect(self._webxr_session_ended)
+ * 		webxr_interface.session_failed.connect(self._webxr_session_failed)
+ *
+ * 		# This returns immediately - our _webxr_session_supported() method
+ * 		# (which we connected to the "session_supported" signal above) will
+ * 		# be called sometime later to let us know if it's supported or not.
+ * 		webxr_interface.is_session_supported("immersive-vr")
+ *
+ * func _webxr_session_supported(session_mode, supported):
+ * 	if session_mode == 'immersive-vr':
+ * 		vr_supported = supported
+ *
+ * func _on_button_pressed():
+ * 	if not vr_supported:
+ * 		OS.alert("Your browser doesn't support VR")
+ * 		return
+ *
+ * 	# We want an immersive VR session, as opposed to AR ('immersive-ar') or a
+ * 	# simple 3DoF viewer ('viewer').
+ * 	webxr_interface.session_mode = 'immersive-vr'
+ * 	# 'bounded-floor' is room scale, 'local-floor' is a standing or sitting
+ * 	# experience (it puts you 1.6m above the ground if you have 3DoF headset),
+ * 	# whereas as 'local' puts you down at the XROrigin.
+ * 	# This list means it'll first try to request 'bounded-floor', then
+ * 	# fallback on 'local-floor' and ultimately 'local', if nothing else is
+ * 	# supported.
+ * 	webxr_interface.requested_reference_space_types = 'bounded-floor, local-floor, local'
+ * 	# In order to use 'local-floor' or 'bounded-floor' we must also
+ * 	# mark the features as required or optional. By including 'hand-tracking'
+ * 	# as an optional feature, it will be enabled if supported.
+ * 	webxr_interface.required_features = 'local-floor'
+ * 	webxr_interface.optional_features = 'bounded-floor, hand-tracking'
+ *
+ * 	# This will return false if we're unable to even request the session,
+ * 	# however, it can still fail asynchronously later in the process, so we
+ * 	# only know if it's really succeeded or failed when our
+ * 	# _webxr_session_started() or _webxr_session_failed() methods are called.
+ * 	if not webxr_interface.initialize():
+ * 		OS.alert("Failed to initialize")
+ * 		return
+ *
+ * func _webxr_session_started():
+ * 	$Button.visible = false
+ * 	# This tells Godot to start rendering to the headset.
+ * 	get_viewport().use_xr = true
+ * 	# This will be the reference space type you ultimately got, out of the
+ * 	# types that you requested above. This is useful if you want the game to
+ * 	# work a little differently in 'bounded-floor' versus 'local-floor'.
+ * 	print("Reference space type: ", webxr_interface.reference_space_type)
+ * 	# This will be the list of features that were successfully enabled
+ * 	# (except on browsers that don't support this property).
+ * 	print("Enabled features: ", webxr_interface.enabled_features)
+ *
+ * func _webxr_session_ended():
+ * 	$Button.visible = true
+ * 	# If the user exits immersive mode, then we tell Godot to render to the web
+ * 	# page again.
+ * 	get_viewport().use_xr = false
+ *
+ * func _webxr_session_failed(message):
+ * 	OS.alert("Failed to initialize: " + message)
+ *
+ * ```
+ *
+ * There are a couple ways to handle "controller" input:
+ * - Using {@link XRController3D} nodes and their {@link XRController3D.button_pressed} and {@link XRController3D.button_released} signals. This is how controllers are typically handled in XR apps in Godot, however, this will only work with advanced VR controllers like the Oculus Touch or Index controllers, for example.
+ * - Using the {@link select}, {@link squeeze} and related signals. This method will work for both advanced VR controllers, and non-traditional input sources like a tap on the screen, a spoken voice command or a button press on the device itself.
+ * You can use both methods to allow your game or app to support a wider or narrower set of devices and input methods, or to allow more advanced interactions with more advanced devices.
+ */
+export class WebXRInterface extends XRInterface {
+
+    /**
+     * Checks if the given `sessionMode` is supported by the user's browser.
+     * Possible values come from [WebXR's XRSessionMode](https://developer.mozilla.org/en-US/docs/Web/API/XRSessionMode), including: `"immersive-vr"`, `"immersive-ar"`, and `"inline"`.
+     * This method returns nothing, instead it emits the {@link session_supported} signal with the result.
+     */
+    isSessionSupported(sessionMode: string): void { _C(this, 8293, sessionMode); }
+
+    /**
+     * Returns `true` if there is an active input source with the given `inputSourceId`.
+     */
+    isInputSourceActive(inputSourceId: number): boolean { return _C(this, 8030, inputSourceId) as boolean; }
+
+    /**
+     * Gets an {@link XRControllerTracker} for the given `inputSourceId`.
+     * In the context of WebXR, an input source can be an advanced VR controller like the Oculus Touch or Index controllers, or even a tap on the screen, a spoken voice command or a button press on the device itself. When a non-traditional input source is used, interpret the position and orientation of the {@link XRPositionalTracker} as a ray pointing at the object the user wishes to interact with.
+     * Use this method to get information about the input source that triggered one of these signals:
+     * - {@link selectstart}
+     * - {@link select}
+     * - {@link selectend}
+     * - {@link squeezestart}
+     * - {@link squeeze}
+     * - {@link squeezestart}
+     */
+    getInputSourceTracker(inputSourceId: number): XRControllerTracker { return _C(this, 5126, inputSourceId) as XRControllerTracker; }
+
+    /**
+     * Returns the target ray mode for the given `inputSourceId`.
+     * This can help interpret the input coming from that input source. See [XRInputSource.targetRayMode](https://developer.mozilla.org/en-US/docs/Web/API/XRInputSource/targetRayMode) for more information.
+     */
+    getInputSourceTargetRayMode(inputSourceId: number): TargetRayMode { return _C(this, 5125, inputSourceId) as TargetRayMode; }
+
+    /**
+     * Returns the display refresh rate for the current HMD. Not supported on all HMDs and browsers. It may not report an accurate value until after using {@link setDisplayRefreshRate}.
+     */
+    getDisplayRefreshRate(): number { return _C(this, 4519) as number; }
+
+    /**
+     * Sets the display refresh rate for the current HMD. Not supported on all HMDs and browsers. It won't take effect right away until after {@link display_refresh_rate_changed} is emitted.
+     */
+    setDisplayRefreshRate(refreshRate: number): void { _C(this, 11130, refreshRate); }
+
+    /**
+     * Returns display refresh rates supported by the current HMD. Only returned if this feature is supported by the web browser and after the interface has been initialized.
+     */
+    getAvailableDisplayRefreshRates(): GodotArray { return _C(this, 3850) as GodotArray; }
+
+    /**
+     * The session mode used by {@link XRInterface.initialize} when setting up the WebXR session.
+     * This doesn't have any effect on the interface when already initialized.
+     * Possible values come from [WebXR's XRSessionMode](https://developer.mozilla.org/en-US/docs/Web/API/XRSessionMode), including: `"immersive-vr"`, `"immersive-ar"`, and `"inline"`.
+     */
+    get sessionMode(): string { return _C(this, 6347) as string; }
+    set sessionMode(v: string) { _C(this, 12698, v); }
+
+    /**
+     * A comma-seperated list of required features used by {@link XRInterface.initialize} when setting up the WebXR session.
+     * If a user's browser or device doesn't support one of the given features, initialization will fail and {@link session_failed} will be emitted.
+     * This doesn't have any effect on the interface when already initialized.
+     * See the MDN documentation on [WebXR's session features](https://developer.mozilla.org/en-US/docs/Web/API/XRSystem/requestSession#session_features) for a list of possible values.
+     */
+    get requiredFeatures(): string { return _C(this, 6153) as string; }
+    set requiredFeatures(v: string) { _C(this, 12535, v); }
+
+    /**
+     * A comma-seperated list of optional features used by {@link XRInterface.initialize} when setting up the WebXR session.
+     * If a user's browser or device doesn't support one of the given features, initialization will continue, but you won't be able to use the requested feature.
+     * This doesn't have any effect on the interface when already initialized.
+     * See the MDN documentation on [WebXR's session features](https://developer.mozilla.org/en-US/docs/Web/API/XRSystem/requestSession#session_features) for a list of possible values.
+     */
+    get optionalFeatures(): string { return _C(this, 5734) as string; }
+    set optionalFeatures(v: string) { _C(this, 12198, v); }
+
+    /**
+     * A comma-seperated list of reference space types used by {@link XRInterface.initialize} when setting up the WebXR session.
+     * The reference space types are requested in order, and the first one supported by the user's device or browser will be used. The {@link referenceSpaceType} property contains the reference space type that was ultimately selected.
+     * This doesn't have any effect on the interface when already initialized.
+     * Possible values come from [WebXR's XRReferenceSpaceType](https://developer.mozilla.org/en-US/docs/Web/API/XRReferenceSpaceType). If you want to use a particular reference space type, it must be listed in either {@link requiredFeatures} or {@link optionalFeatures}.
+     */
+    get requestedReferenceSpaceTypes(): string { return _C(this, 6151) as string; }
+    set requestedReferenceSpaceTypes(v: string) { _C(this, 12533, v); }
+
+    /**
+     * The reference space type (from the list of requested types set in the {@link requestedReferenceSpaceTypes} property), that was ultimately used by {@link XRInterface.initialize} when setting up the WebXR session.
+     * Possible values come from [WebXR's XRReferenceSpaceType](https://developer.mozilla.org/en-US/docs/Web/API/XRReferenceSpaceType). If you want to use a particular reference space type, it must be listed in either {@link requiredFeatures} or {@link optionalFeatures}.
+     */
+    get referenceSpaceType(): string { return _C(this, 6105) as string; }
+
+    /**
+     * A comma-separated list of features that were successfully enabled by {@link XRInterface.initialize} when setting up the WebXR session.
+     * This may include features requested by setting {@link requiredFeatures} and {@link optionalFeatures}, and will only be available after {@link session_started} has been emitted.
+     * **Note:** This may not be support by all web browsers, in which case it will be an empty string.
+     */
+    get enabledFeatures(): string { return _C(this, 4658) as string; }
+
+    /**
+     * Indicates if the WebXR session's imagery is visible to the user.
+     * Possible values come from [WebXR's XRVisibilityState](https://developer.mozilla.org/en-US/docs/Web/API/XRVisibilityState), including `"hidden"`, `"visible"`, and `"visible-blurred"`.
+     */
+    get visibilityState(): string { return _C(this, 7101) as string; }
+
+    /**
+     * Emitted by {@link isSessionSupported} to indicate if the given `sessionMode` is supported or not.
+     */
+    get sessionSupported(): Signal<(sessionMode: string, supported: boolean) => void> { return _G(this, 10389) as Signal<(sessionMode: string, supported: boolean) => void>; }
+    set sessionSupported(v: ((sessionMode: string, supported: boolean) => void) | null) { _G(this, 10389, v); }
+
+    /**
+     * Emitted by {@link XRInterface.initialize} if the session is successfully started.
+     * At this point, it's safe to do `get_viewport().use_xr = true` to instruct Godot to start rendering to the XR device.
+     */
+    get sessionStarted(): Signal<() => void> { return _G(this, 10387) as Signal<() => void>; }
+    set sessionStarted(v: (() => void) | null) { _G(this, 10387, v); }
+
+    /**
+     * Emitted when the user ends the WebXR session (which can be done using UI from the browser or device).
+     * At this point, you should do `get_viewport().use_xr = false` to instruct Godot to resume rendering to the screen.
+     */
+    get sessionEnded(): Signal<() => void> { return _G(this, 10382) as Signal<() => void>; }
+    set sessionEnded(v: (() => void) | null) { _G(this, 10382, v); }
+
+    /**
+     * Emitted by {@link XRInterface.initialize} if the session fails to start.
+     * `message` may optionally contain an error message from WebXR, or an empty string if no message is available.
+     */
+    get sessionFailed(): Signal<(message: string) => void> { return _G(this, 10383) as Signal<(message: string) => void>; }
+    set sessionFailed(v: ((message: string) => void) | null) { _G(this, 10383, v); }
+
+    /**
+     * Emitted when one of the input source has started its "primary action".
+     * Use {@link getInputSourceTracker} and {@link getInputSourceTargetRayMode} to get more information about the input source.
+     */
+    get selectstart(): Signal<(inputSourceId: number) => void> { return _G(this, 10366) as Signal<(inputSourceId: number) => void>; }
+    set selectstart(v: ((inputSourceId: number) => void) | null) { _G(this, 10366, v); }
+
+    /**
+     * Emitted after one of the input sources has finished its "primary action".
+     * Use {@link getInputSourceTracker} and {@link getInputSourceTargetRayMode} to get more information about the input source.
+     */
+    get select(): Signal<(inputSourceId: number) => void> { return _G(this, 10353) as Signal<(inputSourceId: number) => void>; }
+    set select(v: ((inputSourceId: number) => void) | null) { _G(this, 10353, v); }
+
+    /**
+     * Emitted when one of the input sources has finished its "primary action".
+     * Use {@link getInputSourceTracker} and {@link getInputSourceTargetRayMode} to get more information about the input source.
+     */
+    get selectend(): Signal<(inputSourceId: number) => void> { return _G(this, 10363) as Signal<(inputSourceId: number) => void>; }
+    set selectend(v: ((inputSourceId: number) => void) | null) { _G(this, 10363, v); }
+
+    /**
+     * Emitted when one of the input sources has started its "primary squeeze action".
+     * Use {@link getInputSourceTracker} and {@link getInputSourceTargetRayMode} to get more information about the input source.
+     */
+    get squeezestart(): Signal<(inputSourceId: number) => void> { return _G(this, 13802) as Signal<(inputSourceId: number) => void>; }
+    set squeezestart(v: ((inputSourceId: number) => void) | null) { _G(this, 13802, v); }
+
+    /**
+     * Emitted after one of the input sources has finished its "primary squeeze action".
+     * Use {@link getInputSourceTracker} and {@link getInputSourceTargetRayMode} to get more information about the input source.
+     */
+    get squeeze(): Signal<(inputSourceId: number) => void> { return _G(this, 13800) as Signal<(inputSourceId: number) => void>; }
+    set squeeze(v: ((inputSourceId: number) => void) | null) { _G(this, 13800, v); }
+
+    /**
+     * Emitted when one of the input sources has finished its "primary squeeze action".
+     * Use {@link getInputSourceTracker} and {@link getInputSourceTargetRayMode} to get more information about the input source.
+     */
+    get squeezeend(): Signal<(inputSourceId: number) => void> { return _G(this, 13801) as Signal<(inputSourceId: number) => void>; }
+    set squeezeend(v: ((inputSourceId: number) => void) | null) { _G(this, 13801, v); }
+
+    /**
+     * Emitted when {@link visibilityState} has changed.
+     */
+    get visibilityStateChanged(): Signal<() => void> { return _G(this, 14786) as Signal<() => void>; }
+    set visibilityStateChanged(v: (() => void) | null) { _G(this, 14786, v); }
+
+    /**
+     * Emitted to indicate that the reference space has been reset or reconfigured.
+     * When (or whether) this is emitted depends on the user's browser or device, but may include when the user has changed the dimensions of their play space (which you may be able to access via {@link XRInterface.getPlayArea}) or pressed/held a button to recenter their position.
+     * See [WebXR's XRReferenceSpace reset event](https://developer.mozilla.org/en-US/docs/Web/API/XRReferenceSpace/reset_event) for more information.
+     */
+    get referenceSpaceReset(): Signal<() => void> { return _G(this, 9774) as Signal<() => void>; }
+    set referenceSpaceReset(v: (() => void) | null) { _G(this, 9774, v); }
+
+    /**
+     * Emitted after the display's refresh rate has changed.
+     */
+    get displayRefreshRateChanged(): Signal<() => void> { return _G(this, 2838) as Signal<() => void>; }
+    set displayRefreshRateChanged(v: (() => void) | null) { _G(this, 2838, v); }
+
+    static readonly name = _R(963, WebXRInterface);
+}
+
+export const TargetRayMode = {
+    /**
+     * We don't know the target ray mode.
+     */
+    TARGET_RAY_MODE_UNKNOWN: 0,
+    /**
+     * Target ray originates at the viewer's eyes and points in the direction they are looking.
+     */
+    TARGET_RAY_MODE_GAZE: 1,
+    /**
+     * Target ray from a handheld pointer, most likely a VR touch controller.
+     */
+    TARGET_RAY_MODE_TRACKED_POINTER: 2,
+    /**
+     * Target ray from touch screen, mouse or other tactile input device.
+     */
+    TARGET_RAY_MODE_SCREEN: 3,
+} as const;
+
+export type TargetRayMode = (typeof TargetRayMode)[keyof typeof TargetRayMode];
+