import { type Channel, type DeviceCommand, type DeviceCommandResult, type DeviceState, type SensorState, type WaveFrame } from '@dg-kit/core';
import type { BluetoothDeviceLike, BluetoothRemoteGATTCharacteristicLike, BluetoothRemoteGATTServerLike } from './types.js';
export type StateListener = (state: DeviceState) => void;
export interface WebBluetoothAvailability {
    supported: boolean;
    reason?: string;
}
export interface WebBluetoothConnectionContext {
    device: BluetoothDeviceLike;
    server: BluetoothRemoteGATTServerLike;
}
export interface WebBluetoothProtocolAdapter {
    onConnected(context: WebBluetoothConnectionContext): Promise<void>;
    onDisconnected(): Promise<void>;
    getState(): DeviceState;
    execute(command: DeviceCommand): Promise<DeviceCommandResult>;
    emergencyStop(): Promise<void>;
    subscribe(listener: StateListener): () => void;
    /**
     * Update the per-channel strength soft-limits.
     *
     * V3: re-sends a BF init packet so the device enforces the new limits.
     * V2: limits are clamped client-side at each tick (V2 protocol has no
     * device-side limit command).
     *
     * Limits also clamp current strength downward if reduced.
     */
    setLimits(limitA: number, limitB: number): Promise<void>;
}
/**
 * Contract for sensor-family devices (paw-prints, civet-edging): they push
 * event/telemetry streams instead of exposing a two-channel strength state,
 * so they get a narrower adapter shape than `WebBluetoothProtocolAdapter`
 * rather than being forced into the stim-specific `DeviceState`/
 * `DeviceCommand` types. `TReading` is the device-specific parsed event
 * union (e.g. a button trigger, a pressure sample).
 */
export interface WebBluetoothSensorAdapter<TReading> {
    onConnected(context: WebBluetoothConnectionContext): Promise<void>;
    onDisconnected(): Promise<void>;
    getState(): SensorState;
    /** Subscribe to parsed device readings/events. */
    subscribe(listener: (reading: TReading) => void): () => void;
    onStateChanged(listener: (state: SensorState) => void): () => void;
}
export interface ChannelWaveState {
    waveformId?: string;
    frames: WaveFrame[] | null;
    index: number;
    loop: boolean;
    active: boolean;
}
export type Quad = [number, number, number, number];
export type WaveStep = {
    freq: number;
    int: number;
};
export declare const INACTIVE_FREQ: Quad;
export declare const INACTIVE_INT: Quad;
export declare const SILENT_WAVE_STEP: WaveStep;
export declare abstract class BaseCoyoteProtocolAdapter implements WebBluetoothProtocolAdapter {
    private readonly listeners;
    protected readonly waveState: Record<Channel, ChannelWaveState>;
    protected readonly burstRestores: Map<Channel, number>;
    protected state: DeviceState;
    protected batteryChar: BluetoothRemoteGATTCharacteristicLike | null;
    private readonly tickLoop;
    private readonly waveCursor;
    protected tickPaused: boolean;
    protected suppressStaleStopStrengthNotifications: boolean;
    subscribe(listener: StateListener): () => void;
    onDisconnected(): Promise<void>;
    protected resetConnectionState(options: {
        emit: boolean;
    }): Promise<void>;
    getState(): DeviceState;
    execute(command: DeviceCommand): Promise<DeviceCommandResult>;
    setLimits(limitA: number, limitB: number): Promise<void>;
    emergencyStop(): Promise<void>;
    protected setConnectedDevice(device: BluetoothDeviceLike): void;
    protected startProtocolLoop(): void;
    protected resetWaveState(): void;
    protected setWave(channel: Channel, waveformId: string, frames: WaveFrame[], loop: boolean): void;
    protected clearWave(channel: Channel): void;
    protected runBurst(channel: Channel, strength: number, durationMs: number): void;
    protected cancelBurstRestore(channel: Channel): void;
    protected onTick(): Promise<void>;
    protected waitForTickIdle(): Promise<void>;
    protected advanceWaveStep(channel: Channel): WaveStep | null;
    protected advanceWavePacket(channel: Channel): {
        freq: Quad;
        int: Quad;
    };
    protected clamp(value: number, min: number, max: number): number;
    protected toInt(value: unknown, fallback?: number): number;
    protected readBattery(): Promise<void>;
    protected shouldIgnoreStaleStopStrengthNotification(strengthA: number, strengthB: number): boolean;
    protected writeCharacteristicValue(characteristic: BluetoothRemoteGATTCharacteristicLike, value: ArrayBufferView | ArrayBuffer, options?: {
        preferResponse?: boolean;
    }): Promise<void>;
    protected emit(): void;
    private startTickLoop;
    private stopTickLoop;
    protected abstract disconnectProtocol(): Promise<void>;
    abstract onConnected(context: WebBluetoothConnectionContext): Promise<void>;
    protected abstract resetProtocolState(): void;
    protected abstract resetEmergencyStopState(): void;
    protected abstract setAbsoluteStrength(channel: Channel, value: number): void;
    protected abstract adjustStrength(channel: Channel, delta: number): void;
    protected abstract performTick(): Promise<void>;
    protected abstract writeEmergencyStopPacket(): Promise<void>;
    /**
     * Push the current `state.limitA` / `state.limitB` to the device.
     * V3 sends a BF packet; V2 is a no-op (limits enforced via clamp at tick).
     */
    protected abstract writeLimitsToDevice(): Promise<void>;
}
//# sourceMappingURL=base.d.ts.map