@ringozz/godot 0.1.0

package/gen/classes/SurfaceTool.ts

@@ -0,0 +1,271 @@
+// 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 { GodotArray, PackedColorArray, PackedFloat32Array, PackedInt32Array, PackedVector2Array, PackedVector3Array } from '../heap-types/index.ts';
+import type { AABB, Color, Plane, Transform3D, Vector2, Vector3 } from '../value-types/index.ts';
+import type { ArrayMesh } from './ArrayMesh.ts';
+import type { Material } from './Material.ts';
+import type { Mesh, PrimitiveType } from './Mesh.ts';
+
+/**
+ * The {@link SurfaceTool} is used to construct a {@link Mesh} by specifying vertex attributes individually. It can be used to construct a {@link Mesh} from a script. All properties except indices need to be added before calling {@link addVertex}. For example, to add vertex colors and UVs:
+ *
+ *
+ * ```gdscript
+ *
+ * var st = SurfaceTool.new()
+ * st.begin(Mesh.PRIMITIVE_TRIANGLES)
+ * st.set_color(Color(1, 0, 0))
+ * st.set_uv(Vector2(0, 0))
+ * st.add_vertex(Vector3(0, 0, 0))
+ *
+ * ```
+ *
+ *
+ *
+ * The above {@link SurfaceTool} now contains one vertex of a triangle which has a UV coordinate and a specified {@link Color}. If another vertex were added without calling {@link setUv} or {@link setColor}, then the last values would be used.
+ * Vertex attributes must be passed **before** calling {@link addVertex}. Failure to do so will result in an error when committing the vertex information to a mesh.
+ * Additionally, the attributes used before the first vertex is added determine the format of the mesh. For example, if you only add UVs to the first vertex, you cannot add color to any of the subsequent vertices.
+ * See also {@link ArrayMesh}, {@link ImmediateMesh} and {@link MeshDataTool} for procedural geometry generation.
+ * **Note:** Godot uses clockwise [winding order](https://learnopengl.com/Advanced-OpenGL/Face-culling) for front faces of triangle primitive modes.
+ */
+export class SurfaceTool extends RefCounted {
+    constructor(name = 760) { super(name); }
+
+    /**
+     * Set to {@link SKIN_8_WEIGHTS} to indicate that up to 8 bone influences per vertex may be used.
+     * By default, only 4 bone influences are used ({@link SKIN_4_WEIGHTS}).
+     * **Note:** This function takes an enum, not the exact number of weights.
+     */
+    setSkinWeightCount(count: SkinWeightCount): void { _C(this, 12765, count); }
+
+    /**
+     * By default, returns {@link SKIN_4_WEIGHTS} to indicate only 4 bone influences per vertex are used.
+     * Returns {@link SKIN_8_WEIGHTS} if up to 8 influences are used.
+     * **Note:** This function returns an enum, not the exact number of weights.
+     */
+    getSkinWeightCount(): SkinWeightCount { return _C(this, 6416) as SkinWeightCount; }
+
+    /**
+     * Sets the color format for this custom `channelIndex`. Use {@link CUSTOM_MAX} to disable.
+     * Must be invoked after {@link begin} and should be set before {@link commit} or {@link commitToArrays}.
+     */
+    setCustomFormat(channelIndex: number, format: CustomFormat): void { _C(this, 11013, channelIndex, format); }
+
+    /**
+     * Returns the format for custom `channelIndex` (currently up to 4). Returns {@link CUSTOM_MAX} if this custom channel is unused.
+     */
+    getCustomFormat(channelIndex: number): CustomFormat { return _C(this, 4389, channelIndex) as CustomFormat; }
+
+    /**
+     * Called before adding any vertices. Takes the primitive type as an argument (e.g. {@link Mesh.PRIMITIVE_TRIANGLES}).
+     */
+    begin(primitive: PrimitiveType): void { _C(this, 1745, primitive); }
+
+    /**
+     * Specifies the position of current vertex. Should be called after specifying other vertex properties (e.g. Color, UV).
+     */
+    addVertex(vertex: Vector3): void { _C(this, 1335, vertex); }
+
+    /**
+     * Specifies a {@link Color} to use for the *next* vertex. If every vertex needs to have this information set and you fail to submit it for the first vertex, this information may not be used at all.
+     * **Note:** The material must have {@link BaseMaterial3D.vertexColorUseAsAlbedo} enabled for the vertex color to be visible.
+     */
+    setColor(color: Color): void { _C(this, 10905, color); }
+
+    /**
+     * Specifies a normal to use for the *next* vertex. If every vertex needs to have this information set and you fail to submit it for the first vertex, this information may not be used at all.
+     */
+    setNormal(normal: Vector3): void { _C(this, 12145, normal); }
+
+    /**
+     * Specifies a tangent to use for the *next* vertex. If every vertex needs to have this information set and you fail to submit it for the first vertex, this information may not be used at all.
+     * **Note:** Even though `tangent` is a {@link Plane}, it does not directly represent the tangent plane. Its {@link Plane.x}, {@link Plane.y}, and {@link Plane.z} represent the tangent vector and {@link Plane.d} should be either `-1` or `1`. See also {@link Mesh.ARRAY_TANGENT}.
+     */
+    setTangent(tangent: Plane): void { _C(this, 12992, tangent); }
+
+    /**
+     * Specifies a set of UV coordinates to use for the *next* vertex. If every vertex needs to have this information set and you fail to submit it for the first vertex, this information may not be used at all.
+     */
+    setUv(uv: Vector2): void { _C(this, 13251, uv); }
+
+    /**
+     * Specifies an optional second set of UV coordinates to use for the *next* vertex. If every vertex needs to have this information set and you fail to submit it for the first vertex, this information may not be used at all.
+     */
+    setUv2(uv2: Vector2): void { _C(this, 13255, uv2); }
+
+    /**
+     * Specifies an array of bones to use for the *next* vertex. `bones` must contain 4 integers.
+     */
+    setBones(bones: PackedInt32Array): void { _C(this, 10722, bones); }
+
+    /**
+     * Specifies weight values to use for the *next* vertex. `weights` must contain 4 values. If every vertex needs to have this information set and you fail to submit it for the first vertex, this information may not be used at all.
+     */
+    setWeights(weights: PackedFloat32Array): void { _C(this, 13369, weights); }
+
+    /**
+     * Sets the custom value on this vertex for `channelIndex`.
+     * {@link setCustomFormat} must be called first for this `channelIndex`. Formats which are not RGBA will ignore other color channels.
+     */
+    setCustom(channelIndex: number, customColor: Color): void { _C(this, 10998, channelIndex, customColor); }
+
+    /**
+     * Specifies the smooth group to use for the *next* vertex. If this is never called, all vertices will have the default smooth group of `0` and will be smoothed with adjacent vertices of the same group. To produce a mesh with flat normals, set the smooth group to `-1`.
+     * **Note:** This function actually takes a `uint32_t`, so C# users should use `uint32.MaxValue` instead of `-1` to produce a mesh with flat normals.
+     */
+    setSmoothGroup(index: number /* uint32 */): void { _C(this, 12796, index); }
+
+    /**
+     * Inserts a triangle fan made of array data into {@link Mesh} being constructed.
+     * Requires the primitive type be set to {@link Mesh.PRIMITIVE_TRIANGLES}.
+     */
+    addTriangleFan(vertices: PackedVector3Array, uvs?: PackedVector2Array /* = PackedVector2Array() */, colors?: PackedColorArray /* = PackedColorArray() */, uv2s?: PackedVector2Array /* = PackedVector2Array() */, normals?: PackedVector3Array /* = PackedVector3Array() */, tangents?: GodotArray<Plane> /* = Array[Plane]([]) */): void { _C(this, 1322, vertices, uvs, colors, uv2s, normals, tangents); }
+
+    /**
+     * Adds a vertex to index array if you are using indexed vertices. Does not need to be called before adding vertices.
+     */
+    addIndex(index: number): void { _C(this, 1236, index); }
+
+    /**
+     * Shrinks the vertex array by creating an index array. This can improve performance by avoiding vertex reuse.
+     */
+    index(): void { _C(this, 7592); }
+
+    /**
+     * Removes the index array by expanding the vertex array.
+     */
+    deindex(): void { _C(this, 2717); }
+
+    /**
+     * Generates normals from vertices so you do not have to do it manually. If `flip` is `true`, the resulting normals will be inverted. {@link generateNormals} should be called *after* generating geometry and *before* committing the mesh using {@link commit} or {@link commitToArrays}. For correct display of normal-mapped surfaces, you will also have to generate tangents using {@link generateTangents}.
+     * **Note:** {@link generateNormals} only works if the primitive type is set to {@link Mesh.PRIMITIVE_TRIANGLES}.
+     * **Note:** {@link generateNormals} takes smooth groups into account. To generate smooth normals, set the smooth group to a value greater than or equal to `0` using {@link setSmoothGroup} or leave the smooth group at the default of `0`. To generate flat normals, set the smooth group to `-1` using {@link setSmoothGroup} prior to adding vertices.
+     */
+    generateNormals(flip?: boolean /* = false */): void { _C(this, 3633, flip); }
+
+    /**
+     * Generates a tangent vector for each vertex. Requires that each vertex already has UVs and normals set (see {@link generateNormals}).
+     */
+    generateTangents(): void { _C(this, 3641); }
+
+    /**
+     * Optimizes triangle sorting for performance. Requires that {@link getPrimitiveType} is {@link Mesh.PRIMITIVE_TRIANGLES}.
+     */
+    optimizeIndicesForCache(): void { _C(this, 9208); }
+
+    /**
+     * Returns the axis-aligned bounding box of the vertex positions.
+     */
+    getAabb(): AABB { return _C(this, 3659) as AABB; }
+
+    /**
+     * Generates an LOD for a given `ndThreshold` in linear units (square root of quadric error metric), using at most `targetIndexCount` indices.
+     */
+    generateLod(ndThreshold: number, targetIndexCount?: number /* = 3 */): PackedInt32Array { return _C(this, 3630, ndThreshold, targetIndexCount) as PackedInt32Array; }
+
+    /**
+     * Sets {@link Material} to be used by the {@link Mesh} you are constructing.
+     */
+    setMaterial(material: Material): void { _C(this, 11978, material); }
+
+    /**
+     * Returns the type of mesh geometry, such as {@link Mesh.PRIMITIVE_TRIANGLES}.
+     */
+    getPrimitiveType(): PrimitiveType { return _C(this, 6013) as PrimitiveType; }
+
+    /**
+     * Clear all information passed into the surface tool so far.
+     */
+    clear(): void { _C(this, 2232); }
+
+    /**
+     * Creates a vertex array from an existing {@link Mesh}.
+     */
+    createFrom(existing: Mesh, surface: number): void { _C(this, 2528, existing, surface); }
+
+    /**
+     * Creates this SurfaceTool from existing vertex arrays such as returned by {@link commitToArrays}, {@link Mesh.surfaceGetArrays}, {@link Mesh.surfaceGetBlendShapeArrays}, {@link ImporterMesh.getSurfaceArrays}, and {@link ImporterMesh.getSurfaceBlendShapeArrays}. `primitiveType` controls the type of mesh data, defaulting to {@link Mesh.PRIMITIVE_TRIANGLES}.
+     */
+    createFromArrays(arrays: GodotArray, primitiveType?: PrimitiveType /* = 3 */): void { _C(this, 2529, arrays, primitiveType); }
+
+    /**
+     * Creates a vertex array from the specified blend shape of an existing {@link Mesh}. This can be used to extract a specific pose from a blend shape.
+     */
+    createFromBlendShape(existing: Mesh, surface: number, blendShape: string): void { _C(this, 2530, existing, surface, blendShape); }
+
+    /**
+     * Append vertices from a given {@link Mesh} surface onto the current vertex array with specified {@link Transform3D}.
+     */
+    appendFrom(existing: Mesh, surface: number, transform: Transform3D): void { _C(this, 1517, existing, surface, transform); }
+
+    /**
+     * Returns a constructed {@link ArrayMesh} from current information passed in. If an existing {@link ArrayMesh} is passed in as an argument, will add an extra surface to the existing {@link ArrayMesh}.
+     * The `flags` argument can be the bitwise OR of {@link Mesh.ARRAY_FLAG_USE_DYNAMIC_UPDATE}, {@link Mesh.ARRAY_FLAG_USE_8_BONE_WEIGHTS}, or {@link Mesh.ARRAY_FLAG_USES_EMPTY_VERTEX_ARRAY}.
+     */
+    commit(existing?: ArrayMesh /* = null */, flags?: number /* = 0,  uint64 */): ArrayMesh { return _C(this, 2382, existing, flags) as ArrayMesh; }
+
+    /**
+     * Commits the data to the same format used by {@link ArrayMesh.addSurfaceFromArrays}, {@link ImporterMesh.addSurface}, and {@link createFromArrays}. This way you can further process the mesh data using the {@link ArrayMesh} or {@link ImporterMesh} APIs.
+     */
+    commitToArrays(): GodotArray { return _C(this, 2384) as GodotArray; }
+
+    static readonly name = _R(760, SurfaceTool);
+}
+
+export const CustomFormat = {
+    /**
+     * Limits range of data passed to {@link setCustom} to unsigned normalized 0 to 1 stored in 8 bits per channel. See {@link Mesh.ARRAY_CUSTOM_RGBA8_UNORM}.
+     */
+    CUSTOM_RGBA8_UNORM: 0,
+    /**
+     * Limits range of data passed to {@link setCustom} to signed normalized -1 to 1 stored in 8 bits per channel. See {@link Mesh.ARRAY_CUSTOM_RGBA8_SNORM}.
+     */
+    CUSTOM_RGBA8_SNORM: 1,
+    /**
+     * Stores data passed to {@link setCustom} as half precision floats, and uses only red and green color channels. See {@link Mesh.ARRAY_CUSTOM_RG_HALF}.
+     */
+    CUSTOM_RG_HALF: 2,
+    /**
+     * Stores data passed to {@link setCustom} as half precision floats and uses all color channels. See {@link Mesh.ARRAY_CUSTOM_RGBA_HALF}.
+     */
+    CUSTOM_RGBA_HALF: 3,
+    /**
+     * Stores data passed to {@link setCustom} as full precision floats, and uses only red color channel. See {@link Mesh.ARRAY_CUSTOM_R_FLOAT}.
+     */
+    CUSTOM_R_FLOAT: 4,
+    /**
+     * Stores data passed to {@link setCustom} as full precision floats, and uses only red and green color channels. See {@link Mesh.ARRAY_CUSTOM_RG_FLOAT}.
+     */
+    CUSTOM_RG_FLOAT: 5,
+    /**
+     * Stores data passed to {@link setCustom} as full precision floats, and uses only red, green and blue color channels. See {@link Mesh.ARRAY_CUSTOM_RGB_FLOAT}.
+     */
+    CUSTOM_RGB_FLOAT: 6,
+    /**
+     * Stores data passed to {@link setCustom} as full precision floats, and uses all color channels. See {@link Mesh.ARRAY_CUSTOM_RGBA_FLOAT}.
+     */
+    CUSTOM_RGBA_FLOAT: 7,
+    /**
+     * Used to indicate a disabled custom channel.
+     */
+    CUSTOM_MAX: 8,
+} as const;
+
+export type CustomFormat = (typeof CustomFormat)[keyof typeof CustomFormat];
+
+export const SkinWeightCount = {
+    /**
+     * Each individual vertex can be influenced by only 4 bone weights.
+     */
+    SKIN_4_WEIGHTS: 0,
+    /**
+     * Each individual vertex can be influenced by up to 8 bone weights.
+     */
+    SKIN_8_WEIGHTS: 1,
+} as const;
+
+export type SkinWeightCount = (typeof SkinWeightCount)[keyof typeof SkinWeightCount];
+

