brick-engine-js 1.0.22 → 1.0.23

package/dist/types/core/helpers/InterfaceIdentifierHelper.d.ts

@@ -1,7 +1,41 @@
 import { Debuggable, Initializable, StateSyncable, Serializable } from '../types/Interfaces';
+/**
+ * Type guard utility for runtime interface identification of engine modules.
+ *
+ * TypeScript interfaces are erased at compile-time. This class provides the
+ * architectural capability to perform dynamic feature discovery during the
+ * engine's bootstrap and serialization phases (e.g. checking if a registered
+ * module supports state syncing) by duck-typing the expected method contracts.
+ */
 export default class InterfaceIdentifierHelper {
+    /**
+     * Determines whether a given module implements the {@link Serializable} interface.
+     *
+     * @param {object} module - The generic module instance to inspect.
+     * @returns {boolean} True if the module fulfills the contract (has `serialize`, `deserialize`, and `serialId`).
+     */
     static isSerializable(module: object): module is Serializable;
+    /**
+     * Determines whether a given module implements the {@link Initializable} interface.
+     *
+     * @param {object} module - The generic module instance to inspect.
+     * @returns {boolean} True if the module exposes a valid `setup` phase function.
+     */
     static isInitializable(module: object): module is Initializable;
+    /**
+     * Determines whether a given module implements the {@link StateSyncable} interface.
+     *
+     * Explicitly ignores the {@link GameState} itself to prevent cyclical sync loops.
+     *
+     * @param {object} module - The generic module instance to inspect.
+     * @returns {boolean} True if the module exposes a `syncState` function and is NOT the core `GameState`.
+     */
     static isStateSyncable(module: object): module is StateSyncable;
+    /**
+     * Determines whether a given module implements the {@link Debuggable} interface.
+     *
+     * @param {object} module - The generic module instance to inspect.
+     * @returns {boolean} True if the module provides a `getDebugData` function payload.
+     */
     static isDebuggable(module: object): module is Debuggable;
 }

package/dist/types/core/helpers/RelativeValuesHelper.d.ts

@@ -1,20 +1,22 @@
 /**
- * Static utility for calculating pixel values relative to the canvas size.
- * Allows for responsive design by defining sizes as percentages (0.0 - 1.0).
+ * Static mathematical utility for calculating pixel scalar values relative to the base runtime canvas.
+ *
+ * Provides isolated layout functions specifically for responsive dimensional
+ * generation in drawing or element placement without hardcoding absolute pixels.
  */
 export default class RelativeValuesHelper {
     /**
-     * Calculates a pixel width based on a percentage of the canvas width.
+     * Calculates an absolute pixel width length based against the main display context width.
      *
-     * @param {number} size - The percentage (0.0 to 1.0).
-     * @returns {number} The absolute width in pixels.
+     * @param {number} size - The desired scale fraction bounded between 0.0 and 1.0.
+     * @returns {number} The absolute integer or float mapped width scale in physical pixels.
      */
     static getRelativeWidth(size: number): number;
     /**
-     * Calculates a pixel height based on a percentage of the canvas height.
+     * Calculates an absolute pixel height length based against the main display context height.
      *
-     * @param {number} size - The percentage (0.0 to 1.0).
-     * @returns {number} The absolute height in pixels.
+     * @param {number} size - The desired scale fraction bounded between 0.0 and 1.0.
+     * @returns {number} The absolute integer or float mapped height scale in physical pixels.
      */
     static getRelativeHeight(size: number): number;
 }

package/dist/types/core/module/control/GameControl.d.ts

