declare type ControlCallback = (value: number, event: ControlChangeEvent) => void;

export declare type ControlChangeEvent = {
    type: 'controlchange';
    controller: number;
    normalizedValue: number;
    midiValue: number;
    channel: number;
    raw: any;
};

declare type ControlChangeHandler = (event: ControlChangeEvent) => void;

declare type ControlTarget = SimpleControlTarget | KnobControlTarget | DetailedControlTarget | ControlCallback;

declare type DetailedControlTarget = {
    onControlChange: (value: number, event: ControlChangeEvent) => void;
};

/**
 * Get browser-specific MIDI support information
 */
export declare function getMidiSupportInfo(): {
    supported: boolean;
    browserName: string;
    message: string;
};

declare class InputController {
    #private;
    init(): Promise<boolean>;
    onNoteOn(handler: NoteHandler): () => void;
    onNoteOff(handler: NoteHandler): () => void;
    onControlChange(handler: ControlChangeHandler): () => void;
    onSustainPedal(handler: SustainPedalHandler): () => void;
    /**
     * Register one or more control targets to respond to MIDI CC messages.
     *
     * By default, passes normalized values (0-1) to targets. Use transformValue for custom behavior.
     *
     * Supports multiple target types for maximum flexibility:
     *
     * @example
     * // Knobs - automatically calls setValueNormalized if available
     * inputController.registerControlTarget(knobElement, { controller: 15 });
     *
     * @example
     * // Simple callback function - cleanest for custom logic
     * inputController.registerControlTarget(
     *   (value, event) => console.log(`CC${event.controller}: ${value}`),
     *   { controller: 15 }
     * );
     *
     * @example
     * // Multiple targets controlled by same CC
     * inputController.registerControlTarget([knob1, knob2], { controller: 15 });
     *
     * @example
     * // Raw MIDI values (0-127) instead of normalized (0-1)
     * inputController.registerControlTarget(knobElement, {
     *   controller: 15,
     *   transformValue: (event) => event.midiValue
     * });
     *
     * @example
     * // Object with setValue method (sliders, etc.)
     * inputController.registerControlTarget({ setValue: (v) => slider.value = v }, { controller: 15 });
     */
    registerControlTarget(target: ControlTarget | ControlTarget[], options: RegisterControlOptions): () => void;
    registerSustainPedalTarget(target: SustainPedalTarget, channel?: number | 'all'): () => void;
    get initialized(): boolean;
}

export declare const inputController: InputController;

declare type KnobControlTarget = {
    setValueNormalized?: (value: number) => void;
    setValue?: (value: number) => void;
};

/**
 * MIDI Input Controller - Clean, Flexible API
 *
 * Supports multiple target types for maximum convenience:
 * - Knob elements (auto-detects setValueNormalized/setValue methods)
 * - Simple callback functions
 * - Objects with setValue method
 * - Objects with onControlChange method
 *
 * ControlChangeEvent provides both value formats:
 * - event.normalizedValue: 0-1 range (default, most common)
 * - event.midiValue: 0-127 range (raw MIDI spec)
 *
 * @example
 * // Knobs - automatically calls the right method
 * inputController.registerControlTarget(knobElement, { controller: 15 });
 *
 * @example
 * // Simple callback - cleanest for custom logic
 * inputController.registerControlTarget(
 *   (value, event) => console.log(`CC${event.controller}: ${value}`),
 *   { controller: 15 }
 * );
 *
 * @example
 * // Raw MIDI values instead of normalized
 * inputController.registerControlTarget(knob, {
 *   controller: 15,
 *   transformValue: (event) => event.midiValue
 * });
 */
export declare type NoteEvent = {
    type: 'noteon' | 'noteoff';
    note: number;
    velocity: number;
    channel: number;
    raw: any;
};

declare type NoteHandler = (event: NoteEvent) => void;

export declare type NoteTarget = {
    play: (note: number, velocity?: number) => void;
    release: (note: number) => void;
};

declare type RegisterControlOptions = {
    controller: number | number[];
    channel?: number | 'all';
    transformValue?: (event: ControlChangeEvent) => number;
};

declare type SimpleControlTarget = {
    setValue: (value: number) => void;
};

declare type SustainPedalEvent = {
    type: 'sustainpedal';
    pressed: boolean;
    channel: number;
    raw: any;
};

declare type SustainPedalHandler = (event: SustainPedalEvent) => void;

declare type SustainPedalTarget = {
    setSustainPedal: (pressed: boolean) => void;
};

export { }