package/gen/classes/SyntaxHighlighter.ts

@@ -0,0 +1,54 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Resource } from './Resource.ts';
+import type { GodotDictionary } from '../heap-types/index.ts';
+import type { TextEdit } from './TextEdit.ts';
+
+/**
+ * Base class for syntax highlighters. Provides syntax highlighting data to a {@link TextEdit}. The associated {@link TextEdit} will call into the {@link SyntaxHighlighter} on an as-needed basis.
+ * **Note:** A {@link SyntaxHighlighter} instance should not be used across multiple {@link TextEdit} nodes.
+ */
+export class SyntaxHighlighter extends Resource {
+    constructor(name = 761) { super(name); }
+
+    /**
+     * Returns the syntax highlighting data for the line at index `line`. If the line is not cached, calls {@link _getLineSyntaxHighlighting} first to calculate the data.
+     * Each entry is a column number containing a nested {@link Dictionary}. The column number denotes the start of a region, the region will end if another region is found, or at the end of the line. The nested {@link Dictionary} contains the data for that region. Currently only the key `"color"` is supported.
+     * **Example:** Possible return value. This means columns `0` to `4` should be red, and columns `5` to the end of the line should be green:
+     *
+     * ```text
+     *
+     * {
+     * 	0: {
+     * 		"color": Color(1, 0, 0)
+     * 	},
+     * 	5: {
+     * 		"color": Color(0, 1, 0)
+     * 	}
+     * }
+     *
+     * ```
+     */
+    getLineSyntaxHighlighting(line: number): GodotDictionary { return _C(this, 5373, line) as GodotDictionary; }
+
+    /**
+     * Clears then updates the {@link SyntaxHighlighter} caches. Override {@link _updateCache} for a callback.
+     * **Note:** This is called automatically when the associated {@link TextEdit} node, updates its own cache.
+     */
+    updateCache(): void { _C(this, 14512); }
+
+    /**
+     * Clears all cached syntax highlighting data.
+     * Then calls overridable method {@link _clearHighlightingCache}.
+     */
+    clearHighlightingCache(): void { _C(this, 2272); }
+
+    /**
+     * Returns the associated {@link TextEdit} node.
+     */
+    getTextEdit(): TextEdit { return _C(this, 6721) as TextEdit; }
+
+    static readonly name = _R(761, SyntaxHighlighter);
+}

