@ringozz/godot 0.1.0

package/gen/classes/JointLimitation3D.ts

@@ -0,0 +1,14 @@
+// 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';
+
+/**
+ * The limitation is attached to each joint and limits the rotation of the bone.
+ */
+export class JointLimitation3D extends Resource {
+    constructor(name = 381) { super(name); }
+
+    static readonly name = _R(381, JointLimitation3D);
+}

package/gen/classes/JointLimitationCone3D.ts

@@ -0,0 +1,21 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { JointLimitation3D } from './JointLimitation3D.ts';
+
+/**
+ * A cone shape limitation that interacts with {@link ChainIK3D}.
+ */
+export class JointLimitationCone3D extends JointLimitation3D {
+    constructor(name = 382) { super(name); }
+
+    /**
+     * The radius range of the hole made by the cone.
+     * `0` degrees makes a sphere without hole, `180` degrees makes a hemisphere, and `360` degrees become empty (no limitation).
+     */
+    get angle(): number { return _C(this, 3749) as number; }
+    set angle(v: number) { _C(this, 10492, v); }
+
+    static readonly name = _R(382, JointLimitationCone3D);
+}

package/gen/classes/KinematicCollision2D.ts

@@ -0,0 +1,83 @@
+// 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 { RID } from '../heap-types/index.ts';
+import type { Vector2 } from '../value-types/index.ts';
+import type { Object } from './Object.ts';
+
+/**
+ * Holds collision data from the movement of a {@link PhysicsBody2D}, usually from {@link PhysicsBody2D.moveAndCollide}. When a {@link PhysicsBody2D} is moved, it stops if it detects a collision with another body. If a collision is detected, a {@link KinematicCollision2D} object is returned.
+ * The collision data includes the colliding object, the remaining motion, and the collision position. This data can be used to determine a custom response to the collision.
+ */
+export class KinematicCollision2D extends RefCounted {
+    constructor(name = 383) { super(name); }
+
+    /**
+     * Returns the point of collision in global coordinates.
+     */
+    getPosition(): Vector2 { return _C(this, 5973) as Vector2; }
+
+    /**
+     * Returns the colliding body's shape's normal at the point of collision.
+     */
+    getNormal(): Vector2 { return _C(this, 5675) as Vector2; }
+
+    /**
+     * Returns the moving object's travel before collision.
+     */
+    getTravel(): Vector2 { return _C(this, 6901) as Vector2; }
+
+    /**
+     * Returns the moving object's remaining movement vector.
+     */
+    getRemainder(): Vector2 { return _C(this, 6123) as Vector2; }
+
+    /**
+     * Returns the collision angle according to `upDirection`, which is {@link Vector2.UP} by default. This value is always positive.
+     */
+    getAngle(upDirection?: Vector2 /* = Vector2(0, -1) */): number { return _C(this, 3749, upDirection) as number; }
+
+    /**
+     * Returns the colliding body's length of overlap along the collision normal.
+     */
+    getDepth(): number { return _C(this, 4468) as number; }
+
+    /**
+     * Returns the moving object's colliding shape.
+     */
+    getLocalShape(): Object { return _C(this, 5400) as Object; }
+
+    /**
+     * Returns the colliding body's attached {@link Object}.
+     */
+    getCollider(): Object { return _C(this, 4188) as Object; }
+
+    /**
+     * Returns the unique instance ID of the colliding body's attached {@link Object}. See {@link Object.getInstanceId}.
+     */
+    getColliderId(): number { return _C(this, 4189) as number; }
+
+    /**
+     * Returns the colliding body's {@link RID} used by the {@link PhysicsServer2D}.
+     */
+    getColliderRid(): RID { return _C(this, 4190) as RID; }
+
+    /**
+     * Returns the colliding body's shape.
+     */
+    getColliderShape(): Object { return _C(this, 4191) as Object; }
+
+    /**
+     * Returns the colliding body's shape index. See {@link CollisionObject2D}.
+     */
+    getColliderShapeIndex(): number { return _C(this, 4192) as number; }
+
+    /**
+     * Returns the colliding body's velocity.
+     */
+    getColliderVelocity(): Vector2 { return _C(this, 4193) as Vector2; }
+
+    static readonly name = _R(383, KinematicCollision2D);
+}

