@nayan-ui/games 1.19.0 → 1.20.0

package/lib/typescript/src/games/number-search/NumberSearchStore.d.ts

@@ -1,70 +0,0 @@
-import type { GameSettings } from '../../services/UtilsService';
-import { type GridCell, type PlacedNumber } from './NumberSearchService';
-export interface SelectionState {
-    startCell: {
-        row: number;
-        col: number;
-    } | null;
-    currentCell: {
-        row: number;
-        col: number;
-    } | null;
-    selectedCells: {
-        row: number;
-        col: number;
-    }[];
-}
-export interface FoundNumberHighlight {
-    numberId: string;
-    cells: {
-        row: number;
-        col: number;
-    }[];
-    color: string;
-}
-export interface NumberSearchState {
-    isPlaying: boolean;
-    isGameOver: boolean;
-    isWin: boolean;
-    grid: GridCell[][];
-    gridSize: number;
-    placedNumbers: PlacedNumber[];
-    foundNumbers: string[];
-    foundNumberHighlights: FoundNumberHighlight[];
-    selection: SelectionState;
-    score: number;
-    time: number;
-    highlightVersion: number;
-    foundNumbersVersion: number;
-    selectionSig: string;
-    generation: number;
-    startGame: () => void;
-    stopGame: () => void;
-    resetGame: () => void;
-    initializeGame: () => void;
-    startSelection: (row: number, col: number) => void;
-    updateSelection: (row: number, col: number) => void;
-    endSelection: (settings: GameSettings) => void;
-    decrementTime: () => void;
-}
-export declare const HIGHLIGHT_COLORS: string[];
-export declare const useNumberSearchStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<NumberSearchState>, "subscribe"> & {
-    subscribe: {
-        (listener: (selectedState: NumberSearchState, previousSelectedState: NumberSearchState) => void): () => void;
-        <U>(selector: (state: NumberSearchState) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
-            equalityFn?: ((a: U, b: U) => boolean) | undefined;
-            fireImmediately?: boolean;
-        } | undefined): () => void;
-    };
-}>;
-export declare const useIsPlaying: () => boolean;
-export declare const useIsGameOver: () => boolean;
-export declare const useIsWin: () => boolean;
-export declare const useGridSize: () => number;
-export declare const useGridReady: () => number;
-export declare const usePlacedNumbers: () => PlacedNumber[];
-export declare const useHighlightVersion: () => number;
-export declare const useFoundNumbersVersion: () => number;
-export declare const useSelectionSig: () => string;
-export declare const useScore: () => number;
-export declare const useTime: () => number;

package/lib/typescript/src/games/number-search/components/GameBoard.d.ts

@@ -1,7 +0,0 @@
-import React from 'react';
-import type { GameSettings } from '../../../services/UtilsService';
-interface GameBoardProps {
-    settings: GameSettings;
-}
-export declare const GameBoard: React.FC<GameBoardProps>;
-export {};

package/lib/typescript/src/games/number-search/components/NumberList.d.ts

@@ -1,2 +0,0 @@
-import React from 'react';
-export declare const NumberList: React.FC;

package/lib/typescript/src/games/number-search/components/ScoreBoard.d.ts

@@ -1,6 +0,0 @@
-import React from 'react';
-interface ScoreBoardProps {
-    offset?: number;
-}
-export declare const ScoreBoard: React.FC<ScoreBoardProps>;
-export {};

package/lib/typescript/src/games/nuts-and-bolts/NutsAndBoltsService.d.ts