package/gen/classes/SystemFont.ts

@@ -0,0 +1,122 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Font } from './Font.ts';
+import type { PackedStringArray } from '../heap-types/index.ts';
+import type { FontAntialiasing, Hinting, SubpixelPositioning } from './TextServer.ts';
+
+/**
+ * {@link SystemFont} loads a font from a system font with the first matching name from {@link fontNames}.
+ * It will attempt to match font style, but it's not guaranteed.
+ * The returned font might be part of a font collection or be a variable font with OpenType "weight", "width" and/or "italic" features set.
+ * You can create {@link FontVariation} of the system font for precise control over its features.
+ * **Note:** This class is implemented on iOS, Linux, macOS and Windows, on other platforms it will fallback to default theme font.
+ */
+export class SystemFont extends Font {
+    constructor(name = 762) { super(name); }
+
+    /**
+     * Array of font family names to search, first matching font found is used.
+     */
+    get fontNames(): PackedStringArray { return _C(this, 4851) as PackedStringArray; }
+    set fontNames(v: PackedStringArray) { _C(this, 11456, v); }
+
+    /**
+     * If set to `true`, italic or oblique font is preferred.
+     */
+    get fontItalic(): boolean { return _C(this, 4848) as boolean; }
+    set fontItalic(v: boolean) { _C(this, 11454, v); }
+
+    /**
+     * Preferred weight (boldness) of the font. A value in the `100...999` range, normal font weight is `400`, bold font weight is `700`.
+     */
+    get fontWeight(): number { return _C(this, 4859) as number; }
+    set fontWeight(v: number) { _C(this, 11461, v); }
+
+    /**
+     * Preferred font stretch amount, compared to a normal width. A percentage value between `50%` and `200%`.
+     */
+    get fontStretch(): number { return _C(this, 4855) as number; }
+    set fontStretch(v: number) { _C(this, 11458, v); }
+
+    /**
+     * Font anti-aliasing mode.
+     */
+    get antialiasing(): FontAntialiasing { return _C(this, 3776) as FontAntialiasing; }
+    set antialiasing(v: FontAntialiasing) { _C(this, 10514, v); }
+
+    /**
+     * If set to `true`, generate mipmaps for the font textures.
+     */
+    get generateMipmaps(): boolean { return _C(this, 4917) as boolean; }
+    set generateMipmaps(v: boolean) { _C(this, 11507, v); }
+
+    /**
+     * If set to `true`, embedded font bitmap loading is disabled (bitmap-only and color fonts ignore this property).
+     */
+    get disableEmbeddedBitmaps(): boolean { return _C(this, 4510) as boolean; }
+    set disableEmbeddedBitmaps(v: boolean) { _C(this, 11116, v); }
+
+    /**
+     * If set to `true`, system fonts can be automatically used as fallbacks.
+     */
+    get allowSystemFallback(): boolean { return _C(this, 7753) as boolean; }
+    set allowSystemFallback(v: boolean) { _C(this, 10460, v); }
+
+    /**
+     * If set to `true`, auto-hinting is supported and preferred over font built-in hinting.
+     */
+    get forceAutohinter(): boolean { return _C(this, 7969) as boolean; }
+    set forceAutohinter(v: boolean) { _C(this, 11462, v); }
+
+    /**
+     * If set to `true`, color modulation is applied when drawing colored glyphs, otherwise it's applied to the monochrome glyphs only.
+     */
+    get modulateColorGlyphs(): boolean { return _C(this, 8110) as boolean; }
+    set modulateColorGlyphs(v: boolean) { _C(this, 12082, v); }
+
+    /**
+     * Font hinting mode.
+     */
+    get hinting(): Hinting { return _C(this, 5039) as Hinting; }
+    set hinting(v: Hinting) { _C(this, 11634, v); }
+
+    /**
+     * Font glyph subpixel positioning mode. Subpixel positioning provides shaper text and better kerning for smaller font sizes, at the cost of memory usage and font rasterization speed. Use {@link TextServer.SUBPIXEL_POSITIONING_AUTO} to automatically enable it based on the font size.
+     */
+    get subpixelPositioning(): SubpixelPositioning { return _C(this, 6605) as SubpixelPositioning; }
+    set subpixelPositioning(v: SubpixelPositioning) { _C(this, 12929, v); }
+
+    /**
+     * 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.
+     */
+    get keepRoundingRemainders(): boolean { return _C(this, 5284) as boolean; }
+    set keepRoundingRemainders(v: boolean) { _C(this, 11862, v); }
+
+    /**
+     * If set to `true`, glyphs of all sizes are rendered using single multichannel signed distance field generated from the dynamic font vector data.
+     */
+    get multichannelSignedDistanceField(): boolean { return _C(this, 8121) as boolean; }
+    set multichannelSignedDistanceField(v: boolean) { _C(this, 12105, v); }
+
+    /**
+     * The width of the range around the shape between the minimum and maximum representable signed distance. If using font outlines, {@link msdfPixelRange} must be set to at least *twice* the size of the largest font outline. The default {@link msdfPixelRange} value of `16` allows outline sizes up to `8` to look correct.
+     */
+    get msdfPixelRange(): number { return _C(this, 5595) as number; }
+    set msdfPixelRange(v: number) { _C(this, 12103, v); }
+
+    /**
+     * Source font size used to generate MSDF textures. Higher values allow for more precision, but are slower to render and require more memory. Only increase this value if you notice a visible lack of precision in glyph rendering.
+     */
+    get msdfSize(): number { return _C(this, 5596) as number; }
+    set msdfSize(v: number) { _C(this, 12104, v); }
+
+    /**
+     * 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.
+     */
+    get oversampling(): number { return _C(this, 5778) as number; }
+    set oversampling(v: number) { _C(this, 12229, v); }
+
+    static readonly name = _R(762, SystemFont);
+}

