@ringozz/godot 0.1.0

package/gen/classes/PlaceholderCubemapArray.ts

@@ -0,0 +1,17 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { PlaceholderTextureLayered } from './PlaceholderTextureLayered.ts';
+
+/**
+ * This class replaces a {@link CubemapArray} or a {@link CubemapArray}-derived class in 2 conditions:
+ * - In dedicated server mode, where the image data shouldn't affect game logic. This allows reducing the exported PCK's size significantly.
+ * - When the {@link CubemapArray}-derived class is missing, for example when using a different engine version.
+ * **Note:** This class is not intended for rendering or for use in shaders. Operations like calculating UV are not guaranteed to work.
+ */
+export class PlaceholderCubemapArray extends PlaceholderTextureLayered {
+    constructor(name = 590) { super(name); }
+
+    static readonly name = _R(590, PlaceholderCubemapArray);
+}

package/gen/classes/PlaceholderMaterial.ts

@@ -0,0 +1,16 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Material } from './Material.ts';
+
+/**
+ * This class is used when loading a project that uses a {@link Material} subclass in 2 conditions:
+ * - When running the project exported in dedicated server mode, only the texture's dimensions are kept (as they may be relied upon for gameplay purposes or positioning of other elements). This allows reducing the exported PCK's size significantly.
+ * - When this subclass is missing due to using a different engine version or build (e.g. modules disabled).
+ */
+export class PlaceholderMaterial extends Material {
+    constructor(name = 591) { super(name); }
+
+    static readonly name = _R(591, PlaceholderMaterial);
+}

package/gen/classes/PlaceholderMesh.ts

@@ -0,0 +1,23 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Mesh } from './Mesh.ts';
+import type { AABB } from '../value-types/index.ts';
+
+/**
+ * This class is used when loading a project that uses a {@link Mesh} subclass in 2 conditions:
+ * - When running the project exported in dedicated server mode, only the texture's dimensions are kept (as they may be relied upon for gameplay purposes or positioning of other elements). This allows reducing the exported PCK's size significantly.
+ * - When this subclass is missing due to using a different engine version or build (e.g. modules disabled).
+ */
+export class PlaceholderMesh extends Mesh {
+    constructor(name = 592) { super(name); }
+
+    /**
+     * The smallest {@link AABB} enclosing this mesh in local space.
+     */
+    get aabb(): AABB { return _C(this, 3659) as AABB; }
+    set aabb(v: AABB) { _C(this, 10395, v); }
+
+    static readonly name = _R(592, PlaceholderMesh);
+}

package/gen/classes/PlaceholderTexture2D.ts

@@ -0,0 +1,24 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Texture2D } from './Texture2D.ts';
+import type { Vector2 } from '../value-types/index.ts';
+
+/**
+ * This class is used when loading a project that uses a {@link Texture2D} subclass in 2 conditions:
+ * - When running the project exported in dedicated server mode, only the texture's dimensions are kept (as they may be relied upon for gameplay purposes or positioning of other elements). This allows reducing the exported PCK's size significantly.
+ * - When this subclass is missing due to using a different engine version or build (e.g. modules disabled).
+ * **Note:** This is not intended to be used as an actual texture for rendering. It is not guaranteed to work like one in shaders or materials (for example when calculating UV).
+ */
+export class PlaceholderTexture2D extends Texture2D {
+    constructor(name = 593) { super(name); }
+
+    /**
+     * The texture's size (in pixels).
+     */
+    get size(): Vector2 { return _C(this, 6399) as Vector2; }
+    set size(v: Vector2) { _C(this, 12752, v); }
+
+    static readonly name = _R(593, PlaceholderTexture2D);
+}

package/gen/classes/PlaceholderTexture2DArray.ts

