@ringozz/godot 0.1.0

package/gen/classes/XRPose.ts

@@ -0,0 +1,80 @@
+// 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 { StringName } from '../heap-types/index.ts';
+import type { Transform3D, Vector3 } from '../value-types/index.ts';
+
+/**
+ * XR runtimes often identify multiple locations on devices such as controllers that are spatially tracked.
+ * Orientation, location, linear velocity and angular velocity are all provided for each pose by the XR runtime. This object contains this state of a pose.
+ */
+export class XRPose extends RefCounted {
+    constructor(name = 987) { super(name); }
+
+    /**
+     * Returns the {@link transform} with world scale and our reference frame applied. This is the transform used to position {@link XRNode3D} objects.
+     */
+    getAdjustedTransform(): Transform3D { return _C(this, 3696) as Transform3D; }
+
+    /**
+     * If `true` our tracking data is up to date. If `false` we're no longer receiving new tracking data and our state is whatever that last valid state was.
+     */
+    get hasTrackingData(): boolean { return _C(this, 5022) as boolean; }
+    set hasTrackingData(v: boolean) { _C(this, 11606, v); }
+
+    /**
+     * The name of this pose. Usually, this name is derived from an action map set up by the user. Godot also suggests some pose names that {@link XRInterface} objects are expected to implement:
+     * - `root` is the root location, often used for tracked objects that do not have further nodes.
+     * - `aim` is the tip of a controller with its orientation pointing outwards, often used for raycasts.
+     * - `grip` is the location where the user grips the controller.
+     * - `skeleton` is the root location for a hand mesh, when using hand tracking and an animated skeleton is supplied by the XR runtime.
+     */
+    get name(): StringName { return _C(this, 5602) as StringName; }
+    set name(v: StringName) { _C(this, 12113, v); }
+
+    /**
+     * The transform containing the original and transform as reported by the XR runtime.
+     */
+    get transform(): Transform3D { return _C(this, 6874) as Transform3D; }
+    set transform(v: Transform3D) { _C(this, 13134, v); }
+
+    /**
+     * The linear velocity of this pose.
+     */
+    get linearVelocity(): Vector3 { return _C(this, 5386) as Vector3; }
+    set linearVelocity(v: Vector3) { _C(this, 11935, v); }
+
+    /**
+     * The angular velocity for this pose.
+     */
+    get angularVelocity(): Vector3 { return _C(this, 3757) as Vector3; }
+    set angularVelocity(v: Vector3) { _C(this, 10500, v); }
+
+    /**
+     * The tracking confidence for this pose, provides insight on how accurate the spatial positioning of this record is.
+     */
+    get trackingConfidence(): TrackingConfidence { return _C(this, 6867) as TrackingConfidence; }
+    set trackingConfidence(v: TrackingConfidence) { _C(this, 13126, v); }
+
+    static readonly name = _R(987, XRPose);
+}
+
+export const TrackingConfidence = {
+    /**
+     * No tracking information is available for this pose.
+     */
+    XR_TRACKING_CONFIDENCE_NONE: 0,
+    /**
+     * Tracking information may be inaccurate or estimated. For example, with inside out tracking this would indicate a controller may be (partially) obscured.
+     */
+    XR_TRACKING_CONFIDENCE_LOW: 1,
+    /**
+     * Tracking information is considered accurate and up to date.
+     */
+    XR_TRACKING_CONFIDENCE_HIGH: 2,
+} as const;
+
+export type TrackingConfidence = (typeof TrackingConfidence)[keyof typeof TrackingConfidence];
+

package/gen/classes/XRPositionalTracker.ts

