@ringozz/godot 0.1.0

package/gen/classes/StreamPeer.ts

@@ -0,0 +1,206 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { RefCounted } from './RefCounted.ts';
+import type { Error } from '../global-enums.ts';
+import type { GodotArray, PackedByteArray, Variant } from '../heap-types/index.ts';
+
+/**
+ * StreamPeer is an abstract base class mostly used for stream-based protocols (such as TCP). It provides an API for sending and receiving data through streams as raw data or strings.
+ * **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 StreamPeer extends RefCounted {
+
+    /**
+     * Sends a chunk of data through the connection, blocking if necessary until the data is done sending. This function returns an {@link Error} code.
+     */
+    putData(data: PackedByteArray): Error { return _C(this, 9668, data) as Error; }
+
+    /**
+     * Sends a chunk of data through the connection. If all the data could not be sent at once, only part of it will. This function returns two values, an {@link Error} code and an integer, describing how much data was actually sent.
+     */
+    putPartialData(data: PackedByteArray): GodotArray { return _C(this, 9673, data) as GodotArray; }
+
+    /**
+     * Returns a chunk data with the received bytes, as an {@link Array} containing two elements: an {@link Error} constant and a {@link PackedByteArray}. `bytes` is the number of bytes to be received. If not enough bytes are available, the function will block until the desired amount is received.
+     */
+    getData(bytes: number): GodotArray { return _C(this, 4410, bytes) as GodotArray; }
+
+    /**
+     * Returns a chunk data with the received bytes, as an {@link Array} containing two elements: an {@link Error} constant and a {@link PackedByteArray}. `bytes` is the number of bytes to be received. If not enough bytes are available, the function will return how many were actually received.
+     */
+    getPartialData(bytes: number): GodotArray { return _C(this, 5831, bytes) as GodotArray; }
+
+    /**
+     * Returns the number of bytes this {@link StreamPeer} has available.
+     */
+    getAvailableBytes(): number { return _C(this, 3849) as number; }
+
+    /**
+     * Puts a signed byte into the stream.
+     */
+    put8(value: number /* int8 */): void { _C(this, 9667, value); }
+
+    /**
+     * Puts an unsigned byte into the stream.
+     */
+    putU8(value: number /* uint8 */): void { _C(this, 9678, value); }
+
+    /**
+     * Puts a signed 16-bit value into the stream.
+     */
+    put16(value: number /* int16 */): void { _C(this, 9664, value); }
+
+    /**
+     * Puts an unsigned 16-bit value into the stream.
+     */
+    putU16(value: number /* uint16 */): void { _C(this, 9675, value); }
+
+    /**
+     * Puts a signed 32-bit value into the stream.
+     */
+    put32(value: number): void { _C(this, 9665, value); }
+
+    /**
+     * Puts an unsigned 32-bit value into the stream.
+     */
+    putU32(value: number /* uint32 */): void { _C(this, 9676, value); }
+
+    /**
+     * Puts a signed 64-bit value into the stream.
+     */
+    put64(value: number /* int64 */): void { _C(this, 9666, value); }
+
+    /**
+     * Puts an unsigned 64-bit value into the stream.
+     */
+    putU64(value: number /* uint64 */): void { _C(this, 9677, value); }
+
+    /**
+     * Puts a half-precision float into the stream.
+     */
+    putHalf(value: number): void { _C(this, 9671, value); }
+
+    /**
+     * Puts a single-precision float into the stream.
+     */
+    putFloat(value: number): void { _C(this, 9670, value); }
+
+    /**
+     * Puts a double-precision float into the stream.
+     */
+    putDouble(value: number /* double */): void { _C(this, 9669, value); }
+
+    /**
+     * Puts a zero-terminated ASCII string into the stream prepended by a 32-bit unsigned integer representing its size.
+     * **Note:** To put an ASCII string without prepending its size, you can use {@link putData}:
+     *
+     *
+     * ```gdscript
+     *
+     * put_data("Hello world".to_ascii_buffer())
+     *
+     * ```
+     */
+    putString(value: string): void { _C(this, 9674, value); }
+
+    /**
+     * Puts a zero-terminated UTF-8 string into the stream prepended by a 32 bits unsigned integer representing its size.
+     * **Note:** To put a UTF-8 string without prepending its size, you can use {@link putData}:
+     *
+     *
+     * ```gdscript
+     *
+     * put_data("Hello world".to_utf8_buffer())
+     *
+     * ```
+     */
+    putUtf8String(value: string): void { _C(this, 9679, value); }
+
+    /**
+     * Puts a Variant into the stream. If `fullObjects` is `true` encoding objects is allowed (and can potentially include code).
+     * Internally, this uses the same encoding mechanism as the {@link varToBytes} method.
+     */
+    putVar(value: Variant, fullObjects?: boolean /* = false */): void { _C(this, 9680, value, fullObjects); }
+
+    /**
+     * Gets a signed byte from the stream.
+     */
+    get8(): number { return _C(this, 3656) as number; }
+
+    /**
+     * Gets an unsigned byte from the stream.
+     */
+    getU8(): number { return _C(this, 6938) as number; }
+
+    /**
+     * Gets a signed 16-bit value from the stream.
+     */
+    get16(): number { return _C(this, 3653) as number; }
+
+    /**
+     * Gets an unsigned 16-bit value from the stream.
+     */
+    getU16(): number { return _C(this, 6935) as number; }
+
+    /**
+     * Gets a signed 32-bit value from the stream.
+     */
+    get32(): number { return _C(this, 3654) as number; }
+
+    /**
+     * Gets an unsigned 32-bit value from the stream.
+     */
+    getU32(): number { return _C(this, 6936) as number; }
+
+    /**
+     * Gets a signed 64-bit value from the stream.
+     */
+    get64(): number { return _C(this, 3655) as number; }
+
+    /**
+     * Gets an unsigned 64-bit value from the stream.
+     */
+    getU64(): number { return _C(this, 6937) as number; }
+
+    /**
+     * Gets a half-precision float from the stream.
+     */
+    getHalf(): number { return _C(this, 5005) as number; }
+
+    /**
+     * Gets a single-precision float from the stream.
+     */
+    getFloat(): number { return _C(this, 4813) as number; }
+
+    /**
+     * Gets a double-precision float from the stream.
+     */
+    getDouble(): number { return _C(this, 4546) as number; }
+
+    /**
+     * Gets an ASCII string with byte-length `bytes` from the stream. If `bytes` is negative (default) the length will be read from the stream using the reverse process of {@link putString}.
+     */
+    getString(bytes?: number /* = -1 */): string { return _C(this, 6574, bytes) as string; }
+
+    /**
+     * Gets a UTF-8 string with byte-length `bytes` from the stream (this decodes the string sent as UTF-8). If `bytes` is negative (default) the length will be read from the stream using the reverse process of {@link putUtf8String}.
+     */
+    getUtf8String(bytes?: number /* = -1 */): string { return _C(this, 7000, bytes) as string; }
+
+    /**
+     * Gets a Variant from the stream. If `allowObjects` is `true`, decoding objects is allowed.
+     * Internally, this uses the same decoding mechanism as the {@link bytesToVar} method.
+     * **Warning:** Deserialized objects can contain code which gets executed. Do not use this option if the serialized object comes from untrusted sources to avoid potential security threats such as remote code execution.
+     */
+    getVar(allowObjects?: boolean /* = false */): Variant { return _C(this, 7021, allowObjects) as Variant; }
+
+    /**
+     * If `true`, this {@link StreamPeer} will using big-endian format for encoding and decoding.
+     */
+    get bigEndian(): boolean { return _C(this, 7795) as boolean; }
+    set bigEndian(v: boolean) { _C(this, 10658, v); }
+
+    static readonly name = _R(744, StreamPeer);
+}