@@ -1,67 +0,0 @@
-export interface Hole {
-    id: string;
-    row: number;
-    col: number;
-    boltId: string | null;
-}
-export interface Bolt {
-    id: string;
-    row: number;
-    col: number;
-    originalRow: number;
-    originalCol: number;
-    holeId: string | null;
-}
-export interface Plank {
-    id: string;
-    orientation: 'horizontal' | 'vertical';
-    startRow: number;
-    startCol: number;
-    length: number;
-    color: string;
-    zIndex: number;
-}
-export interface PuzzleState {
-    holes: Hole[];
-    bolts: Bolt[];
-    planks: Plank[];
-}
-export declare const formatScore: (score: number) => string;
-export declare const getPlankPositions: (plank: Plank) => {
-    row: number;
-    col: number;
-}[];
-export declare const plankCoversPosition: (plank: Plank, row: number, col: number) => boolean;
-export declare const generatePuzzle: () => PuzzleState;
-export declare const getBoltById: (boltId: string, bolts: Bolt[]) => Bolt | null;
-export declare const getBoltAtPosition: (row: number, col: number, bolts: Bolt[]) => Bolt | null;
-export declare const getHoleById: (holeId: string, holes: Hole[]) => Hole | null;
-export declare const getPlanksAtPosition: (row: number, col: number, planks: Plank[]) => Plank[];
-export declare const getPlankIntersections: (planks: Plank[]) => {
-    row: number;
-    col: number;
-}[];
-export declare const getValidBoltPositions: (planks: Plank[]) => {
-    row: number;
-    col: number;
-}[];
-export declare const getEmptyGridHoles: (_planks: Plank[], bolts: Bolt[]) => {
-    row: number;
-    col: number;
-}[];
-export declare const canSelectBolt: (bolt: Bolt, planks: Plank[]) => boolean;
-export declare const canPlaceBoltInHole: (hole: Hole) => boolean;
-export declare const moveBoltToHole: (boltId: string, holeId: string, bolts: Bolt[], holes: Hole[]) => {
-    bolts: Bolt[];
-    holes: Hole[];
-};
-export declare const moveBoltToGrid: (boltId: string, row: number, col: number, bolts: Bolt[], holes: Hole[]) => {
-    bolts: Bolt[];
-    holes: Hole[];
-};
-export declare const checkPlankRemoval: (planks: Plank[], bolts: Bolt[]) => {
-    removedPlanks: Plank[];
-    remainingPlanks: Plank[];
-};
-export declare const isPuzzleComplete: (planks: Plank[]) => boolean;
-export declare const calculateScore: (timeRemaining: number) => number;

package/lib/typescript/src/games/nuts-and-bolts/NutsAndBoltsStore.d.ts

@@ -1,45 +0,0 @@
-import type { GameSettings } from '../../services/UtilsService';
-import { type Hole, type Bolt, type Plank } from './NutsAndBoltsService';
-export interface FallingPlank extends Plank {
-    fallStartTime: number;
-}
-export interface NutsAndBoltsState {
-    isPlaying: boolean;
-    isGameOver: boolean;
-    isWin: boolean;
-    holes: Hole[];
-    bolts: Bolt[];
-    planks: Plank[];
-    fallingPlanks: FallingPlank[];
-    originalBoltPositions: {
-        row: number;
-        col: number;
-    }[];
-    selectedBoltId: string | null;
-    score: number;
-    time: number;
-    initialTime: number;
-    boardReady: boolean;
-    boltsVersion: number;
-    planksVersion: number;
-    fallingVersion: number;
-    startGame: () => void;
-    stopGame: () => void;
-    resetGame: () => void;
-    initializeGame: () => void;
-    handleTap: (row: number, col: number, isHole: boolean, holeId: string | null, settings: GameSettings) => void;
-    removeFallingPlank: (plankId: string) => void;
-    decrementTime: () => void;
-}
-export declare const useNutsAndBoltsStore: import("zustand").UseBoundStore<import("zustand").StoreApi<NutsAndBoltsState>>;
-export declare const useIsPlaying: () => boolean;
-export declare const useIsGameOver: () => boolean;
-export declare const useIsWin: () => boolean;
-export declare const useBoardReady: () => boolean;
-export declare const useBoltsVersion: () => number;
-export declare const usePlanksVersion: () => number;
-export declare const useFallingVersion: () => number;
-export declare const useSelectedBoltId: () => string | null;
-export declare const useScore: () => number;
-export declare const useTime: () => number;
-export declare const usePlanksCount: () => number;

package/lib/typescript/src/games/nuts-and-bolts/components/GameBoard.d.ts

@@ -1,7 +0,0 @@
-import React from 'react';
-import type { GameSettings } from '../../../services/UtilsService';
-interface GameBoardProps {
-    settings: GameSettings;
-}
-export declare const GameBoard: React.FC<GameBoardProps>;
-export {};

package/lib/typescript/src/games/nuts-and-bolts/components/ScoreBoard.d.ts

@@ -1,6 +0,0 @@
-import React from 'react';
-interface ScoreBoardProps {
-    offset?: number;
-}
-export declare const ScoreBoard: React.FC<ScoreBoardProps>;
-export {};

