@sandustry-modding/types 0.1.0

package/sandkit/api/elements.d.ts

@@ -0,0 +1,237 @@
+import { CellCoordinates, Vector2 } from "../../shared/player";
+import { shared } from "../../shared";
+
+/**
+ * `sandkit.api.elements` — register elements and read or change cells when idle.
+ * Main thread only.
+ */
+export namespace elements {
+
+  // Shared types
+  /** Numeric id for a registered element type. */
+  export import ElementType = shared.api.elements.ElementType;
+  /** Mod or built-in element string id. */
+  export import ElementId = shared.api.elements.ElementId;
+  /** Type handle or string id accepted by lookup helpers. */
+  export import ElementRef = shared.api.elements.ElementRef;
+  /** Matter category for element physics behavior. */
+  export import MatterType = shared.api.elements.MatterType;
+  /** Full definition used to register a custom element. */
+  export import ElementDefinition = shared.api.elements.ElementDefinition;
+  /** Options for create and replace calls. */
+  export import ElementCreateOptions = shared.api.elements.ElementCreateOptions;
+  /** Options for element removal. */
+  export import ElementRemovalOptions = shared.api.elements.ElementRemovalOptions;
+  /** Resolves a string element id to its numeric type. */
+  export import getTypeFromId = shared.api.elements.getTypeFromId;
+  /** Returns the definition for an element type. */
+  export import getDefinitionByType = shared.api.elements.getDefinitionByType;
+  /** Returns the element type at a cell, or null. */
+  export import getTypeAtCell = shared.api.elements.getTypeAtCell;
+  /** Returns the resolved element type at a cell, or null. */
+  export import getResolvedTypeAtCell = shared.api.elements.getResolvedTypeAtCell;
+  /** Returns the resolved element type from a cell id, or null. */
+  export import getResolvedTypeFromCellId = shared.api.elements.getResolvedTypeFromCellId;
+  /** Returns element info at a cell, or null. */
+  export import getInfoAtCell = shared.api.elements.getInfoAtCell;
+  /** Returns the matter type at a cell, or null. */
+  export import getMatterTypeAtCell = shared.api.elements.getMatterTypeAtCell;
+  /** Returns true when the cell contains the given element type. */
+  export import isTypeAtCell = shared.api.elements.isTypeAtCell;
+  /** Returns true when the element at the cell is free-falling. */
+  export import isFreeFallingAtCell = shared.api.elements.isFreeFallingAtCell;
+  /** Returns particle velocity at a cell, or null. */
+  export import getVelocityAtCell = shared.api.elements.getVelocityAtCell;
+  /** Returns a data field value at a cell, or null. */
+  export import getDataFieldAtCell = shared.api.elements.getDataFieldAtCell;
+
+  /** Optional tooltip metadata on structure interactions. */
+  export interface InteractionStructureMetadata {
+    /** i18n key for custom interaction label text. */
+    textKey?: string;
+    /** Hide the label when a data field matches a value. */
+    crossedOutWhen?: { dataField: number; equals: number; };
+    /** Show the label only when a data field matches a value. */
+    visibleWhen?: { dataField: number; equals: number; };
+    /** Require the text key to exist in the active locale. */
+    onlyWhenTranslated?: boolean;
+  }
+
+  /** Interaction that destroys specific items. */
+  export type InteractionDestroyer = {
+    kind: "destroyer";
+    /** Item ids removed by this interaction (for example `"drill"`). */
+    items: readonly string[];
+  };
+
+  /** Interaction that affects specific structures. */
+  export type InteractionStructure = InteractionStructureMetadata & {
+    kind: "structure";
+    /** Structure ids shown in the interaction tooltip. */
+    structures: readonly string[];
+  };
+
+  /** Interaction that affects specific entities. */
+  export type InteractionEntity = {
+    kind: "entity";
+    /** Entity type ids referenced by the interaction. */
+    entities: readonly string[];
+  };
+
+  /** Interaction that marks the element as flammable. */
+  export type InteractionFlammable = { kind: "flammable" };
+  /** Interaction that marks the element as meltable. */
+  export type InteractionMeltable = { kind: "meltable" };
+  /** Interaction that marks the element as freezable. */
+  export type InteractionFreezable = { kind: "freezable" };
+  /** Interaction handled by custom mod logic and tooltip text. */
+  export type InteractionCustom = InteractionStructureMetadata & { kind: "custom" };
+
+  /** Union of element interaction kinds for tool and structure logic. */
+  export type Interaction = InteractionDestroyer
+    | InteractionStructure
+    | InteractionEntity
+    | InteractionFlammable
+    | InteractionMeltable
+    | InteractionFreezable
+    | InteractionCustom;
+
+  /** Returns all registered element type ids. */
+  export function getRegisteredTypes(): ElementType[];
+
+  /**
+   * Registers a new element and returns its assigned type id.
+   * @param definition - Full element definition to register.
+   * @returns Object with the assigned `elementType`.
+   */
+  export function register(definition: ElementDefinition): { elementType: ElementType; };
+
+  /**
+   * Updates fields on an existing element definition.
+   * @param elementTypeOrId - Numeric type or string id.
+   * @param partial - Fields to merge onto the definition.
+   */
+  export function updateDefinition(elementTypeOrId: ElementRef, partial: Partial<ElementDefinition>): void;
+
+  /**
+   * Adds an interaction entry to an element definition.
+   * @param elementTypeOrId - Numeric type or string id.
+   * @param interaction - Interaction entry to append.
+   */
+  export function addInteractionInfo(elementTypeOrId: ElementRef, interaction: Interaction): void;
+
+  /**
+   * Returns the display name for an element type.
+   * @param elementType - Numeric element type.
+   */
+  export function getNameByType(elementType: ElementType): string;
+
+  /**
+   * Finds a free cell inside a structure footprint, or null.
+   * @param structureCellX - Structure anchor cell column.
+   * @param structureCellY - Structure anchor cell row.
+   * @param structureSize - Structure footprint size in cells.
+   * @returns Cell coordinates of a free cell, or null when none.
+   */
+  export function findFreeCellInStructure(structureCellX: number, structureCellY: number, structureSize: number): Vector2 | null;
+
+  /**
+   * Creates an element at a cell when the simulation is idle.
+   * @param cellX - Grid column of the target cell.
+   * @param cellY - Grid row of the target cell.
+   * @param elementType - Element type to place.
+   * @param options - Optional spawn overrides.
+   */
+  export function createAtCellWhenIdle(...args: [...CellCoordinates, elementType: ElementType, options?: ElementCreateOptions]): void;
+
+  /**
+   * Replaces the element at a cell when the simulation is idle.
+   * @param cellX - Grid column of the target cell.
+   * @param cellY - Grid row of the target cell.
+   * @param elementType - Element type to place.
+   * @param options - Optional spawn overrides.
+   */
+  export function replaceAtCellWhenIdle(...args: [...CellCoordinates, elementType: ElementType, options?: ElementCreateOptions]): void;
+
+  /**
+   * Removes the element at a cell when the simulation is idle.
+   * @param cellX - Grid column of the target cell.
+   * @param cellY - Grid row of the target cell.
+   * @param options - Optional removal flags.
+   */
+  export function removeAtCellWhenIdle(...args: [...CellCoordinates, options?: ElementRemovalOptions]): void;
+
+  /**
+   * Moves an element between cells when the simulation is idle.
+   * @param fromCellX - Source cell column.
+   * @param fromCellY - Source cell row.
+   * @param toCellX - Destination cell column.
+   * @param toCellY - Destination cell row.
+   */
+  export function teleportBetweenCellsWhenIdle(fromCellX: number, fromCellY: number, toCellX: number, toCellY: number): void;
+
+  /**
+   * Sets particle velocity at a cell when the simulation is idle.
+   * @param cellX - Grid column of the target cell.
+   * @param cellY - Grid row of the target cell.
+   * @param velocity - New velocity vector.
+   */
+  export function setVelocityAtCellWhenIdle(...args: [...CellCoordinates, velocity: Vector2]): void;
+
+  /**
+   * Adds velocity to a particle at a cell when the simulation is idle.
+   * @param cellX - Grid column of the target cell.
+   * @param cellY - Grid row of the target cell.
+   * @param velocity - Velocity delta to add.
+   * @param maxSpeed - Optional speed cap after the addition.
+   */
+  export function addParticleVelocityAtCellWhenIdle(...args: [...CellCoordinates, velocity: Vector2, maxSpeed?: number]): void;
+
+  /**
+   * Converts a cell element to a particle when the simulation is idle.
+   * @param cellX - Grid column of the target cell.
+   * @param cellY - Grid row of the target cell.
+   * @param velocity - Initial particle velocity.
+   */
+  export function convertToParticleAtCellWhenIdle(...args: [...CellCoordinates, velocity: Vector2]): void;
+
+  /**
+   * Converts a particle back to a solid element when the simulation is idle.
+   * @param cellX - Grid column of the target cell.
+   * @param cellY - Grid row of the target cell.
+   */
+  export function convertFromParticleAtCellWhenIdle(...args: CellCoordinates): void;
+
+  /**
+   * Sets a data field on the element at a cell when the simulation is idle.
+   * @param cellX - Grid column of the target cell.
+   * @param cellY - Grid row of the target cell.
+   * @param fieldNumber - Data field index (1–4).
+   * @param value - New field value.
+   */
+  export function setDataFieldAtCellWhenIdle(...args: [...CellCoordinates, fieldNumber: 1 | 2 | 3 | 4, value: number]): void;
+
+  /**
+   * Refreshes the rendered color at a cell when the simulation is idle.
+   * @param cellX - Grid column of the target cell.
+   * @param cellY - Grid row of the target cell.
+   */
+  export function refreshColorAtCellWhenIdle(...args: CellCoordinates): void;
+
+  /**
+   * Sets the physics skip mode at a cell when the simulation is idle.
+   * @param cellX - Grid column of the target cell.
+   * @param cellY - Grid row of the target cell.
+   * @param physicsState - Physics skip flags for the element.
+   */
+  export function setPhysicsAtCellWhenIdle(...args: [...CellCoordinates, physicsState: number]): void;
+
+  /**
+   * Sets element duration at a cell when the simulation is idle.
+   * @param cellX - Grid column of the target cell.
+   * @param cellY - Grid row of the target cell.
+   * @param duration - Duration in simulation units.
+   * @param options - When `updateMax` is true, also update max duration.
+   */
+  export function setDurationAtCellWhenIdle(...args: [...CellCoordinates, duration: number, options?: { updateMax?: boolean; }]): void;
+}

