@ringozz/godot 0.1.0

package/gen/classes/TileSetAtlasSource.ts

@@ -0,0 +1,269 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { TileSetSource } from './TileSetSource.ts';
+import type { PackedVector2Array } from '../heap-types/index.ts';
+import type { Rect2i, Vector2i } from '../value-types/index.ts';
+import type { Texture2D } from './Texture2D.ts';
+import type { TileData } from './TileData.ts';
+
+/**
+ * An atlas is a grid of tiles laid out on a texture. Each tile in the grid must be exposed using {@link createTile}. Those tiles are then indexed using their coordinates in the grid.
+ * Each tile can also have a size in the grid coordinates, making it more or less cells in the atlas.
+ * Alternatives version of a tile can be created using {@link createAlternativeTile}, which are then indexed using an alternative ID. The main tile (the one in the grid), is accessed with an alternative ID equal to 0.
+ * Each tile alternate has a set of properties that is defined by the source's {@link TileSet} layers. Those properties are stored in a TileData object that can be accessed and modified using {@link getTileData}.
+ * As TileData properties are stored directly in the TileSetAtlasSource resource, their properties might also be set using `TileSetAtlasSource.set("<coords_x>:<coords_y>/<alternative_id>/<tile_data_property>")`.
+ */
+export class TileSetAtlasSource extends TileSetSource {
+    constructor(name = 798) { super(name); }
+
+    /**
+     * Creates a new tile at coordinates `atlasCoords` with the given `size`.
+     */
+    createTile(atlasCoords: Vector2i, size?: Vector2i /* = Vector2i(1, 1) */): void { _C(this, 2580, atlasCoords, size); }
+
+    /**
+     * Remove a tile and its alternative at coordinates `atlasCoords`.
+     */
+    removeTile(atlasCoords: Vector2i): void { _C(this, 9976, atlasCoords); }
+
+    /**
+     * Move the tile and its alternatives at the `atlasCoords` coordinates to the `newAtlasCoords` coordinates with the `newSize` size. This functions will fail if a tile is already present in the given area.
+     * If `newAtlasCoords` is `Vector2i(-1, -1)`, keeps the tile's coordinates. If `newSize` is `Vector2i(-1, -1)`, keeps the tile's size.
+     * To avoid an error, first check if a move is possible using {@link hasRoomForTile}.
+     */
+    moveTileInAtlas(atlasCoords: Vector2i, newAtlasCoords?: Vector2i /* = Vector2i(-1, -1) */, newSize?: Vector2i /* = Vector2i(-1, -1) */): void { _C(this, 8999, atlasCoords, newAtlasCoords, newSize); }
+
+    /**
+     * Returns the size of the tile (in the grid coordinates system) at coordinates `atlasCoords`.
+     */
+    getTileSizeInAtlas(atlasCoords: Vector2i): Vector2i { return _C(this, 6799, atlasCoords) as Vector2i; }
+
+    /**
+     * Returns whether there is enough room in an atlas to create/modify a tile with the given properties. If `ignoredTile` is provided, act as is the given tile was not present in the atlas. This may be used when you want to modify a tile's properties.
+     */
+    hasRoomForTile(atlasCoords: Vector2i, size: Vector2i, animationColumns: number, animationSeparation: Vector2i, framesCount: number, ignoredTile?: Vector2i /* = Vector2i(-1, -1) */): boolean { return _C(this, 7437, atlasCoords, size, animationColumns, animationSeparation, framesCount, ignoredTile) as boolean; }
+
+    /**
+     * Returns an array of tiles coordinates ID that will be automatically removed when modifying one or several of those properties: `texture`, `margins`, `separation` or `textureRegionSize`. This can be used to undo changes that would have caused tiles data loss.
+     */
+    getTilesToBeRemovedOnChange(texture: Texture2D, margins: Vector2i, separation: Vector2i, textureRegionSize: Vector2i): PackedVector2Array { return _C(this, 6802, texture, margins, separation, textureRegionSize) as PackedVector2Array; }
+
+    /**
+     * If there is a tile covering the `atlasCoords` coordinates, returns the top-left coordinates of the tile (thus its coordinate ID). Returns `Vector2i(-1, -1)` otherwise.
+     */
+    getTileAtCoords(atlasCoords: Vector2i): Vector2i { return _C(this, 6790, atlasCoords) as Vector2i; }
+
+    /**
+     * Checks if the source has any tiles that don't fit the texture area (either partially or completely).
+     */
+    hasTilesOutsideTexture(): boolean { return _C(this, 7472) as boolean; }
+
+    /**
+     * Removes all tiles that don't fit the available texture area. This method iterates over all the source's tiles, so it's advised to use {@link hasTilesOutsideTexture} beforehand.
+     */
+    clearTilesOutsideTexture(): void { _C(this, 2306); }
+
+    /**
+     * Sets the number of columns in the animation layout of the tile at coordinates `atlasCoords`. If set to 0, then the different frames of the animation are laid out as a single horizontal line in the atlas.
+     */
+    setTileAnimationColumns(atlasCoords: Vector2i, frameColumns: number): void { _C(this, 13065, atlasCoords, frameColumns); }
+
+    /**
+     * Returns how many columns the tile at `atlasCoords` has in its animation layout.
+     */
+    getTileAnimationColumns(atlasCoords: Vector2i): number { return _C(this, 6783, atlasCoords) as number; }
+
+    /**
+     * Sets the margin (in grid tiles) between each tile in the animation layout of the tile at coordinates `atlasCoords` has.
+     */
+    setTileAnimationSeparation(atlasCoords: Vector2i, separation: Vector2i): void { _C(this, 13069, atlasCoords, separation); }
+
+    /**
+     * Returns the separation (as in the atlas grid) between each frame of an animated tile at coordinates `atlasCoords`.
+     */
+    getTileAnimationSeparation(atlasCoords: Vector2i): Vector2i { return _C(this, 6787, atlasCoords) as Vector2i; }
+
+    /**
+     * Sets the animation speed of the tile at coordinates `atlasCoords` has.
+     */
+    setTileAnimationSpeed(atlasCoords: Vector2i, speed: number): void { _C(this, 13070, atlasCoords, speed); }
+
+    /**
+     * Returns the animation speed of the tile at coordinates `atlasCoords`.
+     */
+    getTileAnimationSpeed(atlasCoords: Vector2i): number { return _C(this, 6788, atlasCoords) as number; }
+
+    /**
+     * Sets the tile animation mode of the tile at `atlasCoords` to `mode`. See also {@link getTileAnimationMode}.
+     */
+    setTileAnimationMode(atlasCoords: Vector2i, mode: TileAnimationMode): void { _C(this, 13068, atlasCoords, mode); }
+
+    /**
+     * Returns the tile animation mode of the tile at `atlasCoords`. See also {@link setTileAnimationMode}.
+     */
+    getTileAnimationMode(atlasCoords: Vector2i): TileAnimationMode { return _C(this, 6786, atlasCoords) as TileAnimationMode; }
+
+    /**
+     * Sets how many animation frames the tile at coordinates `atlasCoords` has.
+     */
+    setTileAnimationFramesCount(atlasCoords: Vector2i, framesCount: number): void { _C(this, 13067, atlasCoords, framesCount); }
+
+    /**
+     * Returns how many animation frames has the tile at coordinates `atlasCoords`.
+     */
+    getTileAnimationFramesCount(atlasCoords: Vector2i): number { return _C(this, 6785, atlasCoords) as number; }
+
+    /**
+     * Sets the animation frame `duration` of frame `frameIndex` for the tile at coordinates `atlasCoords`.
+     */
+    setTileAnimationFrameDuration(atlasCoords: Vector2i, frameIndex: number, duration: number): void { _C(this, 13066, atlasCoords, frameIndex, duration); }
+
+    /**
+     * Returns the animation frame duration of frame `frameIndex` for the tile at coordinates `atlasCoords`.
+     */
+    getTileAnimationFrameDuration(atlasCoords: Vector2i, frameIndex: number): number { return _C(this, 6784, atlasCoords, frameIndex) as number; }
+
+    /**
+     * Returns the sum of the sum of the frame durations of the tile at coordinates `atlasCoords`. This value needs to be divided by the animation speed to get the actual animation loop duration.
+     */
+    getTileAnimationTotalDuration(atlasCoords: Vector2i): number { return _C(this, 6789, atlasCoords) as number; }
+
+    /**
+     * Creates an alternative tile for the tile at coordinates `atlasCoords`. If `alternativeIdOverride` is -1, give it an automatically generated unique ID, or assigns it the given ID otherwise.
+     * Returns the new alternative identifier, or -1 if the alternative could not be created with a provided `alternativeIdOverride`.
+     */
+    createAlternativeTile(atlasCoords: Vector2i, alternativeIdOverride?: number /* = -1 */): number { return _C(this, 2508, atlasCoords, alternativeIdOverride) as number; }
+
+    /**
+     * Remove a tile's alternative with alternative ID `alternativeTile`.
+     * Calling this function with `alternativeTile` equals to 0 will fail, as the base tile alternative cannot be removed.
+     */
+    removeAlternativeTile(atlasCoords: Vector2i, alternativeTile: number): void { _C(this, 9882, atlasCoords, alternativeTile); }
+
+    /**
+     * Change a tile's alternative ID from `alternativeTile` to `newId`.
+     * Calling this function with `newId` of 0 will fail, as the base tile alternative cannot be moved.
+     */
+    setAlternativeTileId(atlasCoords: Vector2i, alternativeTile: number, newId: number): void { _C(this, 10474, atlasCoords, alternativeTile, newId); }
+
+    /**
+     * Returns the alternative ID a following call to {@link createAlternativeTile} would return.
+     */
+    getNextAlternativeTileId(atlasCoords: Vector2i): number { return _C(this, 5623, atlasCoords) as number; }
+
+    /**
+     * Returns the {@link TileData} object for the given atlas coordinates and alternative ID.
+     */
+    getTileData(atlasCoords: Vector2i, alternativeTile: number): TileData { return _C(this, 6791, atlasCoords, alternativeTile) as TileData; }
+
+    /**
+     * Returns the atlas grid size, which depends on how many tiles can fit in the texture. It thus depends on the {@link texture}'s size, the atlas {@link margins}, and the tiles' {@link textureRegionSize}.
+     */
+    getAtlasGridSize(): Vector2i { return _C(this, 3804) as Vector2i; }
+
+    /**
+     * Returns a tile's texture region in the atlas texture. For animated tiles, a `frame` argument might be provided for the different frames of the animation.
+     */
+    getTileTextureRegion(atlasCoords: Vector2i, frame?: number /* = 0 */): Rect2i { return _C(this, 6800, atlasCoords, frame) as Rect2i; }
+
+    /**
+     * If {@link useTexturePadding} is `false`, returns {@link texture}. Otherwise, returns an internal {@link ImageTexture} created that includes the padding.
+     */
+    getRuntimeTexture(): Texture2D { return _C(this, 6224) as Texture2D; }
+
+    /**
+     * Returns the region of the tile at coordinates `atlasCoords` for the given `frame` inside the texture returned by {@link getRuntimeTexture}.
+     * **Note:** If {@link useTexturePadding} is `false`, returns the same as {@link getTileTextureRegion}.
+     */
+    getRuntimeTileTextureRegion(atlasCoords: Vector2i, frame: number): Rect2i { return _C(this, 6225, atlasCoords, frame) as Rect2i; }
+
+    /**
+     * The atlas texture.
+     */
+    get texture(): Texture2D { return _C(this, 6726) as Texture2D; }
+    set texture(v: Texture2D) { _C(this, 13024, v); }
+
+    /**
+     * Margins, in pixels, to offset the origin of the grid in the texture.
+     */
+    get margins(): Vector2i { return _C(this, 5442) as Vector2i; }
+    set margins(v: Vector2i) { _C(this, 11971, v); }
+
+    /**
+     * Separation, in pixels, between each tile texture region of the grid.
+     */
+    get separation(): Vector2i { return _C(this, 6344) as Vector2i; }
+    set separation(v: Vector2i) { _C(this, 12695, v); }
+
+    /**
+     * The base tile size in the texture (in pixel). This size must be bigger than or equal to the TileSet's `tile_size` value.
+     */
+    get textureRegionSize(): Vector2i { return _C(this, 6746) as Vector2i; }
+    set textureRegionSize(v: Vector2i) { _C(this, 13043, v); }
+
+    /**
+     * If `true`, generates an internal texture with an additional one pixel padding around each tile. Texture padding avoids a common artifact where lines appear between tiles.
+     * Disabling this setting might lead a small performance improvement, as generating the internal texture requires both memory and processing time when the TileSetAtlasSource resource is modified.
+     */
+    get useTexturePadding(): boolean { return _C(this, 6987) as boolean; }
+    set useTexturePadding(v: boolean) { _C(this, 13242, v); }
+
+    /**
+     * Represents cell's horizontal flip flag. Should be used directly with {@link TileMapLayer} to flip placed tiles by altering their alternative IDs.
+     *
+     * ```text
+     *
+     * var alternate_id = $TileMapLayer.get_cell_alternative_tile(Vector2i(2, 2))
+     * if not alternate_id & TileSetAtlasSource.TRANSFORM_FLIP_H:
+     * 	# If tile is not already flipped, flip it.
+     * 	$TileMapLayer.set_cell(Vector2i(2, 2), source_id, atlas_coords, alternate_id | TileSetAtlasSource.TRANSFORM_FLIP_H)
+     *
+     * ```
+     *
+     * **Note:** These transformations can be combined to do the equivalent of 0, 90, 180, and 270 degree rotations, as shown below:
+     *
+     * ```text
+     *
+     * enum TileTransform {
+     * 	ROTATE_0 = 0,
+     * 	ROTATE_90 = TileSetAtlasSource.TRANSFORM_TRANSPOSE | TileSetAtlasSource.TRANSFORM_FLIP_H,
+     * 	ROTATE_180 = TileSetAtlasSource.TRANSFORM_FLIP_H | TileSetAtlasSource.TRANSFORM_FLIP_V,
+     * 	ROTATE_270 = TileSetAtlasSource.TRANSFORM_TRANSPOSE | TileSetAtlasSource.TRANSFORM_FLIP_V,
+     * }
+     *
+     * ```
+     */
+    static readonly TRANSFORM_FLIP_H = 4096;
+
+    /**
+     * Represents cell's vertical flip flag. See {@link TRANSFORM_FLIP_H} for usage.
+     */
+    static readonly TRANSFORM_FLIP_V = 8192;
+
+    /**
+     * Represents cell's transposed flag. See {@link TRANSFORM_FLIP_H} for usage.
+     */
+    static readonly TRANSFORM_TRANSPOSE = 16384;
+
+    static readonly name = _R(798, TileSetAtlasSource);
+}
+
+export const TileAnimationMode = {
+    /**
+     * Tile animations start at same time, looking identical.
+     */
+    TILE_ANIMATION_MODE_DEFAULT: 0,
+    /**
+     * Tile animations start at random times, looking varied.
+     */
+    TILE_ANIMATION_MODE_RANDOM_START_TIMES: 1,
+    /**
+     * Represents the size of the {@link TileAnimationMode} enum.
+     */
+    TILE_ANIMATION_MODE_MAX: 2,
+} as const;
+
+export type TileAnimationMode = (typeof TileAnimationMode)[keyof typeof TileAnimationMode];
+