package/gen/classes/StreamPeerBuffer.ts

@@ -0,0 +1,52 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { StreamPeer } from './StreamPeer.ts';
+import type { PackedByteArray } from '../heap-types/index.ts';
+
+/**
+ * A data buffer stream peer that uses a byte array as the stream. This object can be used to handle binary data from network sessions. To handle binary data stored in files, {@link FileAccess} can be used directly.
+ * A {@link StreamPeerBuffer} object keeps an internal cursor which is the offset in bytes to the start of the buffer. Get and put operations are performed at the cursor position and will move the cursor accordingly.
+ */
+export class StreamPeerBuffer extends StreamPeer {
+    constructor(name = 745) { super(name); }
+
+    /**
+     * Moves the cursor to the specified position. `position` must be a valid index of {@link dataArray}.
+     */
+    seek(position: number): void { _C(this, 10343, position); }
+
+    /**
+     * Returns the size of {@link dataArray}.
+     */
+    getSize(): number { return _C(this, 6399) as number; }
+
+    /**
+     * Returns the current cursor position.
+     */
+    getPosition(): number { return _C(this, 5973) as number; }
+
+    /**
+     * Resizes the {@link dataArray}. This *doesn't* update the cursor.
+     */
+    resize(size: number): void { _C(this, 10077, size); }
+
+    /**
+     * Clears the {@link dataArray} and resets the cursor.
+     */
+    clear(): void { _C(this, 2232); }
+
+    /**
+     * Returns a new {@link StreamPeerBuffer} with the same {@link dataArray} content.
+     */
+    duplicate(): StreamPeerBuffer { return _C(this, 2980) as StreamPeerBuffer; }
+
+    /**
+     * The underlying data buffer. Setting this value resets the cursor.
+     */
+    get dataArray(): PackedByteArray { return _C(this, 4411) as PackedByteArray; }
+    set dataArray(v: PackedByteArray) { _C(this, 11035, v); }
+
+    static readonly name = _R(745, StreamPeerBuffer);
+}