package/sandkit/api/energy.d.ts

@@ -0,0 +1,70 @@
+import { CellCoordinates } from "../../shared/player";
+
+/**
+ * `sandkit.api.energy` — structure energy networks, storage, and consumption.
+ * Main thread only.
+ */
+export namespace energy {
+  /**
+   * Registers an energy type on a structure as conductor or storage.
+   * @param structureId - Structure type id string.
+   * @param type - `conductor` forwards energy; `storage` holds energy.
+   * @param options - Capacity and energy-type options for storage nodes.
+   */
+  export function registerType(structureId: string, type: 'conductor' | 'storage', options?: EnergyRegisterTypeOptions): void;
+  /**
+   * Adds energy at a cell. Returns the amount actually added.
+   * @param cellX - Grid cell X coordinate.
+   * @param cellY - Grid cell Y coordinate.
+   * @param amount - Energy amount to add.
+   * @param options - Optional energy type and network options.
+   */
+  export function addAtCell(...args: [...CellCoordinates, amount: number, options?: EnergyAddOptions]): number;
+  /**
+   * Consumes energy from the global pool. Returns the amount consumed.
+   * @param amount - Energy amount to consume.
+   * @param options - When `allOrNothing` is true, consume zero unless the full amount is available.
+   */
+  export function consume(amount: number, options?: {
+    allOrNothing?: boolean;
+  }): number;
+  /**
+   * Consumes energy from networks other than the one at the cell.
+   * @param cellX - Grid cell X coordinate.
+   * @param cellY - Grid cell Y coordinate.
+   * @param amount - Energy amount to consume.
+   */
+  export function consumeExcludingNetworkAtCell(...args: [...CellCoordinates, amount: number]): number;
+  /**
+   * Returns energy network nodes connected at the cell.
+   * @param cellX - Grid cell X coordinate.
+   * @param cellY - Grid cell Y coordinate.
+   */
+  export function getNetworkAtCell(...args: CellCoordinates): {
+    x: number;
+    y: number;
+    type: string;
+  }[];
+  /**
+   * Returns free storage capacity in the network at the cell.
+   * @param cellX - Grid cell X coordinate.
+   * @param cellY - Grid cell Y coordinate.
+   */
+  export function getNetworkFreeCapacityAtCell(...args: CellCoordinates): number;
+
+  /** Options for {@link registerType}. */
+  export interface EnergyRegisterTypeOptions {
+    /** Maximum stored energy for storage nodes. */
+    capacity?: number;
+    /** Energy type id when multiple networks exist. */
+    energyType?: string;
+    [key: string]: unknown;
+  }
+
+  /** Options for {@link addAtCell}. */
+  export interface EnergyAddOptions {
+    /** Energy type id when multiple networks exist. */
+    energyType?: string;
+    [key: string]: unknown;
+  }
+}