@@ -0,0 +1,125 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { XRTracker } from './XRTracker.ts';
+import type { Signal, StringName, Variant } from '../heap-types/index.ts';
+import type { Transform3D, Vector2, Vector3 } from '../value-types/index.ts';
+import type { TrackingConfidence, XRPose } from './XRPose.ts';
+
+/**
+ * An instance of this object represents a device that is tracked, such as a controller or anchor point. HMDs aren't represented here as they are handled internally.
+ * As controllers are turned on and the {@link XRInterface} detects them, instances of this object are automatically added to this list of active tracking objects accessible through the {@link XRServer}.
+ * The {@link XRNode3D} and {@link XRAnchor3D} both consume objects of this type and should be used in your project. The positional trackers are just under-the-hood objects that make this all work. These are mostly exposed so that GDExtension-based interfaces can interact with them.
+ */
+export class XRPositionalTracker extends XRTracker {
+    constructor(name = 988) { super(name); }
+
+    /**
+     * Returns `true` if the tracker is available and is currently tracking the bound `name` pose.
+     */
+    hasPose(name: StringName): boolean { return _C(this, 7431, name) as boolean; }
+
+    /**
+     * Returns the current {@link XRPose} state object for the bound `name` pose.
+     */
+    getPose(name: StringName): XRPose { return _C(this, 5971, name) as XRPose; }
+
+    /**
+     * Marks this pose as invalid, we don't clear the last reported state but it allows users to decide if trackers need to be hidden if we lose tracking or just remain at their last known position.
+     */
+    invalidatePose(name: StringName): void { _C(this, 7713, name); }
+
+    /**
+     * Sets the transform, linear velocity, angular velocity and tracking confidence for the given pose. This method is called by an {@link XRInterface} implementation and should not be used directly.
+     */
+    setPose(name: StringName, transform: Transform3D, linearVelocity: Vector3, angularVelocity: Vector3, trackingConfidence: TrackingConfidence): void { _C(this, 12379, name, transform, linearVelocity, angularVelocity, trackingConfidence); }
+
+    /**
+     * Returns an input for this tracker. It can return a boolean, float or {@link Vector2} value depending on whether the input is a button, trigger or thumbstick/thumbpad.
+     */
+    getInput(name: StringName): Variant { return _C(this, 5106, name) as Variant; }
+
+    /**
+     * Changes the value for the given input. This method is called by an {@link XRInterface} implementation and should not be used directly.
+     */
+    setInput(name: StringName, value: Variant): void { _C(this, 11707, name, value); }
+
+    /**
+     * The profile associated with this tracker, interface dependent but will indicate the type of controller being tracked.
+     */
+    get profile(): string { return _C(this, 6864) as string; }
+    set profile(v: string) { _C(this, 13124, v); }
+
+    /**
+     * Defines which hand this tracker relates to.
+     */
+    get hand(): TrackerHand { return _C(this, 6862) as TrackerHand; }
+    set hand(v: TrackerHand) { _C(this, 13122, v); }
+
+    /**
+     * Emitted when the state of a pose tracked by this tracker changes.
+     */
+    get poseChanged(): Signal<(pose: XRPose) => void> { return _G(this, 9500) as Signal<(pose: XRPose) => void>; }
+    set poseChanged(v: ((pose: XRPose) => void) | null) { _G(this, 9500, v); }
+
+    /**
+     * Emitted when a pose tracked by this tracker stops getting updated tracking data.
+     */
+    get poseLostTracking(): Signal<(pose: XRPose) => void> { return _G(this, 9501) as Signal<(pose: XRPose) => void>; }
+    set poseLostTracking(v: ((pose: XRPose) => void) | null) { _G(this, 9501, v); }
+
+    /**
+     * Emitted when a button on this tracker is pressed. Note that many XR runtimes allow other inputs to be mapped to buttons.
+     */
+    get buttonPressed(): Signal<(actionName: string) => void> { return _G(this, 1947) as Signal<(actionName: string) => void>; }
+    set buttonPressed(v: ((actionName: string) => void) | null) { _G(this, 1947, v); }
+
+    /**
+     * Emitted when a button on this tracker is released.
+     */
+    get buttonReleased(): Signal<(actionName: string) => void> { return _G(this, 1948) as Signal<(actionName: string) => void>; }
+    set buttonReleased(v: ((actionName: string) => void) | null) { _G(this, 1948, v); }
+
+    /**
+     * Emitted when a trigger or similar input on this tracker changes value.
+     */
+    get inputFloatChanged(): Signal<(actionName: string, value: number) => void> { return _G(this, 7624) as Signal<(actionName: string, value: number) => void>; }
+    set inputFloatChanged(v: ((actionName: string, value: number) => void) | null) { _G(this, 7624, v); }
+
+    /**
+     * Emitted when a thumbstick or thumbpad on this tracker moves.
+     */
+    get inputVector2Changed(): Signal<(actionName: string, vector: Vector2) => void> { return _G(this, 7630) as Signal<(actionName: string, vector: Vector2) => void>; }
+    set inputVector2Changed(v: ((actionName: string, vector: Vector2) => void) | null) { _G(this, 7630, v); }
+
+    /**
+     * Emitted when the profile of our tracker changes.
+     */
+    get profileChanged(): Signal<(role: string) => void> { return _G(this, 9582) as Signal<(role: string) => void>; }
+    set profileChanged(v: ((role: string) => void) | null) { _G(this, 9582, v); }
+
+    static readonly name = _R(988, XRPositionalTracker);
+}
+
+export const TrackerHand = {
+    /**
+     * The hand this tracker is held in is unknown or not applicable.
+     */
+    TRACKER_HAND_UNKNOWN: 0,
+    /**
+     * This tracker is the left hand controller.
+     */
+    TRACKER_HAND_LEFT: 1,
+    /**
+     * This tracker is the right hand controller.
+     */
+    TRACKER_HAND_RIGHT: 2,
+    /**
+     * Represents the size of the {@link TrackerHand} enum.
+     */
+    TRACKER_HAND_MAX: 3,
+} as const;
+
+export type TrackerHand = (typeof TrackerHand)[keyof typeof TrackerHand];
+