package/gen/classes/TileSetScenesCollectionSource.ts

@@ -0,0 +1,87 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { TileSetSource } from './TileSetSource.ts';
+import type { PackedScene } from './PackedScene.ts';
+
+/**
+ * When placed on a {@link TileMapLayer}, tiles from {@link TileSetScenesCollectionSource} will automatically instantiate an associated scene at the cell's position in the TileMapLayer.
+ * Scenes are instantiated as children of the {@link TileMapLayer} after it enters the tree, at the end of the frame (their creation is deferred). If you add/remove a scene tile in the {@link TileMapLayer} that is already inside the tree, the {@link TileMapLayer} will automatically instantiate/free the scene accordingly.
+ * **Note:** Scene tiles all occupy one tile slot and instead use alternate tile ID to identify scene index. {@link TileSetSource.getTilesCount} will always return `1`. Use {@link getSceneTilesCount} to get a number of scenes in a {@link TileSetScenesCollectionSource}.
+ * Use this code if you want to find the scene path at a given tile in {@link TileMapLayer}:
+ *
+ *
+ * ```gdscript
+ *
+ * var source_id = tile_map_layer.get_cell_source_id(Vector2i(x, y))
+ * if source_id > -1:
+ * 	var scene_source = tile_map_layer.tile_set.get_source(source_id)
+ * 	if scene_source is TileSetScenesCollectionSource:
+ * 		var alt_id = tile_map_layer.get_cell_alternative_tile(Vector2i(x, y))
+ * 		# The assigned PackedScene.
+ * 		var scene = scene_source.get_scene_tile_scene(alt_id)
+ *
+ * ```
+ */
+export class TileSetScenesCollectionSource extends TileSetSource {
+    constructor(name = 799) { super(name); }
+
+    /**
+     * Returns the number or scene tiles this TileSet source has.
+     */
+    getSceneTilesCount(): number { return _C(this, 6255) as number; }
+
+    /**
+     * Returns the scene tile ID of the scene tile at `index`.
+     */
+    getSceneTileId(index: number): number { return _C(this, 6253, index) as number; }
+
+    /**
+     * Returns whether this TileSet source has a scene tile with `id`.
+     */
+    hasSceneTileId(id: number): boolean { return _C(this, 7438, id) as boolean; }
+
+    /**
+     * Creates a scene-based tile out of the given scene.
+     * Returns a newly generated unique ID.
+     */
+    createSceneTile(packedScene: PackedScene, idOverride?: number /* = -1 */): number { return _C(this, 2567, packedScene, idOverride) as number; }
+
+    /**
+     * Changes a scene tile's ID from `id` to `newId`. This will fail if there is already a tile with an ID equal to `newId`.
+     */
+    setSceneTileId(id: number, newId: number): void { _C(this, 12623, id, newId); }
+
+    /**
+     * Assigns a {@link PackedScene} resource to the scene tile with `id`. This will fail if the scene does not extend {@link CanvasItem}, as positioning properties are needed to place the scene on the {@link TileMapLayer}.
+     */
+    setSceneTileScene(id: number, packedScene: PackedScene): void { _C(this, 12624, id, packedScene); }
+
+    /**
+     * Returns the {@link PackedScene} resource of scene tile with `id`.
+     */
+    getSceneTileScene(id: number): PackedScene { return _C(this, 6254, id) as PackedScene; }
+
+    /**
+     * Sets whether or not the scene tile with `id` should display a placeholder in the editor. This might be useful for scenes that are not visible.
+     */
+    setSceneTileDisplayPlaceholder(id: number, displayPlaceholder: boolean): void { _C(this, 12622, id, displayPlaceholder); }
+
+    /**
+     * Returns whether the scene tile with `id` displays a placeholder in the editor.
+     */
+    getSceneTileDisplayPlaceholder(id: number): boolean { return _C(this, 6252, id) as boolean; }
+
+    /**
+     * Remove the scene tile with `id`.
+     */
+    removeSceneTile(id: number): void { _C(this, 9953, id); }
+
+    /**
+     * Returns the scene ID a following call to {@link createSceneTile} would return.
+     */
+    getNextSceneTileId(): number { return _C(this, 5630) as number; }
+
+    static readonly name = _R(799, TileSetScenesCollectionSource);
+}