package/sandkit/api/events.d.ts

@@ -0,0 +1,53 @@
+import type { LooseString } from "../../shared/nominal";
+
+/**
+ * `sandkit.api.events` — subscribe to and emit named game events.
+ * Main thread only. The `events` object is frozen; do not replace `on` or `emit`.
+ */
+export namespace events {
+  /**
+   * Subscribes to an event. Returns an unsubscribe function.
+   * @param eventId - Registered event name.
+   * @param callback - Called when the event is emitted.
+   */
+  export function on<K extends EventId>(eventId: K, callback: (payload: EventPayload<K>) => void): () => void;
+  /**
+   * Emits an event with a payload to all subscribers.
+   * @param eventId - Registered event name.
+   * @param payload - Serializable payload passed to listeners.
+   */
+  export function emit<K extends EventId>(eventId: K, payload: EventPayload<K>): void;
+
+  /**
+   * Mutable payload for `player:collision:prepare`.
+   * Listeners may change `maxStepCells` (clamped 1–8) and phasing flags.
+   */
+  export interface PlayerCollisionPreparePayload {
+    /** When true, terrain collision is skipped this sub-step. */
+    phaseThroughTerrain: boolean;
+    /** When true, structure collision is skipped this sub-step. */
+    phaseThroughStructures: boolean;
+    /** Max cells the player can step up when blocked horizontally (1–8). */
+    maxStepCells: number;
+  }
+
+  /** Known event payloads. Unlisted ids still use `unknown`. */
+  export interface EventPayloadMap {
+    "player:collision:prepare": PlayerCollisionPreparePayload;
+    "player:moved": {
+      /**
+       * Simulation step duration in seconds.
+       * `0` on teleports. The event runs after collision; landing already
+       * zeroes `velocity.y`. Vanilla gravity is applied after this event.
+       */
+      dt?: number;
+      state?: unknown;
+    };
+  }
+
+  /** Known event names plus any custom string id. */
+  export type EventId = LooseString<keyof EventPayloadMap>;
+
+  /** Event payload type for a given event id. */
+  export type EventPayload<K> = K extends keyof EventPayloadMap ? EventPayloadMap[K] : unknown;
+}

