@sandustry-modding/types 0.1.0

package/sandkit/api/ui.d.ts

@@ -0,0 +1,175 @@
+/**
+ * UI overlays, dialogs, tooltips, and controller navigation hooks.
+ *
+ * Available as `sandkit.api.ui`.
+ *
+ * @module
+ */
+import type { ComponentType, ReactNode, RefObject } from "react";
+import type { ComponentId as ComponentIdEnum } from "../enums/index";
+import { shared } from "../../shared";
+import type { LooseString } from "../../shared/nominal";
+
+export namespace ui {
+  /** Show a toast message. */
+  export import toast = shared.api.ui.toast;
+  /** Localized text value for UI strings. */
+  export import LocalizedText = shared.api.ui.LocalizedText;
+  /** Options for toast display. */
+  export import ToastOptions = shared.api.ui.ToastOptions;
+
+  /**
+   * Update a registered UI component by id.
+   * @param componentId - Built-in {@link ComponentIdEnum} value or custom string id.
+   * @param options - Component-specific update payload.
+   */
+  export function update(componentId: ComponentId, options?: ComponentUpdateOptions): void;
+
+  /** Open the pause menu. */
+  export function openPauseMenu(): void;
+
+  /**
+   * Show a tooltip with the given data.
+   * @param data - Tooltip type and localized content.
+   */
+  export function showTooltip(data: TooltipData): void;
+
+  /**
+   * Show an alert dialog.
+   * @param message - Dialog body text.
+   * @param title - Optional dialog title.
+   * @returns Promise that resolves when the user dismisses the dialog.
+   */
+  export function alert(message: LocalizedText, title?: LocalizedText): Promise<void>;
+
+  /**
+   * Show a confirm dialog.
+   * @param message - Dialog body text.
+   * @param title - Optional dialog title.
+   * @returns Promise that resolves with true when confirmed, or false when cancelled.
+   */
+  export function confirm(message: LocalizedText, title?: LocalizedText): Promise<boolean>;
+
+  /**
+   * Show a prompt dialog.
+   * @param message - Dialog body text.
+   * @param defaultValue - Initial input value.
+   * @param placeholder - Placeholder text in the input field.
+   * @param title - Optional dialog title.
+   * @param allowCopy - When true, allow copying the result from the dialog.
+   * @returns Promise that resolves with entered text, or null when cancelled.
+   */
+  export function prompt(message: LocalizedText, defaultValue?: string, placeholder?: LocalizedText, title?: LocalizedText, allowCopy?: boolean): Promise<string | null>;
+
+  /**
+   * Mount a React component by id.
+   * @param componentId - Overlay slot or custom mount point id.
+   * @param component - React component to render.
+   * @returns Function that unmounts the injected component.
+   */
+  export function inject(componentId: ComponentId, component: ComponentType<Record<string, never>>): () => void;
+
+  /** Overlay slot registration and updates. */
+  export namespace overlays {
+    /**
+     * Register a render function in an overlay slot.
+     * @param slot - Slot name (for example `"hotbar"`).
+     * @param overlayId - Unique id for this overlay within the slot.
+     * @param render - Function that returns React content.
+     */
+    export function register(slot: OverlaySlot, overlayId: string, render: () => ReactNode): void;
+
+    /**
+     * Remove an overlay from a slot.
+     * @param slot - Slot name the overlay was registered in.
+     * @param overlayId - Overlay id passed to {@link register}.
+     */
+    export function unregister(slot: OverlaySlot, overlayId: string): void;
+
+    /**
+     * Request a re-render for all overlays in a slot.
+     * @param slot - Slot name to refresh.
+     */
+    export function update(slot: OverlaySlot): void;
+  }
+
+  /** Controller focus and scope navigation hooks. */
+  export namespace navigation {
+    /**
+     * React hook for a focusable UI element in a scope.
+     * @param options - Focus registration and neighbor wiring.
+     * @returns Ref, focus state, and a focus helper.
+     */
+    export function useFocusable<T extends HTMLElement = HTMLDivElement>(options: FocusOptions): Focusable<T>;
+
+    /**
+     * React hook to register a focus scope with back handling.
+     * @param options - Scope id, priority, default focus, and back handler.
+     */
+    export function useFocusScope(options: { readonly id: string; readonly active: boolean; readonly priority?: number; readonly defaultId?: string; readonly onBack?: (() => boolean | void); }): void;
+
+    /**
+     * Return CSS class for controller focus ring state.
+     * @param focused - True when the element has controller focus.
+     * @returns Class name string for the focus ring.
+     */
+    export function controllerFocusClass(focused: boolean): string;
+  }
+
+  /**
+   * Overlay slot name. Known vanilla slots autocomplete; any string is allowed.
+   */
+  export type OverlaySlot = LooseString<"hotbar" | "global">;
+
+  /**
+   * Registered UI component id.
+   * Built-in {@link ComponentIdEnum} values autocomplete; custom string ids are allowed.
+   */
+  export type ComponentId = ComponentIdEnum | LooseString<never>;
+
+  /** Component-specific update payload passed to {@link update}. */
+  export type ComponentUpdateOptions = Record<string, unknown>;
+
+  /** Tooltip payload shown near the cursor or UI target. */
+  export type TooltipData = TooltipMessageData;
+
+  /** Message tooltip with localized body text. */
+  export interface TooltipMessageData {
+    /** Discriminator for tooltip renderer selection. */
+    type: 'message';
+    /** Message body as localized text. */
+    text: LocalizedText;
+  }
+
+  /** Focusable element state from useFocusable. */
+  export interface Focusable<T extends HTMLElement = HTMLDivElement> {
+    /** Ref to attach to the focusable element. */
+    readonly ref: RefObject<T>;
+    /** True when the element has controller focus. */
+    readonly focused: boolean;
+    /** Move controller focus to this element. */
+    readonly focus: () => void;
+  }
+
+  /** Options for useFocusable registration. */
+  export interface FocusOptions {
+    /** Unique id within the focus scope. */
+    readonly id: string;
+    /** Focus scope id this element belongs to. */
+    readonly scope: string;
+    /** Called when the element is activated (A button / Enter). */
+    readonly onActivate: (element?: HTMLElement) => void;
+    /** Called when the element receives focus. */
+    readonly onFocus?: (() => void);
+    /** When true, skip this element during navigation. */
+    readonly disabled?: boolean;
+    /** Optional grid column for spatial navigation. */
+    readonly x?: number;
+    /** Optional grid row for spatial navigation. */
+    readonly y?: number;
+    /** Neighbor ids for directional navigation. */
+    readonly neighbors?: Partial<Record<'left' | 'right' | 'up' | 'down', string>>;
+    /** When true, scroll the element into view on focus. */
+    readonly scrollIntoView?: boolean;
+  }
+}