package/gen/classes/KinematicCollision3D.ts

@@ -0,0 +1,88 @@
+// 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 { RID } from '../heap-types/index.ts';
+import type { Vector3 } from '../value-types/index.ts';
+import type { Object } from './Object.ts';
+
+/**
+ * Holds collision data from the movement of a {@link PhysicsBody3D}, usually from {@link PhysicsBody3D.moveAndCollide}. When a {@link PhysicsBody3D} is moved, it stops if it detects a collision with another body. If a collision is detected, a {@link KinematicCollision3D} object is returned.
+ * The collision data includes the colliding object, the remaining motion, and the collision position. This data can be used to determine a custom response to the collision.
+ */
+export class KinematicCollision3D extends RefCounted {
+    constructor(name = 384) { super(name); }
+
+    /**
+     * Returns the moving object's travel before collision.
+     */
+    getTravel(): Vector3 { return _C(this, 6901) as Vector3; }
+
+    /**
+     * Returns the moving object's remaining movement vector.
+     */
+    getRemainder(): Vector3 { return _C(this, 6123) as Vector3; }
+
+    /**
+     * Returns the colliding body's length of overlap along the collision normal.
+     */
+    getDepth(): number { return _C(this, 4468) as number; }
+
+    /**
+     * Returns the number of detected collisions.
+     */
+    getCollisionCount(): number { return _C(this, 4197) as number; }
+
+    /**
+     * Returns the point of collision in global coordinates given a collision index (the deepest collision by default).
+     */
+    getPosition(collisionIndex?: number /* = 0 */): Vector3 { return _C(this, 5973, collisionIndex) as Vector3; }
+
+    /**
+     * Returns the colliding body's shape's normal at the point of collision given a collision index (the deepest collision by default).
+     */
+    getNormal(collisionIndex?: number /* = 0 */): Vector3 { return _C(this, 5675, collisionIndex) as Vector3; }
+
+    /**
+     * Returns the collision angle according to `upDirection`, which is {@link Vector3.UP} by default. This value is always positive.
+     */
+    getAngle(collisionIndex?: number /* = 0 */, upDirection?: Vector3 /* = Vector3(0, 1, 0) */): number { return _C(this, 3749, collisionIndex, upDirection) as number; }
+
+    /**
+     * Returns the moving object's colliding shape given a collision index (the deepest collision by default).
+     */
+    getLocalShape(collisionIndex?: number /* = 0 */): Object { return _C(this, 5400, collisionIndex) as Object; }
+
+    /**
+     * Returns the colliding body's attached {@link Object} given a collision index (the deepest collision by default).
+     */
+    getCollider(collisionIndex?: number /* = 0 */): Object { return _C(this, 4188, collisionIndex) as Object; }
+
+    /**
+     * Returns the unique instance ID of the colliding body's attached {@link Object} given a collision index (the deepest collision by default). See {@link Object.getInstanceId}.
+     */
+    getColliderId(collisionIndex?: number /* = 0 */): number { return _C(this, 4189, collisionIndex) as number; }
+
+    /**
+     * Returns the colliding body's {@link RID} used by the {@link PhysicsServer3D} given a collision index (the deepest collision by default).
+     */
+    getColliderRid(collisionIndex?: number /* = 0 */): RID { return _C(this, 4190, collisionIndex) as RID; }
+
+    /**
+     * Returns the colliding body's shape given a collision index (the deepest collision by default).
+     */
+    getColliderShape(collisionIndex?: number /* = 0 */): Object { return _C(this, 4191, collisionIndex) as Object; }
+
+    /**
+     * Returns the colliding body's shape index given a collision index (the deepest collision by default). See {@link CollisionObject3D}.
+     */
+    getColliderShapeIndex(collisionIndex?: number /* = 0 */): number { return _C(this, 4192, collisionIndex) as number; }
+
+    /**
+     * Returns the colliding body's velocity given a collision index (the deepest collision by default).
+     */
+    getColliderVelocity(collisionIndex?: number /* = 0 */): Vector3 { return _C(this, 4193, collisionIndex) as Vector3; }
+
+    static readonly name = _R(384, KinematicCollision3D);
+}

