import { ReelSymbol } from '../symbols/ReelSymbol.js';
import { ReelAxis } from './ReelAxis.js';
import { ReelCurve } from './ReelCurve.js';
/**
 * The physics of one reel: march symbols along the travel axis and wrap them
 * around. Projected through a {@link ReelAxis} so the same code runs vertical
 * or horizontal, forward or reverse; the default axis is vertical/forward,
 * matching every v1 layout.
 *
 * Positions are DERIVED from array index every frame, never accumulated, and
 * the rotation count is DERIVED from total travel. Rigidity, ordering and
 * boundedness are therefore true by construction, and no "at most one wrap per
 * call" precondition exists - any step size is legal (ADR 016 section 3.2,
 * ADR 018). `_symbols[0]` is always the symbol nearest the strip's start edge
 * (top for vertical, left for horizontal); each wrap moves the wrapping symbol
 * to the array end that matches its travel so the ordering stays consistent
 * with the grid.
 */
export declare class ReelMotion {
    private _symbols;
    private _onSymbolWrapped;
    private _curve?;
    private _pitch;
    private _bufferStart;
    private _axis;
    private _travel;
    private _rot;
    private _off;
    constructor(_symbols: ReelSymbol[], symbolHeight: number, symbolGapY: number, bufferStart: number, _visibleCells: number, _bufferEnd: number, _onSymbolWrapped: (symbol: ReelSymbol) => void, axis?: ReelAxis, _curve?: ReelCurve | undefined);
    /**
     * Move the strip by `delta` screen pixels along the travel axis (positive =
     * toward the larger coordinate: down for vertical, right for horizontal).
     * `delta` is relative to the reel's direction via the axis polarity, so
     * StartPhase's step-back pull (a negative delta) reads as "backwards for this
     * reel" in either direction. Any magnitude is legal.
     */
    advance(delta: number): void;
    /**
     * Swap the curvature in or out at runtime. Symbols projected by the outgoing
     * curve are flattened first, otherwise dropping to `amount: 0` would leave
     * the last quad it handed out still on screen.
     */
    setCurve(curve: ReelCurve | undefined): void;
    /** Snap all symbols to their grid positions (array index = visual cell). */
    snapToGrid(): void;
    /** The correct main-axis coordinate for a symbol at visual cell `cell`. */
    getCellMain(cell: number): number;
    get slotPitch(): number;
    /**
     * Reshape the motion layer for a new visible-cell count and cell pitch.
     * Called by `Reel.reshape()` during AdjustPhase on MultiWays slots; the
     * symbol array is re-bound via the same reference, and `Reel` snaps right
     * after, so this only refreshes the geometry.
     */
    reshape(symbolHeight: number, symbolGapY: number, bufferStart: number, _visibleCells: number, _bufferEnd: number): void;
    private _rotateToStart;
    private _rotateToEnd;
    private _render;
}
//# sourceMappingURL=ReelMotion.d.ts.map