package/gen/classes/XRServer.ts

@@ -0,0 +1,226 @@
+// 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 { GodotArray, GodotDictionary, Signal, StringName } from '../heap-types/index.ts';
+import type { Transform3D } from '../value-types/index.ts';
+import type { XRInterface } from './XRInterface.ts';
+import type { XRTracker } from './XRTracker.ts';
+
+let _$: any;
+const $ = () => _$ ?? (_$ = _C(null, 40, 989));
+
+/**
+ * The AR/VR server is the heart of our Advanced and Virtual Reality solution and handles all the processing.
+ */
+export class XRServer extends GodotVar {
+
+    /**
+     * Returns the reference frame transform. Mostly used internally and exposed for GDExtension build interfaces.
+     */
+    static getReferenceFrame(): Transform3D { return _C($(), 6100) as Transform3D; }
+
+    /**
+     * Clears the reference frame that was set by previous calls to {@link centerOnHmd}.
+     */
+    static clearReferenceFrame(): void { _C($(), 2291); }
+
+    /**
+     * This is an important function to understand correctly. AR and VR platforms all handle positioning slightly differently.
+     * For platforms that do not offer spatial tracking, our origin point `(0, 0, 0)` is the location of our HMD, but you have little control over the direction the player is facing in the real world.
+     * For platforms that do offer spatial tracking, our origin point depends very much on the system. For OpenVR, our origin point is usually the center of the tracking space, on the ground. For other platforms, it's often the location of the tracking camera.
+     * This method allows you to center your tracker on the location of the HMD. It will take the current location of the HMD and use that to adjust all your tracking data; in essence, realigning the real world to your player's current position in the game world.
+     * For this method to produce usable results, tracking information must be available. This often takes a few frames after starting your game.
+     * You should call this method after a few seconds have passed. For example, when the user requests a realignment of the display holding a designated button on a controller for a short period of time, or when implementing a teleport mechanism.
+     */
+    static centerOnHmd(rotationMode: RotationMode, keepHeight: boolean): void { _C($(), 2178, rotationMode, keepHeight); }
+
+    /**
+     * Returns the primary interface's transformation.
+     */
+    static getHmdTransform(): Transform3D { return _C($(), 5043) as Transform3D; }
+
+    /**
+     * Registers an {@link XRInterface} object.
+     */
+    static addInterface(_interface: XRInterface): void { _C($(), 1240, _interface); }
+
+    /**
+     * Returns the number of interfaces currently registered with the AR/VR server. If your project supports multiple AR/VR platforms, you can look through the available interface, and either present the user with a selection or simply try to initialize each interface and use the first one that returns `true`.
+     */
+    static getInterfaceCount(): number { return _C($(), 5148) as number; }
+
+    /**
+     * Removes this `interface`.
+     */
+    static removeInterface(_interface: XRInterface): void { _C($(), 9923, _interface); }
+
+    /**
+     * Returns the interface registered at the given `idx` index in the list of interfaces.
+     */
+    static getInterface(idx: number): XRInterface { return _C($(), 5147, idx) as XRInterface; }
+
+    /**
+     * Returns a list of available interfaces the ID and name of each interface.
+     */
+    static getInterfaces(): GodotArray<GodotDictionary> { return _C($(), 5149) as GodotArray<GodotDictionary>; }
+
+    /**
+     * Finds an interface by its `name`. For example, if your project uses capabilities of an AR/VR platform, you can find the interface for that platform by name and initialize it.
+     */
+    static findInterface(name: string): XRInterface { return _C($(), 3289, name) as XRInterface; }
+
+    /**
+     * Registers a new {@link XRTracker} that tracks a physical object.
+     */
+    static addTracker(tracker: XRTracker): void { _C($(), 1317, tracker); }
+
+    /**
+     * Removes this `tracker`.
+     */
+    static removeTracker(tracker: XRTracker): void { _C($(), 9979, tracker); }
+
+    /**
+     * Returns a dictionary of trackers for `trackerTypes`.
+     */
+    static getTrackers(trackerTypes: number): GodotDictionary { return _C($(), 6866, trackerTypes) as GodotDictionary; }
+
+    /**
+     * Returns the positional tracker with the given `trackerName`.
+     */
+    static getTracker(trackerName: StringName): XRTracker { return _C($(), 6860, trackerName) as XRTracker; }
+
+    /**
+     * The scale of the game world compared to the real world. By default, most AR/VR platforms assume that 1 game unit corresponds to 1 real world meter.
+     */
+    static get worldScale(): number { return _C($(), 7163) as number; }
+    static set worldScale(v: number) { _C($(), 13383, v); }
+
+    /**
+     * The current origin of our tracking space in the virtual world. This is used by the renderer to properly position the camera with new tracking data.
+     * **Note:** This property is managed by the current {@link XROrigin3D} node. It is exposed for access from GDExtensions.
+     */
+    static get worldOrigin(): Transform3D { return _C($(), 7162) as Transform3D; }
+    static set worldOrigin(v: Transform3D) { _C($(), 13382, v); }
+
+    /**
+     * If set to `true`, the scene will be rendered as if the camera is locked to the {@link XROrigin3D}.
+     * **Note:** This doesn't provide a very comfortable experience for users. This setting exists for doing benchmarking or automated testing, where you want to control what is rendered via code.
+     */
+    static get cameraLockedToOrigin(): boolean { return _C($(), 7813) as boolean; }
+    static set cameraLockedToOrigin(v: boolean) { _C($(), 10787, v); }
+
+    /**
+     * The primary {@link XRInterface} currently bound to the {@link XRServer}.
+     */
+    static get primaryInterface(): XRInterface { return _C($(), 6005) as XRInterface; }
+    static set primaryInterface(v: XRInterface) { _C($(), 12410, v); }
+
+    /**
+     * Emitted when the reference frame transform changes.
+     */
+    static get referenceFrameChanged(): Signal<() => void> { return _G($(), 9773) as Signal<() => void>; }
+    static set referenceFrameChanged(v: (() => void) | null) { _G($(), 9773, v); }
+
+    /**
+     * Emitted when a new interface has been added.
+     */
+    static get interfaceAdded(): Signal<(interfaceName: StringName) => void> { return _G($(), 7685) as Signal<(interfaceName: StringName) => void>; }
+    static set interfaceAdded(v: ((interfaceName: StringName) => void) | null) { _G($(), 7685, v); }
+
+    /**
+     * Emitted when an interface is removed.
+     */
+    static get interfaceRemoved(): Signal<(interfaceName: StringName) => void> { return _G($(), 7687) as Signal<(interfaceName: StringName) => void>; }
+    static set interfaceRemoved(v: ((interfaceName: StringName) => void) | null) { _G($(), 7687, v); }
+
+    /**
+     * Emitted when a new tracker has been added. If you don't use a fixed number of controllers or if you're using {@link XRAnchor3D}s for an AR solution, it is important to react to this signal to add the appropriate {@link XRController3D} or {@link XRAnchor3D} nodes related to this new tracker.
+     */
+    static get trackerAdded(): Signal<(trackerName: StringName, type: number) => void> { return _G($(), 14373) as Signal<(trackerName: StringName, type: number) => void>; }
+    static set trackerAdded(v: ((trackerName: StringName, type: number) => void) | null) { _G($(), 14373, v); }
+
+    /**
+     * Emitted when an existing tracker has been updated. This can happen if the user switches controllers.
+     */
+    static get trackerUpdated(): Signal<(trackerName: StringName, type: number) => void> { return _G($(), 14375) as Signal<(trackerName: StringName, type: number) => void>; }
+    static set trackerUpdated(v: ((trackerName: StringName, type: number) => void) | null) { _G($(), 14375, v); }
+
+    /**
+     * Emitted when a tracker is removed. You should remove any {@link XRController3D} or {@link XRAnchor3D} points if applicable. This is not mandatory, the nodes simply become inactive and will be made active again when a new tracker becomes available (i.e. a new controller is switched on that takes the place of the previous one).
+     */
+    static get trackerRemoved(): Signal<(trackerName: StringName, type: number) => void> { return _G($(), 14374) as Signal<(trackerName: StringName, type: number) => void>; }
+    static set trackerRemoved(v: ((trackerName: StringName, type: number) => void) | null) { _G($(), 14374, v); }
+
+    /**
+     * Emitted when the world origin transform changes.
+     */
+    static get worldOriginChanged(): Signal<() => void> { return _G($(), 14924) as Signal<() => void>; }
+    static set worldOriginChanged(v: (() => void) | null) { _G($(), 14924, v); }
+
+    static readonly name = _R(989, XRServer);
+}
+
+export const TrackerType = {
+    /**
+     * The tracker tracks the location of the player's head. This is usually a location centered between the player's eyes. Note that for handheld AR devices this can be the current location of the device.
+     */
+    TRACKER_HEAD: 1,
+    /**
+     * The tracker tracks the location of a controller.
+     */
+    TRACKER_CONTROLLER: 2,
+    /**
+     * The tracker tracks the location of a base station.
+     */
+    TRACKER_BASESTATION: 4,
+    /**
+     * The tracker tracks the location and size of an AR anchor.
+     */
+    TRACKER_ANCHOR: 8,
+    /**
+     * The tracker tracks the location and joints of a hand.
+     */
+    TRACKER_HAND: 16,
+    /**
+     * The tracker tracks the location and joints of a body.
+     */
+    TRACKER_BODY: 32,
+    /**
+     * The tracker tracks the expressions of a face.
+     */
+    TRACKER_FACE: 64,
+    /**
+     * Used internally to filter trackers of any known type.
+     */
+    TRACKER_ANY_KNOWN: 127,
+    /**
+     * Used internally if we haven't set the tracker type yet.
+     */
+    TRACKER_UNKNOWN: 128,
+    /**
+     * Used internally to select all trackers.
+     */
+    TRACKER_ANY: 255,
+} as const;
+
+export type TrackerType = (typeof TrackerType)[keyof typeof TrackerType];
+
+export const RotationMode = {
+    /**
+     * Fully reset the orientation of the HMD. Regardless of what direction the user is looking to in the real world. The user will look dead ahead in the virtual world.
+     */
+    RESET_FULL_ROTATION: 0,
+    /**
+     * Resets the orientation but keeps the tilt of the device. So if we're looking down, we keep looking down but heading will be reset.
+     */
+    RESET_BUT_KEEP_TILT: 1,
+    /**
+     * Does not reset the orientation of the HMD, only the position of the player gets centered.
+     */
+    DONT_RESET_ROTATION: 2,
+} as const;
+
+export type RotationMode = (typeof RotationMode)[keyof typeof RotationMode];
+