package/gen/classes/TileSetSource.ts

@@ -0,0 +1,50 @@
+// 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 { Vector2i } from '../value-types/index.ts';
+
+/**
+ * Exposes a set of tiles for a {@link TileSet} resource.
+ * Tiles in a source are indexed with two IDs, coordinates ID (of type Vector2i) and an alternative ID (of type int), named according to their use in the {@link TileSetAtlasSource} class.
+ * Depending on the TileSet source type, those IDs might have restrictions on their values, this is why the base {@link TileSetSource} class only exposes getters for them.
+ * You can iterate over all tiles exposed by a TileSetSource by first iterating over coordinates IDs using {@link getTilesCount} and {@link getTileId}, then over alternative IDs using {@link getAlternativeTilesCount} and {@link getAlternativeTileId}.
+ * **Warning:** {@link TileSetSource} can only be added to one TileSet at the same time. Calling {@link TileSet.addSource} on a second {@link TileSet} will remove the source from the first one.
+ */
+export class TileSetSource extends Resource {
+
+    /**
+     * Returns how many tiles this atlas source defines (not including alternative tiles).
+     */
+    getTilesCount(): number { return _C(this, 6801) as number; }
+
+    /**
+     * Returns the tile coordinates ID of the tile with index `index`.
+     */
+    getTileId(index: number): Vector2i { return _C(this, 6792, index) as Vector2i; }
+
+    /**
+     * Returns if this atlas has a tile with coordinates ID `atlasCoords`.
+     */
+    hasTile(atlasCoords: Vector2i): boolean { return _C(this, 7471, atlasCoords) as boolean; }
+
+    /**
+     * Returns the number of alternatives tiles for the coordinates ID `atlasCoords`.
+     * For {@link TileSetAtlasSource}, this always return at least 1, as the base tile with ID 0 is always part of the alternatives list.
+     * Returns -1 if there is not tile at the given coords.
+     */
+    getAlternativeTilesCount(atlasCoords: Vector2i): number { return _C(this, 3733, atlasCoords) as number; }
+
+    /**
+     * Returns the alternative ID for the tile with coordinates ID `atlasCoords` at index `index`.
+     */
+    getAlternativeTileId(atlasCoords: Vector2i, index: number): number { return _C(this, 3732, atlasCoords, index) as number; }
+
+    /**
+     * Returns if the base tile at coordinates `atlasCoords` has an alternative with ID `alternativeTile`.
+     */
+    hasAlternativeTile(atlasCoords: Vector2i, alternativeTile: number): boolean { return _C(this, 7355, atlasCoords, alternativeTile) as boolean; }
+
+    static readonly name = _R(800, TileSetSource);
+}