package/gen/classes/StreamPeerExtension.ts

@@ -0,0 +1,12 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { StreamPeer } from './StreamPeer.ts';
+import type { Error } from '../global-enums.ts';
+
+export class StreamPeerExtension extends StreamPeer {
+    constructor(name = 746) { super(name); }
+
+    static readonly name = _R(746, StreamPeerExtension);
+}

package/gen/classes/StreamPeerGZIP.ts

@@ -0,0 +1,37 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { StreamPeer } from './StreamPeer.ts';
+import type { Error } from '../global-enums.ts';
+
+/**
+ * This class allows to compress or decompress data using GZIP/deflate in a streaming fashion. This is particularly useful when compressing or decompressing files that have to be sent through the network without needing to allocate them all in memory.
+ * After starting the stream via {@link startCompression} (or {@link startDecompression}), calling {@link StreamPeer.putPartialData} on this stream will compress (or decompress) the data, writing it to the internal buffer. Calling {@link StreamPeer.getAvailableBytes} will return the pending bytes in the internal buffer, and {@link StreamPeer.getPartialData} will retrieve the compressed (or decompressed) bytes from it. When the stream is over, you must call {@link finish} to ensure the internal buffer is properly flushed (make sure to call {@link StreamPeer.getAvailableBytes} on last time to check if more data needs to be read after that).
+ */
+export class StreamPeerGZIP extends StreamPeer {
+    constructor(name = 747) { super(name); }
+
+    /**
+     * Start the stream in compression mode with the given `bufferSize`, if `useDeflate` is `true` uses deflate instead of GZIP.
+     */
+    startCompression(useDeflate?: boolean /* = false */, bufferSize?: number /* = 65535 */): Error { return _C(this, 13831, useDeflate, bufferSize) as Error; }
+
+    /**
+     * Start the stream in decompression mode with the given `bufferSize`, if `useDeflate` is `true` uses deflate instead of GZIP.
+     */
+    startDecompression(useDeflate?: boolean /* = false */, bufferSize?: number /* = 65535 */): Error { return _C(this, 13832, useDeflate, bufferSize) as Error; }
+
+    /**
+     * Finalizes the stream, compressing any buffered chunk left.
+     * You must call it only when you are compressing.
+     */
+    finish(): Error { return _C(this, 3309) as Error; }
+
+    /**
+     * Clears this stream, resetting the internal state.
+     */
+    clear(): void { _C(this, 2232); }
+
+    static readonly name = _R(747, StreamPeerGZIP);
+}

package/gen/classes/StreamPeerSocket.ts