package/sandkit/api/excavation.d.ts

@@ -0,0 +1,34 @@
+/**
+ * `sandkit.api.excavation` — register custom excavation tool dig profiles.
+ * Main thread only.
+ */
+export namespace excavation {
+  /**
+   * Registers an excavation profile by id.
+   * @param id - Unique profile id (1–128 chars: letters, numbers, `.`, `_`, `:`, `-`).
+   * @param definition - Pattern, power, and profile options.
+   */
+  export function registerProfile(id: string, definition: ExcavationProfileDefinitionV1): void;
+
+  /** Excavation tool profile definition. */
+  export interface ExcavationProfileDefinitionV1 {
+    /** Dig pattern grid; non-zero cells are removed. */
+    pattern: number[][];
+    /** Dig strength applied to matched cells. Clamped to 0–1000. */
+    power: number;
+    /** Optional profile-specific excavation flags. */
+    options?: ExcavationProfileOptions;
+  }
+
+  /** Options attached to an excavation profile definition. */
+  export interface ExcavationProfileOptions {
+    fromGun?: boolean;
+    fromRocketExplosion?: boolean;
+    fromDrill?: boolean;
+    useLiteralOutVelocity?: boolean;
+    destroyNonDestructible?: boolean;
+    forceRemoveAll?: boolean;
+    /** Clamped to 0–1000 when set. */
+    drillTierDamage?: number;
+  }
+}

package/sandkit/api/fire.d.ts