package/gen/classes/Label.ts

@@ -0,0 +1,184 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Control } from './Control.ts';
+import type { HorizontalAlignment, VerticalAlignment } from '../global-enums.ts';
+import type { GodotArray, PackedFloat32Array } from '../heap-types/index.ts';
+import type { Rect2 } from '../value-types/index.ts';
+import type { TextDirection } from './Control.ts';
+import type { LabelSettings } from './LabelSettings.ts';
+import type { AutowrapMode, JustificationFlag, LineBreakFlag, OverrunBehavior, StructuredTextParser, VisibleCharactersBehavior } from './TextServer.ts';
+
+/**
+ * A control for displaying plain text. It gives you control over the horizontal and vertical alignment and can wrap the text inside the node's bounding rectangle. It doesn't support bold, italics, or other rich text formatting. For that, use {@link RichTextLabel} instead.
+ * **Note:** A single Label node is not designed to display huge amounts of text. To display large amounts of text in a single node, consider using {@link RichTextLabel} instead as it supports features like an integrated scroll bar and threading. {@link RichTextLabel} generally performs better when displaying large amounts of text (several pages or more).
+ */
+export class Label extends Control {
+    constructor(name = 385) { super(name); }
+
+    /**
+     * Returns the height of the line `line`.
+     * If `line` is set to `-1`, returns the biggest line height.
+     * If there are no lines, returns font size in pixels.
+     */
+    getLineHeight(line?: number /* = -1 */): number { return _C(this, 5362, line) as number; }
+
+    /**
+     * Returns the number of lines of text the Label has.
+     */
+    getLineCount(): number { return _C(this, 5355) as number; }
+
+    /**
+     * Returns the number of lines shown. Useful if the {@link Label}'s height cannot currently display all lines.
+     */
+    getVisibleLineCount(): number { return _C(this, 7108) as number; }
+
+    /**
+     * Returns the total number of printable characters in the text (excluding spaces and newlines).
+     */
+    getTotalCharacterCount(): number { return _C(this, 6850) as number; }
+
+    /**
+     * Returns the bounding rectangle of the character at position `pos` in the label's local coordinate system. If the character is a non-visual character or `pos` is outside the valid range, an empty {@link Rect2} is returned. If the character is a part of a composite grapheme, the bounding rectangle of the whole grapheme is returned.
+     */
+    getCharacterBounds(pos: number): Rect2 { return _C(this, 4143, pos) as Rect2; }
+
+    /**
+     * The text to display on screen.
+     */
+    get text(): string { return _C(this, 6718) as string; }
+    set text(v: string) { _C(this, 13020, v); }
+
+    /**
+     * A {@link LabelSettings} resource that can be shared between multiple {@link Label} nodes. Takes priority over theme properties.
+     */
+    get labelSettings(): LabelSettings { return _C(this, 5298) as LabelSettings; }
+    set labelSettings(v: LabelSettings) { _C(this, 11870, v); }
+
+    /**
+     * Controls the text's horizontal alignment. Supports left, center, right, and fill (also known as justify).
+     */
+    get horizontalAlignment(): HorizontalAlignment { return _C(this, 5044) as HorizontalAlignment; }
+    set horizontalAlignment(v: HorizontalAlignment) { _C(this, 11638, v); }
+
+    /**
+     * Controls the text's vertical alignment. Supports top, center, bottom, and fill.
+     */
+    get verticalAlignment(): VerticalAlignment { return _C(this, 7063) as VerticalAlignment; }
+    set verticalAlignment(v: VerticalAlignment) { _C(this, 13303, v); }
+
+    /**
+     * If set to something other than {@link TextServer.AUTOWRAP_OFF}, the text gets wrapped inside the node's bounding rectangle. If you resize the node, it will change its height automatically to show all the text.
+     * **Note:** Labels with autowrapping enabled must have a custom maximum width configured to work correctly, either through the Label's own {@link Control.customMaximumSize} or as a result of a propagated maximum size from a parent Control with {@link Control.propagateMaximumSize} enabled.
+     */
+    get autowrapMode(): AutowrapMode { return _C(this, 3847) as AutowrapMode; }
+    set autowrapMode(v: AutowrapMode) { _C(this, 10596, v); }
+
+    /**
+     * Autowrap space trimming flags. See {@link TextServer.BREAK_TRIM_START_EDGE_SPACES} and {@link TextServer.BREAK_TRIM_END_EDGE_SPACES} for more info.
+     */
+    get autowrapTrimFlags(): LineBreakFlag { return _C(this, 3848) as LineBreakFlag; }
+    set autowrapTrimFlags(v: LineBreakFlag) { _C(this, 10597, v); }
+
+    /**
+     * Line fill alignment rules.
+     */
+    get justificationFlags(): JustificationFlag { return _C(this, 5279) as JustificationFlag; }
+    set justificationFlags(v: JustificationFlag) { _C(this, 11853, v); }
+
+    /**
+     * String used as a paragraph separator. Each paragraph is processed independently, in its own BiDi context.
+     */
+    get paragraphSeparator(): string { return _C(this, 5807) as string; }
+    set paragraphSeparator(v: string) { _C(this, 12245, v); }
+
+    /**
+     * If `true`, the Label only shows the text that fits inside its bounding rectangle and will clip text horizontally.
+     */
+    get clipText(): boolean { return _C(this, 7834) as boolean; }
+    set clipText(v: boolean) { _C(this, 10869, v); }
+
+    /**
+     * The clipping behavior when the text exceeds the node's bounding rectangle.
+     */
+    get textOverrunBehavior(): OverrunBehavior { return _C(this, 6724) as OverrunBehavior; }
+    set textOverrunBehavior(v: OverrunBehavior) { _C(this, 13023, v); }
+
+    /**
+     * Ellipsis character used for text clipping.
+     */
+    get ellipsisChar(): string { return _C(this, 4610) as string; }
+    set ellipsisChar(v: string) { _C(this, 11226, v); }
+
+    /**
+     * If `true`, all the text displays as UPPERCASE.
+     */
+    get uppercase(): boolean { return _C(this, 8385) as boolean; }
+    set uppercase(v: boolean) { _C(this, 13187, v); }
+
+    /**
+     * Aligns text to the given tab-stops.
+     */
+    get tabStops(): PackedFloat32Array { return _C(this, 6683) as PackedFloat32Array; }
+    set tabStops(v: PackedFloat32Array) { _C(this, 12981, v); }
+
+    /**
+     * The number of the lines ignored and not displayed from the start of the {@link text} value.
+     */
+    get linesSkipped(): number { return _C(this, 5388) as number; }
+    set linesSkipped(v: number) { _C(this, 11937, v); }
+
+    /**
+     * Limits the lines of text the node shows on screen.
+     */
+    get maxLinesVisible(): number { return _C(this, 5473) as number; }
+    set maxLinesVisible(v: number) { _C(this, 11997, v); }
+
+    /**
+     * The number of characters to display. If set to `-1`, all characters are displayed. This can be useful when animating the text appearing in a dialog box.
+     * **Note:** Setting this property updates {@link visibleRatio} accordingly.
+     * **Note:** Characters are counted as Unicode codepoints. A single visible grapheme may contain multiple codepoints (e.g. certain emoji use three codepoints). A single codepoint may contain two UTF-16 characters, which are used in C# strings.
+     */
+    get visibleCharacters(): number { return _C(this, 7104) as number; }
+    set visibleCharacters(v: number) { _C(this, 13332, v); }
+
+    /**
+     * The clipping behavior when {@link visibleCharacters} or {@link visibleRatio} is set.
+     */
+    get visibleCharactersBehavior(): VisibleCharactersBehavior { return _C(this, 7105) as VisibleCharactersBehavior; }
+    set visibleCharactersBehavior(v: VisibleCharactersBehavior) { _C(this, 13333, v); }
+
+    /**
+     * The fraction of characters to display, relative to the total number of characters (see {@link getTotalCharacterCount}). If set to `1.0`, all characters are displayed. If set to `0.5`, only half of the characters will be displayed. This can be useful when animating the text appearing in a dialog box.
+     * **Note:** Setting this property updates {@link visibleCharacters} accordingly.
+     */
+    get visibleRatio(): number { return _C(this, 7111) as number; }
+    set visibleRatio(v: number) { _C(this, 13335, v); }
+
+    /**
+     * Base text writing direction.
+     */
+    get textDirection(): TextDirection { return _C(this, 6720) as TextDirection; }
+    set textDirection(v: TextDirection) { _C(this, 13022, v); }
+
+    /**
+     * Language code used for line-breaking and text shaping algorithms. If left empty, the current locale is used instead.
+     */
+    get language(): string { return _C(this, 5299) as string; }
+    set language(v: string) { _C(this, 11871, v); }
+
+    /**
+     * Set BiDi algorithm override for the structured text.
+     */
+    get structuredTextBidiOverride(): StructuredTextParser { return _C(this, 6585) as StructuredTextParser; }
+    set structuredTextBidiOverride(v: StructuredTextParser) { _C(this, 12913, v); }
+
+    /**
+     * Set additional options for BiDi override.
+     */
+    get structuredTextBidiOverrideOptions(): GodotArray { return _C(this, 6586) as GodotArray; }
+    set structuredTextBidiOverrideOptions(v: GodotArray) { _C(this, 12914, v); }
+
+    static readonly name = _R(385, Label);
+}