@@ -0,0 +1,51 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { StreamPeer } from './StreamPeer.ts';
+import type { Error } from '../global-enums.ts';
+
+/**
+ * StreamPeerSocket is an abstract base class that defines common behavior for socket-based streams.
+ */
+export class StreamPeerSocket extends StreamPeer {
+
+    /**
+     * Polls the socket, updating its state. See {@link getStatus}.
+     */
+    poll(): Error { return _C(this, 9471) as Error; }
+
+    /**
+     * Returns the status of the connection.
+     */
+    getStatus(): Status { return _C(this, 6542) as Status; }
+
+    /**
+     * Disconnects from host.
+     */
+    disconnectFromHost(): void { _C(this, 2822); }
+
+    static readonly name = _R(748, StreamPeerSocket);
+}
+
+export const Status = {
+    /**
+     * The initial status of the {@link StreamPeerSocket}. This is also the status after disconnecting.
+     */
+    STATUS_NONE: 0,
+    /**
+     * A status representing a {@link StreamPeerSocket} that is connecting to a host.
+     */
+    STATUS_CONNECTING: 1,
+    /**
+     * A status representing a {@link StreamPeerSocket} that is connected to a host.
+     */
+    STATUS_CONNECTED: 2,
+    /**
+     * A status representing a {@link StreamPeerSocket} in error state.
+     */
+    STATUS_ERROR: 3,
+} as const;
+
+export type Status = (typeof Status)[keyof typeof Status];
+

package/gen/classes/StreamPeerTCP.ts

@@ -0,0 +1,48 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { StreamPeerSocket } from './StreamPeerSocket.ts';
+import type { Error } from '../global-enums.ts';
+
+/**
+ * A stream peer that handles TCP connections. This object can be used to connect to TCP servers, or also is returned by a TCP server.
+ * **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 StreamPeerTCP extends StreamPeerSocket {
+    constructor(name = 749) { super(name); }
+
+    /**
+     * Opens the TCP socket, and binds it to the specified local address.
+     * This method is generally not needed, and only used to force the subsequent call to {@link connectToHost} to use the specified `host` and `port` as source address. This can be desired in some NAT punchthrough techniques, or when forcing the source network interface.
+     */
+    bind(port: number, host?: string /* = "*" */): Error { return _C(this, 1776, port, host) as Error; }
+
+    /**
+     * Connects to the specified `host:port` pair. A hostname will be resolved if valid. Returns {@link OK} on success.
+     */
+    connectToHost(host: string, port: number): Error { return _C(this, 2438, host, port) as Error; }
+
+    /**
+     * Returns the IP of this peer.
+     */
+    getConnectedHost(): string { return _C(this, 4260) as string; }
+
+    /**
+     * Returns the port of this peer.
+     */
+    getConnectedPort(): number { return _C(this, 4264) as number; }
+
+    /**
+     * Returns the local port to which this peer is bound.
+     */
+    getLocalPort(): number { return _C(this, 5398) as number; }
+
+    /**
+     * If `enabled` is `true`, packets will be sent immediately. If `enabled` is `false` (the default), packet transfers will be delayed and combined using [Nagle's algorithm](https://en.wikipedia.org/wiki/Nagle%27s_algorithm).
+     * **Note:** It's recommended to leave this disabled for applications that send large packets or need to transfer a lot of data, as enabling this can decrease the total available bandwidth.
+     */
+    setNoDelay(enabled: boolean): void { _C(this, 12135, enabled); }
+
+    static readonly name = _R(749, StreamPeerTCP);
+}

package/gen/classes/StreamPeerTLS.ts