@@ -0,0 +1,17 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { PlaceholderTextureLayered } from './PlaceholderTextureLayered.ts';
+
+/**
+ * This class is used when loading a project that uses a {@link Texture2D} subclass in 2 conditions:
+ * - When running the project exported in dedicated server mode, only the texture's dimensions are kept (as they may be relied upon for gameplay purposes or positioning of other elements). This allows reducing the exported PCK's size significantly.
+ * - When this subclass is missing due to using a different engine version or build (e.g. modules disabled).
+ * **Note:** This is not intended to be used as an actual texture for rendering. It is not guaranteed to work like one in shaders or materials (for example when calculating UV).
+ */
+export class PlaceholderTexture2DArray extends PlaceholderTextureLayered {
+    constructor(name = 594) { super(name); }
+
+    static readonly name = _R(594, PlaceholderTexture2DArray);
+}

package/gen/classes/PlaceholderTexture3D.ts

@@ -0,0 +1,24 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Texture3D } from './Texture3D.ts';
+import type { Vector3i } from '../value-types/index.ts';
+
+/**
+ * This class is used when loading a project that uses a {@link Texture3D} subclass in 2 conditions:
+ * - When running the project exported in dedicated server mode, only the texture's dimensions are kept (as they may be relied upon for gameplay purposes or positioning of other elements). This allows reducing the exported PCK's size significantly.
+ * - When this subclass is missing due to using a different engine version or build (e.g. modules disabled).
+ * **Note:** This is not intended to be used as an actual texture for rendering. It is not guaranteed to work like one in shaders or materials (for example when calculating UV).
+ */
+export class PlaceholderTexture3D extends Texture3D {
+    constructor(name = 595) { super(name); }
+
+    /**
+     * The texture's size (in pixels).
+     */
+    get size(): Vector3i { return _C(this, 6399) as Vector3i; }
+    set size(v: Vector3i) { _C(this, 12752, v); }
+
+    static readonly name = _R(595, PlaceholderTexture3D);
+}

package/gen/classes/PlaceholderTextureLayered.ts

@@ -0,0 +1,29 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { TextureLayered } from './TextureLayered.ts';
+import type { Vector2i } from '../value-types/index.ts';
+
+/**
+ * This class is used when loading a project that uses a {@link TextureLayered} subclass in 2 conditions:
+ * - When running the project exported in dedicated server mode, only the texture's dimensions are kept (as they may be relied upon for gameplay purposes or positioning of other elements). This allows reducing the exported PCK's size significantly.
+ * - When this subclass is missing due to using a different engine version or build (e.g. modules disabled).
+ * **Note:** This is not intended to be used as an actual texture for rendering. It is not guaranteed to work like one in shaders or materials (for example when calculating UV).
+ */
+export class PlaceholderTextureLayered extends TextureLayered {
+
+    /**
+     * The size of each texture layer (in pixels).
+     */
+    get size(): Vector2i { return _C(this, 6399) as Vector2i; }
+    set size(v: Vector2i) { _C(this, 12752, v); }
+
+    /**
+     * The number of layers in the texture array.
+     */
+    get layers(): number { return _C(this, 5327) as number; }
+    set layers(v: number) { _C(this, 11888, v); }
+
+    static readonly name = _R(596, PlaceholderTextureLayered);
+}

package/gen/classes/PlaneMesh.ts