package/lib/typescript/src/games/pac-man/PacManService.d.ts

@@ -1,73 +0,0 @@
-import { GhostMode, GhostName, type Direction } from './PacManConstants';
-export interface Position {
-    x: number;
-    y: number;
-}
-export interface PacMan extends Position {
-    direction: Direction;
-    nextDirection: Direction;
-    mouthOpen: boolean;
-    mouthAngle: number;
-    visualX: number;
-    visualY: number;
-}
-export interface Ghost extends Position {
-    name: GhostName;
-    direction: Direction;
-    mode: GhostMode;
-    previousMode: GhostMode;
-    targetX: number;
-    targetY: number;
-    frightenedTimer: number;
-    isFlashing: boolean;
-    visualX: number;
-    visualY: number;
-}
-export interface Fruit extends Position {
-    active: boolean;
-    expiresAt: number;
-}
-export interface GameMaze {
-    cells: number[][];
-    dotsRemaining: number;
-    totalDots: number;
-}
-export declare class PacManService {
-    private maze;
-    private mouthAnimationFrame;
-    constructor();
-    initializeMaze(): GameMaze;
-    resetMaze(): GameMaze;
-    getMaze(): GameMaze;
-    initializePacMan(): PacMan;
-    initializeGhosts(): Ghost[];
-    private createGhost;
-    animateMouth(pacman: PacMan): void;
-    movePacMan(pacman: PacMan): PacMan;
-    canMove(x: number, y: number): boolean;
-    canGhostMove(x: number, y: number, ghost: Ghost): boolean;
-    eatDot(x: number, y: number): {
-        points: number;
-        isPowerPellet: boolean;
-    } | null;
-    checkGhostCollision(pacman: PacMan, ghost: Ghost): boolean;
-    moveGhost(ghost: Ghost, pacman: PacMan, blinky: Ghost | null): Ghost;
-    private getChaseTarget;
-    private moveTowardsTarget;
-    private moveRandomly;
-    private getPossibleMoves;
-    private getOppositeDirection;
-    frightenGhosts(ghosts: Ghost[], duration: number): Ghost[];
-    updateFrightenedTimer(ghost: Ghost, deltaTime: number): Ghost;
-    releaseGhost(ghost: Ghost): Ghost;
-    checkGhostReachedHouse(ghost: Ghost): Ghost;
-    getDotsRemaining(): number;
-    isLevelComplete(): boolean;
-    getDotsEaten(): number;
-    shouldSpawnFruit(): boolean;
-    createFruit(): Fruit;
-    isFruitExpired(fruit: Fruit): boolean;
-    checkFruitCollision(pacman: PacMan, fruit: Fruit): boolean;
-    getPacManRotation(direction: Direction): number;
-    isValidDirectionChange(_currentDirection: Direction, newDirection: Direction): boolean;
-}

package/lib/typescript/src/games/pac-man/PacManStore.d.ts