@@ -0,0 +1,26 @@
+import { CellCoordinates } from "../../shared/player";
+
+/**
+ * `sandkit.api.fire` — ignite and burn elements at grid cells.
+ * Main thread only.
+ */
+export namespace fire {
+  /**
+   * Returns true when the element at the cell can burn.
+   * @param cellX - Grid cell X coordinate.
+   * @param cellY - Grid cell Y coordinate.
+   */
+  export function canBurnElementAtCell(...args: CellCoordinates): boolean;
+  /**
+   * Queues a burn at the cell when the simulation is idle.
+   * @param cellX - Grid cell X coordinate.
+   * @param cellY - Grid cell Y coordinate.
+   */
+  export function burnElementAtCellWhenIdle(...args: CellCoordinates): void;
+  /**
+   * Burns the element at the cell immediately. Returns true on success.
+   * @param cellX - Grid cell X coordinate.
+   * @param cellY - Grid cell Y coordinate.
+   */
+  export function burnElementAtCell(...args: CellCoordinates): boolean;
+}

package/sandkit/api/gameconfig.d.ts

@@ -0,0 +1,15 @@
+import { JsonObjectV1, JsonValueV1 } from "../../shared/jsonvalue";
+
+/**
+ * `sandkit.api.gameConfig` — read merged game configuration values.
+ * Main thread only.
+ */
+export declare namespace gameConfig {
+  /**
+   * Returns a config value by key, or undefined when missing.
+   * @param key - Game config key (merged defaults and overrides).
+   */
+  export function get(key: string): JsonValueV1 | undefined;
+  /** Returns the full config object. */
+  export function getAll(): JsonObjectV1;
+}

package/sandkit/api/grid.d.ts

@@ -0,0 +1,26 @@
+import { CellCoordinates } from "../../shared/player";
+
+/**
+ * `sandkit.api.grid` — iterate cells in rectangular and circular regions.
+ * Main thread only.
+ */
+export namespace grid {
+  /**
+   * Calls the callback for each cell in a rectangle.
+   * @param cellX - Origin cell column (top-left).
+   * @param cellY - Origin cell row (top-left).
+   * @param width - Rectangle width in cells.
+   * @param height - Rectangle height in cells.
+   * @param callback - Invoked for each cell with `(cellX, cellY)`.
+   */
+  export function forEachCellInRect(...args: [...CellCoordinates, width: number, height: number, callback: (...args: CellCoordinates) => void]): void;
+
+  /**
+   * Calls the callback for each cell inside a circle.
+   * @param centerCellX - Circle center cell column.
+   * @param centerCellY - Circle center cell row.
+   * @param radius - Circle radius in cells.
+   * @param callback - Invoked for each cell with `(cellX, cellY)`.
+   */
+  export function forEachCellInCircle(centerCellX: number, centerCellY: number, radius: number, callback: (...args: CellCoordinates) => void): void;
+}

package/sandkit/api/hooks.d.ts

@@ -0,0 +1,52 @@
+/**
+ * `sandkit.api.hooks` — intercept and modify internal game hook points.
+ * Main thread only.
+ */
+export namespace hooks {
+  /**
+   * Registers an intercept hook. Returns an unsubscribe function.
+   * @param hookId - Registered hook identifier.
+   * @param callback - Called with hook arguments and context; may cancel the hook.
+   * @param options - Optional priority and filter options.
+   */
+  export function intercept<K extends keyof InterceptHookMap>(hookId: K, callback: (args: InterceptHookMap[K], context: HookContext) => void, options?: HookOptions): () => void;
+  /**
+   * Registers a modifier hook. Returns an unsubscribe function.
+   * @param hookId - Registered hook identifier.
+   * @param callback - Called with hook arguments; may mutate hook payload.
+   * @param options - Optional priority and filter options.
+   */
+  export function modify<K extends keyof ModifierHookMap>(hookId: K, callback: (args: ModifierHookMap[K]) => void, options?: HookOptions): () => void;
+
+  /** Map of intercept hook ids to argument shapes (not yet typed in declarations). */
+  export interface InterceptHookMap {
+    "input:boost-down": Record<string, never>;
+    "input:descend-down": Record<string, never>;
+    "input:keydown": {
+      key?: string;
+      code?: string;
+      event?: Event;
+    };
+    "input:keyup": {
+      key?: string;
+      code?: string;
+      event?: Event;
+    };
+    "input:escape": Record<string, never>;
+    "input:scroll": Record<string, unknown>;
+  }
+
+  /** Context passed to intercept hook callbacks. */
+  export interface HookContext {
+    /** When called, the intercepted action is skipped. */
+    cancel(): void;
+  }
+  /** Map of modifier hook ids to argument shapes (not yet typed in declarations). */
+  export type ModifierHookMap = unknown
+  /** Options for hook registration. */
+  export interface HookOptions {
+    /** Run this hook before others with lower priority. */
+    priority?: number;
+    [key: string]: unknown;
+  }
+}