@@ -0,0 +1,64 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { PrimitiveMesh } from './PrimitiveMesh.ts';
+import type { Vector2, Vector3 } from '../value-types/index.ts';
+
+/**
+ * Class representing a planar {@link PrimitiveMesh}. This flat mesh does not have a thickness. By default, this mesh is aligned on the X and Z axes; this default rotation isn't suited for use with billboarded materials. For billboarded materials, change {@link orientation} to {@link FACE_Z}.
+ * **Note:** When using a large textured {@link PlaneMesh} (e.g. as a floor), you may stumble upon UV jittering issues depending on the camera angle. To solve this, increase {@link subdivideDepth} and {@link subdivideWidth} until you no longer notice UV jittering.
+ */
+export class PlaneMesh extends PrimitiveMesh {
+    constructor(name = 597) { super(name); }
+
+    /**
+     * Size of the generated plane.
+     */
+    get size(): Vector2 { return _C(this, 6399) as Vector2; }
+    set size(v: Vector2) { _C(this, 12752, v); }
+
+    /**
+     * Number of subdivision along the X axis.
+     */
+    get subdivideWidth(): number { return _C(this, 6600) as number; }
+    set subdivideWidth(v: number) { _C(this, 12926, v); }
+
+    /**
+     * Number of subdivision along the Z axis.
+     */
+    get subdivideDepth(): number { return _C(this, 6598) as number; }
+    set subdivideDepth(v: number) { _C(this, 12924, v); }
+
+    /**
+     * Offset of the generated plane. Useful for particles.
+     */
+    get centerOffset(): Vector3 { return _C(this, 4129) as Vector3; }
+    set centerOffset(v: Vector3) { _C(this, 10842, v); }
+
+    /**
+     * Direction that the {@link PlaneMesh} is facing.
+     */
+    get orientation(): Orientation { return _C(this, 5738) as Orientation; }
+    set orientation(v: Orientation) { _C(this, 12200, v); }
+
+    static readonly name = _R(597, PlaneMesh);
+}
+
+export const Orientation = {
+    /**
+     * {@link PlaneMesh} will face the positive X-axis.
+     */
+    FACE_X: 0,
+    /**
+     * {@link PlaneMesh} will face the positive Y-axis. This matches the behavior of the {@link PlaneMesh} in Godot 3.x.
+     */
+    FACE_Y: 1,
+    /**
+     * {@link PlaneMesh} will face the positive Z-axis. This matches the behavior of the QuadMesh in Godot 3.x.
+     */
+    FACE_Z: 2,
+} as const;
+
+export type Orientation = (typeof Orientation)[keyof typeof Orientation];
+

package/gen/classes/PointLight2D.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 { Light2D } from './Light2D.ts';
+import type { Vector2 } from '../value-types/index.ts';
+import type { Texture2D } from './Texture2D.ts';
+
+/**
+ * Casts light in a 2D environment. This light's shape is defined by a (usually grayscale) texture.
+ */
+export class PointLight2D extends Light2D {
+    constructor(name = 598) { super(name); }
+
+    /**
+     * {@link Texture2D} used for the light's appearance.
+     */
+    get texture(): Texture2D { return _C(this, 6726) as Texture2D; }
+    set texture(v: Texture2D) { _C(this, 13024, v); }
+
+    /**
+     * The offset of the light's {@link texture}.
+     */
+    get offset(): Vector2 { return _C(this, 6740) as Vector2; }
+    set offset(v: Vector2) { _C(this, 13037, v); }
+
+    /**
+     * The {@link texture}'s scale factor.
+     */
+    get textureScale(): number { return _C(this, 6751) as number; }
+    set textureScale(v: number) { _C(this, 13047, v); }
+
+    /**
+     * The height of the light. Used with 2D normal mapping. The units are in pixels, e.g. if the height is 100, then it will illuminate an object 100 pixels away at a 45° angle to the plane.
+     */
+    get height(): number { return _C(this, 5024) as number; }
+    set height(v: number) { _C(this, 11609, v); }
+
+    static readonly name = _R(598, PointLight2D);
+}

package/gen/classes/PointMesh.ts

@@ -0,0 +1,16 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { PrimitiveMesh } from './PrimitiveMesh.ts';
+
+/**
+ * A {@link PointMesh} is a primitive mesh composed of a single point. Instead of relying on triangles, points are rendered as a single rectangle on the screen with a constant size. They are intended to be used with particle systems, but can also be used as a cheap way to render billboarded sprites (for example in a point cloud).
+ * In order to be displayed, point meshes must be used with a material that has a point size. The point size can be accessed in a shader with the `POINT_SIZE` built-in, or in a {@link BaseMaterial3D} by setting the {@link BaseMaterial3D.usePointSize} and {@link BaseMaterial3D.pointSize} properties.
+ * **Note:** When using point meshes, properties that normally affect vertices will be ignored, including {@link BaseMaterial3D.billboardMode}, {@link BaseMaterial3D.grow}, and {@link BaseMaterial3D.cullMode}.
+ */
+export class PointMesh extends PrimitiveMesh {
+    constructor(name = 599) { super(name); }
+
+    static readonly name = _R(599, PointMesh);
+}

