import { Rect, RenderCanvasSize, RenderWindow } from "./rendering";
import { AudioModel } from "./recordings";
import { Signal } from "@lit-labs/preact-signals";
import { Annotation } from "./annotation";
export type Milliseconds = number;
export type Seconds = number;
export type Hertz = number;
export type MHertz = number;
export type Sample = number;
export type Pixel = number;
export type EmUnit = number;
export type AngleDegrees = number;
/**
 * A value that is bounded from [0, 1]
 * A unit intervals can be used to represent percentages in decimal form
 */
export type UnitInterval = number;
export type ScaleDomain<T extends number> = [min: T, min: T];
export type ScaleRange<T extends number> = [min: T, max: T];
export type LinearScale<T extends number> = (value: T) => Pixel;
export type InverseLinearScale<T extends number> = (value: Pixel) => T;
export type TemporalScale = LinearScale<Seconds>;
export type FrequencyScale = LinearScale<Hertz>;
export type InvertTemporalScale = InverseLinearScale<Seconds>;
export type InvertFrequencyScale = InverseLinearScale<Hertz>;
export declare class UnitConverter {
    readonly renderWindow: Signal<RenderWindow>;
    readonly canvasSize: Signal<RenderCanvasSize>;
    readonly audioModel: Signal<AudioModel>;
    readonly melScale: Signal<boolean>;
    constructor(renderWindow: Signal<RenderWindow>, canvasSize: Signal<RenderCanvasSize>, audioModel: Signal<AudioModel>, melScale: Signal<boolean>);
    readonly nyquist: import("@lit-labs/preact-signals").ReadonlySignal<number>;
    private readonly frequencyInterpolator;
    readonly temporalDomain: import("@lit-labs/preact-signals").ReadonlySignal<ScaleDomain<number>>;
    readonly frequencyDomain: import("@lit-labs/preact-signals").ReadonlySignal<ScaleDomain<number>>;
    readonly temporalRange: import("@lit-labs/preact-signals").ReadonlySignal<ScaleRange<number>>;
    readonly frequencyRange: import("@lit-labs/preact-signals").ReadonlySignal<ScaleRange<number>>;
    /**
     * Convert Seconds into a Pixel value on the canvas
     *
     * @param value the value in seconds
     * @returns the x-offset that the seconds value should be drawn
     */
    readonly scaleX: import("@lit-labs/preact-signals").ReadonlySignal<TemporalScale>;
    /**
     * Convert a Pixel value on a canvas value into a number of Seconds
     *
     * @param value the x-offset on the canvas
     * @returns what seconds value the x-offset represents
     */
    readonly scaleXInverse: import("@lit-labs/preact-signals").ReadonlySignal<InvertTemporalScale>;
    /**
     * Convert Hertz into a Pixel value on the canvas
     *
     * @param value the value in Hertz
     * @returns the y-offset that the Hertz value should be drawn
     */
    readonly scaleY: import("@lit-labs/preact-signals").ReadonlySignal<FrequencyScale>;
    /**
     * Convert a Pixel value on a canvas into a number of Hertz
     *
     * @param value the y-offset on the canvas
     * @returns what Hertz value the y-offset represents
     */
    readonly scaleYInverse: import("@lit-labs/preact-signals").ReadonlySignal<InvertFrequencyScale>;
    annotationRect(annotation: Readonly<Annotation>): Readonly<Rect<Signal<Pixel>>>;
    /**
     * @returns
     * A boolean indicating if any part of the value is within the temporal
     * domain
     */
    overlapsTemporalDomain(value: ScaleDomain<Seconds>): boolean;
    /**
     * @returns
     * A boolean indicating if any part of the value is within the frequency
     * domain.
     */
    overlapsFrequencyDomain(value: ScaleDomain<Hertz>): boolean;
    /**
     * @returns a function that converts a value to a pixel value
     */
    private linearScale;
    /**
     * @returns a function that converts a pixel value to a value
     */
    private inverseLinearScale;
    /**
     * calculate the magnitude of a linear function using
     * (y_2 - y_1) / (x_2 - x_1)
     *
     * @returns the magnitude of the mathematical function
     */
    private calculateMagnitude;
}