package/sandkit/api/upgrades.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Upgrade categories, definitions, and level queries.
+ *
+ * Available as `sandkit.api.upgrades`.
+ *
+ * @module
+ */
+export namespace upgrades {
+  /**
+   * Register an upgrade category.
+   * @param definition - Category id and display metadata.
+   */
+  export function registerCategory(definition: UpgradeCategoryDefinition): void;
+  /**
+   * Register an upgrade definition.
+   * @param definition - Item id, upgrade id, costs, and level metadata.
+   */
+  export function register(definition: UpgradeDefinition): void;
+  /**
+   * Patch fields on an existing upgrade definition.
+   * @param itemId - Parent item id.
+   * @param upgradeId - Upgrade id within the item.
+   * @param partial - Fields to merge into the definition.
+   */
+  export function updateDefinition(itemId: string, upgradeId: string, partial: Partial<UpgradeDefinition>): void;
+  /**
+   * Return the current purchased level for an upgrade.
+   * @param itemId - Parent item id.
+   * @param upgradeId - Upgrade id within the item.
+   */
+  export function getLevelById(itemId: string, upgradeId: string): number;
+  /**
+   * Return the maximum available level for an upgrade.
+   * @param itemId - Parent item id.
+   * @param upgradeId - Upgrade id within the item.
+   */
+  export function getAvailableLevelById(itemId: string, upgradeId: string): number;
+
+  /** Upgrade definition registered for an item. */
+  export interface UpgradeDefinition {
+    itemId: string;
+    itemNameKey?: string;
+    categoryId?: string;
+    upgrade: {
+      id: string;
+      nameKey?: string;
+      descriptionKey?: string;
+      maxLevel: number;
+      costs: number[];
+      oneOff?: boolean;
+    };
+    [key: string]: unknown;
+  }
+
+  /** Upgrade category definition shape. */
+  export interface UpgradeCategoryDefinition {
+    /** Category identifier referenced by upgrades. */
+    id: string;
+    /** Display name translation key. */
+    nameKey?: string;
+    [key: string]: unknown;
+  }
+}