package/gen/classes/Polygon2D.ts

@@ -0,0 +1,150 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Node2D } from './Node2D.ts';
+import type { GodotArray, NodePath, PackedColorArray, PackedFloat32Array, PackedVector2Array } from '../heap-types/index.ts';
+import type { Color, Vector2 } from '../value-types/index.ts';
+import type { Texture2D } from './Texture2D.ts';
+
+/**
+ * A Polygon2D is defined by a set of points. Each point is connected to the next, with the final point being connected to the first, resulting in a closed polygon. Polygon2Ds can be filled with color (solid or gradient) or filled with a given texture.
+ */
+export class Polygon2D extends Node2D {
+    constructor(name = 600) { super(name); }
+
+    /**
+     * Adds a bone with the specified `path` and `weights`.
+     */
+    addBone(path: NodePath, weights: PackedFloat32Array): void { _C(this, 1187, path, weights); }
+
+    /**
+     * Returns the number of bones in this {@link Polygon2D}.
+     */
+    getBoneCount(): number { return _C(this, 3961) as number; }
+
+    /**
+     * Returns the path to the node associated with the specified bone.
+     */
+    getBonePath(index: number): NodePath { return _C(this, 3974, index) as NodePath; }
+
+    /**
+     * Returns the weight values of the specified bone.
+     */
+    getBoneWeights(index: number): PackedFloat32Array { return _C(this, 3983, index) as PackedFloat32Array; }
+
+    /**
+     * Removes the specified bone from this {@link Polygon2D}.
+     */
+    eraseBone(index: number): void { _C(this, 3156, index); }
+
+    /**
+     * Removes all bones from this {@link Polygon2D}.
+     */
+    clearBones(): void { _C(this, 2238); }
+
+    /**
+     * Sets the path to the node associated with the specified bone.
+     */
+    setBonePath(index: number, path: NodePath): void { _C(this, 10712, index, path); }
+
+    /**
+     * Sets the weight values for the specified bone.
+     */
+    setBoneWeights(index: number, weights: PackedFloat32Array): void { _C(this, 10721, index, weights); }
+
+    /**
+     * The polygon's fill color. If {@link texture} is set, it will be multiplied by this color. It will also be the default color for vertices not set in {@link vertexColors}.
+     */
+    get color(): Color { return _C(this, 4219) as Color; }
+    set color(v: Color) { _C(this, 10905, v); }
+
+    /**
+     * The offset applied to each vertex.
+     */
+    get offset(): Vector2 { return _C(this, 5703) as Vector2; }
+    set offset(v: Vector2) { _C(this, 12170, v); }
+
+    /**
+     * If `true`, polygon edges will be anti-aliased.
+     */
+    get antialiased(): boolean { return _C(this, 3775) as boolean; }
+    set antialiased(v: boolean) { _C(this, 10513, v); }
+
+    /**
+     * The polygon's fill texture. Use {@link uv} to set texture coordinates.
+     */
+    get texture(): Texture2D { return _C(this, 6726) as Texture2D; }
+    set texture(v: Texture2D) { _C(this, 13024, v); }
+
+    /**
+     * Amount to offset the polygon's {@link texture}. If set to `Vector2(0, 0)`, the texture's origin (its top-left corner) will be placed at the polygon's position.
+     */
+    get textureOffset(): Vector2 { return _C(this, 6740) as Vector2; }
+    set textureOffset(v: Vector2) { _C(this, 13037, v); }
+
+    /**
+     * Amount to multiply the {@link uv} coordinates when using {@link texture}. Larger values make the texture smaller, and vice versa.
+     */
+    get textureScale(): Vector2 { return _C(this, 6751) as Vector2; }
+    set textureScale(v: Vector2) { _C(this, 13047, v); }
+
+    /**
+     * The texture's rotation in radians.
+     */
+    get textureRotation(): number { return _C(this, 6748) as number; }
+    set textureRotation(v: number) { _C(this, 13045, v); }
+
+    /**
+     * Path to a {@link Skeleton2D} node used for skeleton-based deformations of this polygon. If empty or invalid, skeletal deformations will not be used.
+     */
+    get skeleton(): NodePath { return _C(this, 6405) as NodePath; }
+    set skeleton(v: NodePath) { _C(this, 12757, v); }
+
+    /**
+     * If `true`, the polygon will be inverted, containing the area outside the defined points and extending to the {@link invertBorder}.
+     */
+    get invertEnabled(): boolean { return _C(this, 5166) as boolean; }
+    set invertEnabled(v: boolean) { _C(this, 11749, v); }
+
+    /**
+     * Added padding applied to the bounding box when {@link invertEnabled} is set to `true`. Setting this value too small may result in a "Bad Polygon" error.
+     */
+    get invertBorder(): number { return _C(this, 5165) as number; }
+    set invertBorder(v: number) { _C(this, 11748, v); }
+
+    /**
+     * The polygon's list of vertices. The final point will be connected to the first.
+     */
+    get polygon(): PackedVector2Array { return _C(this, 5962) as PackedVector2Array; }
+    set polygon(v: PackedVector2Array) { _C(this, 12373, v); }
+
+    /**
+     * Texture coordinates for each vertex of the polygon. There should be one UV value per polygon vertex. If there are fewer, undefined vertices will use `Vector2(0, 0)`.
+     */
+    get uv(): PackedVector2Array { return _C(this, 7002) as PackedVector2Array; }
+    set uv(v: PackedVector2Array) { _C(this, 13251, v); }
+
+    /**
+     * Color for each vertex. Colors are interpolated between vertices, resulting in smooth gradients. There should be one per polygon vertex. If there are fewer, undefined vertices will use {@link color}.
+     */
+    get vertexColors(): PackedColorArray { return _C(this, 7050) as PackedColorArray; }
+    set vertexColors(v: PackedColorArray) { _C(this, 13291, v); }
+
+    /**
+     * The list of polygons, in case more than one is being represented. Every individual polygon is stored as a {@link PackedInt32Array} where each {@link int} is an index to a point in {@link polygon}. If empty, this property will be ignored, and the resulting single polygon will be composed of all points in {@link polygon}, using the order they are stored in.
+     */
+    get polygons(): GodotArray { return _C(this, 5964) as GodotArray; }
+    set polygons(v: GodotArray) { _C(this, 12374, v); }
+
+    get bones(): GodotArray { return _C(this, 996) as GodotArray; }
+    set bones(v: GodotArray) { _C(this, 1022, v); }
+
+    /**
+     * Number of internal vertices, used for UV mapping.
+     */
+    get internalVertexCount(): number { return _C(this, 5151) as number; }
+    set internalVertexCount(v: number) { _C(this, 11739, v); }
+
+    static readonly name = _R(600, Polygon2D);
+}