package/gen/classes/TCPServer.ts

@@ -0,0 +1,35 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { SocketServer } from './SocketServer.ts';
+import type { Error } from '../global-enums.ts';
+import type { StreamPeerTCP } from './StreamPeerTCP.ts';
+
+/**
+ * A TCP server. Listens to connections on a port and returns a {@link StreamPeerTCP} when it gets an incoming connection.
+ * **Note:** When exporting to Android, make sure to enable the `INTERNET` permission in the Android export preset before exporting the project or using one-click deploy. Otherwise, network communication of any kind will be blocked by Android.
+ */
+export class TCPServer extends SocketServer {
+    constructor(name = 763) { super(name); }
+
+    /**
+     * Listen on the `port` binding to `bindAddress`.
+     * If `bindAddress` is set as `"*"` (default), the server will listen on all available addresses (both IPv4 and IPv6).
+     * If `bindAddress` is set as `"0.0.0.0"` (for IPv4) or `"::"` (for IPv6), the server will listen on all available addresses matching that IP type.
+     * If `bindAddress` is set to any valid address (e.g. `"192.168.1.101"`, `"::1"`, etc.), the server will only listen on the interface with that address (or fail if no interface with the given address exists).
+     */
+    listen(port: number /* uint16 */, bindAddress?: string /* = "*" */): Error { return _C(this, 8664, port, bindAddress) as Error; }
+
+    /**
+     * Returns the local port this server is listening to.
+     */
+    getLocalPort(): number { return _C(this, 5398) as number; }
+
+    /**
+     * If a connection is available, returns a StreamPeerTCP with the connection.
+     */
+    takeConnection(): StreamPeerTCP { return _C(this, 14114) as StreamPeerTCP; }
+
+    static readonly name = _R(763, TCPServer);
+}