package/gen/classes/XRTracker.ts

@@ -0,0 +1,40 @@
+// 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 { StringName } from '../heap-types/index.ts';
+import type { TrackerType } from './XRServer.ts';
+
+/**
+ * This object is the base of all XR trackers.
+ */
+export class XRTracker extends RefCounted {
+
+    /**
+     * The type of tracker.
+     */
+    get type(): TrackerType { return _C(this, 6865) as TrackerType; }
+    set type(v: TrackerType) { _C(this, 13125, v); }
+
+    /**
+     * The unique name of this tracker. The trackers that are available differ between various XR runtimes and can often be configured by the user. Godot maintains a number of reserved names that it expects the {@link XRInterface} to implement if applicable:
+     * - `"head"` identifies the {@link XRPositionalTracker} of the player's head
+     * - `"left_hand"` identifies the {@link XRControllerTracker} in the player's left hand
+     * - `"right_hand"` identifies the {@link XRControllerTracker} in the player's right hand
+     * - `"/user/hand_tracker/left"` identifies the {@link XRHandTracker} for the player's left hand
+     * - `"/user/hand_tracker/right"` identifies the {@link XRHandTracker} for the player's right hand
+     * - `"/user/body_tracker"` identifies the {@link XRBodyTracker} for the player's body
+     * - `"/user/face_tracker"` identifies the {@link XRFaceTracker} for the player's face
+     */
+    get name(): StringName { return _C(this, 6863) as StringName; }
+    set name(v: StringName) { _C(this, 13123, v); }
+
+    /**
+     * The description of this tracker.
+     */
+    get description(): string { return _C(this, 6861) as string; }
+    set description(v: string) { _C(this, 13121, v); }
+
+    static readonly name = _R(990, XRTracker);
+}