@@ -3,30 +3,40 @@ import { Control } from '../../types/modules';
 import { Debuggable } from '../../types/Interfaces';
 import { ControlCallback, ControlEventType, GameModules } from '../../types/Types';
 /**
- * Manages game control inputs and event dispatching.
- * Acts as the central hub for handling user input and notifying subscribers.
+ * Central event bus module processing physical hardware inputs into abstract engine events.
+ *
+ * It establishes a dedicated hub that isolates browser/device specific listeners out from
+ * the game domains. It maps normalized key presses directly to {@link ControlKey} abstractions
+ * and actively restricts event propagation downstream depending on the core {@link GameState}
+ * (e.g. blocking inputs during session modals or paused states).
  */
 export default class GameControl implements Control, Debuggable {
     private _modules;
     private _keyBinding;
     private _activeListeners;
     /**
-     * Initializes the control system.
-     * Sets up key bindings and prepares the input handler.
+     * Initializes the central control system and mounts physical browser DOM listeners.
+     *
+     * @returns {void} Returns nothing.
      */
     setup(): void;
     /**
-     * Unbinds all control event listeners.
+     * Unbinds all control event listeners and detaches physical DOM bindings.
+     *
+     * @returns {void} Returns nothing.
      */
     unbindControls(): void;
     /**
-     * Binds all control event listeners.
+     * Re-binds physical control event listeners if detached.
+     *
+     * @returns {void} Returns nothing.
      */
     bindControls(): void;
     /**
-     * Injects the game modules for context-aware events.
+     * Injects the active context game modules needed for state-aware event blocking logic.
      *
-     * @param {GameModules} modules - The collected game modules.
+     * @param {GameModules} modules - The active registered cluster of generic game modules.
+     * @returns {void} Returns nothing.
      */
     setModules(modules: GameModules): void;
     subscribe(key: ControlKey, type: ControlEventType, callback: ControlCallback): void;
@@ -42,17 +52,19 @@ export default class GameControl implements Control, Debuggable {
     private _subscribe;
     private _unsubscribe;
     /**
-     * Notifies subscribers of a control event.
+     * Natively triggers an abstract game event securely down the core pipeline.
+     * Processes strict architectural logic gates (e.g., blocking during modals) before broadcasting.
      *
-     * @param {ControlKey} key - The key triggering the event.
-     * @param {ControlEventType} type - The type of event.
-     * @throws {Error} If modules have not been initialized.
+     * @param {ControlKey} key - The abstract virtual key intent dispatching the signal.
+     * @param {ControlEventType} type - The behavior suffix (e.g. PRESSED vs HELD).
+     * @returns {void} Returns nothing.
+     * @throws {Error} Immediately if the foundational context modules have not yet been initialized.
      */
     notify(key: ControlKey, type: ControlEventType): void;
     /**
-     * Retrieves debug information about the control system.
+     * Calculates debug metadata mapping arrays for the live diagnostics monitor.
      *
-     * @returns {Record<string, string | number | boolean>} The debug data.
+     * @returns {Record<string, string | number | boolean>} A shallow payload of the list length sizes.
      */
     getDebugData(): Record<string, string | number | boolean>;
 }

package/dist/types/core/module/grid/GameGrid.d.ts

@@ -4,10 +4,12 @@ import { Debuggable } from '../../types/Interfaces';
 import { Grid } from '../../types/modules';
 import { Serializable } from '../../types/Interfaces';
 /**
- * Manages the game's logical grid state and operations.
+ * Core module responsible for managing the logical 2D grid matrix and spatial states.
  *
- * Provides a robust API for cell manipulation, row/column management,
- * collision detection, and mass grid modifications.
+ * It serves as the authoritative boundary for all coordinate mathematics,
+ * cell modifications, and collision detection logic, completely agnostic
+ * to the physical rendering loop. It ensures no pieces can mathematically
+ * step out of bounds or override occupied spaces incorrectly.
  */
 export default class GameGrid implements Grid, Debuggable, Serializable {
     /**
@@ -66,7 +68,7 @@ export default class GameGrid implements Grid, Debuggable, Serializable {
     /**
      * Initializes the grid by resetting its content to an empty state.
      *
-     * @returns {void}
+     * @returns {void} Returns nothing.
      */
     setup(): void;
     /**
@@ -74,14 +76,14 @@ export default class GameGrid implements Grid, Debuggable, Serializable {
      *
      * Populates the grid with empty cells using {@link CellHelper.emptyCell}.
      *
-     * @returns {void}
+     * @returns {void} Returns nothing.
      */
     resetGrid(): void;
     /**
      * Iterates over every cell in the grid and executes a callback.
      *
      * @param {function(Cell): void} callback - The function to execute for each cell.
-     * @returns {void}
+     * @returns {void} Returns nothing.
      */
     forEach(callback: (cell: Cell) => void): void;
     /**
@@ -103,7 +105,7 @@ export default class GameGrid implements Grid, Debuggable, Serializable {
      *
      * @param {Coordinate} coordinate - The target coordinate.
      * @param {number} value - The new value (e.g., 0 for inactive, >0 for active).
-     * @returns {void}
+     * @returns {void} Returns nothing.
      */
     setCellValue(coordinate: Coordinate, value: number): void;
     /**
@@ -111,23 +113,23 @@ export default class GameGrid implements Grid, Debuggable, Serializable {
      *
      * @param {Coordinate} coordinate - The target coordinate.
      * @param {Color} color - The new color enum value.
-     * @returns {void}
+     * @returns {void} Returns nothing.
      */
     setCellColor(coordinate: Coordinate, color: Color): void;
     /**
-     * Checks if a cell at a specific coordinate is active (value > 0).
+     * Checks if a cell is active (value > 0).
      *
-     * @param {Coordinate} coordinate - The coordinate to check.
+     * @param {Cell} cell - The cell to check.
      * @returns {boolean} True if active, false otherwise.
      */
-    isCellActive(coordinate: Coordinate): boolean;
+    isCellActive(cell: Cell): boolean;
     /**
-     * Checks if a cell at a specific coordinate is inactive (value === 0).
+     * Checks if a cell is inactive (value === 0).
      *
-     * @param {Coordinate} coordinate - The coordinate to check.
+     * @param {Cell} cell - The cell to check.
      * @returns {boolean} True if inactive, false otherwise.
      */
-    isCellInactive(coordinate: Coordinate): boolean;
+    isCellInactive(cell: Cell): boolean;
     /**
      * Checks if every cell in a specific row is active.
      *
@@ -146,7 +148,7 @@ export default class GameGrid implements Grid, Debuggable, Serializable {
      * Resets all cells in a specific row to their default empty state.
      *
      * @param {number} y - The row index to clear.
-     * @returns {void}
+     * @returns {void} Returns nothing.
      */
     clearRow(y: number): void;
     /**
@@ -155,7 +157,7 @@ export default class GameGrid implements Grid, Debuggable, Serializable {
      * Clears the top-most row after shifting.
      *
      * @param {number} fromY - The starting row index for the shift down.
-     * @returns {void}
+     * @returns {void} Returns nothing.
      */
     shiftRowsDown(fromY: number): void;
     /**
@@ -164,7 +166,7 @@ export default class GameGrid implements Grid, Debuggable, Serializable {
      * Clears the bottom-most row after shifting.
      *
      * @param {number} fromY - The starting row index for the shift up.
-     * @returns {void}
+     * @returns {void} Returns nothing.
      */
     shiftRowsUp(fromY: number): void;
     /**
@@ -193,7 +195,7 @@ export default class GameGrid implements Grid, Debuggable, Serializable {
      * Resets all cells in a specific column to their default empty state.
      *
      * @param {number} x - The column index to clear.
-     * @returns {void}
+     * @returns {void} Returns nothing.
      */
     clearColumn(x: number): void;
     /**
@@ -202,7 +204,7 @@ export default class GameGrid implements Grid, Debuggable, Serializable {
      * Clears the left-most column (index 0) after shifting.
      *
      * @param {number} fromX - The starting column index for the shift right.
-     * @returns {void}
+     * @returns {void} Returns nothing.
      */
     shiftColumnsRight(fromX: number): void;
     /**
@@ -211,7 +213,7 @@ export default class GameGrid implements Grid, Debuggable, Serializable {
      * Clears the right-most column after shifting.
      *
      * @param {number} fromX - The starting column index for the shift left.
-     * @returns {void}
+     * @returns {void} Returns nothing.
      */
     shiftColumnsLeft(fromX: number): void;
     /**
@@ -236,7 +238,7 @@ export default class GameGrid implements Grid, Debuggable, Serializable {
      * @param {Coordinate} end - The opposite corner of the rectangle.
      * @param {number} value - The cell status value to apply.
      * @param {Color} color - The color to apply.
-     * @returns {void}
+     * @returns {void} Returns nothing.
      */
     fillArea(start: Coordinate, end: Coordinate, value: number, color: Color): void;
     /**
@@ -244,15 +246,15 @@ export default class GameGrid implements Grid, Debuggable, Serializable {
      *
      * Effectively "stamps" a piece's shape onto the static grid.
      *
-     * @param {Piece} piece - The collection of cells to stamp.
-     * @returns {void}
+     * @param {Piece | Cell[]} piece - The collection of cells to stamp.
+     * @returns {void} Returns nothing.
      */
-    stampPiece(piece: Piece): void;
+    stampPiece(piece: Piece | Cell[]): void;
     /**
      * Updates a single coordinate with a specific value and color from a Cell.
      *
      * @param {Cell} cell - The cell containing coordinate, value and color.
-     * @returns {void}
+     * @returns {void} Returns nothing.
      */
     stampCell(cell: Cell): void;
     /**
@@ -261,35 +263,35 @@ export default class GameGrid implements Grid, Debuggable, Serializable {
      * Validates that all new positions are within grid boundaries and are not
      * occupied by other active cells (excluding the cells that are part of the original piece).
      *
-     * @param {Piece} piece - The current piece (collection of cells).
+     * @param {Piece | Cell[]} piece - The current piece (collection of cells).
      * @param {Vector} direction - The movement vector (e.g., {x: -1, y: 0} for left).
-     * @returns {Piece | null} The new piece with updated coordinates if the move is valid, or null if blocked.
+     * @returns {Piece} The new piece with updated coordinates if the move is valid, or the original piece if blocked.
      */
-    movePiece(piece: Piece, direction: Vector): Piece | null;
+    movePiece(piece: Piece | Cell[], direction: Vector): Piece;
     /**
      * Alias for {@link movePiece} shifting one unit to the left.
-     * @param {Piece} piece - The current piece.
-     * @returns {Piece | null}
+     * @param {Piece | Cell[]} piece - The current piece.
+     * @returns {Piece}
      */
-    movePieceLeft(piece: Piece): Piece | null;
+    movePieceLeft(piece: Piece | Cell[]): Piece;
     /**
      * Alias for {@link movePiece} shifting one unit to the right.
-     * @param {Piece} piece - The current piece.
-     * @returns {Piece | null}
+     * @param {Piece | Cell[]} piece - The current piece.
+     * @returns {Piece}
      */
-    movePieceRight(piece: Piece): Piece | null;
+    movePieceRight(piece: Piece | Cell[]): Piece;
     /**
      * Alias for {@link movePiece} shifting one unit up.
-     * @param {Piece} piece - The current piece.
-     * @returns {Piece | null}
+     * @param {Piece | Cell[]} piece - The current piece.
+     * @returns {Piece}
      */
-    movePieceUp(piece: Piece): Piece | null;
+    movePieceUp(piece: Piece | Cell[]): Piece;
     /**
      * Alias for {@link movePiece} shifting one unit down.
-     * @param {Piece} piece - The current piece.
-     * @returns {Piece | null}
+     * @param {Piece | Cell[]} piece - The current piece.
+     * @returns {Piece}
      */
-    movePieceDown(piece: Piece): Piece | null;
+    movePieceDown(piece: Piece | Cell[]): Piece;
     /**
      * Attempts to shift a single cell in a given direction.
      *
@@ -297,42 +299,42 @@ export default class GameGrid implements Grid, Debuggable, Serializable {
      *
      * @param {Cell} cell - The current cell.
      * @param {Vector} direction - The movement vector.
-     * @returns {Cell | null} The new cell with updated coordinate if the move is valid, or null if blocked.
+     * @returns {Cell} The new cell with updated coordinate if the move is valid, or the original cell if blocked.
      */
-    moveCell(cell: Cell, direction: Vector): Cell | null;
+    moveCell(cell: Cell, direction: Vector): Cell;
     /**
      * Alias for {@link moveCell} shifting one unit to the left.
      * @param {Cell} cell - The current cell.
-     * @returns {Cell | null}
+     * @returns {Cell}
      */
-    moveCellLeft(cell: Cell): Cell | null;
+    moveCellLeft(cell: Cell): Cell;
     /**
      * Alias for {@link moveCell} shifting one unit to the right.
      * @param {Cell} cell - The current cell.
-     * @returns {Cell | null}
+     * @returns {Cell}
      */
-    moveCellRight(cell: Cell): Cell | null;
+    moveCellRight(cell: Cell): Cell;
     /**
      * Alias for {@link moveCell} shifting one unit up.
      * @param {Cell} cell - The current cell.
-     * @returns {Cell | null}
+     * @returns {Cell}
      */
-    moveCellUp(cell: Cell): Cell | null;
+    moveCellUp(cell: Cell): Cell;
     /**
      * Alias for {@link moveCell} shifting one unit down.
      * @param {Cell} cell - The current cell.
-     * @returns {Cell | null}
+     * @returns {Cell}
      */
-    moveCellDown(cell: Cell): Cell | null;
+    moveCellDown(cell: Cell): Cell;
     /**
      * Attempts to rotate a piece 90 degrees around a specific origin.
      *
      * @param {Piece} piece - The current piece.
      * @param {Coordinate} origin - The center of rotation.
      * @param {boolean} [clockwise=true] - Direction of rotation.
-     * @returns {Piece | null} The new piece if rotation is valid, or null if blocked.
+     * @returns {Piece} The new piece if rotation is valid, or the original piece if blocked.
      */
-    rotatePiece(piece: Piece, origin: Coordinate, clockwise?: boolean): Piece | null;
+    rotatePiece(piece: Piece, origin: Coordinate, clockwise?: boolean): Piece;
     /**
      * Identifies all rows that are completely filled with active cells.
      *
@@ -402,7 +404,7 @@ export default class GameGrid implements Grid, Debuggable, Serializable {
      *
      * @param {Coordinate} a - First coordinate.
      * @param {Coordinate} b - Second coordinate.
-     * @returns {void}
+     * @returns {void} Returns nothing.
      */
     swapCells(a: Coordinate, b: Coordinate): void;
     /**
@@ -418,6 +420,19 @@ export default class GameGrid implements Grid, Debuggable, Serializable {
      * @returns {Record<string, string | number | boolean>} Technical debugging data.
      */
     getDebugData(): Record<string, string | number | boolean>;
+    /**
+     * Extracts and converts the internal 2D grid matrix into a flat string payload limit.
+     * Required by the Engine's {@link Session} component for persisting cross-session layouts.
+     *
+     * @returns {string} The JSON stringified representation of the dynamic objects mapped.
+     */
     serialize(): string;
+    /**
+     * Hydrates the grid layout from a previously frozen flat string blob.
+     * Executes dynamically during engine session recovery.
+     *
+     * @param {string} data - The compacted JSON representation resolving back to standard Cell instances.
+     * @returns {void} Returns nothing.
+     */
     deserialize(data: string): void;
 }

package/dist/types/core/module/grid/GameHudGrid.d.ts

@@ -1,22 +1,24 @@
 import { Serializable } from '../../types/Interfaces';
 import GameGrid from './GameGrid';
 /**
- * A specialized grid implementation for the Heads-Up Display (HUD).
- * Typically used for previewing the "next piece" in Tetris-like games.
- * It has fixed dimensions (usually 4x4).
+ * Specialized engine module isolating the visual preview logic for upcoming pieces.
+ *
+ * It statically overrides the fluid grid dimensions strictly to a 4x4 coordinate plane.
+ * By extending the core {@link GameGrid}, it transparently inherits all complex collision
+ * and stamping logic without polluting the global game field with temporary shapes.
  */
 export default class GameHudGrid extends GameGrid implements Serializable {
     serialId: string;
     /**
-     * The fixed width of the HUD grid.
+     * Statically overrides the dynamic configuration to enforce a perfect 4x4 box.
      *
-     * @returns {number} Always returns 4.
+     * @returns {number} The strict integer width threshold (always 4).
      */
     get width(): number;
     /**
-     * The fixed height of the HUD grid.
+     * Statically overrides the dynamic configuration to enforce a perfect 4x4 box.
      *
-     * @returns {number} Always returns 4.
+     * @returns {number} The strict integer height threshold (always 4).
      */
     get height(): number;
     serialize(): string;

package/dist/types/core/module/grid/engines/GridAnalysisEngine.d.ts

@@ -1,29 +1,48 @@
 import { Cell, Coordinate, Piece } from '../../../types/Types';
 import { Grid } from '../../../types/modules';
 /**
- * Handles analysis and search operations on the grid.
+ * Engineering sub-module providing structural data mapping and traversal logic.
+ *
+ * Implements the {@link Grid} analytical operations. It specializes in read-only iterations,
+ * like returning complete line matrices, verifying connected graph components (via logic like BFS),
+ * and securely interacting with cell metadata without persisting changes automatically.
  */
 export default class GridAnalysisEngine {
     private grid;
     constructor(grid: Grid);
     /**
-     * Identifies all rows that are completely filled with active cells.
+     * Sweeps horizontally evaluating grid integrity across specific vertical line coordinates.
+     *
+     * @returns {number[]} An array mapping integer strings to valid completed row limits.
      */
     getFullRows(): number[];
     /**
-     * Identifies all columns that are completely filled with active cells.
+     * Sweeps vertically evaluating grid integrity across specific horizontal line coordinates.
+     *
+     * @returns {number[]} An array mapping integer strings to valid completed column limits.
      */
     getFullColumns(): number[];
     /**
-     * Returns the active cells adjacent to a specific coordinate.
+     * Inspects surrounding spaces around a central anchor leveraging specific pixel offsets.
+     *
+     * @param {Coordinate} coord - The central coordinate checking all immediate directions.
+     * @param {boolean} [includeDiagonal=false] - Broadens strict 4-neighbor searches to all corners.
+     * @returns {Cell[]} Array of loaded grid cells directly interfacing the starting point.
      */
     getNeighbors(coord: Coordinate, includeDiagonal?: boolean): Cell[];
     /**
-     * Finds all connected active cells of the same value starting from a specific coordinate.
+     * Orchestrates a Breadth-First Search (BFS) algorithm chaining adjacent blocks with identical density signatures.
+     *
+     * @param {Coordinate} coord - The starting block containing the desired active target density.
+     * @returns {Piece} An aggregated piece matching every adjacent cell linked continuously.
      */
     findConnectedCells(coord: Coordinate): Piece;
     /**
-     * Swaps the values and colors of two cells.
+     * Executes an encapsulated memory exchange operation overriding values safely between two points.
+     *
+     * @param {Coordinate} a - First point target.
+     * @param {Coordinate} b - Second point target.
+     * @returns {void} Returns nothing.
      */
     swapCells(a: Coordinate, b: Coordinate): void;
 }

package/dist/types/core/module/grid/engines/GridLineEngine.d.ts

@@ -1,56 +1,94 @@
 import { Grid } from '../../../types/modules';
 /**
- * Handles line-based operations (rows and columns) on the grid.
+ * Engineering sub-module handling comprehensive shifting row operations and grid clearance.
+ *
+ * Implements the {@link Grid} structural line shifts. It drives heavy multi-cell displacement,
+ * manipulating memory locations explicitly when the engine demands sweeping block changes
+ * to simulate gravity or clean completely occupied board bounds.
  */
 export default class GridLineEngine {
     private grid;
     constructor(grid: Grid);
     /**
-     * Checks if every cell in a specific row is active.
+     * Executes horizontal sweeping verifying no static empty elements disrupt a physical row footprint.
+     *
+     * @param {number} y - The integer declaring the horizontal map layer mapped to height.
+     * @returns {boolean} A boolean true if density confirms completely loaded limits.
      */
     isRowFull(y: number): boolean;
     /**
-     * Checks if every cell in a specific row is inactive.
+     * Executes horizontal sweeping verifying no active elements exist across a physical row footprint.
+     *
+     * @param {number} y - The integer declaring the horizontal map layer mapped to height.
+     * @returns {boolean} A boolean true if all limits check out completely zeroed out.
      */
     isRowEmpty(y: number): boolean;
     /**
-     * Resets all cells in a specific row to their default empty state.
+     * Purges specific memory instances mapping empty metadata objects identically across a row length.
+     *
+     * @param {number} y - The integer mapped horizontally mapping height to wipe.
+     * @returns {void} Returns nothing.
      */
     clearRow(y: number): void;
     /**
-     * Shifts all rows above a certain index down by one position.
+     * Transplants memory contents shifting row sequences securely down one numerical grid measure.
+     *
+     * @param {number} fromY - The explicit target line evaluating continuous transfers upwards.
+     * @returns {void} Returns nothing.
      */
     shiftRowsDown(fromY: number): void;
     /**
-     * Shifts all rows below a certain index up by one position.
+     * Transplants memory contents shifting row sequences securely up one numerical grid measure.
+     *
+     * @param {number} fromY - The explicit target line evaluating continuous transfers downwards.
+     * @returns {void} Returns nothing.
      */
     shiftRowsUp(fromY: number): void;
     /**
-     * Scans for full rows, clears them, and shifts remaining rows down.
+     * Orchestrates comprehensive cascading block removal across multiple overlapping frame steps.
+     *
+     * @returns {number} The integer metric mapping strictly deleted physical bounds.
      */
     clearFullRows(): number;
     /**
-     * Checks if every cell in a specific column is active.
+     * Executes vertical sweeping verifying no static empty elements disrupt a physical column footprint.
+     *
+     * @param {number} x - The integer declaring the vertical map layer mapped to width.
+     * @returns {boolean} A boolean true if density confirms completely loaded limits.
      */
     isColumnFull(x: number): boolean;
     /**
-     * Checks if every cell in a specific column is inactive.
+     * Executes vertical sweeping verifying no active elements exist across a physical column footprint.
+     *
+     * @param {number} x - The integer declaring the vertical map layer mapped to width.
+     * @returns {boolean} A boolean true if all limits check out completely zeroed out.
      */
     isColumnEmpty(x: number): boolean;
     /**
-     * Resets all cells in a specific column to their default empty state.
+     * Purges specific memory instances mapping empty metadata objects identically across a column length.
+     *
+     * @param {number} x - The integer mapped vertically mapping width to wipe.
+     * @returns {void} Returns nothing.
      */
     clearColumn(x: number): void;
     /**
-     * Shifts all columns to the left of a certain index one position to the right.
+     * Transplants memory contents shifting column sequences securely right one numerical grid measure.
+     *
+     * @param {number} fromX - The explicit target line evaluating continuous transfers.
+     * @returns {void} Returns nothing.
      */
     shiftColumnsRight(fromX: number): void;
     /**
-     * Shifts all columns to the right of a certain index one position to the left.
+     * Transplants memory contents shifting column sequences securely left one numerical grid measure.
+     *
+     * @param {number} fromX - The explicit target line evaluating continuous transfers.
+     * @returns {void} Returns nothing.
      */
     shiftColumnsLeft(fromX: number): void;
     /**
-     * Scans for full columns, clears them, and shifts remaining columns right.
+     * Orchestrates comprehensive cascading block removal across multiple overlapping frame steps on columns.
+     *
+     * @returns {number} The integer metric mapping strictly deleted physical bounds.
      */
     clearFullColumns(): number;
 }