package/gen/classes/TLSOptions.ts

@@ -0,0 +1,79 @@
+// 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 { CryptoKey } from './CryptoKey.ts';
+import type { X509Certificate } from './X509Certificate.ts';
+
+/**
+ * TLSOptions abstracts the configuration options for the {@link StreamPeerTLS} and {@link PacketPeerDTLS} classes.
+ * Objects of this class cannot be instantiated directly, and one of the static methods {@link client}, {@link clientUnsafe}, or {@link server} should be used instead.
+ *
+ *
+ * ```gdscript
+ *
+ * # Create a TLS client configuration which uses our custom trusted CA chain.
+ * var client_trusted_cas = load("res://my_trusted_cas.crt")
+ * var client_tls_options = TLSOptions.client(client_trusted_cas)
+ *
+ * # Create a TLS server configuration.
+ * var server_certs = load("res://my_server_cas.crt")
+ * var server_key = load("res://my_server_key.key")
+ * var server_tls_options = TLSOptions.server(server_key, server_certs)
+ *
+ * ```
+ */
+export class TLSOptions extends RefCounted {
+
+    /**
+     * Creates a TLS client configuration which validates certificates and their common names (fully qualified domain names).
+     * You can specify a custom `trustedChain` of certification authorities (the default CA list will be used if `null`), and optionally provide a `commonNameOverride` if you expect the certificate to have a common name other than the server FQDN.
+     * **Note:** On the Web platform, TLS verification is always enforced against the CA list of the web browser. This is considered a security feature.
+     */
+    static client(trustedChain?: X509Certificate /* = null */, commonNameOverride?: string /* = "" */): TLSOptions { return _C(764, 2314, trustedChain, commonNameOverride) as TLSOptions; }
+
+    /**
+     * Creates an **unsafe** TLS client configuration where certificate validation is optional. You can optionally provide a valid `trustedChain`, but the common name of the certificates will never be checked. Using this configuration for purposes other than testing **is not recommended**.
+     * **Note:** On the Web platform, TLS verification is always enforced against the CA list of the web browser. This is considered a security feature.
+     */
+    static clientUnsafe(trustedChain?: X509Certificate /* = null */): TLSOptions { return _C(764, 2315, trustedChain) as TLSOptions; }
+
+    /**
+     * Creates a TLS server configuration using the provided `key` and `certificate`.
+     * **Note:** The `certificate` should include the full certificate chain up to the signing CA (certificates file can be concatenated using a general purpose text editor).
+     */
+    static server(key: CryptoKey, certificate: X509Certificate): TLSOptions { return _C(764, 10375, key, certificate) as TLSOptions; }
+
+    /**
+     * Returns `true` if created with {@link TLSOptions.server}, `false` otherwise.
+     */
+    isServer(): boolean { return _C(this, 8290) as boolean; }
+
+    /**
+     * Returns `true` if created with {@link TLSOptions.clientUnsafe}, `false` otherwise.
+     */
+    isUnsafeClient(): boolean { return _C(this, 8383) as boolean; }
+
+    /**
+     * Returns the common name (domain name) override specified when creating with {@link TLSOptions.client}.
+     */
+    getCommonNameOverride(): string { return _C(this, 4246) as string; }
+
+    /**
+     * Returns the CA {@link X509Certificate} chain specified when creating with {@link TLSOptions.client} or {@link TLSOptions.clientUnsafe}.
+     */
+    getTrustedCaChain(): X509Certificate { return _C(this, 6913) as X509Certificate; }
+
+    /**
+     * Returns the {@link CryptoKey} specified when creating with {@link TLSOptions.server}.
+     */
+    getPrivateKey(): CryptoKey { return _C(this, 6016) as CryptoKey; }
+
+    /**
+     * Returns the {@link X509Certificate} specified when creating with {@link TLSOptions.server}.
+     */
+    getOwnCertificate(): X509Certificate { return _C(this, 5781) as X509Certificate; }
+
+    static readonly name = _R(764, TLSOptions);
+}