package/gen/classes/XRVRS.ts

@@ -0,0 +1,40 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Object } from './Object.ts';
+import type { PackedVector2Array, RID } from '../heap-types/index.ts';
+import type { Rect2i, Vector2 } from '../value-types/index.ts';
+
+/**
+ * This class is used by various XR interfaces to generate VRS textures that can be used to speed up rendering.
+ */
+export class XRVRS extends Object {
+    constructor(name = 991) { super(name); }
+
+    /**
+     * Generates the VRS texture based on a render `targetSize` adjusted by our VRS tile size. For each eyes focal point passed in `eyeFoci` a layer is created. Focal point should be in NDC.
+     * The result will be cached, requesting a VRS texture with unchanged parameters and settings will return the cached RID.
+     */
+    makeVrsTexture(targetSize: Vector2, eyeFoci: PackedVector2Array): RID { return _C(this, 8744, targetSize, eyeFoci) as RID; }
+
+    /**
+     * The minimum radius around the focal point where full quality is guaranteed if VRS is used as a percentage of screen size.
+     */
+    get vrsMinRadius(): number { return _C(this, 7134) as number; }
+    set vrsMinRadius(v: number) { _C(this, 13359, v); }
+
+    /**
+     * The strength used to calculate the VRS density map. The greater this value, the more noticeable VRS is.
+     */
+    get vrsStrength(): number { return _C(this, 7137) as number; }
+    set vrsStrength(v: number) { _C(this, 13362, v); }
+
+    /**
+     * The render region that the VRS texture will be scaled to when generated.
+     */
+    get vrsRenderRegion(): Rect2i { return _C(this, 7136) as Rect2i; }
+    set vrsRenderRegion(v: Rect2i) { _C(this, 13361, v); }
+
+    static readonly name = _R(991, XRVRS);
+}

