@ringozz/godot 0.1.0

package/gen/classes/TextServer.ts

@@ -0,0 +1,1891 @@
+// 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 { InlineAlignment } from '../global-enums.ts';
+import type { GodotArray, GodotDictionary, PackedByteArray, PackedColorArray, PackedFloat32Array, PackedInt32Array, PackedStringArray, PackedVector2Array, RID, Variant } from '../heap-types/index.ts';
+import type { Color, Rect2, Transform2D, Vector2, Vector2i, Vector3i } from '../value-types/index.ts';
+import type { Image } from './Image.ts';
+
+/**
+ * {@link TextServer} is the API backend for managing fonts and rendering text.
+ * **Note:** This is a low-level API, consider using {@link TextLine}, {@link TextParagraph}, and {@link Font} classes instead.
+ * This is an abstract class, so to get the currently active {@link TextServer} instance, use the following code:
+ *
+ *
+ * ```gdscript
+ *
+ * var ts = TextServerManager.get_primary_interface()
+ *
+ * ```
+ */
+export class TextServer extends RefCounted {
+
+    /**
+     * Returns `true` if the server supports a feature.
+     */
+    hasFeature(feature: Feature): boolean { return _C(this, 7395, feature) as boolean; }
+
+    /**
+     * Returns the name of the server interface.
+     */
+    getName(): string { return _C(this, 5602) as string; }
+
+    /**
+     * Returns text server features, see {@link Feature}.
+     */
+    getFeatures(): number { return _C(this, 4762) as number; }
+
+    /**
+     * Loads optional TextServer database (e.g. ICU break iterators and dictionaries).
+     * **Note:** This function should be called before any other TextServer functions used, otherwise it won't have any effect.
+     */
+    loadSupportData(filename: string): boolean { return _C(this, 8685, filename) as boolean; }
+
+    /**
+     * Returns default TextServer database (e.g. ICU break iterators and dictionaries) filename.
+     */
+    getSupportDataFilename(): string { return _C(this, 6614) as string; }
+
+    /**
+     * Returns TextServer database (e.g. ICU break iterators and dictionaries) description.
+     */
+    getSupportDataInfo(): string { return _C(this, 6615) as string; }
+
+    /**
+     * Saves optional TextServer database (e.g. ICU break iterators and dictionaries) to the file.
+     * **Note:** This function is used by during project export, to include TextServer database.
+     */
+    saveSupportData(filename: string): boolean { return _C(this, 10207, filename) as boolean; }
+
+    /**
+     * Returns default TextServer database (e.g. ICU break iterators and dictionaries).
+     */
+    getSupportData(): PackedByteArray { return _C(this, 6613) as PackedByteArray; }
+
+    /**
+     * Returns `true` if the locale requires text server support data for line/word breaking.
+     */
+    isLocaleUsingSupportData(locale: string): boolean { return _C(this, 8090, locale) as boolean; }
+
+    /**
+     * Returns `true` if locale is right-to-left.
+     */
+    isLocaleRightToLeft(locale: string): boolean { return _C(this, 8089, locale) as boolean; }
+
+    /**
+     * Converts the given readable name of a feature, variation, script, or language to an OpenType tag.
+     */
+    nameToTag(name: string): number { return _C(this, 9047, name) as number; }
+
+    /**
+     * Converts the given OpenType tag to the readable name of a feature, variation, script, or language.
+     */
+    tagToName(tag: number /* int64 */): string { return _C(this, 14112, tag) as string; }
+
+    /**
+     * Returns `true` if `rid` is valid resource owned by this text server.
+     */
+    has(rid: RID): boolean { return _C(this, 7349, rid) as boolean; }
+
+    /**
+     * Frees an object created by this {@link TextServer}.
+     */
+    freeRid(rid: RID): void { _C(this, 3583, rid); }
+
+    /**
+     * Creates a new, empty font cache entry resource. To free the resulting resource, use the {@link freeRid} method.
+     */
+    createFont(): RID { return _C(this, 2525) as RID; }
+
+    /**
+     * Creates a new variation existing font which is reusing the same glyph cache and font data. To free the resulting resource, use the {@link freeRid} method.
+     */
+    createFontLinkedVariation(fontRid: RID): RID { return _C(this, 2526, fontRid) as RID; }
+
+    /**
+     * Sets font source data, e.g contents of the dynamic font source file.
+     */
+    fontSetData(fontRid: RID, data: PackedByteArray): void { _C(this, 3479, fontRid, data); }
+
+    /**
+     * Sets an active face index in the TrueType / OpenType collection.
+     */
+    fontSetFaceIndex(fontRid: RID, faceIndex: number /* int64 */): void { _C(this, 3483, fontRid, faceIndex); }
+
+    /**
+     * Returns an active face index in the TrueType / OpenType collection.
+     */
+    fontGetFaceIndex(fontRid: RID): number { return _C(this, 3405, fontRid) as number; }
+
+    /**
+     * Returns number of faces in the TrueType / OpenType collection.
+     */
+    fontGetFaceCount(fontRid: RID): number { return _C(this, 3404, fontRid) as number; }
+
+    /**
+     * Sets the font style flags.
+     * **Note:** This value is used for font matching only and will not affect font rendering. Use {@link fontSetFaceIndex}, {@link fontSetVariationCoordinates}, {@link fontSetEmbolden}, or {@link fontSetTransform} instead.
+     */
+    fontSetStyle(fontRid: RID, style: FontStyle): void { _C(this, 3510, fontRid, style); }
+
+    /**
+     * Returns font style flags.
+     */
+    fontGetStyle(fontRid: RID): FontStyle { return _C(this, 3443, fontRid) as FontStyle; }
+
+    /**
+     * Sets the font family name.
+     */
+    fontSetName(fontRid: RID, name: string): void { _C(this, 3502, fontRid, name); }
+
+    /**
+     * Returns font family name.
+     */
+    fontGetName(fontRid: RID): string { return _C(this, 3428, fontRid) as string; }
+
+    /**
+     * Returns {@link Dictionary} with OpenType font name strings (localized font names, version, description, license information, sample text, etc.).
+     */
+    fontGetOtNameStrings(fontRid: RID): GodotDictionary { return _C(this, 3430, fontRid) as GodotDictionary; }
+
+    /**
+     * Sets the font style name.
+     */
+    fontSetStyleName(fontRid: RID, name: string): void { _C(this, 3511, fontRid, name); }
+
+    /**
+     * Returns font style name.
+     */
+    fontGetStyleName(fontRid: RID): string { return _C(this, 3444, fontRid) as string; }
+
+    /**
+     * Sets weight (boldness) of the font. A value in the `100...999` range, normal font weight is `400`, bold font weight is `700`.
+     * **Note:** This value is used for font matching only and will not affect font rendering. Use {@link fontSetFaceIndex}, {@link fontSetVariationCoordinates}, or {@link fontSetEmbolden} instead.
+     */
+    fontSetWeight(fontRid: RID, weight: number /* int64 */): void { _C(this, 3520, fontRid, weight); }
+
+    /**
+     * Returns weight (boldness) of the font. A value in the `100...999` range, normal font weight is `400`, bold font weight is `700`.
+     */
+    fontGetWeight(fontRid: RID): number { return _C(this, 3456, fontRid) as number; }
+
+    /**
+     * Sets font stretch amount, compared to a normal width. A percentage value between `50%` and `200%`.
+     * **Note:** This value is used for font matching only and will not affect font rendering. Use {@link fontSetFaceIndex}, {@link fontSetVariationCoordinates}, or {@link fontSetTransform} instead.
+     */
+    fontSetStretch(fontRid: RID, weight: number /* int64 */): void { _C(this, 3509, fontRid, weight); }
+
+    /**
+     * Returns font stretch amount, compared to a normal width. A percentage value between `50%` and `200%`.
+     */
+    fontGetStretch(fontRid: RID): number { return _C(this, 3442, fontRid) as number; }
+
+    /**
+     * Sets font anti-aliasing mode.
+     */
+    fontSetAntialiasing(fontRid: RID, antialiasing: FontAntialiasing): void { _C(this, 3476, fontRid, antialiasing); }
+
+    /**
+     * Returns font anti-aliasing mode.
+     */
+    fontGetAntialiasing(fontRid: RID): FontAntialiasing { return _C(this, 3397, fontRid) as FontAntialiasing; }
+
+    /**
+     * If set to `true`, embedded font bitmap loading is disabled (bitmap-only and color fonts ignore this property).
+     */
+    fontSetDisableEmbeddedBitmaps(fontRid: RID, disableEmbeddedBitmaps: boolean): void { _C(this, 3481, fontRid, disableEmbeddedBitmaps); }
+
+    /**
+     * Returns whether the font's embedded bitmap loading is disabled.
+     */
+    fontGetDisableEmbeddedBitmaps(fontRid: RID): boolean { return _C(this, 3402, fontRid) as boolean; }
+
+    /**
+     * If set to `true` font texture mipmap generation is enabled.
+     */
+    fontSetGenerateMipmaps(fontRid: RID, generateMipmaps: boolean): void { _C(this, 3487, fontRid, generateMipmaps); }
+
+    /**
+     * Returns `true` if font texture mipmap generation is enabled.
+     */
+    fontGetGenerateMipmaps(fontRid: RID): boolean { return _C(this, 3408, fontRid) as boolean; }
+
+    /**
+     * If set to `true`, glyphs of all sizes are rendered using single multichannel signed distance field generated from the dynamic font vector data. MSDF rendering allows displaying the font at any scaling factor without blurriness, and without incurring a CPU cost when the font size changes (since the font no longer needs to be rasterized on the CPU). As a downside, font hinting is not available with MSDF. The lack of font hinting may result in less crisp and less readable fonts at small sizes.
+     * **Note:** MSDF font rendering does not render glyphs with overlapping shapes correctly. Overlapping shapes are not valid per the OpenType standard, but are still commonly found in many font files, especially those converted by Google Fonts. To avoid issues with overlapping glyphs, consider downloading the font file directly from the type foundry instead of relying on Google Fonts.
+     */
+    fontSetMultichannelSignedDistanceField(fontRid: RID, msdf: boolean): void { _C(this, 3501, fontRid, msdf); }
+
+    /**
+     * Returns `true` if glyphs of all sizes are rendered using single multichannel signed distance field generated from the dynamic font vector data.
+     */
+    fontIsMultichannelSignedDistanceField(fontRid: RID): boolean { return _C(this, 3462, fontRid) as boolean; }
+
+    /**
+     * Sets the width of the range around the shape between the minimum and maximum representable signed distance.
+     */
+    fontSetMsdfPixelRange(fontRid: RID, msdfPixelRange: number /* int64 */): void { _C(this, 3499, fontRid, msdfPixelRange); }
+
+    /**
+     * Returns the width of the range around the shape between the minimum and maximum representable signed distance.
+     */
+    fontGetMsdfPixelRange(fontRid: RID): number { return _C(this, 3426, fontRid) as number; }
+
+    /**
+     * Sets source font size used to generate MSDF textures.
+     */
+    fontSetMsdfSize(fontRid: RID, msdfSize: number /* int64 */): void { _C(this, 3500, fontRid, msdfSize); }
+
+    /**
+     * Returns source font size used to generate MSDF textures.
+     */
+    fontGetMsdfSize(fontRid: RID): number { return _C(this, 3427, fontRid) as number; }
+
+    /**
+     * Sets bitmap font fixed size. If set to value greater than zero, same cache entry will be used for all font sizes.
+     */
+    fontSetFixedSize(fontRid: RID, fixedSize: number /* int64 */): void { _C(this, 3484, fontRid, fixedSize); }
+
+    /**
+     * Returns bitmap font fixed size.
+     */
+    fontGetFixedSize(fontRid: RID): number { return _C(this, 3406, fontRid) as number; }
+
+    /**
+     * Sets bitmap font scaling mode. This property is used only if `fixed_size` is greater than zero.
+     */
+    fontSetFixedSizeScaleMode(fontRid: RID, fixedSizeScaleMode: FixedSizeScaleMode): void { _C(this, 3485, fontRid, fixedSizeScaleMode); }
+
+    /**
+     * Returns bitmap font scaling mode.
+     */
+    fontGetFixedSizeScaleMode(fontRid: RID): FixedSizeScaleMode { return _C(this, 3407, fontRid) as FixedSizeScaleMode; }
+
+    /**
+     * If set to `true`, system fonts can be automatically used as fallbacks.
+     */
+    fontSetAllowSystemFallback(fontRid: RID, allowSystemFallback: boolean): void { _C(this, 3475, fontRid, allowSystemFallback); }
+
+    /**
+     * Returns `true` if system fonts can be automatically used as fallbacks.
+     */
+    fontIsAllowSystemFallback(fontRid: RID): boolean { return _C(this, 3458, fontRid) as boolean; }
+
+    /**
+     * Frees all automatically loaded system fonts.
+     */
+    fontClearSystemFallbackCache(): void { _C(this, 3392); }
+
+    /**
+     * If set to `true` auto-hinting is preferred over font built-in hinting.
+     */
+    fontSetForceAutohinter(fontRid: RID, forceAutohinter: boolean): void { _C(this, 3486, fontRid, forceAutohinter); }
+
+    /**
+     * Returns `true` if auto-hinting is supported and preferred over font built-in hinting. Used by dynamic fonts only.
+     */
+    fontIsForceAutohinter(fontRid: RID): boolean { return _C(this, 3459, fontRid) as boolean; }
+
+    /**
+     * If set to `true`, color modulation is applied when drawing colored glyphs, otherwise it's applied to the monochrome glyphs only.
+     */
+    fontSetModulateColorGlyphs(fontRid: RID, modulate: boolean): void { _C(this, 3498, fontRid, modulate); }
+
+    /**
+     * Returns `true` if color modulation is applied when drawing the font's colored glyphs.
+     */
+    fontIsModulateColorGlyphs(fontRid: RID): boolean { return _C(this, 3461, fontRid) as boolean; }
+
+    /**
+     * Returns the number of predefined color palettes. Palette contains all colors used to render font glyphs. Each palette has the same number of colors.
+     */
+    fontGetPaletteCount(fontRid: RID): number { return _C(this, 3433, fontRid) as number; }
+
+    /**
+     * Returns the name of the predefined color palette at `index`. Palette contains all colors used to render font glyphs. Each palette has the same number of colors.
+     */
+    fontGetPaletteName(fontRid: RID, index: number /* int64 */): string { return _C(this, 3435, fontRid, index) as string; }
+
+    /**
+     * Returns the array in the predefined color palette at `index`. Palette contains all colors used to render font glyphs. Each palette has the same number of colors. Colors can be overridden using {@link fontSetPaletteCustomColors}.
+     */
+    fontGetPaletteColors(fontRid: RID, index: number /* int64 */): PackedColorArray { return _C(this, 3432, fontRid, index) as PackedColorArray; }
+
+    /**
+     * Sets array of custom colors to override predefined palette. Set to empty array to reset overrides. Use `Color(0, 0, 0, 0)`, to keep predefined palette color at specific position.
+     */
+    fontSetPaletteCustomColors(fontRid: RID, colors: PackedColorArray): void { _C(this, 3505, fontRid, colors); }
+
+    /**
+     * Returns array of custom colors to override predefined palette.
+     */
+    fontGetPaletteCustomColors(fontRid: RID): PackedColorArray { return _C(this, 3434, fontRid) as PackedColorArray; }
+
+    /**
+     * Returns used palette index.
+     */
+    fontGetUsedPalette(fontRid: RID): number { return _C(this, 3454, fontRid) as number; }
+
+    /**
+     * Sets used palette index.
+     */
+    fontSetUsedPalette(fontRid: RID, index: number /* int64 */): void { _C(this, 3518, fontRid, index); }
+
+    /**
+     * Sets font hinting mode. Used by dynamic fonts only.
+     */
+    fontSetHinting(fontRid: RID, hinting: Hinting): void { _C(this, 3494, fontRid, hinting); }
+
+    /**
+     * Returns the font hinting mode. Used by dynamic fonts only.
+     */
+    fontGetHinting(fontRid: RID): Hinting { return _C(this, 3420, fontRid) as Hinting; }
+
+    /**
+     * Sets font subpixel glyph positioning mode.
+     */
+    fontSetSubpixelPositioning(fontRid: RID, subpixelPositioning: SubpixelPositioning): void { _C(this, 3512, fontRid, subpixelPositioning); }
+
+    /**
+     * Returns font subpixel glyph positioning mode.
+     */
+    fontGetSubpixelPositioning(fontRid: RID): SubpixelPositioning { return _C(this, 3445, fontRid) as SubpixelPositioning; }
+
+    /**
+     * Sets glyph position rounding behavior. If set to `true`, when aligning glyphs to the pixel boundaries rounding remainders are accumulated to ensure more uniform glyph distribution. This setting has no effect if subpixel positioning is enabled.
+     */
+    fontSetKeepRoundingRemainders(fontRid: RID, keepRoundingRemainders: boolean): void { _C(this, 3495, fontRid, keepRoundingRemainders); }
+
+    /**
+     * Returns glyph position rounding behavior. If set to `true`, when aligning glyphs to the pixel boundaries rounding remainders are accumulated to ensure more uniform glyph distribution. This setting has no effect if subpixel positioning is enabled.
+     */
+    fontGetKeepRoundingRemainders(fontRid: RID): boolean { return _C(this, 3421, fontRid) as boolean; }
+
+    /**
+     * Sets font embolden strength. If `strength` is not equal to zero, emboldens the font outlines. Negative values reduce the outline thickness.
+     */
+    fontSetEmbolden(fontRid: RID, strength: number /* double */): void { _C(this, 3482, fontRid, strength); }
+
+    /**
+     * Returns font embolden strength.
+     */
+    fontGetEmbolden(fontRid: RID): number { return _C(this, 3403, fontRid) as number; }
+
+    /**
+     * Sets the spacing for `spacing` to `value` in pixels (not relative to the font size).
+     */
+    fontSetSpacing(fontRid: RID, spacing: SpacingType, value: number /* int64 */): void { _C(this, 3508, fontRid, spacing, value); }
+
+    /**
+     * Returns the spacing for `spacing` in pixels (not relative to the font size).
+     */
+    fontGetSpacing(fontRid: RID, spacing: SpacingType): number { return _C(this, 3441, fontRid, spacing) as number; }
+
+    /**
+     * Sets extra baseline offset (as a fraction of font height).
+     */
+    fontSetBaselineOffset(fontRid: RID, baselineOffset: number /* double */): void { _C(this, 3478, fontRid, baselineOffset); }
+
+    /**
+     * Returns extra baseline offset (as a fraction of font height).
+     */
+    fontGetBaselineOffset(fontRid: RID): number { return _C(this, 3399, fontRid) as number; }
+
+    /**
+     * Sets 2D transform, applied to the font outlines, can be used for slanting, flipping, and rotating glyphs.
+     * For example, to simulate italic typeface by slanting, apply the following transform `Transform2D(1.0, slant, 0.0, 1.0, 0.0, 0.0)`.
+     */
+    fontSetTransform(fontRid: RID, transform: Transform2D): void { _C(this, 3515, fontRid, transform); }
+
+    /**
+     * Returns 2D transform applied to the font outlines.
+     */
+    fontGetTransform(fontRid: RID): Transform2D { return _C(this, 3451, fontRid) as Transform2D; }
+
+    /**
+     * Sets variation coordinates for the specified font cache entry. See {@link fontSupportedVariationList} for more info.
+     */
+    fontSetVariationCoordinates(fontRid: RID, variationCoordinates: GodotDictionary): void { _C(this, 3519, fontRid, variationCoordinates); }
+
+    /**
+     * Returns variation coordinates for the specified font cache entry. See {@link fontSupportedVariationList} for more info.
+     */
+    fontGetVariationCoordinates(fontRid: RID): GodotDictionary { return _C(this, 3455, fontRid) as GodotDictionary; }
+
+    /**
+     * If set to a positive value, overrides the oversampling factor of the viewport this font is used in. See {@link Viewport.oversampling}. This value doesn't override the {@link code skip-lint}oversampling[/code] parameter of {@link code skip-lint}draw_*[/code] methods. Used by dynamic fonts only.
+     */
+    fontSetOversampling(fontRid: RID, oversampling: number /* double */): void { _C(this, 3504, fontRid, oversampling); }
+
+    /**
+     * Returns oversampling factor override. If set to a positive value, overrides the oversampling factor of the viewport this font is used in. See {@link Viewport.oversampling}. This value doesn't override the {@link code skip-lint}oversampling[/code] parameter of {@link code skip-lint}draw_*[/code] methods. Used by dynamic fonts only.
+     */
+    fontGetOversampling(fontRid: RID): number { return _C(this, 3431, fontRid) as number; }
+
+    /**
+     * Returns list of the font sizes in the cache. Each size is {@link Vector2i} with font size and outline size.
+     */
+    fontGetSizeCacheList(fontRid: RID): GodotArray<Vector2i> { return _C(this, 3440, fontRid) as GodotArray<Vector2i>; }
+
+    /**
+     * Removes all font sizes from the cache entry.
+     */
+    fontClearSizeCache(fontRid: RID): void { _C(this, 3391, fontRid); }
+
+    /**
+     * Removes specified font size from the cache entry.
+     */
+    fontRemoveSizeCache(fontRid: RID, size: Vector2i): void { _C(this, 3471, fontRid, size); }
+
+    /**
+     * Returns font cache information, each entry contains the following fields: `Vector2i size_px` - font size in pixels, `float viewport_oversampling` - viewport oversampling factor, `int glyphs` - number of rendered glyphs, `int textures` - number of used textures, `int textures_size` - size of texture data in bytes.
+     */
+    fontGetSizeCacheInfo(fontRid: RID): GodotArray<GodotDictionary> { return _C(this, 3439, fontRid) as GodotArray<GodotDictionary>; }
+
+    /**
+     * Sets the font ascent (number of pixels above the baseline).
+     */
+    fontSetAscent(fontRid: RID, size: number /* int64 */, ascent: number /* double */): void { _C(this, 3477, fontRid, size, ascent); }
+
+    /**
+     * Returns the font ascent (number of pixels above the baseline).
+     */
+    fontGetAscent(fontRid: RID, size: number /* int64 */): number { return _C(this, 3398, fontRid, size) as number; }
+
+    /**
+     * Sets the font descent (number of pixels below the baseline).
+     */
+    fontSetDescent(fontRid: RID, size: number /* int64 */, descent: number /* double */): void { _C(this, 3480, fontRid, size, descent); }
+
+    /**
+     * Returns the font descent (number of pixels below the baseline).
+     */
+    fontGetDescent(fontRid: RID, size: number /* int64 */): number { return _C(this, 3401, fontRid, size) as number; }
+
+    /**
+     * Sets pixel offset of the underline below the baseline.
+     */
+    fontSetUnderlinePosition(fontRid: RID, size: number /* int64 */, underlinePosition: number /* double */): void { _C(this, 3516, fontRid, size, underlinePosition); }
+
+    /**
+     * Returns pixel offset of the underline below the baseline.
+     */
+    fontGetUnderlinePosition(fontRid: RID, size: number /* int64 */): number { return _C(this, 3452, fontRid, size) as number; }
+
+    /**
+     * Sets thickness of the underline in pixels.
+     */
+    fontSetUnderlineThickness(fontRid: RID, size: number /* int64 */, underlineThickness: number /* double */): void { _C(this, 3517, fontRid, size, underlineThickness); }
+
+    /**
+     * Returns thickness of the underline in pixels.
+     */
+    fontGetUnderlineThickness(fontRid: RID, size: number /* int64 */): number { return _C(this, 3453, fontRid, size) as number; }
+
+    /**
+     * Sets scaling factor of the color bitmap font.
+     */
+    fontSetScale(fontRid: RID, size: number /* int64 */, scale: number /* double */): void { _C(this, 3506, fontRid, size, scale); }
+
+    /**
+     * Returns scaling factor of the color bitmap font.
+     */
+    fontGetScale(fontRid: RID, size: number /* int64 */): number { return _C(this, 3436, fontRid, size) as number; }
+
+    /**
+     * Returns number of textures used by font cache entry.
+     */
+    fontGetTextureCount(fontRid: RID, size: Vector2i): number { return _C(this, 3448, fontRid, size) as number; }
+
+    /**
+     * Removes all textures from font cache entry.
+     * **Note:** This function will not remove glyphs associated with the texture, use {@link fontRemoveGlyph} to remove them manually.
+     */
+    fontClearTextures(fontRid: RID, size: Vector2i): void { _C(this, 3393, fontRid, size); }
+
+    /**
+     * Removes specified texture from the cache entry.
+     * **Note:** This function will not remove glyphs associated with the texture, remove them manually, using {@link fontRemoveGlyph}.
+     */
+    fontRemoveTexture(fontRid: RID, size: Vector2i, textureIndex: number /* int64 */): void { _C(this, 3472, fontRid, size, textureIndex); }
+
+    /**
+     * Sets font cache texture image data.
+     */
+    fontSetTextureImage(fontRid: RID, size: Vector2i, textureIndex: number /* int64 */, image: Image): void { _C(this, 3513, fontRid, size, textureIndex, image); }
+
+    /**
+     * Returns font cache texture image data.
+     */
+    fontGetTextureImage(fontRid: RID, size: Vector2i, textureIndex: number /* int64 */): Image { return _C(this, 3449, fontRid, size, textureIndex) as Image; }
+
+    /**
+     * Sets array containing glyph packing data.
+     */
+    fontSetTextureOffsets(fontRid: RID, size: Vector2i, textureIndex: number /* int64 */, offset: PackedInt32Array): void { _C(this, 3514, fontRid, size, textureIndex, offset); }
+
+    /**
+     * Returns array containing glyph packing data.
+     */
+    fontGetTextureOffsets(fontRid: RID, size: Vector2i, textureIndex: number /* int64 */): PackedInt32Array { return _C(this, 3450, fontRid, size, textureIndex) as PackedInt32Array; }
+
+    /**
+     * Returns list of rendered glyphs in the cache entry.
+     */
+    fontGetGlyphList(fontRid: RID, size: Vector2i): PackedInt32Array { return _C(this, 3413, fontRid, size) as PackedInt32Array; }
+
+    /**
+     * Removes all rendered glyph information from the cache entry.
+     * **Note:** This function will not remove textures associated with the glyphs, use {@link fontRemoveTexture} to remove them manually.
+     */
+    fontClearGlyphs(fontRid: RID, size: Vector2i): void { _C(this, 3389, fontRid, size); }
+
+    /**
+     * Removes specified rendered glyph information from the cache entry.
+     * **Note:** This function will not remove textures associated with the glyphs, use {@link fontRemoveTexture} to remove them manually.
+     */
+    fontRemoveGlyph(fontRid: RID, size: Vector2i, glyph: number /* int64 */): void { _C(this, 3467, fontRid, size, glyph); }
+
+    /**
+     * Returns glyph advance (offset of the next glyph).
+     * **Note:** Advance for glyphs outlines is the same as the base glyph advance and is not saved.
+     */
+    fontGetGlyphAdvance(fontRid: RID, size: number /* int64 */, glyph: number /* int64 */): Vector2 { return _C(this, 3410, fontRid, size, glyph) as Vector2; }
+
+    /**
+     * Sets glyph advance (offset of the next glyph).
+     * **Note:** Advance for glyphs outlines is the same as the base glyph advance and is not saved.
+     */
+    fontSetGlyphAdvance(fontRid: RID, size: number /* int64 */, glyph: number /* int64 */, advance: Vector2): void { _C(this, 3489, fontRid, size, glyph, advance); }
+
+    /**
+     * Returns glyph offset from the baseline.
+     */
+    fontGetGlyphOffset(fontRid: RID, size: Vector2i, glyph: number /* int64 */): Vector2 { return _C(this, 3414, fontRid, size, glyph) as Vector2; }
+
+    /**
+     * Sets glyph offset from the baseline.
+     */
+    fontSetGlyphOffset(fontRid: RID, size: Vector2i, glyph: number /* int64 */, offset: Vector2): void { _C(this, 3490, fontRid, size, glyph, offset); }
+
+    /**
+     * Returns size of the glyph.
+     */
+    fontGetGlyphSize(fontRid: RID, size: Vector2i, glyph: number /* int64 */): Vector2 { return _C(this, 3415, fontRid, size, glyph) as Vector2; }
+
+    /**
+     * Sets size of the glyph.
+     */
+    fontSetGlyphSize(fontRid: RID, size: Vector2i, glyph: number /* int64 */, glSize: Vector2): void { _C(this, 3491, fontRid, size, glyph, glSize); }
+
+    /**
+     * Returns rectangle in the cache texture containing the glyph.
+     */
+    fontGetGlyphUvRect(fontRid: RID, size: Vector2i, glyph: number /* int64 */): Rect2 { return _C(this, 3419, fontRid, size, glyph) as Rect2; }
+
+    /**
+     * Sets rectangle in the cache texture containing the glyph.
+     */
+    fontSetGlyphUvRect(fontRid: RID, size: Vector2i, glyph: number /* int64 */, uvRect: Rect2): void { _C(this, 3493, fontRid, size, glyph, uvRect); }
+
+    /**
+     * Returns index of the cache texture containing the glyph.
+     */
+    fontGetGlyphTextureIdx(fontRid: RID, size: Vector2i, glyph: number /* int64 */): number { return _C(this, 3416, fontRid, size, glyph) as number; }
+
+    /**
+     * Sets index of the cache texture containing the glyph.
+     */
+    fontSetGlyphTextureIdx(fontRid: RID, size: Vector2i, glyph: number /* int64 */, textureIdx: number /* int64 */): void { _C(this, 3492, fontRid, size, glyph, textureIdx); }
+
+    /**
+     * Returns resource ID of the cache texture containing the glyph.
+     * **Note:** If there are pending glyphs to render, calling this function might trigger the texture cache update.
+     */
+    fontGetGlyphTextureRid(fontRid: RID, size: Vector2i, glyph: number /* int64 */): RID { return _C(this, 3417, fontRid, size, glyph) as RID; }
+
+    /**
+     * Returns size of the cache texture containing the glyph.
+     * **Note:** If there are pending glyphs to render, calling this function might trigger the texture cache update.
+     */
+    fontGetGlyphTextureSize(fontRid: RID, size: Vector2i, glyph: number /* int64 */): Vector2 { return _C(this, 3418, fontRid, size, glyph) as Vector2; }
+
+    /**
+     * Returns outline contours of the glyph as a {@link Dictionary} with the following contents:
+     * `points`         - {@link PackedVector3Array}, containing outline points. `x` and `y` are point coordinates. `z` is the type of the point, using the {@link ContourPointTag} values.
+     * `contours`       - {@link PackedInt32Array}, containing indices the end points of each contour.
+     * `orientation`    - {@link bool}, contour orientation. If `true`, clockwise contours must be filled.
+     * - Two successive {@link CONTOUR_CURVE_TAG_ON} points indicate a line segment.
+     * - One {@link CONTOUR_CURVE_TAG_OFF_CONIC} point between two {@link CONTOUR_CURVE_TAG_ON} points indicates a single conic (quadratic) Bézier arc.
+     * - Two {@link CONTOUR_CURVE_TAG_OFF_CUBIC} points between two {@link CONTOUR_CURVE_TAG_ON} points indicate a single cubic Bézier arc.
+     * - Two successive {@link CONTOUR_CURVE_TAG_OFF_CONIC} points indicate two successive conic (quadratic) Bézier arcs with a virtual {@link CONTOUR_CURVE_TAG_ON} point at their middle.
+     * - Each contour is closed. The last point of a contour uses the first point of a contour as its next point, and vice versa. The first point can be {@link CONTOUR_CURVE_TAG_OFF_CONIC} point.
+     */
+    fontGetGlyphContours(font: RID, size: number /* int64 */, index: number /* int64 */): GodotDictionary { return _C(this, 3411, font, size, index) as GodotDictionary; }
+
+    /**
+     * Returns list of the kerning overrides.
+     */
+    fontGetKerningList(fontRid: RID, size: number /* int64 */): GodotArray<Vector2i> { return _C(this, 3423, fontRid, size) as GodotArray<Vector2i>; }
+
+    /**
+     * Removes all kerning overrides.
+     */
+    fontClearKerningMap(fontRid: RID, size: number /* int64 */): void { _C(this, 3390, fontRid, size); }
+
+    /**
+     * Removes kerning override for the pair of glyphs.
+     */
+    fontRemoveKerning(fontRid: RID, size: number /* int64 */, glyphPair: Vector2i): void { _C(this, 3468, fontRid, size, glyphPair); }
+
+    /**
+     * Sets kerning for the pair of glyphs.
+     */
+    fontSetKerning(fontRid: RID, size: number /* int64 */, glyphPair: Vector2i, kerning: Vector2): void { _C(this, 3496, fontRid, size, glyphPair, kerning); }
+
+    /**
+     * Returns kerning for the pair of glyphs.
+     */
+    fontGetKerning(fontRid: RID, size: number /* int64 */, glyphPair: Vector2i): Vector2 { return _C(this, 3422, fontRid, size, glyphPair) as Vector2; }
+
+    /**
+     * Returns the glyph index of a `char`, optionally modified by the `variationSelector`. See {@link fontGetCharFromGlyphIndex}.
+     */
+    fontGetGlyphIndex(fontRid: RID, size: number /* int64 */, _char: number /* int64 */, variationSelector: number /* int64 */): number { return _C(this, 3412, fontRid, size, _char, variationSelector) as number; }
+
+    /**
+     * Returns character code associated with `glyphIndex`, or `0` if `glyphIndex` is invalid. See {@link fontGetGlyphIndex}.
+     */
+    fontGetCharFromGlyphIndex(fontRid: RID, size: number /* int64 */, glyphIndex: number /* int64 */): number { return _C(this, 3400, fontRid, size, glyphIndex) as number; }
+
+    /**
+     * Returns `true` if a Unicode `char` is available in the font.
+     */
+    fontHasChar(fontRid: RID, _char: number /* int64 */): boolean { return _C(this, 3457, fontRid, _char) as boolean; }
+
+    /**
+     * Returns a string containing all the characters available in the font.
+     */
+    fontGetSupportedChars(fontRid: RID): string { return _C(this, 3446, fontRid) as string; }
+
+    /**
+     * Returns an array containing all glyph indices in the font.
+     */
+    fontGetSupportedGlyphs(fontRid: RID): PackedInt32Array { return _C(this, 3447, fontRid) as PackedInt32Array; }
+
+    /**
+     * Renders the range of characters to the font cache texture.
+     */
+    fontRenderRange(fontRid: RID, size: Vector2i, start: number /* int64 */, end: number /* int64 */): void { _C(this, 3474, fontRid, size, start, end); }
+
+    /**
+     * Renders specified glyph to the font cache texture.
+     */
+    fontRenderGlyph(fontRid: RID, size: Vector2i, index: number /* int64 */): void { _C(this, 3473, fontRid, size, index); }
+
+    /**
+     * Draws single glyph into a canvas item at the position, using `fontRid` at the size `size`. If `oversampling` is greater than zero, it is used as font oversampling factor, otherwise viewport oversampling settings are used.
+     * **Note:** Glyph index is specific to the font, use glyphs indices returned by {@link shapedTextGetGlyphs} or {@link fontGetGlyphIndex}.
+     * **Note:** If there are pending glyphs to render, calling this function might trigger the texture cache update.
+     */
+    fontDrawGlyph(fontRid: RID, canvas: RID, size: number /* int64 */, pos: Vector2, index: number /* int64 */, color?: Color /* = Color(1, 1, 1, 1) */, oversampling?: number /* = 0.0 */): void { _C(this, 3395, fontRid, canvas, size, pos, index, color, oversampling); }
+
+    /**
+     * Draws single glyph outline of size `outlineSize` into a canvas item at the position, using `fontRid` at the size `size`. If `oversampling` is greater than zero, it is used as font oversampling factor, otherwise viewport oversampling settings are used.
+     * **Note:** Glyph index is specific to the font, use glyphs indices returned by {@link shapedTextGetGlyphs} or {@link fontGetGlyphIndex}.
+     * **Note:** If there are pending glyphs to render, calling this function might trigger the texture cache update.
+     */
+    fontDrawGlyphOutline(fontRid: RID, canvas: RID, size: number /* int64 */, outlineSize: number /* int64 */, pos: Vector2, index: number /* int64 */, color?: Color /* = Color(1, 1, 1, 1) */, oversampling?: number /* = 0.0 */): void { _C(this, 3396, fontRid, canvas, size, outlineSize, pos, index, color, oversampling); }
+
+    /**
+     * Returns `true` if the font supports the given language (as a [ISO 639](https://en.wikipedia.org/wiki/ISO_639-1) code).
+     */
+    fontIsLanguageSupported(fontRid: RID, language: string): boolean { return _C(this, 3460, fontRid, language) as boolean; }
+
+    /**
+     * Adds override for {@link fontIsLanguageSupported}.
+     */
+    fontSetLanguageSupportOverride(fontRid: RID, language: string, supported: boolean): void { _C(this, 3497, fontRid, language, supported); }
+
+    /**
+     * Returns `true` if support override is enabled for the `language`.
+     */
+    fontGetLanguageSupportOverride(fontRid: RID, language: string): boolean { return _C(this, 3424, fontRid, language) as boolean; }
+
+    /**
+     * Remove language support override.
+     */
+    fontRemoveLanguageSupportOverride(fontRid: RID, language: string): void { _C(this, 3469, fontRid, language); }
+
+    /**
+     * Returns list of language support overrides.
+     */
+    fontGetLanguageSupportOverrides(fontRid: RID): PackedStringArray { return _C(this, 3425, fontRid) as PackedStringArray; }
+
+    /**
+     * Returns `true` if the font supports the given script (as a [ISO 15924](https://en.wikipedia.org/wiki/ISO_15924) code).
+     */
+    fontIsScriptSupported(fontRid: RID, script: string): boolean { return _C(this, 3463, fontRid, script) as boolean; }
+
+    /**
+     * Adds override for {@link fontIsScriptSupported}.
+     */
+    fontSetScriptSupportOverride(fontRid: RID, script: string, supported: boolean): void { _C(this, 3507, fontRid, script, supported); }
+
+    /**
+     * Returns `true` if support override is enabled for the `script`.
+     */
+    fontGetScriptSupportOverride(fontRid: RID, script: string): boolean { return _C(this, 3437, fontRid, script) as boolean; }
+
+    /**
+     * Removes script support override.
+     */
+    fontRemoveScriptSupportOverride(fontRid: RID, script: string): void { _C(this, 3470, fontRid, script); }
+
+    /**
+     * Returns list of script support overrides.
+     */
+    fontGetScriptSupportOverrides(fontRid: RID): PackedStringArray { return _C(this, 3438, fontRid) as PackedStringArray; }
+
+    /**
+     * Sets font OpenType feature set override.
+     */
+    fontSetOpentypeFeatureOverrides(fontRid: RID, overrides: GodotDictionary): void { _C(this, 3503, fontRid, overrides); }
+
+    /**
+     * Returns font OpenType feature set override.
+     */
+    fontGetOpentypeFeatureOverrides(fontRid: RID): GodotDictionary { return _C(this, 3429, fontRid) as GodotDictionary; }
+
+    /**
+     * Returns the dictionary of the supported OpenType features.
+     */
+    fontSupportedFeatureList(fontRid: RID): GodotDictionary { return _C(this, 3524, fontRid) as GodotDictionary; }
+
+    /**
+     * Returns the dictionary of the supported OpenType variation coordinates.
+     */
+    fontSupportedVariationList(fontRid: RID): GodotDictionary { return _C(this, 3525, fontRid) as GodotDictionary; }
+
+    /**
+     * This method does nothing and always returns `1.0`.
+     */
+    fontGetGlobalOversampling(): number { return _C(this, 3409) as number; }
+
+    /**
+     * This method does nothing.
+     */
+    fontSetGlobalOversampling(oversampling: number /* double */): void { _C(this, 3488, oversampling); }
+
+    /**
+     * Returns size of the replacement character (box with character hexadecimal code that is drawn in place of invalid characters).
+     */
+    getHexCodeBoxSize(size: number /* int64 */, index: number /* int64 */): Vector2 { return _C(this, 5034, size, index) as Vector2; }
+
+    /**
+     * Draws box displaying character hexadecimal code. Used for replacing missing characters.
+     */
+    drawHexCodeBox(canvas: RID, size: number /* int64 */, pos: Vector2, index: number /* int64 */, color: Color): void { _C(this, 2921, canvas, size, pos, index, color); }
+
+    /**
+     * Creates a new buffer for complex text layout, with the given `direction` and `orientation`. To free the resulting buffer, use {@link freeRid} method.
+     * **Note:** Direction is ignored if server does not support {@link FEATURE_BIDI_LAYOUT} feature (supported by {@link TextServerAdvanced}).
+     * **Note:** Orientation is ignored if server does not support {@link FEATURE_VERTICAL_LAYOUT} feature (supported by {@link TextServerAdvanced}).
+     */
+    createShapedText(direction?: Direction /* = 0 */, orientation?: Orientation /* = 0 */): RID { return _C(this, 2570, direction, orientation) as RID; }
+
+    /**
+     * Clears text buffer (removes text and inline objects).
+     */
+    shapedTextClear(rid: RID): void { _C(this, 13498, rid); }
+
+    /**
+     * Duplicates shaped text buffer.
+     */
+    shapedTextDuplicate(rid: RID): RID { return _C(this, 13502, rid) as RID; }
+
+    /**
+     * Sets desired text direction. If set to {@link DIRECTION_AUTO}, direction will be detected based on the buffer contents and current locale.
+     * **Note:** Direction is ignored if server does not support {@link FEATURE_BIDI_LAYOUT} feature (supported by {@link TextServerAdvanced}).
+     */
+    shapedTextSetDirection(shaped: RID, direction?: Direction /* = 0 */): void { _C(this, 13552, shaped, direction); }
+
+    /**
+     * Returns direction of the text.
+     */
+    shapedTextGetDirection(shaped: RID): Direction { return _C(this, 13510, shaped) as Direction; }
+
+    /**
+     * Returns direction of the text, inferred by the BiDi algorithm.
+     */
+    shapedTextGetInferredDirection(shaped: RID): Direction { return _C(this, 13518, shaped) as Direction; }
+
+    /**
+     * Overrides BiDi for the structured text.
+     * Override ranges should cover full source text without overlaps. BiDi algorithm will be used on each range separately.
+     */
+    shapedTextSetBidiOverride(shaped: RID, override: GodotArray): void { _C(this, 13549, shaped, override); }
+
+    /**
+     * Sets custom punctuation character list, used for word breaking. If set to empty string, server defaults are used.
+     */
+    shapedTextSetCustomPunctuation(shaped: RID, punct: string): void { _C(this, 13551, shaped, punct); }
+
+    /**
+     * Returns custom punctuation character list, used for word breaking. If set to empty string, server defaults are used.
+     */
+    shapedTextGetCustomPunctuation(shaped: RID): string { return _C(this, 13508, shaped) as string; }
+
+    /**
+     * Sets ellipsis character used for text clipping.
+     */
+    shapedTextSetCustomEllipsis(shaped: RID, _char: number /* int64 */): void { _C(this, 13550, shaped, _char); }
+
+    /**
+     * Returns ellipsis character used for text clipping.
+     */
+    shapedTextGetCustomEllipsis(shaped: RID): number { return _C(this, 13507, shaped) as number; }
+
+    /**
+     * Sets desired text orientation.
+     * **Note:** Orientation is ignored if server does not support {@link FEATURE_VERTICAL_LAYOUT} feature (supported by {@link TextServerAdvanced}).
+     */
+    shapedTextSetOrientation(shaped: RID, orientation?: Orientation /* = 0 */): void { _C(this, 13553, shaped, orientation); }
+
+    /**
+     * Returns text orientation.
+     */
+    shapedTextGetOrientation(shaped: RID): Orientation { return _C(this, 13525, shaped) as Orientation; }
+
+    /**
+     * If set to `true` text buffer will display invalid characters as hexadecimal codes, otherwise nothing is displayed.
+     */
+    shapedTextSetPreserveInvalid(shaped: RID, enabled: boolean): void { _C(this, 13555, shaped, enabled); }
+
+    /**
+     * Returns `true` if text buffer is configured to display hexadecimal codes in place of invalid characters.
+     * **Note:** If set to `false`, nothing is displayed in place of invalid characters.
+     */
+    shapedTextGetPreserveInvalid(shaped: RID): boolean { return _C(this, 13528, shaped) as boolean; }
+
+    /**
+     * If set to `true` text buffer will display control characters.
+     */
+    shapedTextSetPreserveControl(shaped: RID, enabled: boolean): void { _C(this, 13554, shaped, enabled); }
+
+    /**
+     * Returns `true` if text buffer is configured to display control characters.
+     */
+    shapedTextGetPreserveControl(shaped: RID): boolean { return _C(this, 13527, shaped) as boolean; }
+
+    /**
+     * Sets extra spacing added between glyphs or lines in pixels.
+     */
+    shapedTextSetSpacing(shaped: RID, spacing: SpacingType, value: number /* int64 */): void { _C(this, 13556, shaped, spacing, value); }
+
+    /**
+     * Returns extra spacing added between glyphs or lines in pixels.
+     */
+    shapedTextGetSpacing(shaped: RID, spacing: SpacingType): number { return _C(this, 13532, shaped, spacing) as number; }
+
+    /**
+     * Adds text span and font to draw it to the text buffer.
+     */
+    shapedTextAddString(shaped: RID, text: string, fonts: GodotArray<RID>, size: number /* int64 */, opentypeFeatures?: GodotDictionary /* = {} */, language?: string /* = "" */, meta?: Variant /* = null */): boolean { return _C(this, 13497, shaped, text, fonts, size, opentypeFeatures, language, meta) as boolean; }
+
+    /**
+     * Adds inline object to the text buffer, `key` must be unique. In the text, object is represented as `length` object replacement characters.
+     */
+    shapedTextAddObject(shaped: RID, key: Variant, size: Vector2, inlineAlign?: InlineAlignment /* = 5 */, length?: number /* = 1,  int64 */, baseline?: number /* = 0.0,  double */): boolean { return _C(this, 13496, shaped, key, size, inlineAlign, length, baseline) as boolean; }
+
+    /**
+     * Sets new size and alignment of embedded object.
+     */
+    shapedTextResizeObject(shaped: RID, key: Variant, size: Vector2, inlineAlign?: InlineAlignment /* = 5 */, baseline?: number /* = 0.0,  double */): boolean { return _C(this, 13548, shaped, key, size, inlineAlign, baseline) as boolean; }
+
+    /**
+     * Returns `true` if an object with `key` is embedded in this shaped text buffer.
+     */
+    shapedTextHasObject(shaped: RID, key: Variant): boolean { return _C(this, 13538, shaped, key) as boolean; }
+
+    /**
+     * Returns the text buffer source text, including object replacement characters.
+     */
+    shapedGetText(shaped: RID): string { return _C(this, 13494, shaped) as string; }
+
+    /**
+     * Returns number of text spans added using {@link shapedTextAddString} or {@link shapedTextAddObject}.
+     */
+    shapedGetSpanCount(shaped: RID): number { return _C(this, 13489, shaped) as number; }
+
+    /**
+     * Returns text span metadata.
+     */
+    shapedGetSpanMeta(shaped: RID, index: number /* int64 */): Variant { return _C(this, 13491, shaped, index) as Variant; }
+
+    /**
+     * Returns text embedded object key.
+     */
+    shapedGetSpanEmbeddedObject(shaped: RID, index: number /* int64 */): Variant { return _C(this, 13490, shaped, index) as Variant; }
+
+    /**
+     * Returns the text span source text.
+     */
+    shapedGetSpanText(shaped: RID, index: number /* int64 */): string { return _C(this, 13493, shaped, index) as string; }
+
+    /**
+     * Returns the text span embedded object key.
+     */
+    shapedGetSpanObject(shaped: RID, index: number /* int64 */): Variant { return _C(this, 13492, shaped, index) as Variant; }
+
+    /**
+     * Changes text span font, font size, and OpenType features, without changing the text.
+     */
+    shapedSetSpanUpdateFont(shaped: RID, index: number /* int64 */, fonts: GodotArray<RID>, size: number /* int64 */, opentypeFeatures?: GodotDictionary /* = {} */): void { _C(this, 13495, shaped, index, fonts, size, opentypeFeatures); }
+
+    /**
+     * Returns the number of uniform text runs in the buffer.
+     */
+    shapedGetRunCount(shaped: RID): number { return _C(this, 13480, shaped) as number; }
+
+    /**
+     * Returns the source text of the `index` text run (in visual order).
+     */
+    shapedGetRunText(shaped: RID, index: number /* int64 */): string { return _C(this, 13488, shaped, index) as string; }
+
+    /**
+     * Returns the source text range of the `index` text run (in visual order).
+     */
+    shapedGetRunRange(shaped: RID, index: number /* int64 */): Vector2i { return _C(this, 13487, shaped, index) as Vector2i; }
+
+    /**
+     * Returns the glyph range of the `index` text run (in visual order).
+     */
+    shapedGetRunGlyphRange(shaped: RID, index: number /* int64 */): Vector2i { return _C(this, 13484, shaped, index) as Vector2i; }
+
+    /**
+     * Returns the font RID of the `index` text run (in visual order).
+     */
+    shapedGetRunFontRid(shaped: RID, index: number /* int64 */): RID { return _C(this, 13482, shaped, index) as RID; }
+
+    /**
+     * Returns the font size of the `index` text run (in visual order).
+     */
+    shapedGetRunFontSize(shaped: RID, index: number /* int64 */): number { return _C(this, 13483, shaped, index) as number; }
+
+    /**
+     * Returns the language of the `index` text run (in visual order).
+     */
+    shapedGetRunLanguage(shaped: RID, index: number /* int64 */): string { return _C(this, 13485, shaped, index) as string; }
+
+    /**
+     * Returns the direction of the `index` text run (in visual order).
+     */
+    shapedGetRunDirection(shaped: RID, index: number /* int64 */): Direction { return _C(this, 13481, shaped, index) as Direction; }
+
+    /**
+     * Returns the embedded object of the `index` text run (in visual order).
+     */
+    shapedGetRunObject(shaped: RID, index: number /* int64 */): Variant { return _C(this, 13486, shaped, index) as Variant; }
+
+    /**
+     * Returns text buffer for the substring of the text in the `shaped` text buffer (including inline objects).
+     */
+    shapedTextSubstr(shaped: RID, start: number /* int64 */, length: number /* int64 */): RID { return _C(this, 13559, shaped, start, length) as RID; }
+
+    /**
+     * Returns the parent buffer from which the substring originates.
+     */
+    shapedTextGetParent(shaped: RID): RID { return _C(this, 13526, shaped) as RID; }
+
+    /**
+     * Adjusts text width to fit to specified width, returns new text width.
+     */
+    shapedTextFitToWidth(shaped: RID, width: number /* double */, justificationFlags?: JustificationFlag /* = 3 */): number { return _C(this, 13503, shaped, width, justificationFlags) as number; }
+
+    /**
+     * Aligns shaped text to the given tab-stops.
+     */
+    shapedTextTabAlign(shaped: RID, tabStops: PackedFloat32Array): number { return _C(this, 13560, shaped, tabStops) as number; }
+
+    /**
+     * Shapes buffer if it's not shaped. Returns `true` if the string is shaped successfully.
+     * **Note:** It is not necessary to call this function manually, buffer will be shaped automatically as soon as any of its output data is requested.
+     */
+    shapedTextShape(shaped: RID): boolean { return _C(this, 13557, shaped) as boolean; }
+
+    /**
+     * Returns `true` if buffer is successfully shaped.
+     */
+    shapedTextIsReady(shaped: RID): boolean { return _C(this, 13542, shaped) as boolean; }
+
+    /**
+     * Returns `true` if text buffer contains any visible characters.
+     */
+    shapedTextHasVisibleChars(shaped: RID): boolean { return _C(this, 13539, shaped) as boolean; }
+
+    /**
+     * Returns an array of glyphs in the visual order.
+     */
+    shapedTextGetGlyphs(shaped: RID): GodotArray<GodotDictionary> { return _C(this, 13516, shaped) as GodotArray<GodotDictionary>; }
+
+    /**
+     * Returns text glyphs in the logical order.
+     */
+    shapedTextSortLogical(shaped: RID): GodotArray<GodotDictionary> { return _C(this, 13558, shaped) as GodotArray<GodotDictionary>; }
+
+    /**
+     * Returns number of glyphs in the buffer.
+     */
+    shapedTextGetGlyphCount(shaped: RID): number { return _C(this, 13515, shaped) as number; }
+
+    /**
+     * Returns substring buffer character range in the parent buffer.
+     */
+    shapedTextGetRange(shaped: RID): Vector2i { return _C(this, 13529, shaped) as Vector2i; }
+
+    /**
+     * Breaks text to the lines and columns. Returns character ranges for each segment.
+     */
+    shapedTextGetLineBreaksAdv(shaped: RID, width: PackedFloat32Array, start?: number /* = 0,  int64 */, once?: boolean /* = true */, breakFlags?: LineBreakFlag /* = 3 */): PackedInt32Array { return _C(this, 13520, shaped, width, start, once, breakFlags) as PackedInt32Array; }
+
+    /**
+     * Breaks text to the lines and returns character ranges for each line.
+     */
+    shapedTextGetLineBreaks(shaped: RID, width: number /* double */, start?: number /* = 0,  int64 */, breakFlags?: LineBreakFlag /* = 3 */): PackedInt32Array { return _C(this, 13519, shaped, width, start, breakFlags) as PackedInt32Array; }
+
+    /**
+     * Breaks text into words and returns array of character ranges. Use `graphemeFlags` to set what characters are used for breaking.
+     */
+    shapedTextGetWordBreaks(shaped: RID, graphemeFlags?: GraphemeFlag /* = 264 */, skipGraphemeFlags?: GraphemeFlag /* = 4 */): PackedInt32Array { return _C(this, 13537, shaped, graphemeFlags, skipGraphemeFlags) as PackedInt32Array; }
+
+    /**
+     * Returns the position of the overrun trim.
+     */
+    shapedTextGetTrimPos(shaped: RID): number { return _C(this, 13533, shaped) as number; }
+
+    /**
+     * Returns position of the ellipsis.
+     */
+    shapedTextGetEllipsisPos(shaped: RID): number { return _C(this, 13514, shaped) as number; }
+
+    /**
+     * Returns array of the glyphs in the ellipsis.
+     */
+    shapedTextGetEllipsisGlyphs(shaped: RID): GodotArray<GodotDictionary> { return _C(this, 13513, shaped) as GodotArray<GodotDictionary>; }
+
+    /**
+     * Returns number of glyphs in the ellipsis.
+     */
+    shapedTextGetEllipsisGlyphCount(shaped: RID): number { return _C(this, 13512, shaped) as number; }
+
+    /**
+     * Trims text if it exceeds the given width.
+     */
+    shapedTextOverrunTrimToWidth(shaped: RID, width?: number /* = 0,  double */, overrunTrimFlags?: TextOverrunFlag /* = 0 */): void { _C(this, 13545, shaped, width, overrunTrimFlags); }
+
+    /**
+     * Returns array of inline objects.
+     */
+    shapedTextGetObjects(shaped: RID): GodotArray { return _C(this, 13524, shaped) as GodotArray; }
+
+    /**
+     * Returns bounding rectangle of the inline object.
+     */
+    shapedTextGetObjectRect(shaped: RID, key: Variant): Rect2 { return _C(this, 13523, shaped, key) as Rect2; }
+
+    /**
+     * Returns the character range of the inline object.
+     */
+    shapedTextGetObjectRange(shaped: RID, key: Variant): Vector2i { return _C(this, 13522, shaped, key) as Vector2i; }
+
+    /**
+     * Returns the glyph index of the inline object.
+     */
+    shapedTextGetObjectGlyph(shaped: RID, key: Variant): number { return _C(this, 13521, shaped, key) as number; }
+
+    /**
+     * Returns size of the text.
+     */
+    shapedTextGetSize(shaped: RID): Vector2 { return _C(this, 13531, shaped) as Vector2; }
+
+    /**
+     * Returns the text ascent (number of pixels above the baseline for horizontal layout or to the left of baseline for vertical).
+     * **Note:** Overall ascent can be higher than font ascent, if some glyphs are displaced from the baseline.
+     */
+    shapedTextGetAscent(shaped: RID): number { return _C(this, 13504, shaped) as number; }
+
+    /**
+     * Returns the text descent (number of pixels below the baseline for horizontal layout or to the right of baseline for vertical).
+     * **Note:** Overall descent can be higher than font descent, if some glyphs are displaced from the baseline.
+     */
+    shapedTextGetDescent(shaped: RID): number { return _C(this, 13509, shaped) as number; }
+
+    /**
+     * Returns width (for horizontal layout) or height (for vertical) of the text.
+     */
+    shapedTextGetWidth(shaped: RID): number { return _C(this, 13536, shaped) as number; }
+
+    /**
+     * Returns pixel offset of the underline below the baseline.
+     */
+    shapedTextGetUnderlinePosition(shaped: RID): number { return _C(this, 13534, shaped) as number; }
+
+    /**
+     * Returns thickness of the underline.
+     */
+    shapedTextGetUnderlineThickness(shaped: RID): number { return _C(this, 13535, shaped) as number; }
+
+    /**
+     * Returns shapes of the carets corresponding to the character offset `position` in the text. Returned caret shape is 1 pixel wide rectangle.
+     */
+    shapedTextGetCarets(shaped: RID, position: number /* int64 */): GodotDictionary { return _C(this, 13505, shaped, position) as GodotDictionary; }
+
+    /**
+     * Returns selection rectangles for the specified character range.
+     */
+    shapedTextGetSelection(shaped: RID, start: number /* int64 */, end: number /* int64 */): PackedVector2Array { return _C(this, 13530, shaped, start, end) as PackedVector2Array; }
+
+    /**
+     * Returns grapheme index at the specified pixel offset at the baseline, or `-1` if none is found.
+     */
+    shapedTextHitTestGrapheme(shaped: RID, coords: number /* double */): number { return _C(this, 13540, shaped, coords) as number; }
+
+    /**
+     * Returns caret character offset at the specified pixel offset at the baseline. This function always returns a valid position.
+     */
+    shapedTextHitTestPosition(shaped: RID, coords: number /* double */): number { return _C(this, 13541, shaped, coords) as number; }
+
+    /**
+     * Returns composite character's bounds as offsets from the start of the line.
+     */
+    shapedTextGetGraphemeBounds(shaped: RID, pos: number /* int64 */): Vector2 { return _C(this, 13517, shaped, pos) as Vector2; }
+
+    /**
+     * Returns grapheme end position closest to the `pos`.
+     */
+    shapedTextNextGraphemePos(shaped: RID, pos: number /* int64 */): number { return _C(this, 13544, shaped, pos) as number; }
+
+    /**
+     * Returns grapheme start position closest to the `pos`.
+     */
+    shapedTextPrevGraphemePos(shaped: RID, pos: number /* int64 */): number { return _C(this, 13547, shaped, pos) as number; }
+
+    /**
+     * Returns array of the composite character boundaries.
+     */
+    shapedTextGetCharacterBreaks(shaped: RID): PackedInt32Array { return _C(this, 13506, shaped) as PackedInt32Array; }
+
+    /**
+     * Returns composite character end position closest to the `pos`.
+     */
+    shapedTextNextCharacterPos(shaped: RID, pos: number /* int64 */): number { return _C(this, 13543, shaped, pos) as number; }
+
+    /**
+     * Returns composite character start position closest to the `pos`.
+     */
+    shapedTextPrevCharacterPos(shaped: RID, pos: number /* int64 */): number { return _C(this, 13546, shaped, pos) as number; }
+
+    /**
+     * Returns composite character position closest to the `pos`.
+     */
+    shapedTextClosestCharacterPos(shaped: RID, pos: number /* int64 */): number { return _C(this, 13499, shaped, pos) as number; }
+
+    /**
+     * Draw shaped text into a canvas item at a given position, with `color`. `pos` specifies the leftmost point of the baseline (for horizontal layout) or topmost point of the baseline (for vertical layout). If `oversampling` is greater than zero, it is used as font oversampling factor, otherwise viewport oversampling settings are used.
+     * `clipL` and `clipR` are offsets relative to `pos`, going to the right in horizontal layout and downward in vertical layout. If `clipL` is not negative, glyphs starting before the offset are clipped. If `clipR` is not negative, glyphs ending after the offset are clipped.
+     */
+    shapedTextDraw(shaped: RID, canvas: RID, pos: Vector2, clipL?: number /* = -1,  double */, clipR?: number /* = -1,  double */, color?: Color /* = Color(1, 1, 1, 1) */, oversampling?: number /* = 0.0 */): void { _C(this, 13500, shaped, canvas, pos, clipL, clipR, color, oversampling); }
+
+    /**
+     * Draw the outline of the shaped text into a canvas item at a given position, with `color`. `pos` specifies the leftmost point of the baseline (for horizontal layout) or topmost point of the baseline (for vertical layout). If `oversampling` is greater than zero, it is used as font oversampling factor, otherwise viewport oversampling settings are used.
+     * `clipL` and `clipR` are offsets relative to `pos`, going to the right in horizontal layout and downward in vertical layout. If `clipL` is not negative, glyphs starting before the offset are clipped. If `clipR` is not negative, glyphs ending after the offset are clipped.
+     */
+    shapedTextDrawOutline(shaped: RID, canvas: RID, pos: Vector2, clipL?: number /* = -1,  double */, clipR?: number /* = -1,  double */, outlineSize?: number /* = 1,  int64 */, color?: Color /* = Color(1, 1, 1, 1) */, oversampling?: number /* = 0.0 */): void { _C(this, 13501, shaped, canvas, pos, clipL, clipR, outlineSize, color, oversampling); }
+
+    /**
+     * Returns dominant direction of in the range of text.
+     */
+    shapedTextGetDominantDirectionInRange(shaped: RID, start: number /* int64 */, end: number /* int64 */): Direction { return _C(this, 13511, shaped, start, end) as Direction; }
+
+    /**
+     * Converts a number from Western Arabic (0..9) to the numeral system used in the given `language`.
+     * If `language` is an empty string, the active locale will be used.
+     */
+    formatNumber(number: string, language?: string /* = "" */): string { return _C(this, 3546, number, language) as string; }
+
+    /**
+     * Converts `number` from the numeral system used in the given `language` to Western Arabic (0..9).
+     * If `language` is an empty string, the active locale will be used.
+     */
+    parseNumber(number: string, language?: string /* = "" */): string { return _C(this, 9281, number, language) as string; }
+
+    /**
+     * Returns the percent sign used in the given `language`.
+     * If `language` is an empty string, the active locale will be used.
+     */
+    percentSign(language?: string /* = "" */): string { return _C(this, 9395, language) as string; }
+
+    /**
+     * Returns an array of the word break boundaries. Elements in the returned array are the offsets of the start and end of words. Therefore the length of the array is always even.
+     * When `charsPerLine` is greater than zero, line break boundaries are returned instead.
+     *
+     * ```text
+     *
+     * var ts = TextServerManager.get_primary_interface()
+     * # Corresponds to the substrings "The", "Godot", "Engine", and "4".
+     * print(ts.string_get_word_breaks("The Godot Engine, 4")) # Prints [0, 3, 4, 9, 10, 16, 18, 19]
+     * # Corresponds to the substrings "The", "Godot", "Engin", and "e, 4".
+     * print(ts.string_get_word_breaks("The Godot Engine, 4", "en", 5)) # Prints [0, 3, 4, 9, 10, 15, 15, 19]
+     * # Corresponds to the substrings "The Godot" and "Engine, 4".
+     * print(ts.string_get_word_breaks("The Godot Engine, 4", "en", 10)) # Prints [0, 9, 10, 19]
+     *
+     * ```
+     */
+    stringGetWordBreaks(string: string, language?: string /* = "" */, charsPerLine?: number /* = 0,  int64 */): PackedInt32Array { return _C(this, 13970, string, language, charsPerLine) as PackedInt32Array; }
+
+    /**
+     * Returns array of the composite character boundaries.
+     *
+     * ```text
+     *
+     * var ts = TextServerManager.get_primary_interface()
+     * print(ts.string_get_character_breaks("Test ❤️‍🔥 Test")) # Prints [1, 2, 3, 4, 5, 9, 10, 11, 12, 13, 14]
+     *
+     * ```
+     */
+    stringGetCharacterBreaks(string: string, language?: string /* = "" */): PackedInt32Array { return _C(this, 13969, string, language) as PackedInt32Array; }
+
+    /**
+     * Returns index of the first string in `dict` which is visually confusable with the `string`, or `-1` if none is found.
+     * **Note:** This method doesn't detect invisible characters, for spoof detection use it in combination with {@link spoofCheck}.
+     * **Note:** Always returns `-1` if the server does not support the {@link FEATURE_UNICODE_SECURITY} feature.
+     */
+    isConfusable(string: string, dict: PackedStringArray): number { return _C(this, 7855, string, dict) as number; }
+
+    /**
+     * Returns `true` if `string` is likely to be an attempt at confusing the reader.
+     * **Note:** Always returns `false` if the server does not support the {@link FEATURE_UNICODE_SECURITY} feature.
+     */
+    spoofCheck(string: string): boolean { return _C(this, 13789, string) as boolean; }
+
+    /**
+     * Strips diacritics from the string.
+     * **Note:** The result may be longer or shorter than the original.
+     */
+    stripDiacritics(string: string): string { return _C(this, 13976, string) as string; }
+
+    /**
+     * Returns `true` if `string` is a valid identifier.
+     * If the text server supports the {@link FEATURE_UNICODE_IDENTIFIERS} feature, a valid identifier must:
+     * - Conform to normalization form C.
+     * - Begin with a Unicode character of class XID_Start or `"_"`.
+     * - May contain Unicode characters of class XID_Continue in the other positions.
+     * - Use UAX #31 recommended scripts only (mixed scripts are allowed).
+     * If the {@link FEATURE_UNICODE_IDENTIFIERS} feature is not supported, a valid identifier must:
+     * - Begin with a Unicode character of class XID_Start or `"_"`.
+     * - May contain Unicode characters of class XID_Continue in the other positions.
+     */
+    isValidIdentifier(string: string): boolean { return _C(this, 8440, string) as boolean; }
+
+    /**
+     * Returns `true` if the given code point is a valid letter, i.e. it belongs to the Unicode category "L".
+     */
+    isValidLetter(unicode: number /* uint64 */): boolean { return _C(this, 8443, unicode) as boolean; }
+
+    /**
+     * Returns the string converted to `UPPERCASE`.
+     * **Note:** Casing is locale dependent and context sensitive if server support {@link FEATURE_CONTEXT_SENSITIVE_CASE_CONVERSION} feature (supported by {@link TextServerAdvanced}).
+     * **Note:** The result may be longer or shorter than the original.
+     */
+    stringToUpper(string: string, language?: string /* = "" */): string { return _C(this, 13973, string, language) as string; }
+
+    /**
+     * Returns the string converted to `lowercase`.
+     * **Note:** Casing is locale dependent and context sensitive if server support {@link FEATURE_CONTEXT_SENSITIVE_CASE_CONVERSION} feature (supported by {@link TextServerAdvanced}).
+     * **Note:** The result may be longer or shorter than the original.
+     */
+    stringToLower(string: string, language?: string /* = "" */): string { return _C(this, 13971, string, language) as string; }
+
+    /**
+     * Returns the string converted to `Title Case`.
+     * **Note:** Casing is locale dependent and context sensitive if server support {@link FEATURE_CONTEXT_SENSITIVE_CASE_CONVERSION} feature (supported by {@link TextServerAdvanced}).
+     * **Note:** The result may be longer or shorter than the original.
+     */
+    stringToTitle(string: string, language?: string /* = "" */): string { return _C(this, 13972, string, language) as string; }
+
+    /**
+     * Default implementation of the BiDi algorithm override function.
+     */
+    parseStructuredText(parserType: StructuredTextParser, args: GodotArray, text: string): GodotArray<Vector3i> { return _C(this, 9284, parserType, args, text) as GodotArray<Vector3i>; }
+
+    static readonly name = _R(771, TextServer);
+}
+
+export const FontAntialiasing = {
+    /**
+     * Font glyphs are rasterized as 1-bit bitmaps.
+     */
+    FONT_ANTIALIASING_NONE: 0,
+    /**
+     * Font glyphs are rasterized as 8-bit grayscale anti-aliased bitmaps.
+     */
+    FONT_ANTIALIASING_GRAY: 1,
+    /**
+     * Font glyphs are rasterized for LCD screens.
+     * LCD subpixel layout is determined by the value of the {@link ProjectSettings.gui/theme/lcdSubpixelLayout} setting.
+     * LCD subpixel anti-aliasing mode is suitable only for rendering horizontal, unscaled text in 2D.
+     */
+    FONT_ANTIALIASING_LCD: 2,
+} as const;
+
+export type FontAntialiasing = (typeof FontAntialiasing)[keyof typeof FontAntialiasing];
+
+export const FontLCDSubpixelLayout = {
+    /**
+     * Unknown or unsupported subpixel layout, LCD subpixel antialiasing is disabled.
+     */
+    FONT_LCD_SUBPIXEL_LAYOUT_NONE: 0,
+    /**
+     * Horizontal RGB subpixel layout.
+     */
+    FONT_LCD_SUBPIXEL_LAYOUT_HRGB: 1,
+    /**
+     * Horizontal BGR subpixel layout.
+     */
+    FONT_LCD_SUBPIXEL_LAYOUT_HBGR: 2,
+    /**
+     * Vertical RGB subpixel layout.
+     */
+    FONT_LCD_SUBPIXEL_LAYOUT_VRGB: 3,
+    /**
+     * Vertical BGR subpixel layout.
+     */
+    FONT_LCD_SUBPIXEL_LAYOUT_VBGR: 4,
+    /**
+     * Represents the size of the {@link FontLCDSubpixelLayout} enum.
+     */
+    FONT_LCD_SUBPIXEL_LAYOUT_MAX: 5,
+} as const;
+
+export type FontLCDSubpixelLayout = (typeof FontLCDSubpixelLayout)[keyof typeof FontLCDSubpixelLayout];
+
+export const Direction = {
+    /**
+     * Text direction is determined based on contents and current locale.
+     */
+    DIRECTION_AUTO: 0,
+    /**
+     * Text is written from left to right.
+     */
+    DIRECTION_LTR: 1,
+    /**
+     * Text is written from right to left.
+     */
+    DIRECTION_RTL: 2,
+    /**
+     * Text writing direction is the same as base string writing direction. Used for BiDi override only.
+     */
+    DIRECTION_INHERITED: 3,
+} as const;
+
+export type Direction = (typeof Direction)[keyof typeof Direction];
+
+export const Orientation = {
+    /**
+     * Text is written horizontally.
+     */
+    ORIENTATION_HORIZONTAL: 0,
+    /**
+     * Left to right text is written vertically from top to bottom.
+     * Right to left text is written vertically from bottom to top.
+     */
+    ORIENTATION_VERTICAL: 1,
+} as const;
+
+export type Orientation = (typeof Orientation)[keyof typeof Orientation];
+
+export const JustificationFlag = {
+    /**
+     * Do not justify text.
+     */
+    JUSTIFICATION_NONE: 0,
+    /**
+     * Justify text by adding and removing kashidas.
+     */
+    JUSTIFICATION_KASHIDA: 1,
+    /**
+     * Justify text by changing width of the spaces between the words.
+     */
+    JUSTIFICATION_WORD_BOUND: 2,
+    /**
+     * Remove trailing and leading spaces from the justified text.
+     */
+    JUSTIFICATION_TRIM_EDGE_SPACES: 4,
+    /**
+     * Only apply justification to the part of the text after the last tab.
+     */
+    JUSTIFICATION_AFTER_LAST_TAB: 8,
+    /**
+     * Apply justification to the trimmed line with ellipsis.
+     */
+    JUSTIFICATION_CONSTRAIN_ELLIPSIS: 16,
+    /**
+     * Do not apply justification to the last line of the paragraph.
+     */
+    JUSTIFICATION_SKIP_LAST_LINE: 32,
+    /**
+     * Do not apply justification to the last line of the paragraph with visible characters (takes precedence over {@link JUSTIFICATION_SKIP_LAST_LINE}).
+     */
+    JUSTIFICATION_SKIP_LAST_LINE_WITH_VISIBLE_CHARS: 64,
+    /**
+     * Always apply justification to the paragraphs with a single line ({@link JUSTIFICATION_SKIP_LAST_LINE} and {@link JUSTIFICATION_SKIP_LAST_LINE_WITH_VISIBLE_CHARS} are ignored).
+     */
+    JUSTIFICATION_DO_NOT_SKIP_SINGLE_LINE: 128,
+} as const;
+
+export type JustificationFlag = (typeof JustificationFlag)[keyof typeof JustificationFlag];
+
+export const AutowrapMode = {
+    /**
+     * Autowrap is disabled.
+     */
+    AUTOWRAP_OFF: 0,
+    /**
+     * Wraps the text inside the node's bounding rectangle by allowing to break lines at arbitrary positions, which is useful when very limited space is available.
+     */
+    AUTOWRAP_ARBITRARY: 1,
+    /**
+     * Wraps the text inside the node's bounding rectangle by soft-breaking between words.
+     */
+    AUTOWRAP_WORD: 2,
+    /**
+     * Behaves similarly to {@link AUTOWRAP_WORD}, but force-breaks a word if that single word does not fit in one line.
+     */
+    AUTOWRAP_WORD_SMART: 3,
+} as const;
+
+export type AutowrapMode = (typeof AutowrapMode)[keyof typeof AutowrapMode];
+
+export const LineBreakFlag = {
+    /**
+     * Do not break the line.
+     */
+    BREAK_NONE: 0,
+    /**
+     * Break the line at the line mandatory break characters (e.g. `"\n"`).
+     */
+    BREAK_MANDATORY: 1,
+    /**
+     * Break the line between the words.
+     */
+    BREAK_WORD_BOUND: 2,
+    /**
+     * Break the line between any unconnected graphemes.
+     */
+    BREAK_GRAPHEME_BOUND: 4,
+    /**
+     * Should be used only in conjunction with {@link BREAK_WORD_BOUND}, break the line between any unconnected graphemes, if it's impossible to break it between the words.
+     */
+    BREAK_ADAPTIVE: 8,
+    /**
+     * Remove edge spaces from the broken line segments.
+     */
+    BREAK_TRIM_EDGE_SPACES: 16,
+    /**
+     * Subtract first line indentation width from all lines after the first one.
+     */
+    BREAK_TRIM_INDENT: 32,
+    /**
+     * Remove spaces and line break characters from the start of broken line segments.
+     * E.g, after line breaking, the second segment of the following text `test  \n  next`, is `next` if the flag is set, and `  next` if it is not.
+     */
+    BREAK_TRIM_START_EDGE_SPACES: 64,
+    /**
+     * Remove spaces and line break characters from the end of broken line segments.
+     * E.g, after line breaking, the first segment of the following text `test  \n  next`, is `test` if the flag is set, and `test  \n` if it is not.
+     */
+    BREAK_TRIM_END_EDGE_SPACES: 128,
+} as const;
+
+export type LineBreakFlag = (typeof LineBreakFlag)[keyof typeof LineBreakFlag];
+
+export const VisibleCharactersBehavior = {
+    /**
+     * Trims text before the shaping. e.g, increasing {@link Label.visibleCharacters} or {@link RichTextLabel.visibleCharacters} value is visually identical to typing the text.
+     * **Note:** In this mode, trimmed text is not processed at all. It is not accounted for in line breaking and size calculations.
+     */
+    VC_CHARS_BEFORE_SHAPING: 0,
+    /**
+     * Displays glyphs that are mapped to the first {@link Label.visibleCharacters} or {@link RichTextLabel.visibleCharacters} characters from the beginning of the text.
+     */
+    VC_CHARS_AFTER_SHAPING: 1,
+    /**
+     * Displays {@link Label.visibleRatio} or {@link RichTextLabel.visibleRatio} glyphs, starting from the left or from the right, depending on {@link Control.layoutDirection} value.
+     */
+    VC_GLYPHS_AUTO: 2,
+    /**
+     * Displays {@link Label.visibleRatio} or {@link RichTextLabel.visibleRatio} glyphs, starting from the left.
+     */
+    VC_GLYPHS_LTR: 3,
+    /**
+     * Displays {@link Label.visibleRatio} or {@link RichTextLabel.visibleRatio} glyphs, starting from the right.
+     */
+    VC_GLYPHS_RTL: 4,
+} as const;
+
+export type VisibleCharactersBehavior = (typeof VisibleCharactersBehavior)[keyof typeof VisibleCharactersBehavior];
+
+export const OverrunBehavior = {
+    /**
+     * No text trimming is performed.
+     */
+    OVERRUN_NO_TRIMMING: 0,
+    /**
+     * Trims the text per character.
+     */
+    OVERRUN_TRIM_CHAR: 1,
+    /**
+     * Trims the text per word.
+     */
+    OVERRUN_TRIM_WORD: 2,
+    /**
+     * Trims the text per character and adds an ellipsis to indicate that parts are hidden if trimmed text is 6 characters or longer.
+     */
+    OVERRUN_TRIM_ELLIPSIS: 3,
+    /**
+     * Trims the text per word and adds an ellipsis to indicate that parts are hidden if trimmed text is 6 characters or longer.
+     */
+    OVERRUN_TRIM_WORD_ELLIPSIS: 4,
+    /**
+     * Trims the text per character and adds an ellipsis to indicate that parts are hidden regardless of trimmed text length.
+     */
+    OVERRUN_TRIM_ELLIPSIS_FORCE: 5,
+    /**
+     * Trims the text per word and adds an ellipsis to indicate that parts are hidden regardless of trimmed text length.
+     */
+    OVERRUN_TRIM_WORD_ELLIPSIS_FORCE: 6,
+} as const;
+
+export type OverrunBehavior = (typeof OverrunBehavior)[keyof typeof OverrunBehavior];
+
+export const TextOverrunFlag = {
+    /**
+     * No trimming is performed.
+     */
+    OVERRUN_NO_TRIM: 0,
+    /**
+     * Trims the text when it exceeds the given width.
+     */
+    OVERRUN_TRIM: 1,
+    /**
+     * Trims the text per word instead of per grapheme.
+     */
+    OVERRUN_TRIM_WORD_ONLY: 2,
+    /**
+     * Determines whether an ellipsis should be added at the end of the text.
+     */
+    OVERRUN_ADD_ELLIPSIS: 4,
+    /**
+     * Determines whether the ellipsis at the end of the text is enforced and may not be hidden.
+     */
+    OVERRUN_ENFORCE_ELLIPSIS: 8,
+    /**
+     * Accounts for the text being justified before attempting to trim it (see {@link JustificationFlag}).
+     */
+    OVERRUN_JUSTIFICATION_AWARE: 16,
+    /**
+     * Determines whether the ellipsis should be added regardless of the string length, otherwise it is added only if the string is 6 characters or longer.
+     */
+    OVERRUN_SHORT_STRING_ELLIPSIS: 32,
+} as const;
+
+export type TextOverrunFlag = (typeof TextOverrunFlag)[keyof typeof TextOverrunFlag];
+
+export const GraphemeFlag = {
+    /**
+     * Grapheme is supported by the font, and can be drawn.
+     */
+    GRAPHEME_IS_VALID: 1,
+    /**
+     * Grapheme is part of right-to-left or bottom-to-top run.
+     */
+    GRAPHEME_IS_RTL: 2,
+    /**
+     * Grapheme is not part of source text, it was added by justification process.
+     */
+    GRAPHEME_IS_VIRTUAL: 4,
+    /**
+     * Grapheme is whitespace.
+     */
+    GRAPHEME_IS_SPACE: 8,
+    /**
+     * Grapheme is mandatory break point (e.g. `"\n"`).
+     */
+    GRAPHEME_IS_BREAK_HARD: 16,
+    /**
+     * Grapheme is optional break point (e.g. space).
+     */
+    GRAPHEME_IS_BREAK_SOFT: 32,
+    /**
+     * Grapheme is the tabulation character.
+     */
+    GRAPHEME_IS_TAB: 64,
+    /**
+     * Grapheme is kashida.
+     */
+    GRAPHEME_IS_ELONGATION: 128,
+    /**
+     * Grapheme is punctuation character.
+     */
+    GRAPHEME_IS_PUNCTUATION: 256,
+    /**
+     * Grapheme is underscore character.
+     */
+    GRAPHEME_IS_UNDERSCORE: 512,
+    /**
+     * Grapheme is connected to the previous grapheme. Breaking line before this grapheme is not safe.
+     */
+    GRAPHEME_IS_CONNECTED: 1024,
+    /**
+     * It is safe to insert a U+0640 before this grapheme for elongation.
+     */
+    GRAPHEME_IS_SAFE_TO_INSERT_TATWEEL: 2048,
+    /**
+     * Grapheme is an object replacement character for the embedded object.
+     */
+    GRAPHEME_IS_EMBEDDED_OBJECT: 4096,
+    /**
+     * Grapheme is a soft hyphen.
+     */
+    GRAPHEME_IS_SOFT_HYPHEN: 8192,
+} as const;
+
+export type GraphemeFlag = (typeof GraphemeFlag)[keyof typeof GraphemeFlag];
+
+export const Hinting = {
+    /**
+     * Disables font hinting (smoother but less crisp).
+     */
+    HINTING_NONE: 0,
+    /**
+     * Use the light font hinting mode.
+     */
+    HINTING_LIGHT: 1,
+    /**
+     * Use the default font hinting mode (crisper but less smooth).
+     * **Note:** This hinting mode changes both horizontal and vertical glyph metrics. If applied to monospace font, some glyphs might have different width.
+     */
+    HINTING_NORMAL: 2,
+} as const;
+
+export type Hinting = (typeof Hinting)[keyof typeof Hinting];
+
+export const SubpixelPositioning = {
+    /**
+     * Glyph horizontal position is rounded to the whole pixel size, each glyph is rasterized once.
+     */
+    SUBPIXEL_POSITIONING_DISABLED: 0,
+    /**
+     * Glyph horizontal position is rounded based on font size.
+     * - To one quarter of the pixel size if font size is smaller or equal to {@link SUBPIXEL_POSITIONING_ONE_QUARTER_MAX_SIZE}.
+     * - To one half of the pixel size if font size is smaller or equal to {@link SUBPIXEL_POSITIONING_ONE_HALF_MAX_SIZE}.
+     * - To the whole pixel size for larger fonts.
+     */
+    SUBPIXEL_POSITIONING_AUTO: 1,
+    /**
+     * Glyph horizontal position is rounded to one half of the pixel size, each glyph is rasterized up to two times.
+     */
+    SUBPIXEL_POSITIONING_ONE_HALF: 2,
+    /**
+     * Glyph horizontal position is rounded to one quarter of the pixel size, each glyph is rasterized up to four times.
+     */
+    SUBPIXEL_POSITIONING_ONE_QUARTER: 3,
+    /**
+     * Maximum font size which will use "one half of the pixel" subpixel positioning in {@link SUBPIXEL_POSITIONING_AUTO} mode.
+     */
+    SUBPIXEL_POSITIONING_ONE_HALF_MAX_SIZE: 20,
+    /**
+     * Maximum font size which will use "one quarter of the pixel" subpixel positioning in {@link SUBPIXEL_POSITIONING_AUTO} mode.
+     */
+    SUBPIXEL_POSITIONING_ONE_QUARTER_MAX_SIZE: 16,
+} as const;
+
+export type SubpixelPositioning = (typeof SubpixelPositioning)[keyof typeof SubpixelPositioning];
+
+export const Feature = {
+    /**
+     * TextServer supports simple text layouts.
+     */
+    FEATURE_SIMPLE_LAYOUT: 1,
+    /**
+     * TextServer supports bidirectional text layouts.
+     */
+    FEATURE_BIDI_LAYOUT: 2,
+    /**
+     * TextServer supports vertical layouts.
+     */
+    FEATURE_VERTICAL_LAYOUT: 4,
+    /**
+     * TextServer supports complex text shaping.
+     */
+    FEATURE_SHAPING: 8,
+    /**
+     * TextServer supports justification using kashidas.
+     */
+    FEATURE_KASHIDA_JUSTIFICATION: 16,
+    /**
+     * TextServer supports complex line/word breaking rules (e.g. dictionary based).
+     */
+    FEATURE_BREAK_ITERATORS: 32,
+    /**
+     * TextServer supports loading bitmap fonts.
+     */
+    FEATURE_FONT_BITMAP: 64,
+    /**
+     * TextServer supports loading dynamic (TrueType, OpeType, etc.) fonts.
+     */
+    FEATURE_FONT_DYNAMIC: 128,
+    /**
+     * TextServer supports multichannel signed distance field dynamic font rendering.
+     */
+    FEATURE_FONT_MSDF: 256,
+    /**
+     * TextServer supports loading system fonts.
+     */
+    FEATURE_FONT_SYSTEM: 512,
+    /**
+     * TextServer supports variable fonts.
+     */
+    FEATURE_FONT_VARIABLE: 1024,
+    /**
+     * TextServer supports locale dependent and context sensitive case conversion.
+     */
+    FEATURE_CONTEXT_SENSITIVE_CASE_CONVERSION: 2048,
+    /**
+     * TextServer require external data file for some features, see {@link loadSupportData}.
+     */
+    FEATURE_USE_SUPPORT_DATA: 4096,
+    /**
+     * TextServer supports UAX #31 identifier validation, see {@link isValidIdentifier}.
+     */
+    FEATURE_UNICODE_IDENTIFIERS: 8192,
+    /**
+     * TextServer supports [Unicode Technical Report #36](https://unicode.org/reports/tr36/) and [Unicode Technical Standard #39](https://unicode.org/reports/tr39/) based spoof detection features.
+     */
+    FEATURE_UNICODE_SECURITY: 16384,
+} as const;
+
+export type Feature = (typeof Feature)[keyof typeof Feature];
+
+export const ContourPointTag = {
+    /**
+     * Contour point is on the curve.
+     */
+    CONTOUR_CURVE_TAG_ON: 1,
+    /**
+     * Contour point isn't on the curve, but serves as a control point for a conic (quadratic) Bézier arc.
+     */
+    CONTOUR_CURVE_TAG_OFF_CONIC: 0,
+    /**
+     * Contour point isn't on the curve, but serves as a control point for a cubic Bézier arc.
+     */
+    CONTOUR_CURVE_TAG_OFF_CUBIC: 2,
+} as const;
+
+export type ContourPointTag = (typeof ContourPointTag)[keyof typeof ContourPointTag];
+
+export const SpacingType = {
+    /**
+     * Spacing for each glyph.
+     */
+    SPACING_GLYPH: 0,
+    /**
+     * Spacing for the space character.
+     */
+    SPACING_SPACE: 1,
+    /**
+     * Spacing at the top of the line.
+     */
+    SPACING_TOP: 2,
+    /**
+     * Spacing at the bottom of the line.
+     */
+    SPACING_BOTTOM: 3,
+    /**
+     * Represents the size of the {@link SpacingType} enum.
+     */
+    SPACING_MAX: 4,
+} as const;
+
+export type SpacingType = (typeof SpacingType)[keyof typeof SpacingType];
+
+export const FontStyle = {
+    /**
+     * Font is bold.
+     */
+    FONT_BOLD: 1,
+    /**
+     * Font is italic or oblique.
+     */
+    FONT_ITALIC: 2,
+    /**
+     * Font has fixed-width characters (also known as monospace).
+     */
+    FONT_FIXED_WIDTH: 4,
+} as const;
+
+export type FontStyle = (typeof FontStyle)[keyof typeof FontStyle];
+
+export const StructuredTextParser = {
+    /**
+     * Use default Unicode BiDi algorithm.
+     */
+    STRUCTURED_TEXT_DEFAULT: 0,
+    /**
+     * BiDi override for URI.
+     */
+    STRUCTURED_TEXT_URI: 1,
+    /**
+     * BiDi override for file path.
+     */
+    STRUCTURED_TEXT_FILE: 2,
+    /**
+     * BiDi override for email.
+     */
+    STRUCTURED_TEXT_EMAIL: 3,
+    /**
+     * BiDi override for lists. Structured text options: list separator {@link String}.
+     */
+    STRUCTURED_TEXT_LIST: 4,
+    /**
+     * BiDi override for GDScript.
+     */
+    STRUCTURED_TEXT_GDSCRIPT: 5,
+    /**
+     * User defined structured text BiDi override function.
+     */
+    STRUCTURED_TEXT_CUSTOM: 6,
+} as const;
+
+export type StructuredTextParser = (typeof StructuredTextParser)[keyof typeof StructuredTextParser];
+
+export const FixedSizeScaleMode = {
+    /**
+     * Bitmap font is not scaled.
+     */
+    FIXED_SIZE_SCALE_DISABLE: 0,
+    /**
+     * Bitmap font is scaled to the closest integer multiple of the font's fixed size. This is the recommended option for pixel art fonts.
+     */
+    FIXED_SIZE_SCALE_INTEGER_ONLY: 1,
+    /**
+     * Bitmap font is scaled to an arbitrary (fractional) size. This is the recommended option for non-pixel art fonts.
+     */
+    FIXED_SIZE_SCALE_ENABLED: 2,
+} as const;
+
+export type FixedSizeScaleMode = (typeof FixedSizeScaleMode)[keyof typeof FixedSizeScaleMode];
+