package/gen/classes/PolygonOccluder3D.ts

@@ -0,0 +1,23 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Occluder3D } from './Occluder3D.ts';
+import type { PackedVector2Array } from '../heap-types/index.ts';
+
+/**
+ * {@link PolygonOccluder3D} stores a polygon shape that can be used by the engine's occlusion culling system. When an {@link OccluderInstance3D} with a {@link PolygonOccluder3D} is selected in the editor, an editor will appear at the top of the 3D viewport so you can add/remove points. All points must be placed on the same 2D plane, which means it is not possible to create arbitrary 3D shapes with a single {@link PolygonOccluder3D}. To use arbitrary 3D shapes as occluders, use {@link ArrayOccluder3D} or {@link OccluderInstance3D}'s baking feature instead.
+ * See {@link OccluderInstance3D}'s documentation for instructions on setting up occlusion culling.
+ */
+export class PolygonOccluder3D extends Occluder3D {
+    constructor(name = 601) { super(name); }
+
+    /**
+     * The polygon to use for occlusion culling. The polygon can be convex or concave, but it should have as few points as possible to maximize performance.
+     * The polygon must *not* have intersecting lines. Otherwise, triangulation will fail (with an error message printed).
+     */
+    get polygon(): PackedVector2Array { return _C(this, 5962) as PackedVector2Array; }
+    set polygon(v: PackedVector2Array) { _C(this, 12373, v); }
+
+    static readonly name = _R(601, PolygonOccluder3D);
+}