package/gen/classes/ZIPPacker.ts

@@ -0,0 +1,114 @@
+// 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 { PackedByteArray } from '../heap-types/index.ts';
+import type { UnixPermissionFlags } from './FileAccess.ts';
+
+/**
+ * This class implements a writer that allows storing the multiple blobs in a ZIP archive. See also {@link ZIPReader} and {@link PCKPacker}.
+ *
+ * ```text
+ *
+ * # Create a ZIP archive with a single file at its root.
+ * func write_zip_file():
+ * 	var writer = ZIPPacker.new()
+ * 	var err = writer.open("user://archive.zip")
+ * 	if err != OK:
+ * 		return err
+ * 	writer.start_file("hello.txt")
+ * 	writer.write_file("Hello World".to_utf8_buffer())
+ * 	writer.close_file()
+ *
+ * 	writer.close()
+ * 	return OK
+ *
+ * ```
+ */
+export class ZIPPacker extends RefCounted {
+    constructor(name = 992) { super(name); }
+
+    /**
+     * Opens a zip file for writing at the given path using the specified write mode.
+     * This must be called before everything else.
+     */
+    open(path: string, append?: ZipAppend /* = 0 */): Error { return _C(this, 9189, path, append) as Error; }
+
+    /**
+     * Adds directory to the archive. If `modifiedTime` is set to `0`, current system time is used.
+     * **Note:** Directories are automatically created when {@link startFile} is called, use this function before adding files to create directories with custom permissions and modification time.
+     */
+    addDirectory(path: string, permissions?: UnixPermissionFlags /* = 493 */, modifiedTime?: number /* = 0,  uint64 */): Error { return _C(this, 1208, path, permissions, modifiedTime) as Error; }
+
+    /**
+     * Starts writing to a file within the archive. Only one file can be written at the same time. If `modifiedTime` is set to `0`, current system time is used.
+     * Must be called after {@link open}.
+     */
+    startFile(path: string, permissions?: UnixPermissionFlags /* = 420 */, modifiedTime?: number /* = 0,  uint64 */): Error { return _C(this, 13835, path, permissions, modifiedTime) as Error; }
+
+    /**
+     * Write the given `data` to the file.
+     * Needs to be called after {@link startFile}.
+     */
+    writeFile(data: PackedByteArray): Error { return _C(this, 14936, data) as Error; }
+
+    /**
+     * Stops writing to a file within the archive.
+     * It will fail if there is no open file.
+     */
+    closeFile(): Error { return _C(this, 2332) as Error; }
+
+    /**
+     * Closes the underlying resources used by this instance.
+     */
+    close(): Error { return _C(this, 2331) as Error; }
+
+    /**
+     * The compression level used when {@link startFile} is called. Use {@link ZIPPacker.CompressionLevel} as a reference.
+     */
+    get compressionLevel(): number { return _C(this, 4252) as number; }
+    set compressionLevel(v: number) { _C(this, 10933, v); }
+
+    static readonly name = _R(992, ZIPPacker);
+}
+
+export const ZipAppend = {
+    /**
+     * Create a new zip archive at the given path.
+     */
+    APPEND_CREATE: 0,
+    /**
+     * Append a new zip archive to the end of the already existing file at the given path.
+     */
+    APPEND_CREATEAFTER: 1,
+    /**
+     * Add new files to the existing zip archive at the given path.
+     */
+    APPEND_ADDINZIP: 2,
+} as const;
+
+export type ZipAppend = (typeof ZipAppend)[keyof typeof ZipAppend];
+
+export const CompressionLevel = {
+    /**
+     * Start a file with the default Deflate compression level (`6`). This is a good compromise between speed and file size.
+     */
+    COMPRESSION_DEFAULT: -1,
+    /**
+     * Start a file with no compression. This is also known as the "Store" compression mode and is the fastest method of packing files inside a ZIP archive. Consider using this mode for files that are already compressed (such as JPEG, PNG, MP3, or Ogg Vorbis files).
+     */
+    COMPRESSION_NONE: 0,
+    /**
+     * Start a file with the fastest Deflate compression level (`1`). This is fast to compress, but results in larger file sizes than {@link COMPRESSION_DEFAULT}. Decompression speed is generally unaffected by the chosen compression level.
+     */
+    COMPRESSION_FAST: 1,
+    /**
+     * Start a file with the best Deflate compression level (`9`). This is slow to compress, but results in smaller file sizes than {@link COMPRESSION_DEFAULT}. Decompression speed is generally unaffected by the chosen compression level.
+     */
+    COMPRESSION_BEST: 9,
+} as const;
+
+export type CompressionLevel = (typeof CompressionLevel)[keyof typeof CompressionLevel];
+