package/gen/classes/Time.ts

@@ -0,0 +1,237 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, GodotVar } from '../../src/runtime.ts';
+import { Object } from './Object.ts';
+import type { GodotDictionary } from '../heap-types/index.ts';
+
+let _$: any;
+const $ = () => _$ ?? (_$ = _C(null, 40, 801));
+
+/**
+ * The Time singleton allows converting time between various formats and also getting time information from the system.
+ * This class conforms with as many of the ISO 8601 standards as possible. All dates follow the Proleptic Gregorian calendar. As such, the day before `1582-10-15` is `1582-10-14`, not `1582-10-04`. The year before 1 AD (aka 1 BC) is number `0`, with the year before that (2 BC) being `-1`, etc.
+ * Conversion methods assume "the same timezone", and do not handle timezone conversions or DST automatically. Leap seconds are also not handled, they must be done manually if desired. Suffixes such as "Z" are not handled, you need to strip them away manually.
+ * When getting time information from the system, the time can either be in the local timezone or UTC depending on the `utc` parameter. However, the {@link getUnixTimeFromSystem} method always uses UTC as it returns the seconds passed since the [Unix epoch](https://en.wikipedia.org/wiki/Unix_time).
+ * **Important:** The `_from_system` methods use the system clock that the user can manually set. **Never use** this method for precise time calculation since its results are subject to automatic adjustments by the user or the operating system. **Always use** {@link getTicksUsec} or {@link getTicksMsec} for precise time calculation instead, since they are guaranteed to be monotonic (i.e. never decrease).
+ */
+export class Time extends GodotVar {
+
+    /**
+     * Converts the given Unix timestamp to a dictionary of keys: `year`, `month`, `day`, `weekday`, `hour`, `minute`, and `second`.
+     * The returned Dictionary's values will be the same as the {@link getDatetimeDictFromSystem} if the Unix timestamp is the current time, with the exception of Daylight Savings Time as it cannot be determined from the epoch.
+     */
+    static getDatetimeDictFromUnixTime(unixTimeVal: number /* int64 */): GodotDictionary { return _C($(), 4422, unixTimeVal) as GodotDictionary; }
+
+    /**
+     * Converts the given Unix timestamp to a dictionary of keys: `year`, `month`, `day`, and `weekday`.
+     */
+    static getDateDictFromUnixTime(unixTimeVal: number /* int64 */): GodotDictionary { return _C($(), 4417, unixTimeVal) as GodotDictionary; }
+
+    /**
+     * Converts the given time to a dictionary of keys: `hour`, `minute`, and `second`.
+     */
+    static getTimeDictFromUnixTime(unixTimeVal: number /* int64 */): GodotDictionary { return _C($(), 6808, unixTimeVal) as GodotDictionary; }
+
+    /**
+     * Converts the given Unix timestamp to an ISO 8601 date and time string (YYYY-MM-DDTHH:MM:SS).
+     * If `useSpace` is `true`, the date and time bits are separated by an empty space character instead of the letter T.
+     */
+    static getDatetimeStringFromUnixTime(unixTimeVal: number /* int64 */, useSpace?: boolean /* = false */): string { return _C($(), 4425, unixTimeVal, useSpace) as string; }
+
+    /**
+     * Converts the given Unix timestamp to an ISO 8601 date string (YYYY-MM-DD).
+     */
+    static getDateStringFromUnixTime(unixTimeVal: number /* int64 */): string { return _C($(), 4419, unixTimeVal) as string; }
+
+    /**
+     * Converts the given Unix timestamp to an ISO 8601 time string (HH:MM:SS).
+     */
+    static getTimeStringFromUnixTime(unixTimeVal: number /* int64 */): string { return _C($(), 6816, unixTimeVal) as string; }
+
+    /**
+     * Converts the given ISO 8601 date and time string (YYYY-MM-DDTHH:MM:SS) to a dictionary of keys: `year`, `month`, `day`, {@link code skip-lint}weekday, `hour`, `minute`, and `second`.
+     * If `weekday` is `false`, then the {@link code skip-lint}weekday entry is excluded (the calculation is relatively expensive).
+     * **Note:** Any decimal fraction in the time string will be ignored silently.
+     */
+    static getDatetimeDictFromDatetimeString(datetime: string, weekday: boolean): GodotDictionary { return _C($(), 4420, datetime, weekday) as GodotDictionary; }
+
+    /**
+     * Converts the given dictionary of keys to an ISO 8601 date and time string (YYYY-MM-DDTHH:MM:SS).
+     * The given dictionary can be populated with the following keys: `year`, `month`, `day`, `hour`, `minute`, and `second`. Any other entries (including `dst`) are ignored.
+     * If the dictionary is empty, `0` is returned. If some keys are omitted, they default to the equivalent values for the Unix epoch timestamp 0 (1970-01-01 at 00:00:00).
+     * If `useSpace` is `true`, the date and time bits are separated by an empty space character instead of the letter T.
+     */
+    static getDatetimeStringFromDatetimeDict(datetime: GodotDictionary, useSpace: boolean): string { return _C($(), 4423, datetime, useSpace) as string; }
+
+    /**
+     * Converts a dictionary of time values to a Unix timestamp.
+     * The given dictionary can be populated with the following keys: `year`, `month`, `day`, `hour`, `minute`, and `second`. Any other entries (including `dst`) are ignored.
+     * If the dictionary is empty, `0` is returned. If some keys are omitted, they default to the equivalent values for the Unix epoch timestamp 0 (1970-01-01 at 00:00:00).
+     * You can pass the output from {@link getDatetimeDictFromUnixTime} directly into this function and get the same as what was put in.
+     * **Note:** Unix timestamps are often in UTC. This method does not do any timezone conversion, so the timestamp will be in the same timezone as the given datetime dictionary.
+     */
+    static getUnixTimeFromDatetimeDict(datetime: GodotDictionary): number { return _C($(), 6955, datetime) as number; }
+
+    /**
+     * Converts the given ISO 8601 date and/or time string to a Unix timestamp. The string can contain a date only, a time only, or both.
+     * **Note:** Unix timestamps are often in UTC. This method does not do any timezone conversion, so the timestamp will be in the same timezone as the given datetime string.
+     * **Note:** Any decimal fraction in the time string will be ignored silently.
+     */
+    static getUnixTimeFromDatetimeString(datetime: string): number { return _C($(), 6956, datetime) as number; }
+
+    /**
+     * Converts the given timezone offset in minutes to a timezone offset string. For example, -480 returns "-08:00", 345 returns "+05:45", and 0 returns "+00:00".
+     */
+    static getOffsetStringFromOffsetMinutes(offsetMinutes: number /* int64 */): string { return _C($(), 5706, offsetMinutes) as string; }
+
+    /**
+     * Returns the current date as a dictionary of keys: `year`, `month`, `day`, `weekday`, `hour`, `minute`, `second`, and `dst` (Daylight Savings Time).
+     */
+    static getDatetimeDictFromSystem(utc?: boolean /* = false */): GodotDictionary { return _C($(), 4421, utc) as GodotDictionary; }
+
+    /**
+     * Returns the current date as a dictionary of keys: `year`, `month`, `day`, and `weekday`.
+     * The returned values are in the system's local time when `utc` is `false`, otherwise they are in UTC.
+     */
+    static getDateDictFromSystem(utc?: boolean /* = false */): GodotDictionary { return _C($(), 4416, utc) as GodotDictionary; }
+
+    /**
+     * Returns the current time as a dictionary of keys: `hour`, `minute`, and `second`.
+     * The returned values are in the system's local time when `utc` is `false`, otherwise they are in UTC.
+     */
+    static getTimeDictFromSystem(utc?: boolean /* = false */): GodotDictionary { return _C($(), 6807, utc) as GodotDictionary; }
+
+    /**
+     * Returns the current date and time as an ISO 8601 date and time string (YYYY-MM-DDTHH:MM:SS).
+     * The returned values are in the system's local time when `utc` is `false`, otherwise they are in UTC.
+     * If `useSpace` is `true`, the date and time bits are separated by an empty space character instead of the letter T.
+     */
+    static getDatetimeStringFromSystem(utc?: boolean /* = false */, useSpace?: boolean /* = false */): string { return _C($(), 4424, utc, useSpace) as string; }
+
+    /**
+     * Returns the current date as an ISO 8601 date string (YYYY-MM-DD).
+     * The returned values are in the system's local time when `utc` is `false`, otherwise they are in UTC.
+     */
+    static getDateStringFromSystem(utc?: boolean /* = false */): string { return _C($(), 4418, utc) as string; }
+
+    /**
+     * Returns the current time as an ISO 8601 time string (HH:MM:SS).
+     * The returned values are in the system's local time when `utc` is `false`, otherwise they are in UTC.
+     */
+    static getTimeStringFromSystem(utc?: boolean /* = false */): string { return _C($(), 6815, utc) as string; }
+
+    /**
+     * Returns the current time zone as a dictionary of keys: `bias` and `name`.
+     * - `bias` is the offset from UTC in minutes, since not all time zones are multiples of an hour from UTC.
+     * - `name` is the localized name of the time zone, according to the OS locale settings of the current user.
+     */
+    static getTimeZoneFromSystem(): GodotDictionary { return _C($(), 6818) as GodotDictionary; }
+
+    /**
+     * Returns the current Unix timestamp in seconds based on the system time in UTC. This method is implemented by the operating system and always returns the time in UTC. The Unix timestamp is the number of seconds passed since 1970-01-01 at 00:00:00, the [Unix epoch](https://en.wikipedia.org/wiki/Unix_time).
+     * **Note:** Unlike other methods that use integer timestamps, this method returns the timestamp as a {@link float} for sub-second precision.
+     */
+    static getUnixTimeFromSystem(): number { return _C($(), 6957) as number; }
+
+    /**
+     * Returns the amount of time passed in milliseconds since the engine started.
+     * Will always be positive or 0 and uses a 64-bit value (it will wrap after roughly 500 million years).
+     */
+    static getTicksMsec(): number { return _C($(), 6779) as number; }
+
+    /**
+     * Returns the amount of time passed in microseconds since the engine started.
+     * Will always be positive or 0 and uses a 64-bit value (it will wrap after roughly half a million years).
+     */
+    static getTicksUsec(): number { return _C($(), 6782) as number; }
+
+    static readonly name = _R(801, Time);
+}
+
+export const Month = {
+    /**
+     * The month of January, represented numerically as `01`.
+     */
+    MONTH_JANUARY: 1,
+    /**
+     * The month of February, represented numerically as `02`.
+     */
+    MONTH_FEBRUARY: 2,
+    /**
+     * The month of March, represented numerically as `03`.
+     */
+    MONTH_MARCH: 3,
+    /**
+     * The month of April, represented numerically as `04`.
+     */
+    MONTH_APRIL: 4,
+    /**
+     * The month of May, represented numerically as `05`.
+     */
+    MONTH_MAY: 5,
+    /**
+     * The month of June, represented numerically as `06`.
+     */
+    MONTH_JUNE: 6,
+    /**
+     * The month of July, represented numerically as `07`.
+     */
+    MONTH_JULY: 7,
+    /**
+     * The month of August, represented numerically as `08`.
+     */
+    MONTH_AUGUST: 8,
+    /**
+     * The month of September, represented numerically as `09`.
+     */
+    MONTH_SEPTEMBER: 9,
+    /**
+     * The month of October, represented numerically as `10`.
+     */
+    MONTH_OCTOBER: 10,
+    /**
+     * The month of November, represented numerically as `11`.
+     */
+    MONTH_NOVEMBER: 11,
+    /**
+     * The month of December, represented numerically as `12`.
+     */
+    MONTH_DECEMBER: 12,
+} as const;
+
+export type Month = (typeof Month)[keyof typeof Month];
+
+export const Weekday = {
+    /**
+     * The day of the week Sunday, represented numerically as `0`.
+     */
+    WEEKDAY_SUNDAY: 0,
+    /**
+     * The day of the week Monday, represented numerically as `1`.
+     */
+    WEEKDAY_MONDAY: 1,
+    /**
+     * The day of the week Tuesday, represented numerically as `2`.
+     */
+    WEEKDAY_TUESDAY: 2,
+    /**
+     * The day of the week Wednesday, represented numerically as `3`.
+     */
+    WEEKDAY_WEDNESDAY: 3,
+    /**
+     * The day of the week Thursday, represented numerically as `4`.
+     */
+    WEEKDAY_THURSDAY: 4,
+    /**
+     * The day of the week Friday, represented numerically as `5`.
+     */
+    WEEKDAY_FRIDAY: 5,
+    /**
+     * The day of the week Saturday, represented numerically as `6`.
+     */
+    WEEKDAY_SATURDAY: 6,
+} as const;
+
+export type Weekday = (typeof Weekday)[keyof typeof Weekday];
+