/**
 * Individual DYNAMIXEL Device
 * Represents a single DYNAMIXEL motor with its specific capabilities
 */
export class DynamixelDevice extends EventEmitter<[never]> {
    constructor(id: any, connection: any, deviceInfo?: {});
    id: any;
    connection: any;
    modelNumber: any;
    firmwareVersion: any;
    modelName: any;
    lastError: any;
    /**
     * Ping this device to check if it's responsive
     * @param {number} timeout - Timeout in milliseconds
     * @returns {Promise<Object>} - Device information
     */
    ping(timeout?: number): Promise<Object>;
    /**
     * Read data from the device's control table
     * @param {number} address - Control table address
     * @param {number} length - Number of bytes to read
     * @param {number} timeout - Timeout in milliseconds
     * @returns {Promise<Buffer>} - Read data
     */
    read(address: number, length: number, timeout?: number): Promise<Buffer>;
    /**
     * Write data to the device's control table
     * @param {number} address - Control table address
     * @param {Buffer|Array} data - Data to write
     * @param {number} timeout - Timeout in milliseconds
     * @returns {Promise<boolean>} - Success status
     */
    write(address: number, data: Buffer | any[], timeout?: number): Promise<boolean>;
    /**
     * Read a 1-byte value from control table
     * @param {number} address - Control table address
     * @returns {Promise<number>} - 8-bit value
     */
    readByte(address: number): Promise<number>;
    /**
     * Read a 2-byte value from control table (little-endian)
     * @param {number} address - Control table address
     * @returns {Promise<number>} - 16-bit value
     */
    readWord(address: number): Promise<number>;
    /**
     * Read a 4-byte value from control table (little-endian)
     * @param {number} address - Control table address
     * @returns {Promise<number>} - 32-bit value
     */
    readDWord(address: number): Promise<number>;
    /**
     * Write a 1-byte value to control table
     * @param {number} address - Control table address
     * @param {number} value - 8-bit value
     * @returns {Promise<boolean>} - Success status
     */
    writeByte(address: number, value: number): Promise<boolean>;
    /**
     * Write a 2-byte value to control table (little-endian)
     * @param {number} address - Control table address
     * @param {number} value - 16-bit value
     * @returns {Promise<boolean>} - Success status
     */
    writeWord(address: number, value: number): Promise<boolean>;
    /**
     * Write a 4-byte value to control table (little-endian)
     * @param {number} address - Control table address
     * @param {number} value - 32-bit value
     * @returns {Promise<boolean>} - Success status
     */
    writeDWord(address: number, value: number): Promise<boolean>;
    /**
     * Enable/disable torque
     * @param {boolean} enable - True to enable, false to disable
     * @returns {Promise<boolean>} - Success status
     */
    setTorqueEnable(enable: boolean): Promise<boolean>;
    /**
     * Get torque enable status
     * @returns {Promise<boolean>} - Torque enable status
     */
    getTorqueEnable(): Promise<boolean>;
    /**
     * Set goal position
     * @param {number} position - Goal position (0-4095 for most models)
     * @returns {Promise<boolean>} - Success status
     */
    setGoalPosition(position: number): Promise<boolean>;
    /**
     * Get goal position
     * @returns {Promise<number>} - Goal position
     */
    getGoalPosition(): Promise<number>;
    /**
     * Get present position
     * @returns {Promise<number>} - Present position
     */
    getPresentPosition(): Promise<number>;
    /**
     * Set goal velocity
     * @param {number} velocity - Goal velocity
     * @returns {Promise<boolean>} - Success status
     */
    setGoalVelocity(velocity: number): Promise<boolean>;
    /**
     * Get goal velocity
     * @returns {Promise<number>} - Goal velocity
     */
    getGoalVelocity(): Promise<number>;
    /**
     * Get present velocity
     * @returns {Promise<number>} - Present velocity
     */
    getPresentVelocity(): Promise<number>;
    /**
     * Set goal PWM
     * @param {number} pwm - Goal PWM value
     * @returns {Promise<boolean>} - Success status
     */
    setGoalPWM(pwm: number): Promise<boolean>;
    /**
     * Get present PWM
     * @returns {Promise<number>} - Present PWM
     */
    getPresentPWM(): Promise<number>;
    /**
     * Get present temperature
     * @returns {Promise<number>} - Temperature in Celsius
     */
    getPresentTemperature(): Promise<number>;
    /**
     * Get present voltage
     * @returns {Promise<number>} - Voltage in 0.1V units
     */
    getPresentVoltage(): Promise<number>;
    /**
     * Set LED state
     * @param {boolean} on - True to turn on, false to turn off
     * @returns {Promise<boolean>} - Success status
     */
    setLED(on: boolean): Promise<boolean>;
    /**
     * Get LED state
     * @returns {Promise<boolean>} - LED state
     */
    getLED(): Promise<boolean>;
    /**
     * Check if device is moving
     * @returns {Promise<boolean>} - Moving status
     */
    isMoving(): Promise<boolean>;
    /**
     * Reboot the device
     * @param {number} timeout - Timeout in milliseconds
     * @returns {Promise<boolean>} - Success status
     */
    reboot(timeout?: number): Promise<boolean>;
    /**
     * Get device information summary
     * @returns {Object} - Device information
     */
    getDeviceInfo(): Object;
    /**
     * Get model name from model number
     * @param {number} modelNumber - Model number
     * @returns {string} - Model name
     */
    getModelName(modelNumber: number): string;
    /**
     * Convert position to degrees (assuming 0-4095 range)
     * @param {number} position - Position value
     * @returns {number} - Degrees (0-360)
     */
    positionToDegrees(position: number): number;
    /**
     * Convert degrees to position (assuming 0-4095 range)
     * @param {number} degrees - Degrees (0-360)
     * @returns {number} - Position value
     */
    degreesToPosition(degrees: number): number;
    /**
     * Convert velocity to RPM (model-specific)
     * @param {number} velocity - Velocity value
     * @returns {number} - RPM
     */
    velocityToRPM(velocity: number): number;
    /**
     * Convert RPM to velocity (model-specific)
     * @param {number} rpm - RPM
     * @returns {number} - Velocity value
     */
    rpmToVelocity(rpm: number): number;
    /**
     * Convert voltage reading to actual voltage
     * @param {number} voltageReading - Raw voltage reading
     * @returns {number} - Voltage in volts
     */
    voltageToVolts(voltageReading: number): number;
}
import { EventEmitter } from 'events';