@@ -1,89 +0,0 @@
-import type { SharedValue } from 'react-native-reanimated';
-import { type Fruit, type GameMaze } from './PacManService';
-import { GhostMode, GhostName, type Direction } from './PacManConstants';
-export interface PacManSharedValues {
-    x: SharedValue<number>;
-    y: SharedValue<number>;
-    rotation: SharedValue<number>;
-}
-export interface GhostSharedValues {
-    x: SharedValue<number>;
-    y: SharedValue<number>;
-}
-export declare const registerPacManSharedValues: (sv: PacManSharedValues) => void;
-export declare const unregisterPacManSharedValues: () => void;
-export declare const registerGhostSharedValues: (name: GhostName, sv: GhostSharedValues) => void;
-export declare const unregisterGhostSharedValues: (name: GhostName) => void;
-export declare const getPacManPosition: () => {
-    x: number;
-    y: number;
-    rotation: number;
-};
-export declare const getGhostPosition: (name: GhostName) => {
-    x: number;
-    y: number;
-} | null;
-export interface PacManVisual {
-    direction: Direction;
-    mouthOpen: boolean;
-}
-export interface GhostVisual {
-    name: GhostName;
-    mode: GhostMode;
-    isFlashing: boolean;
-}
-export interface PacManState {
-    pacmanVisual: PacManVisual;
-    ghostVisuals: GhostVisual[];
-    maze: GameMaze;
-    fruit: Fruit | null;
-    score: number;
-    timeElapsed: number;
-    lives: number;
-    isPlaying: boolean;
-    isGameOver: boolean;
-    isWin: boolean;
-    isPaused: boolean;
-    isReady: boolean;
-    enableSounds: boolean;
-    enableHaptics: boolean;
-}
-export interface PacManStore extends PacManState {
-    startGame: () => void;
-    stopGame: () => void;
-    resetGame: () => void;
-    pauseGame: () => void;
-    resumeGame: () => void;
-    initializeGame: () => void;
-    changeDirection: (direction: Direction) => void;
-    updateSettings: (enableSounds: boolean, enableHaptics: boolean) => void;
-    gameLoop: () => void;
-}
-export declare const usePacManStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<PacManStore>, "subscribe"> & {
-    subscribe: {
-        (listener: (selectedState: PacManStore, previousSelectedState: PacManStore) => void): () => void;
-        <U>(selector: (state: PacManStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
-            equalityFn?: ((a: U, b: U) => boolean) | undefined;
-            fireImmediately?: boolean;
-        } | undefined): () => void;
-    };
-}>;
-export declare const usePacManVisual: () => PacManVisual;
-export declare const useGhostVisuals: () => GhostVisual[];
-export declare const useMaze: () => GameMaze;
-export declare const useFruit: () => Fruit | null;
-export declare const useScore: () => number;
-export declare const useTimeElapsed: () => number;
-export declare const useLives: () => number;
-export declare const useIsPlaying: () => boolean;
-export declare const useIsGameOver: () => boolean;
-export declare const useIsWin: () => boolean;
-export declare const useIsPaused: () => boolean;
-export declare const useIsReady: () => boolean;
-export declare const useGameState: () => {
-    isPlaying: boolean;
-    isGameOver: boolean;
-    isWin: boolean;
-    isPaused: boolean;
-    isReady: boolean;
-};

package/lib/typescript/src/games/pac-man/components/GameCanvas.d.ts

@@ -1,2 +0,0 @@
-import React from 'react';
-export declare const GameCanvas: React.NamedExoticComponent<{}>;

package/lib/typescript/src/games/pac-man/components/ScoreBoard.d.ts

@@ -1,6 +0,0 @@
-import React from 'react';
-interface ScoreBoardProps {
-    offset?: number;
-}
-export declare const ScoreBoard: React.FC<ScoreBoardProps>;
-export {};

package/lib/typescript/src/games/paper-io/PaperIoService.d.ts

@@ -1,70 +0,0 @@
-import { type DirCode } from './PaperIoConstants';
-interface Vec {
-    dx: number;
-    dy: number;
-}
-export interface Player {
-    id: number;
-    index: number;
-    isBot: boolean;
-    alive: boolean;
-    col: number;
-    row: number;
-    dir: Vec;
-    pendingDir: Vec;
-    trail: number[];
-    homeCol: number;
-    homeRow: number;
-    respawnAt: number;
-    botState: 'expand' | 'return';
-    botStepsOut: number;
-    botTurned: boolean;
-}
-export declare class PaperIoService {
-    private destroyed;
-    private animationRef;
-    private lastStepTime;
-    private deadline;
-    private lastSecShown;
-    private owners;
-    private trailOwners;
-    private players;
-    private cachedIsPlaying;
-    private onCapture?;
-    private onTurn?;
-    private onGameOver?;
-    setPlaying(v: boolean): void;
-    setCallbacks(onCapture?: () => void, onTurn?: () => void, onGameOver?: () => void): void;
-    getOwners(): Uint8Array<ArrayBuffer>;
-    getTrailOwners(): Uint8Array<ArrayBuffer>;
-    getPlayers(): Player[];
-    private stampBlock;
-    private findSpawn;
-    private defaultSpawn;
-    initialize(): void;
-    startGame(): void;
-    private startLoop;
-    stopLoop(): void;
-    setDirection(code: DirCode): void;
-    private tick;
-    private resolvedDir;
-    private getBlockedByHeadCollision;
-    private movePlayer;
-    private performCapture;
-    private countTerritory;
-    private respawnBot;
-    private decideBotDirection;
-    private pickSafeDir;
-    private roomInDir;
-    private pickOutwardDir;
-    private endByTime;
-    private finishGame;
-    private pushStatsBatched;
-    getPlayerHeadPixel(): {
-        x: number;
-        y: number;
-    };
-    resetGame(): void;
-    cleanup(): void;
-}
-export {};