package/sandkit/api/utils.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Vector math helpers for world and cell coordinates.
+ *
+ * Available as `sandkit.api.utils`.
+ *
+ * @module
+ */
+import type { Vector2 } from "../../shared/player";
+
+export namespace utils {
+  /**
+   * Return distance between two points.
+   * @param pointA - First point.
+   * @param pointB - Second point.
+   */
+  export function getDistance(pointA: Vector2, pointB: Vector2): number;
+  /**
+   * Return normalized direction from point A to point B.
+   * @param pointA - Origin point.
+   * @param pointB - Target point.
+   */
+  export function getDirection(pointA: Vector2, pointB: Vector2): Vector2;
+  /**
+   * Return angle in radians from point A to point B.
+   * @param pointA - Origin point.
+   * @param pointB - Target point.
+   */
+  export function getAngle(pointA: Vector2, pointB: Vector2): number;
+  /**
+   * Return grid cells along a line between two points.
+   * @param pointA - Line start in cell or world coordinates.
+   * @param pointB - Line end in cell or world coordinates.
+   */
+  export function getCoordinatesBetweenPoints(pointA: Vector2, pointB: Vector2): Vector2[];
+}

package/sandkit/api/workers.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Worker thread post-update scheduling control.
+ *
+ * Available as `sandkit.api.workers`.
+ *
+ * @module
+ */
+export namespace workers {
+  /**
+   * Enable or disable worker post-update callbacks.
+   * @param enabled - When true, workers run post-update hooks each tick.
+   */
+  export function setPostUpdateEnabled(enabled: boolean): void;
+}

package/sandkit/api/world.d.ts

@@ -0,0 +1,107 @@
+/**
+ * World cell queries, excavation, fog, redraw, and pickups.
+ *
+ * Available as `sandkit.api.world`.
+ *
+ * @module
+ */
+import { CellCoordinates } from "../../shared/player";
+import { shared } from "../../shared";
+import type { WorldItemType as WorldItemTypeEnum } from "../enums/index";
+
+export namespace world {
+
+  /** Return cell id at a grid cell. */
+  export import getCellIdAtCell = shared.api.world.getCellIdAtCell;
+  /** Return true when the cell is empty. */
+  export import isCellEmptyAtCell = shared.api.world.isCellEmptyAtCell;
+  /** Return true when the cell holds terrain. */
+  export import isTerrainAtCell = shared.api.world.isTerrainAtCell;
+  /** Mark a cell as active for simulation this tick. */
+  export import reportActivityAtCell = shared.api.world.reportActivityAtCell;
+  /** Excavate at a cell with output velocity and damage. */
+  export import excavateAtCell = shared.api.world.excavateAtCell;
+  /** Options for {@link excavateAtCell}. */
+  export import ExcavateOptions = shared.api.world.ExcavateOptions;
+  /** Packed cell id from {@link getCellIdAtCell}. */
+  export import CellId = shared.api.world.CellId;
+
+  /**
+   * Run a callback when simulation is idle.
+   * @param callback - Function invoked on the main thread when workers are idle.
+   */
+  export function runWhenSimulationIdle(callback: () => void): void;
+
+  /**
+   * Reveal fog of war at a cell.
+   * @param cellX - Grid column of the target cell.
+   * @param cellY - Grid row of the target cell.
+   */
+  export function revealFogAtCell(...args: CellCoordinates): void;
+
+  /**
+   * Request redraw around a cell when simulation is idle.
+   * @param cellX - Grid column of the target cell.
+   * @param cellY - Grid row of the target cell.
+   * @param range - Radius in cells to redraw.
+   */
+  export function redrawAroundCellWhenIdle(...args: [...CellCoordinates, range: number]): void;
+
+  /** World item spawn, pickup, and lookup. */
+  export namespace pickups {
+    /**
+     * Spawn a world pickup at world position.
+     * @param type - Pickup type discriminator.
+     * @param worldX - World x position in pixels.
+     * @param worldY - World y position in pixels.
+     * @param data - Optional per-item data bag copied onto the instance.
+     * @param light - Optional point light spawned with the pickup.
+     * @returns The spawned world item instance.
+     */
+    export function spawnAtWorld(type: WorldItemType, worldX: number, worldY: number, data?: Record<string, unknown>, light?: WorldItemLight): WorldItem;
+
+    /**
+     * Destroy a world pickup instance.
+     * @param worldItem - World item returned from spawn or lookup helpers.
+     */
+    export function destroy(worldItem: WorldItem): void;
+
+    /**
+     * Pick up a world item into inventory.
+     * @param worldItem - World item to pick up.
+     * @returns True when the item was collected.
+     */
+    export function pickUp(worldItem: WorldItem): boolean;
+
+    /** Return all active world pickups. */
+    export function getAll(): WorldItem[];
+
+    /**
+     * Return a world pickup by numeric id.
+     * @param worldItemId - Runtime world item id.
+     */
+    export function getById(worldItemId: number): WorldItem | undefined;
+  }
+
+  /** World pickup type discriminator. */
+  export type WorldItemType = WorldItemTypeEnum;
+
+  /** Optional point light attached when spawning a pickup. */
+  export interface WorldItemLight {
+    /** Light brightness multiplier. Default 1. */
+    brightness?: number;
+    /** Light radius in world pixels. Default 100. */
+    size?: number;
+    /** RGB or RGBA color components in 0–1 range. */
+    color?: [number, number, number] | [number, number, number, number];
+  }
+
+  /** Active world pickup instance. */
+  export interface WorldItem {
+    id: number;
+    x: number;
+    y: number;
+    type: WorldItemType;
+    data: Record<string, unknown>;
+  }
+}