@@ -0,0 +1,73 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { StreamPeer } from './StreamPeer.ts';
+import type { Error } from '../global-enums.ts';
+import type { TLSOptions } from './TLSOptions.ts';
+
+/**
+ * A stream peer that handles TLS connections. This object can be used to connect to a TLS server or accept a single TLS client 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 StreamPeerTLS extends StreamPeer {
+    constructor(name = 750) { super(name); }
+
+    /**
+     * Poll the connection to check for incoming bytes. Call this right before {@link StreamPeer.getAvailableBytes} for it to work properly.
+     */
+    poll(): void { _C(this, 9471); }
+
+    /**
+     * Accepts a peer connection as a server using the given `serverOptions`. See {@link TLSOptions.server}.
+     */
+    acceptStream(stream: StreamPeer, serverOptions: TLSOptions): Error { return _C(this, 1059, stream, serverOptions) as Error; }
+
+    /**
+     * Connects to a peer using an underlying {@link StreamPeer} `stream` and verifying the remote certificate is correctly signed for the given `commonName`. You can pass the optional `clientOptions` parameter to customize the trusted certification authorities, or disable the common name verification. See {@link TLSOptions.client} and {@link TLSOptions.clientUnsafe}.
+     */
+    connectToStream(stream: StreamPeer, commonName: string, clientOptions?: TLSOptions /* = null */): Error { return _C(this, 2440, stream, commonName, clientOptions) as Error; }
+
+    /**
+     * Returns the status of the connection.
+     */
+    getStatus(): Status { return _C(this, 6542) as Status; }
+
+    /**
+     * Returns the underlying {@link StreamPeer} connection, used in {@link acceptStream} or {@link connectToStream}.
+     */
+    getStream(): StreamPeer { return _C(this, 6557) as StreamPeer; }
+
+    /**
+     * Disconnects from host.
+     */
+    disconnectFromStream(): void { _C(this, 2824); }
+
+    static readonly name = _R(750, StreamPeerTLS);
+}
+
+export const Status = {
+    /**
+     * A status representing a {@link StreamPeerTLS} that is disconnected.
+     */
+    STATUS_DISCONNECTED: 0,
+    /**
+     * A status representing a {@link StreamPeerTLS} during handshaking.
+     */
+    STATUS_HANDSHAKING: 1,
+    /**
+     * A status representing a {@link StreamPeerTLS} that is connected to a host.
+     */
+    STATUS_CONNECTED: 2,
+    /**
+     * A status representing a {@link StreamPeerTLS} in error state.
+     */
+    STATUS_ERROR: 3,
+    /**
+     * An error status that shows a mismatch in the TLS certificate domain presented by the host and the domain requested for validation.
+     */
+    STATUS_ERROR_HOSTNAME_MISMATCH: 4,
+} as const;
+
+export type Status = (typeof Status)[keyof typeof Status];
+

package/gen/classes/StreamPeerUDS.ts

@@ -0,0 +1,32 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { StreamPeerSocket } from './StreamPeerSocket.ts';
+import type { Error } from '../global-enums.ts';
+
+/**
+ * A stream peer that handles UNIX Domain Socket (UDS) connections. This object can be used to connect to UDS servers, or also is returned by a UDS server. Unix Domain Sockets provide inter-process communication on the same machine using the filesystem namespace.
+ * **Note:** UNIX Domain Sockets are only available on UNIX-like systems (Linux, macOS, etc.) and are not supported on Windows.
+ */
+export class StreamPeerUDS extends StreamPeerSocket {
+    constructor(name = 751) { super(name); }
+
+    /**
+     * Opens the UDS socket, and binds it to the specified socket path.
+     * This method is generally not needed, and only used to force the subsequent call to {@link connectToHost} to use the specified `path` as the source address.
+     */
+    bind(path: string): Error { return _C(this, 1776, path) as Error; }
+
+    /**
+     * Connects to the specified UNIX Domain Socket path. Returns {@link OK} on success.
+     */
+    connectToHost(path: string): Error { return _C(this, 2438, path) as Error; }
+
+    /**
+     * Returns the socket path of this peer.
+     */
+    getConnectedPath(): string { return _C(this, 4263) as string; }
+
+    static readonly name = _R(751, StreamPeerUDS);
+}

package/gen/classes/StyleBox.ts