package/lib/typescript/src/games/paper-io/PaperIoStore.d.ts

@@ -1,51 +0,0 @@
-export interface PaperIoState {
-    score: number;
-    best: number;
-    territoryPct: number;
-    aiPct: number;
-    rank: number;
-    alivePlayers: number;
-    timeLeft: number;
-    won: boolean;
-    isPlaying: boolean;
-    gameOver: boolean;
-    territoryVersion: number;
-    stepVersion: number;
-}
-export interface PaperIoStore extends PaperIoState {
-    startGame: () => void;
-    stopGame: () => void;
-    resetGame: () => void;
-    setTimeLeft: (seconds: number) => void;
-    setWin: (won: boolean) => void;
-    batchTick: (stats: {
-        score: number;
-        territoryPct: number;
-        aiPct: number;
-        rank: number;
-        alivePlayers: number;
-        territoryChanged: boolean;
-    }) => void;
-    batchInit: (timeLeft: number) => void;
-}
-export declare const usePaperIoStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<PaperIoStore>, "subscribe"> & {
-    subscribe: {
-        (listener: (selectedState: PaperIoStore, previousSelectedState: PaperIoStore) => void): () => void;
-        <U>(selector: (state: PaperIoStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
-            equalityFn?: ((a: U, b: U) => boolean) | undefined;
-            fireImmediately?: boolean;
-        } | undefined): () => void;
-    };
-}>;
-export declare const useScore: () => number;
-export declare const useBest: () => number;
-export declare const useTerritoryPct: () => number;
-export declare const useAiPct: () => number;
-export declare const useTimeLeft: () => number;
-export declare const useWon: () => boolean;
-export declare const useRank: () => number;
-export declare const useAlivePlayers: () => number;
-export declare const useIsPlaying: () => boolean;
-export declare const useGameOver: () => boolean;
-export declare const useTerritoryVersion: () => number;
-export declare const useStepVersion: () => number;

package/lib/typescript/src/games/paper-io/components/GameArea.d.ts

@@ -1,8 +0,0 @@
-import React from 'react';
-import type { PaperIoService } from '../PaperIoService';
-interface GameAreaProps {
-    gameService: PaperIoService;
-    offset?: number;
-}
-export declare const GameArea: React.NamedExoticComponent<GameAreaProps>;
-export {};

package/lib/typescript/src/games/paper-io/components/ScoreBoard.d.ts

@@ -1,6 +0,0 @@
-import React from 'react';
-interface ScoreBoardProps {
-    offset?: number;
-}
-export declare const ScoreBoard: React.MemoExoticComponent<({ offset }: ScoreBoardProps) => React.JSX.Element>;
-export {};

package/lib/typescript/src/games/perfect-circle/PerfectCircleService.d.ts

@@ -1,15 +0,0 @@
-import { type Point } from './PerfectCircleStore';
-export declare class PerfectCircleService {
-    private onAccuracyCalculated?;
-    constructor();
-    setCallbacks(onAccuracyCalculated?: (accuracy: number) => void): void;
-    startGame(): void;
-    stopGame(): void;
-    resetGame(): void;
-    cleanup(): void;
-    private fitCircle;
-    private calculateAngularCoverage;
-    calculateCircleAccuracy(points: Point[], guideCircleCenterY: number): number;
-    evaluateDrawing(offset?: number): void;
-    finishDrawing(offset?: number): void;
-}

package/lib/typescript/src/games/perfect-circle/PerfectCircleStore.d.ts