package/sandkit/engine/api/augments.d.ts

@@ -0,0 +1,96 @@
+/**
+ * `sandkit.engine.api.augments` — player augment levels and unlocked perks.
+ *
+ * **Internal API.** Prefer {@link sandkit.api} when a public method exists.
+ * Methods use loose stubs; signatures may take game state as the first argument.
+ * Engine methods pass game state as the first argument (args[0]); remaining entries are method-specific.
+ *
+ * @internal
+ */
+export namespace augments {
+  /**
+   * Return the current dig augment level.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function getDigLevel(...args: unknown[]): unknown;
+  /**
+   * Return the current gun augment level.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function getGunLevel(...args: unknown[]): unknown;
+  /**
+   * Return the current phase augment level.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function getPhaseLevel(...args: unknown[]): unknown;
+  /**
+   * Return the current rocket ammo augment level.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function getRocketAmmoLevel(...args: unknown[]): unknown;
+  /**
+   * Return the current rocket reload augment level.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function getRocketReloadLevel(...args: unknown[]): unknown;
+  /**
+   * Return the current sprint cap augment level.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function getSprintCapLevel(...args: unknown[]): unknown;
+  /**
+   * Return whether the big-dig augment is unlocked.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function hasBigDig(...args: unknown[]): unknown;
+  /**
+   * Return whether the bullet-speed augment is unlocked.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function hasBulletSpeed(...args: unknown[]): unknown;
+  /**
+   * Return whether the bullet-tracer augment is unlocked.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function hasBulletTracer(...args: unknown[]): unknown;
+  /**
+   * Return whether the kickstart-boost augment is unlocked.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function hasKickstartBoost(...args: unknown[]): unknown;
+  /**
+   * Return whether the phase-dash augment is unlocked.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function hasPhaseDash(...args: unknown[]): unknown;
+  /**
+   * Return whether the phase-dash-charge augment is unlocked.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function hasPhaseDashCharge(...args: unknown[]): unknown;
+  /**
+   * Return whether the ride-boost augment is unlocked.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function hasRideBoost(...args: unknown[]): unknown;
+  /**
+   * Return whether the rocket-damage augment is unlocked.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function hasRocketDamage(...args: unknown[]): unknown;
+  /**
+   * Return whether the rocket-warhead augment is unlocked.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function hasRocketWarhead(...args: unknown[]): unknown;
+  /**
+   * Return whether the sprint-power augment is unlocked.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function hasSprintPower(...args: unknown[]): unknown;
+  /**
+   * Return whether the triple-shot augment is unlocked.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function hasTripleShot(...args: unknown[]): unknown;
+}

package/sandkit/engine/api/auralite.d.ts

@@ -0,0 +1,21 @@
+/**
+ * `sandkit.engine.api.auralite` — auralite production tracking.
+ *
+ * **Internal API.** Prefer {@link sandkit.api} when a public method exists.
+ * Methods use loose stubs; signatures may take game state as the first argument.
+ * Engine methods pass game state as the first argument (args[0]); remaining entries are method-specific.
+ *
+ * @internal
+ */
+export namespace auralite {
+  /**
+   * Ensure at least the given amount of auralite has been produced.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function ensureProducedAtLeast(...args: unknown[]): unknown;
+  /**
+   * Return total auralite produced so far.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function getProduced(...args: unknown[]): unknown;
+}

package/sandkit/engine/api/blueprints.d.ts

@@ -0,0 +1,47 @@
+/**
+ * `sandkit.engine.api.blueprints` — blueprint save, load, and import/export.
+ *
+ * **Internal API.** Prefer {@link sandkit.api} when a public method exists.
+ * Methods use loose stubs; signatures may take game state as the first argument.
+ * Engine methods pass game state as the first argument (args[0]); remaining entries are method-specific.
+ *
+ * @internal
+ */
+export namespace blueprints {
+  /**
+   * Delete a saved blueprint. Runtime property name is `delete`.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  function _delete(...args: unknown[]): unknown;
+  export { _delete as delete };
+  /**
+   * Export all blueprints as one string.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function exportAllString(...args: unknown[]): unknown;
+  /**
+   * Export one blueprint as a string.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function exportString(...args: unknown[]): unknown;
+  /**
+   * Return all saved blueprints.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function getAll(...args: unknown[]): unknown;
+  /**
+   * Import a blueprint from a string.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function importString(...args: unknown[]): unknown;
+  /**
+   * Load a blueprint into the active session.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function load(...args: unknown[]): unknown;
+  /**
+   * Save the current selection as a blueprint.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function save(...args: unknown[]): unknown;
+}

package/sandkit/engine/api/clipboard.d.ts

@@ -0,0 +1,46 @@
+/**
+ * `sandkit.engine.api.clipboard` — build clipboard copy, paste, and history.
+ *
+ * **Internal API.** Prefer {@link sandkit.api} when a public method exists.
+ * Methods use loose stubs; signatures may take game state as the first argument.
+ * Engine methods pass game state as the first argument (args[0]); remaining entries are method-specific.
+ *
+ * @internal
+ */
+export namespace clipboard {
+  /**
+   * Activate the clipboard tool or mode.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function activate(...args: unknown[]): unknown;
+  /**
+   * Clear the current clipboard contents.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function clear(...args: unknown[]): unknown;
+  /**
+   * Return the current clipboard payload.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function get(...args: unknown[]): unknown;
+  /**
+   * Return clipboard history entries.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function getHistory(...args: unknown[]): unknown;
+  /**
+   * Return signal links stored on the clipboard.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function getSignalLinks(...args: unknown[]): unknown;
+  /**
+   * Restore a clipboard entry from history.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function selectFromHistory(...args: unknown[]): unknown;
+  /**
+   * Set the clipboard payload.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function set(...args: unknown[]): unknown;
+}

package/sandkit/engine/api/colorPicker.d.ts

@@ -0,0 +1,74 @@
+/**
+ * `sandkit.engine.api.colorPicker` — structure color palette UI helpers.
+ *
+ * **Internal API.** Prefer {@link sandkit.api} when a public method exists.
+ * Methods use loose stubs; signatures may take game state as the first argument.
+ * Engine methods pass game state as the first argument (args[0]); remaining entries are method-specific.
+ *
+ * @internal
+ */
+export namespace colorPicker {
+  /** Sentinel value for cycling through predefined colors. */
+  export const CYCLE_COLOR: unknown;
+  /** Sentinel value for no color selected. */
+  export const NO_COLOR: unknown;
+  /** List of predefined palette colors. */
+  export const PREDEFINED_COLORS: unknown;
+  /** Sentinel value for a random palette color. */
+  export const RANDOM_COLOR: unknown;
+  /**
+   * Close the active color palette UI.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function closePalette(...args: unknown[]): unknown;
+  /**
+   * Return the active palette identifier.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function getActivePalette(...args: unknown[]): unknown;
+  /**
+   * Return the next color in the cycle.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function getCycleColor(...args: unknown[]): unknown;
+  /**
+   * Return a random predefined color.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function getRandomColor(...args: unknown[]): unknown;
+  /**
+   * Convert a hex color string to RGBA components.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function hexToRgba(...args: unknown[]): unknown;
+  /**
+   * Render a color-picker button in the UI.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function renderColorButton(...args: unknown[]): unknown;
+  /**
+   * Render a color section in the UI.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function renderColorSection(...args: unknown[]): unknown;
+  /**
+   * Render the full color palette UI.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function renderPalette(...args: unknown[]): unknown;
+  /**
+   * Convert RGBA components to a hex color string.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function rgbaToHex(...args: unknown[]): unknown;
+  /**
+   * Set the active palette identifier.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function setActivePalette(...args: unknown[]): unknown;
+  /**
+   * Open or close the color palette UI.
+   * @param args - Game state first, then method-specific arguments.
+   */
+  export function togglePalette(...args: unknown[]): unknown;
+}