@@ -0,0 +1,86 @@
+// 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 { Side } from '../global-enums.ts';
+import type { RID } from '../heap-types/index.ts';
+import type { Rect2, Vector2 } from '../value-types/index.ts';
+import type { CanvasItem } from './CanvasItem.ts';
+
+/**
+ * {@link StyleBox} is an abstract base class for drawing stylized boxes for UI elements. It is used for panels, buttons, {@link LineEdit} backgrounds, {@link Tree} backgrounds, etc. and also for testing a transparency mask for pointer signals. If mask test fails on a {@link StyleBox} assigned as mask to a control, clicks and motion signals will go through it to the one below.
+ * **Note:** For control nodes that have *Theme Properties*, the `focus` {@link StyleBox} is displayed over the `normal`, `hover` or `pressed` {@link StyleBox}. This makes the `focus` {@link StyleBox} more reusable across different nodes.
+ */
+export class StyleBox extends Resource {
+    constructor(name = 752) { super(name); }
+
+    /**
+     * Returns the minimum size that this stylebox can be shrunk to.
+     */
+    getMinimumSize(): Vector2 { return _C(this, 5554) as Vector2; }
+
+    /**
+     * Sets the default margin to `offset` pixels for all sides.
+     */
+    setContentMarginAll(offset: number): void { _C(this, 10953, offset); }
+
+    /**
+     * Returns the content margin offset for the specified {@link Side}.
+     * Positive values reduce size inwards, unlike {@link Control}'s margin values.
+     */
+    getMargin(margin: Side): number { return _C(this, 5441, margin) as number; }
+
+    /**
+     * Returns the "offset" of a stylebox. This helper function returns a value equivalent to `Vector2(style.get_margin(MARGIN_LEFT), style.get_margin(MARGIN_TOP))`.
+     */
+    getOffset(): Vector2 { return _C(this, 5703) as Vector2; }
+
+    /**
+     * Draws this stylebox using a canvas item identified by the given {@link RID}.
+     * The {@link RID} value can either be the result of {@link CanvasItem.getCanvasItem} called on an existing {@link CanvasItem}-derived node, or directly from creating a canvas item in the {@link RenderingServer} with {@link RenderingServer.canvasItemCreate}.
+     */
+    draw(canvasItem: RID, rect: Rect2): void { _C(this, 2902, canvasItem, rect); }
+
+    /**
+     * Returns the {@link CanvasItem} that handles its {@link CanvasItem.NOTIFICATION_DRAW} or {@link CanvasItem.Draw} callback at this moment.
+     */
+    getCurrentItemDrawn(): CanvasItem { return _C(this, 4353) as CanvasItem; }
+
+    /**
+     * Test a position in a rectangle, return whether it passes the mask test.
+     */
+    testMask(point: Vector2, rect: Rect2): boolean { return _C(this, 14148, point, rect) as boolean; }
+
+    /**
+     * The left margin for the contents of this style box. Increasing this value reduces the space available to the contents from the left.
+     * Refer to {@link contentMarginBottom} for extra considerations.
+     */
+    get contentMarginLeft(): number { return _C(this, 4311, 0) as number; }
+    set contentMarginLeft(v: number) { _C(this, 10952, 0, v); }
+
+    /**
+     * The top margin for the contents of this style box. Increasing this value reduces the space available to the contents from the top.
+     * Refer to {@link contentMarginBottom} for extra considerations.
+     */
+    get contentMarginTop(): number { return _C(this, 4311, 1) as number; }
+    set contentMarginTop(v: number) { _C(this, 10952, 1, v); }
+
+    /**
+     * The right margin for the contents of this style box. Increasing this value reduces the space available to the contents from the right.
+     * Refer to {@link contentMarginBottom} for extra considerations.
+     */
+    get contentMarginRight(): number { return _C(this, 4311, 2) as number; }
+    set contentMarginRight(v: number) { _C(this, 10952, 2, v); }
+
+    /**
+     * The bottom margin for the contents of this style box. Increasing this value reduces the space available to the contents from the bottom.
+     * If this value is negative, it is ignored and a child-specific margin is used instead. For example, for {@link StyleBoxFlat}, the border thickness (if any) is used instead.
+     * It is up to the code using this style box to decide what these contents are: for example, a {@link Button} respects this content margin for the textual contents of the button.
+     * {@link getMargin} should be used to fetch this value as consumer instead of reading these properties directly. This is because it correctly respects negative values and the fallback mentioned above.
+     */
+    get contentMarginBottom(): number { return _C(this, 4311, 3) as number; }
+    set contentMarginBottom(v: number) { _C(this, 10952, 3, v); }
+
+    static readonly name = _R(752, StyleBox);
+}

package/gen/classes/StyleBoxEmpty.ts

@@ -0,0 +1,14 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { StyleBox } from './StyleBox.ts';
+
+/**
+ * An empty {@link StyleBox} that can be used to display nothing instead of the default style (e.g. it can "disable" `focus` styles).
+ */
+export class StyleBoxEmpty extends StyleBox {
+    constructor(name = 753) { super(name); }
+
+    static readonly name = _R(753, StyleBoxEmpty);
+}