package/gen/classes/Label3D.ts

@@ -0,0 +1,280 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { GeometryInstance3D } from './GeometryInstance3D.ts';
+import type { HorizontalAlignment, VerticalAlignment } from '../global-enums.ts';
+import type { GodotArray } from '../heap-types/index.ts';
+import type { Color, Vector2 } from '../value-types/index.ts';
+import type { AlphaAntiAliasing, BillboardMode } from './BaseMaterial3D.ts';
+import type { Font } from './Font.ts';
+import type { AutowrapMode, Direction, JustificationFlag, LineBreakFlag, StructuredTextParser } from './TextServer.ts';
+import type { TriangleMesh } from './TriangleMesh.ts';
+import type { TextureFilter } from './VisualShaderNodeTextureParameter.ts';
+
+/**
+ * A node for displaying plain text in 3D space. By adjusting various properties of this node, you can configure things such as the text's appearance and whether it always faces the camera.
+ */
+export class Label3D extends GeometryInstance3D {
+    constructor(name = 386) { super(name); }
+
+    /**
+     * Returns a {@link TriangleMesh} with the label's vertices following its current configuration (such as its {@link pixelSize}).
+     */
+    generateTriangleMesh(): TriangleMesh { return _C(this, 3642) as TriangleMesh; }
+
+    /**
+     * The size of one pixel's width on the label to scale it in 3D. To make the font look more detailed when up close, increase {@link fontSize} while decreasing {@link pixelSize} at the same time.
+     */
+    get pixelSize(): number { return _C(this, 5914) as number; }
+    set pixelSize(v: number) { _C(this, 12334, v); }
+
+    /**
+     * The text drawing offset (in pixels).
+     */
+    get offset(): Vector2 { return _C(this, 5703) as Vector2; }
+    set offset(v: Vector2) { _C(this, 12170, v); }
+
+    /**
+     * The billboard mode to use for the label.
+     */
+    get billboard(): BillboardMode { return _C(this, 3913) as BillboardMode; }
+    set billboard(v: BillboardMode) { _C(this, 10659, v); }
+
+    /**
+     * If `true`, the {@link Light3D} in the {@link Environment} has effects on the label.
+     */
+    get shaded(): boolean { return _C(this, 4565, 0) as boolean; }
+    set shaded(v: boolean) { _C(this, 11188, 0, v); }
+
+    /**
+     * If `true`, text can be seen from the back as well, if `false`, it is invisible when looking at it from behind.
+     */
+    get doubleSided(): boolean { return _C(this, 4565, 1) as boolean; }
+    set doubleSided(v: boolean) { _C(this, 11188, 1, v); }
+
+    /**
+     * If `true`, depth testing is disabled and the object will be drawn in render order.
+     */
+    get noDepthTest(): boolean { return _C(this, 4565, 2) as boolean; }
+    set noDepthTest(v: boolean) { _C(this, 11188, 2, v); }
+
+    /**
+     * If `true`, the label is rendered at the same size regardless of distance. The label's size on screen is the same as if the camera was `1.0` units away from the label's origin, regardless of the actual distance from the camera. The {@link Camera3D}'s field of view (or {@link Camera3D.size} when in orthogonal/frustum mode) still affects the size the label is drawn at.
+     */
+    get fixedSize(): boolean { return _C(this, 4565, 3) as boolean; }
+    set fixedSize(v: boolean) { _C(this, 11188, 3, v); }
+
+    /**
+     * The alpha cutting mode to use for the sprite.
+     */
+    get alphaCut(): AlphaCutMode { return _C(this, 3727) as AlphaCutMode; }
+    set alphaCut(v: AlphaCutMode) { _C(this, 10468, v); }
+
+    /**
+     * Threshold at which the alpha scissor will discard values.
+     */
+    get alphaScissorThreshold(): number { return _C(this, 3729) as number; }
+    set alphaScissorThreshold(v: number) { _C(this, 10470, v); }
+
+    /**
+     * The hashing scale for Alpha Hash. Recommended values between `0` and `2`.
+     */
+    get alphaHashScale(): number { return _C(this, 3728) as number; }
+    set alphaHashScale(v: number) { _C(this, 10469, v); }
+
+    /**
+     * The type of alpha antialiasing to apply.
+     */
+    get alphaAntialiasingMode(): AlphaAntiAliasing { return _C(this, 3722) as AlphaAntiAliasing; }
+    set alphaAntialiasingMode(v: AlphaAntiAliasing) { _C(this, 10463, v); }
+
+    /**
+     * Threshold at which antialiasing will be applied on the alpha channel.
+     */
+    get alphaAntialiasingEdge(): number { return _C(this, 3723) as number; }
+    set alphaAntialiasingEdge(v: number) { _C(this, 10464, v); }
+
+    /**
+     * Filter flags for the texture.
+     */
+    get textureFilter(): TextureFilter { return _C(this, 6730) as TextureFilter; }
+    set textureFilter(v: TextureFilter) { _C(this, 13027, v); }
+
+    /**
+     * Sets the render priority for the text. Higher priority objects will be sorted in front of lower priority objects.
+     * **Note:** This only applies if {@link alphaCut} is set to {@link ALPHA_CUT_DISABLED} (default value).
+     * **Note:** This only applies to sorting of transparent objects. This will not impact how transparent objects are sorted relative to opaque objects. This is because opaque objects are not sorted, while transparent objects are sorted from back to front (subject to priority).
+     */
+    get renderPriority(): number { return _C(this, 6131) as number; }
+    set renderPriority(v: number) { _C(this, 12520, v); }
+
+    /**
+     * Sets the render priority for the text outline. Higher priority objects will be sorted in front of lower priority objects.
+     * **Note:** This only applies if {@link alphaCut} is set to {@link ALPHA_CUT_DISABLED} (default value).
+     * **Note:** This only applies to sorting of transparent objects. This will not impact how transparent objects are sorted relative to opaque objects. This is because opaque objects are not sorted, while transparent objects are sorted from back to front (subject to priority).
+     */
+    get outlineRenderPriority(): number { return _C(this, 5759) as number; }
+    set outlineRenderPriority(v: number) { _C(this, 12217, v); }
+
+    /**
+     * Text {@link Color} of the {@link Label3D}.
+     */
+    get modulate(): Color { return _C(this, 5576) as Color; }
+    set modulate(v: Color) { _C(this, 12081, v); }
+
+    /**
+     * The tint of text outline.
+     */
+    get outlineModulate(): Color { return _C(this, 5758) as Color; }
+    set outlineModulate(v: Color) { _C(this, 12216, v); }
+
+    /**
+     * The text to display on screen.
+     */
+    get text(): string { return _C(this, 6718) as string; }
+    set text(v: string) { _C(this, 13020, v); }
+
+    /**
+     * Font configuration used to display text.
+     */
+    get font(): Font { return _C(this, 4846) as Font; }
+    set font(v: Font) { _C(this, 11452, v); }
+
+    /**
+     * Font size of the {@link Label3D}'s text. To make the font look more detailed when up close, increase {@link fontSize} while decreasing {@link pixelSize} at the same time.
+     * Higher font sizes require more time to render new characters, which can cause stuttering during gameplay.
+     */
+    get fontSize(): number { return _C(this, 4852) as number; }
+    set fontSize(v: number) { _C(this, 11457, v); }
+
+    /**
+     * Text outline size.
+     */
+    get outlineSize(): number { return _C(this, 5760) as number; }
+    set outlineSize(v: number) { _C(this, 12218, v); }
+
+    /**
+     * Controls the text's horizontal alignment. Supports left, center, right, and fill (also known as justify).
+     */
+    get horizontalAlignment(): HorizontalAlignment { return _C(this, 5044) as HorizontalAlignment; }
+    set horizontalAlignment(v: HorizontalAlignment) { _C(this, 11638, v); }
+
+    /**
+     * Controls the text's vertical alignment. Supports top, center, and bottom.
+     */
+    get verticalAlignment(): VerticalAlignment { return _C(this, 7063) as VerticalAlignment; }
+    set verticalAlignment(v: VerticalAlignment) { _C(this, 13303, v); }
+
+    /**
+     * If `true`, all the text displays as UPPERCASE.
+     */
+    get uppercase(): boolean { return _C(this, 8385) as boolean; }
+    set uppercase(v: boolean) { _C(this, 13187, v); }
+
+    /**
+     * Additional vertical spacing between lines (in pixels), spacing is added to line descent. This value can be negative.
+     */
+    get lineSpacing(): number { return _C(this, 5372) as number; }
+    set lineSpacing(v: number) { _C(this, 11928, v); }
+
+    /**
+     * If set to something other than {@link TextServer.AUTOWRAP_OFF}, the text gets wrapped inside the node's bounding rectangle. If you resize the node, it will change its height automatically to show all the text.
+     */
+    get autowrapMode(): AutowrapMode { return _C(this, 3847) as AutowrapMode; }
+    set autowrapMode(v: AutowrapMode) { _C(this, 10596, v); }
+
+    /**
+     * Autowrap space trimming flags. See {@link TextServer.BREAK_TRIM_START_EDGE_SPACES} and {@link TextServer.BREAK_TRIM_END_EDGE_SPACES} for more info.
+     */
+    get autowrapTrimFlags(): LineBreakFlag { return _C(this, 3848) as LineBreakFlag; }
+    set autowrapTrimFlags(v: LineBreakFlag) { _C(this, 10597, v); }
+
+    /**
+     * Line fill alignment rules.
+     */
+    get justificationFlags(): JustificationFlag { return _C(this, 5279) as JustificationFlag; }
+    set justificationFlags(v: JustificationFlag) { _C(this, 11853, v); }
+
+    /**
+     * Text width (in pixels), used for autowrap and fill alignment.
+     */
+    get width(): number { return _C(this, 7148) as number; }
+    set width(v: number) { _C(this, 13372, v); }
+
+    /**
+     * Base text writing direction.
+     */
+    get textDirection(): Direction { return _C(this, 6720) as Direction; }
+    set textDirection(v: Direction) { _C(this, 13022, v); }
+
+    /**
+     * Language code used for line-breaking and text shaping algorithms. If left empty, the current locale is used instead.
+     */
+    get language(): string { return _C(this, 5299) as string; }
+    set language(v: string) { _C(this, 11871, v); }
+
+    /**
+     * Set BiDi algorithm override for the structured text.
+     */
+    get structuredTextBidiOverride(): StructuredTextParser { return _C(this, 6585) as StructuredTextParser; }
+    set structuredTextBidiOverride(v: StructuredTextParser) { _C(this, 12913, v); }
+
+    /**
+     * Set additional options for BiDi override.
+     */
+    get structuredTextBidiOverrideOptions(): GodotArray { return _C(this, 6586) as GodotArray; }
+    set structuredTextBidiOverrideOptions(v: GodotArray) { _C(this, 12914, v); }
+
+    static readonly name = _R(386, Label3D);
+}
+
+export const DrawFlags = {
+    /**
+     * If set, lights in the environment affect the label.
+     */
+    FLAG_SHADED: 0,
+    /**
+     * If set, text can be seen from the back as well. If not, the text is invisible when looking at it from behind.
+     */
+    FLAG_DOUBLE_SIDED: 1,
+    /**
+     * Disables the depth test, so this object is drawn on top of all others. However, objects drawn after it in the draw order may cover it.
+     */
+    FLAG_DISABLE_DEPTH_TEST: 2,
+    /**
+     * Label is scaled by depth so that it always appears the same size on screen.
+     */
+    FLAG_FIXED_SIZE: 3,
+    /**
+     * Represents the size of the {@link DrawFlags} enum.
+     */
+    FLAG_MAX: 4,
+} as const;
+
+export type DrawFlags = (typeof DrawFlags)[keyof typeof DrawFlags];
+
+export const AlphaCutMode = {
+    /**
+     * This mode performs standard alpha blending. It can display translucent areas, but transparency sorting issues may be visible when multiple transparent materials are overlapping. {@link GeometryInstance3D.castShadow} has no effect when this transparency mode is used; the {@link Label3D} will never cast shadows.
+     */
+    ALPHA_CUT_DISABLED: 0,
+    /**
+     * This mode only allows fully transparent or fully opaque pixels. Harsh edges will be visible unless some form of screen-space antialiasing is enabled (see {@link ProjectSettings.rendering/antiAliasing/quality/screenSpaceAa}). This mode is also known as *alpha testing* or *1-bit transparency*.
+     * **Note:** This mode might have issues with anti-aliased fonts and outlines, try adjusting {@link alphaScissorThreshold} or using MSDF font.
+     * **Note:** When using text with overlapping glyphs (e.g., cursive scripts), this mode might have transparency sorting issues between the main text and the outline.
+     */
+    ALPHA_CUT_DISCARD: 1,
+    /**
+     * This mode draws fully opaque pixels in the depth prepass. This is slower than {@link ALPHA_CUT_DISABLED} or {@link ALPHA_CUT_DISCARD}, but it allows displaying translucent areas and smooth edges while using proper sorting.
+     * **Note:** When using text with overlapping glyphs (e.g., cursive scripts), this mode might have transparency sorting issues between the main text and the outline.
+     */
+    ALPHA_CUT_OPAQUE_PREPASS: 2,
+    /**
+     * This mode draws cuts off all values below a spatially-deterministic threshold, the rest will remain opaque.
+     */
+    ALPHA_CUT_HASH: 3,
+} as const;
+
+export type AlphaCutMode = (typeof AlphaCutMode)[keyof typeof AlphaCutMode];
+