package/gen/classes/PolygonPathFinder.ts

@@ -0,0 +1,61 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Resource } from './Resource.ts';
+import type { GodotDictionary, PackedInt32Array, PackedVector2Array } from '../heap-types/index.ts';
+import type { Rect2, Vector2 } from '../value-types/index.ts';
+
+export class PolygonPathFinder extends Resource {
+    constructor(name = 602) { super(name); }
+
+    /**
+     * Sets up {@link PolygonPathFinder} with an array of points that define the vertices of the polygon, and an array of indices that determine the edges of the polygon.
+     * The length of `connections` must be even, returns an error if odd.
+     *
+     *
+     * ```gdscript
+     *
+     * var polygon_path_finder = PolygonPathFinder.new()
+     * var points = [Vector2(0.0, 0.0), Vector2(1.0, 0.0), Vector2(0.0, 1.0)]
+     * var connections = [0, 1, 1, 2, 2, 0]
+     * polygon_path_finder.setup(points, connections)
+     *
+     * ```
+     */
+    setup(points: PackedVector2Array, connections: PackedInt32Array): void { _C(this, 13415, points, connections); }
+
+    findPath(from: Vector2, to: Vector2): PackedVector2Array { return _C(this, 3298, from, to) as PackedVector2Array; }
+
+    getIntersections(from: Vector2, to: Vector2): PackedVector2Array { return _C(this, 5159, from, to) as PackedVector2Array; }
+
+    getClosestPoint(point: Vector2): Vector2 { return _C(this, 4174, point) as Vector2; }
+
+    /**
+     * Returns `true` if `point` falls inside the polygon area.
+     *
+     *
+     * ```gdscript
+     *
+     * var polygon_path_finder = PolygonPathFinder.new()
+     * var points = [Vector2(0.0, 0.0), Vector2(1.0, 0.0), Vector2(0.0, 1.0)]
+     * var connections = [0, 1, 1, 2, 2, 0]
+     * polygon_path_finder.setup(points, connections)
+     * print(polygon_path_finder.is_point_inside(Vector2(0.2, 0.2))) # Prints true
+     * print(polygon_path_finder.is_point_inside(Vector2(1.0, 1.0))) # Prints false
+     *
+     * ```
+     */
+    isPointInside(point: Vector2): boolean { return _C(this, 8187, point) as boolean; }
+
+    setPointPenalty(idx: number, penalty: number): void { _C(this, 12359, idx, penalty); }
+
+    getPointPenalty(idx: number): number { return _C(this, 5950, idx) as number; }
+
+    getBounds(): Rect2 { return _C(this, 3997) as Rect2; }
+
+    get data(): GodotDictionary { return _C(this, 1000) as GodotDictionary; }
+    set data(v: GodotDictionary) { _C(this, 1026, v); }
+
+    static readonly name = _R(602, PolygonPathFinder);
+}

package/gen/classes/Popup.ts

@@ -0,0 +1,22 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Window } from './Window.ts';
+import type { Signal } from '../heap-types/index.ts';
+
+/**
+ * {@link Popup} is a base class for contextual windows and panels with fixed position. It's a modal by default (see {@link Window.popupWindow}) and provides methods for implementing custom popup behavior.
+ * **Note:** {@link Popup} is invisible by default. To make it visible, call one of the `popup_*` methods from {@link Window} on the node, such as {@link Window.popupCenteredClamped}.
+ */
+export class Popup extends Window {
+    constructor(name = 603) { super(name); }
+
+    /**
+     * Emitted when the popup is hidden.
+     */
+    get popupHide(): Signal<() => void> { return _G(this, 9493) as Signal<() => void>; }
+    set popupHide(v: (() => void) | null) { _G(this, 9493, v); }
+
+    static readonly name = _R(603, Popup);
+}