package/sandkit/api/i18n.d.ts

@@ -0,0 +1,101 @@
+import type { LooseString } from "../../shared/nominal";
+
+/**
+ * `sandkit.api.i18n` — translations, locales, and display strings for mods.
+ * Main thread only.
+ */
+export namespace i18n {
+  /**
+   * Translates a key with optional parameter substitution.
+   * @param key - Translation key.
+   * @param params - Placeholder values for the key template.
+   */
+  export function t(key: string, params?: Record<string, string | number>): string;
+  /**
+   * Registers translation strings for a locale.
+   * @param locale - Locale code (e.g. `en`).
+   * @param translations - Map of keys to translated strings.
+   */
+  export function register(locale: Locale, translations: Record<string, string>): void;
+  /** Returns the active locale code. */
+  export function getLocale(): Locale;
+  /**
+   * Returns true when a translation exists for the key.
+   * @param key - Translation key.
+   * @param locale - Optional locale; defaults to the active locale.
+   */
+  export function hasTranslation(key: string, locale?: Locale): boolean;
+  /**
+   * Sets the active locale.
+   * @param locale - Locale code to activate.
+   */
+  export function setLocale(locale: Locale): Promise<void>;
+  /** Returns metadata for all known languages. */
+  export function getLanguages(): { code: Locale; nativeName: string; englishName: string; enabled: boolean; }[];
+  /** Returns locale codes that have registered translations. */
+  export function getAvailableLocales(): Locale[];
+  /**
+   * Formats a number for the active locale.
+   * @param value - Number to format.
+   * @param options - Intl-style number format options.
+   */
+  export function formatNumber(value: number, options?: I18nNumberFormatOptions): string;
+  /**
+   * Joins key parts into a single translation key.
+   * @param parts - Key segments joined with `.`.
+   */
+  export function key(...parts: string[]): string;
+  /**
+   * Returns the display name from a definition with nameKey or name.
+   * @param definition - Object with `nameKey` or `name`.
+   */
+  export function getName(definition: { nameKey?: string; name?: string; }): string;
+  /**
+   * Returns the description from a definition with descriptionKey or description.
+   * @param definition - Object with `descriptionKey` or `description`.
+   */
+  export function getDescription(definition: { descriptionKey?: string; description?: string; }): string;
+  /**
+   * Creates a translatable string object with a fallback.
+   * @param key - Translation key.
+   * @param fallback - Text used when no translation is registered.
+   */
+  export function translatable(key: string, fallback: string): { __translatable: true; key: string; fallback: string; };
+  /**
+   * Sets a global string or lazy resolver used in translations.
+   * @param key - Global helper key.
+   * @param value - Static string or function that returns the current value.
+   */
+  export function setGlobal(key: string, value: string | (() => string)): void;
+  /**
+   * Returns a global translation helper value.
+   * @param key - Global helper key.
+   */
+  export function getGlobal(key: string): string | undefined;
+  /**
+   * Removes a global translation helper value.
+   * @param key - Global helper key.
+   */
+  export function clearGlobal(key: string): void;
+  /** Returns all global translation helper values. */
+  export function getGlobals(): Record<string, string>;
+  /**
+   * Formats a key code for display in UI.
+   * @param keyCode - Keyboard key code or binding name.
+   */
+  export function formatKeyForDisplay(keyCode: string): string;
+
+  /** Locale code. `"en"` autocompletes; any locale string is allowed. */
+  export type Locale = LooseString<"en">;
+
+  /** Number format options for {@link formatNumber}. */
+  export interface I18nNumberFormatOptions {
+    /** Minimum fraction digits. */
+    minimumFractionDigits?: number;
+    /** Maximum fraction digits. */
+    maximumFractionDigits?: number;
+    /** When true, use grouping separators. */
+    useGrouping?: boolean;
+    [key: string]: unknown;
+  }
+}