@@ -1,55 +0,0 @@
-export interface Point {
-    x: number;
-    y: number;
-}
-export interface GameState {
-    isPlaying: boolean;
-    isDrawing: boolean;
-    gameOver: boolean;
-    gameWon: boolean;
-    accuracy: number;
-}
-export interface PerfectCircleStore extends GameState {
-    drawnPoints: Point[];
-    startPoint: Point | null;
-    startGame: () => void;
-    stopGame: () => void;
-    resetGame: () => void;
-    startDrawing: (point: Point) => void;
-    addPoint: (point: Point) => void;
-    finishDrawing: () => void;
-    setAccuracy: (accuracy: number) => void;
-    setGameResult: (won: boolean) => void;
-    clearDrawing: () => void;
-}
-export declare const usePerfectCircleStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<PerfectCircleStore>, "subscribe"> & {
-    subscribe: {
-        (listener: (selectedState: PerfectCircleStore, previousSelectedState: PerfectCircleStore) => void): () => void;
-        <U>(selector: (state: PerfectCircleStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
-            equalityFn?: ((a: U, b: U) => boolean) | undefined;
-            fireImmediately?: boolean;
-        } | undefined): () => void;
-    };
-}>;
-export declare const useIsPlaying: () => boolean;
-export declare const useIsDrawing: () => boolean;
-export declare const useGameOver: () => boolean;
-export declare const useGameWon: () => boolean;
-export declare const useAccuracy: () => number;
-export declare const useDrawnPoints: () => Point[];
-export declare const useGameActions: () => {
-    startGame: () => void;
-    stopGame: () => void;
-    resetGame: () => void;
-    startDrawing: (point: Point) => void;
-    addPoint: (point: Point) => void;
-    finishDrawing: () => void;
-    setAccuracy: (accuracy: number) => void;
-    setGameResult: (won: boolean) => void;
-    clearDrawing: () => void;
-};
-export declare const useGameState: () => {
-    isPlaying: boolean;
-    gameOver: boolean;
-    gameWon: boolean;
-};

package/lib/typescript/src/games/perfect-circle/components/DrawingCanvas.d.ts

@@ -1,8 +0,0 @@
-import React from 'react';
-import type { PerfectCircleService } from '../PerfectCircleService';
-interface DrawingCanvasProps {
-    gameService: PerfectCircleService;
-    offset?: number;
-}
-export declare const DrawingCanvas: React.NamedExoticComponent<DrawingCanvasProps>;
-export {};

package/lib/typescript/src/games/perfect-circle/components/ScoreBoard.d.ts

@@ -1,6 +0,0 @@
-import React from 'react';
-interface ScoreBoardProps {
-    offset?: number;
-}
-export declare const ScoreBoard: React.FC<ScoreBoardProps>;
-export {};

package/lib/typescript/src/games/pipe-connect/PipeConnectService.d.ts

@@ -1,17 +0,0 @@
-import { PipeType } from './PipeConnectConstants';
-export interface PipeCell {
-    id: string;
-    row: number;
-    col: number;
-    type: PipeType;
-    rotation: number;
-    filled: boolean;
-    fixed: boolean;
-}
-export declare const getOpenDirections: (cell: PipeCell) => number;
-export declare const findConnectedPath: (grid: PipeCell[][]) => Set<string>;
-export declare const isPuzzleCompleteFromSet: (grid: PipeCell[][], connected: Set<string>) => boolean;
-export declare const isPuzzleComplete: (grid: PipeCell[][]) => boolean;
-export declare const generatePuzzle: () => PipeCell[][];
-export declare const rotatePipe: (cell: PipeCell) => PipeCell;
-export declare const formatScore: (score: number) => string;

package/lib/typescript/src/games/pipe-connect/PipeConnectStore.d.ts

@@ -1,31 +0,0 @@
-import { type PipeCell } from './PipeConnectService';
-import type { GameSettings } from '../../services/UtilsService';
-import { type GameIntervalHandle } from '../../helpers/GameTimer';
-export interface PipeConnectState {
-    isPlaying: boolean;
-    isGameOver: boolean;
-    isWin: boolean;
-    grid: PipeCell[][];
-    score: number;
-    time: number;
-    timerInterval: GameIntervalHandle | null;
-    filledCellIds: Record<string, boolean>;
-    gridVersion: number;
-    cellVersions: Record<string, number>;
-    startGame: () => void;
-    stopGame: () => void;
-    resetGame: () => void;
-    initializeGame: () => void;
-    rotateCellAt: (row: number, col: number, settings: GameSettings) => void;
-    decrementTime: () => void;
-}
-export declare const usePipeConnectStore: import("zustand").UseBoundStore<import("zustand").StoreApi<PipeConnectState>>;
-export declare const useIsPlaying: () => boolean;
-export declare const useIsGameOver: () => boolean;
-export declare const useIsWin: () => boolean;
-export declare const useGrid: () => PipeCell[][];
-export declare const useScore: () => number;
-export declare const useTime: () => number;
-export declare const useFilledCellIds: () => Record<string, boolean>;
-export declare const useCellVersions: () => Record<string, number>;
-export declare const useGridVersion: () => number;