@waveform-playlist/browser 5.0.0-alpha.0

package/dist/index.d.ts

@@ -0,0 +1,1536 @@
+import { BaseContext } from 'tone';
+import { default as default_2 } from 'react';
+import { default as default_3 } from 'waveform-data';
+import { DragEndEvent } from '@dnd-kit/core';
+import { Fade as Fade_2 } from '@waveform-playlist/core';
+import { Gain } from 'tone';
+import { MutableRefObject } from 'react';
+import react__default from 'react';
+import { ReactNode } from 'react';
+import { RefObject } from 'react';
+import { SensorDescriptor } from '@dnd-kit/core';
+import { SensorOptions } from '@dnd-kit/core';
+import * as Tone from 'tone';
+import { ToneAudioNode } from 'tone';
+import { Track } from '@waveform-playlist/core';
+import { Volume } from 'tone';
+
+export declare interface ActiveEffect {
+    instanceId: string;
+    effectId: string;
+    definition: EffectDefinition;
+    params: Record<string, number | string | boolean>;
+    bypassed: boolean;
+}
+
+declare interface Annotation$1 {
+    id: string;
+    start: number;
+    end: number;
+    lines: string[];
+    lang?: string;
+}
+
+declare interface AnnotationAction {
+    class?: string;
+    text?: string;
+    title: string;
+    action: (annotation: AnnotationData, index: number, annotations: AnnotationData[], opts: AnnotationActionOptions) => void;
+}
+
+/**
+ * Configuration options passed to annotation action handlers
+ */
+declare interface AnnotationActionOptions {
+    /** Whether annotation endpoints are linked (moving one endpoint moves the other) */
+    linkEndpoints?: boolean;
+    /** Whether to continue playing after an annotation ends */
+    continuousPlay?: boolean;
+    /** Additional custom properties */
+    [key: string]: unknown;
+}
+
+declare interface AnnotationData {
+    id: string;
+    start: number;
+    end: number;
+    lines: string[];
+    language?: string;
+}
+
+/**
+ * Represents a single audio clip on the timeline
+ *
+ * IMPORTANT: All positions/durations are stored as SAMPLE COUNTS (integers)
+ * to avoid floating-point precision errors. Convert to seconds only when
+ * needed for playback using: seconds = samples / sampleRate
+ */
+declare interface AudioClip {
+    /** Unique identifier for this clip */
+    id: string;
+    /** The audio buffer containing the audio data */
+    audioBuffer: AudioBuffer;
+    /** Position on timeline where this clip starts (in samples at timeline sampleRate) */
+    startSample: number;
+    /** Duration of this clip (in samples) - how much of the audio buffer to play */
+    durationSamples: number;
+    /** Offset into the audio buffer where playback starts (in samples) - the "trim start" point */
+    offsetSamples: number;
+    /** Optional fade in effect */
+    fadeIn?: Fade;
+    /** Optional fade out effect */
+    fadeOut?: Fade;
+    /** Clip-specific gain/volume multiplier (0.0 to 1.0+) */
+    gain: number;
+    /** Optional label/name for this clip */
+    name?: string;
+    /** Optional color for visual distinction */
+    color?: string;
+}
+
+/**
+ * Audio position display that uses the playlist context.
+ * Uses requestAnimationFrame for smooth 60fps updates during playback.
+ * Direct DOM manipulation avoids React re-renders.
+ */
+export declare const AudioPosition: default_2.FC<{
+    className?: string;
+}>;
+
+/**
+ * Configuration for a single audio track to load
+ */
+export declare interface AudioTrackConfig {
+    src: string;
+    name?: string;
+    muted?: boolean;
+    soloed?: boolean;
+    volume?: number;
+    pan?: number;
+    color?: string;
+    effects?: TrackEffectsFunction_2;
+    startTime?: number;
+    duration?: number;
+    offset?: number;
+    fadeIn?: Fade;
+    fadeOut?: Fade;
+}
+
+/**
+ * Automatic scroll checkbox that uses the playlist context
+ * Uses split contexts to avoid re-rendering during animation
+ */
+export declare const AutomaticScrollCheckbox: default_2.FC<{
+    className?: string;
+}>;
+
+/**
+ * Bits type - number of bits for peak data
+ */
+declare type Bits = 8 | 16;
+
+declare interface ClipInfo {
+    buffer: AudioBuffer;
+    startTime: number;
+    duration: number;
+    offset: number;
+    fadeIn?: Fade_2;
+    fadeOut?: Fade_2;
+    gain: number;
+}
+
+declare interface ClipPeaks {
+    clipId: string;
+    trackName: string;
+    peaks: PeakData;
+    startSample: number;
+    durationSamples: number;
+    fadeIn?: Fade;
+    fadeOut?: Fade;
+}
+
+/**
+ * Represents a track containing multiple audio clips
+ */
+declare interface ClipTrack {
+    /** Unique identifier for this track */
+    id: string;
+    /** Display name for this track */
+    name: string;
+    /** Array of audio clips on this track */
+    clips: AudioClip[];
+    /** Whether this track is muted */
+    muted: boolean;
+    /** Whether this track is soloed */
+    soloed: boolean;
+    /** Track volume (0.0 to 1.0+) */
+    volume: number;
+    /** Stereo pan (-1.0 = left, 0 = center, 1.0 = right) */
+    pan: number;
+    /** Optional track color for visual distinction */
+    color?: string;
+    /** Track height in pixels (for UI) */
+    height?: number;
+    /** Optional effects function for this track */
+    effects?: TrackEffectsFunction_2;
+}
+
+/**
+ * Continuous play checkbox that uses the playlist context
+ * Uses split contexts to avoid re-rendering during animation
+ */
+export declare const ContinuousPlayCheckbox: default_2.FC<{
+    className?: string;
+}>;
+
+/**
+ * Create a chain of effects connected in series
+ */
+export declare function createEffectChain(effects: EffectInstance[]): {
+    input: any;
+    output: any;
+    dispose: () => void;
+};
+
+/**
+ * Create an effect instance from a definition with initial parameter values
+ */
+export declare function createEffectInstance(definition: EffectDefinition, initialParams?: Record<string, number | string | boolean>): EffectInstance;
+
+/**
+ * Download annotations button that uses the playlist context
+ * Uses split contexts to avoid re-rendering during animation
+ */
+export declare const DownloadAnnotationsButton: default_2.FC<{
+    filename?: string;
+    className?: string;
+}>;
+
+/**
+ * Editable annotations checkbox that uses the playlist context
+ * Uses split contexts to avoid re-rendering during animation
+ */
+export declare const EditableCheckbox: default_2.FC<{
+    className?: string;
+}>;
+
+export declare const effectCategories: {
+    id: EffectDefinition['category'];
+    name: string;
+}[];
+
+export declare interface EffectDefinition {
+    id: string;
+    name: string;
+    category: 'delay' | 'reverb' | 'modulation' | 'distortion' | 'filter' | 'dynamics' | 'spatial';
+    description: string;
+    parameters: EffectParameter[];
+}
+
+export declare const effectDefinitions: EffectDefinition[];
+
+export declare interface EffectInstance {
+    effect: any;
+    id: string;
+    instanceId: string;
+    dispose: () => void;
+    setParameter: (name: string, value: number | string | boolean) => void;
+    getParameter: (name: string) => number | string | boolean | undefined;
+    connect: (destination: any) => void;
+    disconnect: () => void;
+}
+
+export declare interface EffectParameter {
+    name: string;
+    label: string;
+    type: ParameterType;
+    min?: number;
+    max?: number;
+    step?: number;
+    default: number | string | boolean;
+    unit?: string;
+    options?: {
+        value: string | number;
+        label: string;
+    }[];
+}
+
+export declare type EffectsFunction = (masterGainNode: Volume, destination: ToneAudioNode, isOffline: boolean) => void | (() => void);
+
+export declare interface ExportOptions extends WavEncoderOptions {
+    /** Filename for download (without extension) */
+    filename?: string;
+    /** Export mode: 'master' for stereo mix, 'individual' for single track */
+    mode?: 'master' | 'individual';
+    /** Track index for individual export (only used when mode is 'individual') */
+    trackIndex?: number;
+    /** Whether to trigger automatic download */
+    autoDownload?: boolean;
+    /** Whether to apply effects (fades, etc.) - defaults to true */
+    applyEffects?: boolean;
+    /**
+     * Optional Tone.js effects function for master effects. When provided, export will use Tone.Offline
+     * to render through the effects chain. The function receives isOffline=true.
+     */
+    effectsFunction?: EffectsFunction;
+    /**
+     * Optional function to create offline track effects.
+     * Takes a trackId and returns a TrackEffectsFunction for offline rendering.
+     * This is used instead of track.effects to avoid AudioContext mismatch issues.
+     */
+    createOfflineTrackEffects?: (trackId: string) => TrackEffectsFunction_3 | undefined;
+    /** Progress callback (0-1) */
+    onProgress?: (progress: number) => void;
+}
+
+export declare interface ExportResult {
+    /** The rendered audio buffer */
+    audioBuffer: AudioBuffer;
+    /** The WAV file as a Blob */
+    blob: Blob;
+    /** Duration in seconds */
+    duration: number;
+}
+
+export declare const ExportWavButton: default_2.FC<ExportWavButtonProps>;
+
+export declare interface ExportWavButtonProps {
+    /** Button label */
+    label?: string;
+    /** Filename for the downloaded file (without extension) */
+    filename?: string;
+    /** Export mode: 'master' for stereo mix, 'individual' for single track */
+    mode?: 'master' | 'individual';
+    /** Track index for individual export */
+    trackIndex?: number;
+    /** Bit depth: 16 or 32 */
+    bitDepth?: 16 | 32;
+    /** Whether to apply effects (fades, etc.) - defaults to true */
+    applyEffects?: boolean;
+    /**
+     * Optional Tone.js effects function for master effects. When provided, export will use Tone.Offline
+     * to render through the effects chain. The function receives isOffline=true.
+     */
+    effectsFunction?: EffectsFunction;
+    /**
+     * Optional function to create offline track effects.
+     * Takes a trackId and returns a TrackEffectsFunction for offline rendering.
+     */
+    createOfflineTrackEffects?: (trackId: string) => TrackEffectsFunction_3 | undefined;
+    /** CSS class name */
+    className?: string;
+    /** Callback when export completes */
+    onExportComplete?: (blob: Blob) => void;
+    /** Callback when export fails */
+    onExportError?: (error: Error) => void;
+}
+
+/**
+ * Simple fade configuration
+ */
+declare interface Fade {
+    /** Duration of the fade in seconds */
+    duration: number;
+    /** Type of fade curve (default: 'linear') */
+    type?: FadeType;
+}
+
+declare type FadeType = 'logarithmic' | 'linear' | 'sCurve' | 'exponential';
+
+export declare const FastForwardButton: default_2.FC<{
+    className?: string;
+}>;
+
+export declare const getEffectDefinition: (id: string) => EffectDefinition | undefined;
+
+export declare const getEffectsByCategory: (category: EffectDefinition["category"]) => EffectDefinition[];
+
+/**
+ * Get a human-readable string representation of a keyboard shortcut
+ *
+ * @param shortcut - The keyboard shortcut
+ * @returns Human-readable string (e.g., "Cmd+Shift+S")
+ */
+export declare const getShortcutLabel: (shortcut: KeyboardShortcut) => string;
+
+/**
+ * Get metadata from waveform data file without converting to peaks
+ *
+ * @param src - URL to waveform data file
+ * @returns Metadata (sample rate, channels, duration, bits, etc.)
+ */
+export declare function getWaveformDataMetadata(src: string): Promise<{
+    sampleRate: number;
+    channels: number;
+    duration: number;
+    samplesPerPixel: number;
+    length: number;
+    bits: 8 | 16;
+}>;
+
+/**
+ * Waveform Playlist Theme
+ *
+ * This file defines the theme interface and default values for the waveform playlist components.
+ */
+/**
+ * Gradient color stop for waveform gradients
+ */
+declare interface GradientStop {
+    offset: number;
+    color: string;
+}
+
+export declare interface IntegratedRecordingOptions {
+    /**
+     * Current playback/cursor position in seconds
+     * Recording will start from max(currentTime, lastClipEndTime)
+     */
+    currentTime?: number;
+    /**
+     * MediaTrackConstraints for audio recording
+     * These will override the recording-optimized defaults (echo cancellation off, low latency)
+     */
+    audioConstraints?: MediaTrackConstraints;
+    /**
+     * Number of channels to record (1 = mono, 2 = stereo)
+     * Default: 1 (mono)
+     */
+    channelCount?: number;
+    /**
+     * Samples per pixel for peak generation
+     * Default: 1024
+     */
+    samplesPerPixel?: number;
+}
+
+declare interface KeyboardShortcut {
+    key: string;
+    ctrlKey?: boolean;
+    shiftKey?: boolean;
+    metaKey?: boolean;
+    altKey?: boolean;
+    action: () => void;
+    description?: string;
+    preventDefault?: boolean;
+}
+
+/**
+ * Link endpoints checkbox that uses the playlist context
+ * Uses split contexts to avoid re-rendering during animation
+ */
+export declare const LinkEndpointsCheckbox: default_2.FC<{
+    className?: string;
+}>;
+
+/**
+ * Load waveform data file and convert to Peaks format in one step
+ *
+ * @param src - URL to waveform data file (.dat or .json)
+ * @param channelIndex - Channel index (default: 0)
+ * @returns Peaks data ready for rendering
+ */
+export declare function loadPeaksFromWaveformData(src: string, channelIndex?: number): Promise<{
+    data: Int8Array | Int16Array;
+    bits: 8 | 16;
+    length: number;
+    sampleRate: number;
+}>;
+
+/**
+ * Load waveform data from a .dat or .json file
+ *
+ * @param src - URL to waveform data file (.dat or .json)
+ * @returns WaveformData instance
+ */
+export declare function loadWaveformData(src: string): Promise<default_3>;
+
+/**
+ * Master volume control that uses the playlist context
+ */
+export declare const MasterVolumeControl: default_2.FC<{
+    className?: string;
+}>;
+
+export declare interface MasterVolumeControls {
+    masterVolume: number;
+    setMasterVolume: (volume: number) => void;
+}
+
+declare interface MicrophoneDevice {
+    deviceId: string;
+    label: string;
+    groupId: string;
+}
+
+/**
+ * Effect definitions for all available Tone.js effects
+ * Each effect has parameters with min/max/default values for UI controls
+ */
+export declare type ParameterType = 'number' | 'select' | 'boolean';
+
+export declare const PauseButton: default_2.FC<{
+    className?: string;
+}>;
+
+/**
+ * PeakData - result of peak extraction
+ */
+declare interface PeakData {
+    /** Number of peaks extracted */
+    length: number;
+    /** Array of peak data for each channel */
+    data: Peaks[];
+    /** Bit depth of peak data */
+    bits: Bits;
+}
+
+/**
+ * Peaks type - represents a typed array of peak data
+ */
+declare type Peaks = Int8Array | Int16Array;
+
+declare interface PlaybackAnimationContextValue {
+    isPlaying: boolean;
+    currentTime: number;
+    currentTimeRef: default_2.RefObject<number>;
+    playbackStartTimeRef: default_2.RefObject<number>;
+    audioStartPositionRef: default_2.RefObject<number>;
+}
+
+export declare const PlayButton: default_2.FC<{
+    className?: string;
+}>;
+
+/**
+ * Props passed to the default playhead component or custom render function.
+ */
+declare interface PlayheadProps {
+    /** Position in pixels from left edge (only valid when not playing) */
+    position: number;
+    /** Playhead color (default: #ff0000) */
+    color?: string;
+    /** Whether audio is currently playing */
+    isPlaying: boolean;
+    /** Ref to current time in seconds - use for smooth animation during playback */
+    currentTimeRef: react__default.RefObject<number>;
+    /** Audio context start time when playback began - for calculating elapsed time */
+    playbackStartTimeRef: react__default.RefObject<number>;
+    /** Audio position when playback started - for calculating current position */
+    audioStartPositionRef: react__default.RefObject<number>;
+    /** Samples per pixel - for converting time to pixels */
+    samplesPerPixel: number;
+    /** Sample rate - for converting time to pixels */
+    sampleRate: number;
+    /** Controls offset in pixels */
+    controlsOffset: number;
+    /** Function to get current audio context time - required for smooth animation */
+    getAudioContextTime?: () => number;
+}
+
+declare interface PlaylistControlsContextValue {
+    play: (startTime?: number, playDuration?: number) => Promise<void>;
+    pause: () => void;
+    stop: () => void;
+    seekTo: (time: number) => void;
+    setCurrentTime: (time: number) => void;
+    setTrackMute: (trackIndex: number, muted: boolean) => void;
+    setTrackSolo: (trackIndex: number, soloed: boolean) => void;
+    setTrackVolume: (trackIndex: number, volume: number) => void;
+    setTrackPan: (trackIndex: number, pan: number) => void;
+    setSelection: (start: number, end: number) => void;
+    setSelectedTrackId: (trackId: string | null) => void;
+    setTimeFormat: (format: TimeFormat) => void;
+    formatTime: (seconds: number) => string;
+    zoomIn: () => void;
+    zoomOut: () => void;
+    setMasterVolume: (volume: number) => void;
+    setAutomaticScroll: (enabled: boolean) => void;
+    setScrollContainer: (element: HTMLDivElement | null) => void;
+    scrollContainerRef: default_2.RefObject<HTMLDivElement | null>;
+    setContinuousPlay: (enabled: boolean) => void;
+    setLinkEndpoints: (enabled: boolean) => void;
+    setAnnotationsEditable: (enabled: boolean) => void;
+    setAnnotations: (annotations: AnnotationData[]) => void;
+    setActiveAnnotationId: (id: string | null) => void;
+}
+
+declare interface PlaylistDataContextValue {
+    duration: number;
+    audioBuffers: AudioBuffer[];
+    peaksDataArray: TrackClipPeaks[];
+    trackStates: TrackState[];
+    tracks: ClipTrack[];
+    sampleRate: number;
+    waveHeight: number;
+    timeScaleHeight: number;
+    minimumPlaylistHeight: number;
+    controls: {
+        show: boolean;
+        width: number;
+    };
+    playoutRef: default_2.RefObject<TonePlayout | null>;
+    samplesPerPixel: number;
+    timeFormat: string;
+    masterVolume: number;
+    canZoomIn: boolean;
+    canZoomOut: boolean;
+    barWidth: number;
+    barGap: number;
+    /** Width in pixels of progress bars. Defaults to barWidth + barGap (fills gaps). */
+    progressBarWidth: number;
+}
+
+declare interface PlaylistStateContextValue {
+    continuousPlay: boolean;
+    linkEndpoints: boolean;
+    annotationsEditable: boolean;
+    isAutomaticScroll: boolean;
+    annotations: AnnotationData[];
+    activeAnnotationId: string | null;
+    selectionStart: number;
+    selectionEnd: number;
+    selectedTrackId: string | null;
+}
+
+/**
+ * Type for custom playhead render functions.
+ * Receives position, color, and animation refs for smooth 60fps animation.
+ * Custom playheads should use requestAnimationFrame with the refs during playback.
+ */
+declare type RenderPlayheadFunction = (props: PlayheadProps) => react__default.ReactNode;
+
+export declare const RewindButton: default_2.FC<{
+    className?: string;
+}>;
+
+/**
+ * Selection time inputs that use the playlist context
+ */
+export declare const SelectionTimeInputs: default_2.FC<{
+    className?: string;
+}>;
+
+export declare const SkipBackwardButton: default_2.FC<{
+    skipAmount?: number;
+    className?: string;
+}>;
+
+export declare const SkipForwardButton: default_2.FC<{
+    skipAmount?: number;
+    className?: string;
+}>;
+
+export declare const StopButton: default_2.FC<{
+    className?: string;
+}>;
+
+/**
+ * Time format utilities for displaying and parsing audio timestamps
+ */
+export declare type TimeFormat = 'seconds' | 'thousandths' | 'hh:mm:ss' | 'hh:mm:ss.u' | 'hh:mm:ss.uu' | 'hh:mm:ss.uuu';
+
+export declare interface TimeFormatControls {
+    timeFormat: TimeFormat;
+    setTimeFormat: (format: TimeFormat) => void;
+    formatTime: (seconds: number) => string;
+    parseTime: (timeString: string) => number;
+}
+
+/**
+ * Time format selector that uses the playlist context
+ */
+export declare const TimeFormatSelect: default_2.FC<{
+    className?: string;
+}>;
+
+export { Tone }
+
+declare class TonePlayout {
+    private tracks;
+    private masterVolume;
+    private isInitialized;
+    private soloedTracks;
+    private manualMuteState;
+    private effectsCleanup?;
+    private onPlaybackCompleteCallback?;
+    private activeTracks;
+    private playbackSessionId;
+    constructor(options?: TonePlayoutOptions);
+    private gainToDb;
+    init(): Promise<void>;
+    addTrack(trackOptions: ToneTrackOptions): ToneTrack;
+    removeTrack(trackId: string): void;
+    getTrack(trackId: string): ToneTrack | undefined;
+    play(when?: number, offset?: number, duration?: number): void;
+    pause(): void;
+    stop(): void;
+    setMasterGain(gain: number): void;
+    setSolo(trackId: string, soloed: boolean): void;
+    private updateSoloMuting;
+    setMute(trackId: string, muted: boolean): void;
+    getCurrentTime(): number;
+    seekTo(time: number): void;
+    dispose(): void;
+    get context(): BaseContext;
+    get sampleRate(): number;
+    setOnPlaybackComplete(callback: () => void): void;
+}
+
+declare interface TonePlayoutOptions {
+    tracks?: ToneTrack[];
+    masterGain?: number;
+    effects?: EffectsFunction;
+}
+
+declare class ToneTrack {
+    private clips;
+    private volumeNode;
+    private panNode;
+    private muteGain;
+    private track;
+    private effectsCleanup?;
+    private onStopCallback?;
+    private activePlayers;
+    constructor(options: ToneTrackOptions);
+    /**
+     * Schedule fade envelopes for a clip at the given start time
+     */
+    private scheduleFades;
+    private gainToDb;
+    setVolume(gain: number): void;
+    setPan(pan: number): void;
+    setMute(muted: boolean): void;
+    setSolo(soloed: boolean): void;
+    play(when?: number, offset?: number, duration?: number): void;
+    pause(): void;
+    stop(when?: number): void;
+    dispose(): void;
+    get id(): string;
+    get duration(): number;
+    get buffer(): AudioBuffer;
+    get isPlaying(): boolean;
+    get muted(): boolean;
+    get startTime(): number;
+    setOnStopCallback(callback: () => void): void;
+}
+
+declare interface ToneTrackOptions {
+    buffer?: AudioBuffer;
+    clips?: ClipInfo[];
+    track: Track;
+    effects?: TrackEffectsFunction;
+    destination?: ToneAudioNode;
+}
+
+export declare interface TrackActiveEffect {
+    instanceId: string;
+    effectId: string;
+    definition: EffectDefinition;
+    params: Record<string, number | string | boolean>;
+    bypassed: boolean;
+}
+
+declare type TrackClipPeaks = ClipPeaks[];
+
+export declare type TrackEffectsFunction = (graphEnd: Gain, masterGainNode: ToneAudioNode, isOffline: boolean) => void | (() => void);
+
+/**
+ * Clip-Based Model Types
+ *
+ * These types support a professional multi-track editing model where:
+ * - Each track can contain multiple audio clips
+ * - Clips can be positioned anywhere on the timeline
+ * - Clips have independent trim points (offset/duration)
+ * - Gaps between clips are silent
+ * - Clips can overlap (for crossfades)
+ */
+
+/**
+ * Generic effects function type for track-level audio processing.
+ *
+ * The actual implementation receives Tone.js audio nodes. Using generic types
+ * here to avoid circular dependencies with the playout package.
+ *
+ * @param graphEnd - The end of the track's audio graph (Tone.js Gain node)
+ * @param destination - Where to connect the effects output (Tone.js ToneAudioNode)
+ * @param isOffline - Whether rendering offline (for export)
+ * @returns Optional cleanup function called when track is disposed
+ *
+ * @example
+ * ```typescript
+ * const trackEffects: TrackEffectsFunction = (graphEnd, destination, isOffline) => {
+ *   const reverb = new Tone.Reverb({ decay: 1.5 });
+ *   graphEnd.connect(reverb);
+ *   reverb.connect(destination);
+ *
+ *   return () => {
+ *     reverb.dispose();
+ *   };
+ * };
+ * ```
+ */
+declare type TrackEffectsFunction_2 = (graphEnd: unknown, destination: unknown, isOffline: boolean) => void | (() => void);
+
+/** Function type for per-track effects (same as in @waveform-playlist/core) */
+declare type TrackEffectsFunction_3 = (graphEnd: unknown, destination: unknown, isOffline: boolean) => void | (() => void);
+
+export declare interface TrackEffectsState {
+    trackId: string;
+    activeEffects: TrackActiveEffect[];
+}
+
+export declare interface TrackState {
+    name: string;
+    muted: boolean;
+    soloed: boolean;
+    volume: number;
+    pan: number;
+}
+
+declare interface TrackState_2 {
+    muted: boolean;
+    soloed: boolean;
+    volume: number;
+    pan: number;
+}
+
+/**
+ * Custom hook for handling annotation drag operations (boundary trimming)
+ *
+ * Provides drag handlers for use with @dnd-kit/core DndContext.
+ * Handles annotation boundary resizing with linked endpoints support.
+ *
+ * @example
+ * ```tsx
+ * const { onDragStart, onDragMove, onDragEnd } = useAnnotationDragHandlers({
+ *   annotations,
+ *   onAnnotationsChange: setAnnotations,
+ *   samplesPerPixel,
+ *   sampleRate,
+ *   duration,
+ *   linkEndpoints,
+ * });
+ *
+ * return (
+ *   <DndContext
+ *     onDragStart={onDragStart}
+ *     onDragMove={onDragMove}
+ *     onDragEnd={onDragEnd}
+ *     modifiers={[restrictToHorizontalAxis]}
+ *   >
+ *     {renderAnnotations()}
+ *   </DndContext>
+ * );
+ * ```
+ */
+export declare function useAnnotationDragHandlers({ annotations, onAnnotationsChange, samplesPerPixel, sampleRate, duration, linkEndpoints, }: UseAnnotationDragHandlersOptions): {
+    onDragStart: (event: {
+        active: any;
+    }) => void;
+    onDragMove: (event: {
+        active: any;
+        delta: {
+            x: number;
+            y: number;
+        };
+    }) => void;
+    onDragEnd: () => void;
+};
+
+declare interface UseAnnotationDragHandlersOptions {
+    annotations: Annotation$1[];
+    onAnnotationsChange: (annotations: Annotation$1[]) => void;
+    samplesPerPixel: number;
+    sampleRate: number;
+    duration: number;
+    linkEndpoints: boolean;
+}
+
+/**
+ * Hook for keyboard-based annotation navigation and boundary editing
+ *
+ * Navigation Shortcuts:
+ * - ArrowUp / ArrowLeft = Select previous annotation
+ * - ArrowDown / ArrowRight = Select next annotation
+ * - Home = Select first annotation
+ * - End = Select last annotation
+ * - Escape = Deselect annotation
+ * - Enter = Play selected annotation
+ *
+ * Boundary Editing Shortcuts (requires active annotation):
+ * - [ = Move start boundary earlier (left)
+ * - ] = Move start boundary later (right)
+ * - Shift+[ = Move end boundary earlier (left)
+ * - Shift+] = Move end boundary later (right)
+ *
+ * Respects linkEndpoints and continuousPlay settings.
+ *
+ * @example
+ * ```tsx
+ * useAnnotationKeyboardControls({
+ *   annotations,
+ *   activeAnnotationId,
+ *   onAnnotationsChange: setAnnotations,
+ *   onActiveAnnotationChange: setActiveAnnotationId,
+ *   duration,
+ *   linkEndpoints,
+ * });
+ * ```
+ */
+export declare function useAnnotationKeyboardControls({ annotations, activeAnnotationId, onAnnotationsChange, onActiveAnnotationChange, duration, linkEndpoints, continuousPlay, enabled, scrollContainerRef, samplesPerPixel, sampleRate, controlsWidth, onPlay, }: UseAnnotationKeyboardControlsOptions): {
+    moveStartBoundary: (delta: number) => void;
+    moveEndBoundary: (delta: number) => void;
+    selectPrevious: () => void;
+    selectNext: () => void;
+    selectFirst: () => void;
+    selectLast: () => void;
+    clearSelection: () => void;
+    scrollToAnnotation: (annotationId: string) => void;
+    playActiveAnnotation: () => void;
+};
+
+declare interface UseAnnotationKeyboardControlsOptions {
+    annotations: Annotation$1[];
+    activeAnnotationId: string | null;
+    onAnnotationsChange: (annotations: Annotation$1[]) => void;
+    /** Callback to set the active annotation ID for selection */
+    onActiveAnnotationChange?: (id: string | null) => void;
+    duration: number;
+    linkEndpoints: boolean;
+    /** Whether continuous play is enabled (affects playback duration) */
+    continuousPlay?: boolean;
+    enabled?: boolean;
+    /** Optional: scroll container ref for auto-scrolling to annotation */
+    scrollContainerRef?: React.RefObject<HTMLDivElement | null>;
+    /** Optional: samples per pixel for scroll position calculation */
+    samplesPerPixel?: number;
+    /** Optional: sample rate for scroll position calculation */
+    sampleRate?: number;
+    /** Optional: controls width offset for scroll position calculation */
+    controlsWidth?: number;
+    /** Optional: callback to start playback at a time with optional duration */
+    onPlay?: (startTime: number, duration?: number) => void;
+}
+
+/**
+ * Hook to load audio from URLs and convert to ClipTrack format
+ *
+ * This hook fetches audio files, decodes them, and creates ClipTrack objects
+ * with a single clip per track. Supports custom positioning for multi-clip arrangements.
+ *
+ * @param configs - Array of audio track configurations
+ * @returns Object with tracks array and loading state
+ *
+ * @example
+ * ```typescript
+ * // Basic usage (clips positioned at start)
+ * const { tracks, loading, error } = useAudioTracks([
+ *   { src: 'audio/vocals.mp3', name: 'Vocals' },
+ *   { src: 'audio/drums.mp3', name: 'Drums' },
+ * ]);
+ *
+ * // Multi-clip positioning (clips at different times with gaps)
+ * const { tracks, loading, error } = useAudioTracks([
+ *   { src: 'audio/guitar.mp3', name: 'Guitar Clip 1', startTime: 0, duration: 3 },
+ *   { src: 'audio/guitar.mp3', name: 'Guitar Clip 2', startTime: 5, duration: 3, offset: 5 },
+ *   { src: 'audio/vocals.mp3', name: 'Vocals', startTime: 2, duration: 4 },
+ * ]);
+ *
+ * if (loading) return <div>Loading...</div>;
+ * if (error) return <div>Error: {error}</div>;
+ *
+ * return <WaveformPlaylistProvider tracks={tracks}>...</WaveformPlaylistProvider>;
+ * ```
+ */
+export declare function useAudioTracks(configs: AudioTrackConfig[]): {
+    tracks: ClipTrack[];
+    loading: boolean;
+    error: string | null;
+};
+
+/**
+ * Custom hook for handling clip drag operations (movement and trimming)
+ *
+ * Provides drag handlers and collision modifier for use with @dnd-kit/core DndContext.
+ * Handles both clip movement (dragging entire clips) and boundary trimming (adjusting clip edges).
+ *
+ * @example
+ * ```tsx
+ * const { onDragStart, onDragMove, onDragEnd, collisionModifier } = useClipDragHandlers({
+ *   tracks,
+ *   onTracksChange: setTracks,
+ *   samplesPerPixel,
+ *   sampleRate,
+ * });
+ *
+ * return (
+ *   <DndContext
+ *     onDragStart={onDragStart}
+ *     onDragMove={onDragMove}
+ *     onDragEnd={onDragEnd}
+ *     modifiers={[restrictToHorizontalAxis, collisionModifier]}
+ *   >
+ *     <Waveform showClipHeaders={true} />
+ *   </DndContext>
+ * );
+ * ```
+ */
+export declare function useClipDragHandlers({ tracks, onTracksChange, samplesPerPixel, sampleRate, }: UseClipDragHandlersOptions): {
+    onDragStart: (event: {
+        active: any;
+    }) => void;
+    onDragMove: (event: {
+        active: any;
+        delta: {
+            x: number;
+            y: number;
+        };
+    }) => void;
+    onDragEnd: (event: DragEndEvent) => void;
+    collisionModifier: (args: {
+        transform: {
+            x: number;
+            y: number;
+        };
+        active: any;
+    }) => {
+        scaleX: number;
+        scaleY: number;
+        x: number;
+        y: number;
+    };
+};
+
+declare interface UseClipDragHandlersOptions {
+    tracks: ClipTrack[];
+    onTracksChange: (tracks: ClipTrack[]) => void;
+    samplesPerPixel: number;
+    sampleRate: number;
+}
+
+/**
+ * Hook for splitting clips at the playhead or at a specific time
+ *
+ * @param options - Configuration options
+ * @returns Object with split functions
+ *
+ * @example
+ * ```tsx
+ * const { splitClipAtPlayhead } = useClipSplitting({
+ *   tracks,
+ *   onTracksChange: setTracks,
+ *   currentTime,
+ * });
+ *
+ * // In keyboard handler
+ * const handleKeyPress = (e: KeyboardEvent) => {
+ *   if (e.key === 's' || e.key === 'S') {
+ *     splitClipAtPlayhead();
+ *   }
+ * };
+ * ```
+ */
+export declare const useClipSplitting: (options: UseClipSplittingOptions) => UseClipSplittingResult;
+
+declare interface UseClipSplittingOptions {
+    tracks: ClipTrack[];
+    onTracksChange: (tracks: ClipTrack[]) => void;
+    sampleRate: number;
+    samplesPerPixel: number;
+}
+
+declare interface UseClipSplittingResult {
+    splitClipAtPlayhead: () => boolean;
+    splitClipAt: (trackIndex: number, clipIndex: number, splitTime: number) => boolean;
+}
+
+/**
+ * Hook for configuring @dnd-kit sensors for clip dragging
+ *
+ * Provides consistent drag activation behavior across all examples
+ */
+/**
+ * Returns configured sensors for @dnd-kit drag operations
+ *
+ * @returns Configured sensors with 1px activation distance for immediate feedback
+ */
+export declare function useDragSensors(): SensorDescriptor<SensorOptions>[];
+
+/**
+ * Hook for managing a dynamic chain of audio effects with real-time parameter updates
+ */
+export declare function useDynamicEffects(fftSize?: number): UseDynamicEffectsReturn;
+
+export declare interface UseDynamicEffectsReturn {
+    activeEffects: ActiveEffect[];
+    availableEffects: EffectDefinition[];
+    addEffect: (effectId: string) => void;
+    removeEffect: (instanceId: string) => void;
+    updateParameter: (instanceId: string, paramName: string, value: number | string | boolean) => void;
+    toggleBypass: (instanceId: string) => void;
+    reorderEffects: (fromIndex: number, toIndex: number) => void;
+    clearAllEffects: () => void;
+    masterEffects: EffectsFunction;
+    /**
+     * Creates a fresh effects function for offline rendering.
+     * This creates new effect instances that work in the offline AudioContext.
+     */
+    createOfflineEffectsFunction: () => EffectsFunction | undefined;
+    analyserRef: React.RefObject<any>;
+}
+
+/**
+ * Hook for exporting the waveform playlist to WAV format
+ * Uses OfflineAudioContext for fast, non-real-time rendering
+ */
+export declare function useExportWav(): UseExportWavReturn;
+
+export declare interface UseExportWavReturn {
+    /** Export the playlist to WAV */
+    exportWav: (tracks: ClipTrack[], trackStates: TrackState_2[], options?: ExportOptions) => Promise<ExportResult>;
+    /** Whether export is in progress */
+    isExporting: boolean;
+    /** Export progress (0-1) */
+    progress: number;
+    /** Error message if export failed */
+    error: string | null;
+}
+
+export declare function useIntegratedRecording(tracks: ClipTrack[], setTracks: (tracks: ClipTrack[]) => void, selectedTrackId: string | null, options?: IntegratedRecordingOptions): UseIntegratedRecordingReturn;
+
+export declare interface UseIntegratedRecordingReturn {
+    isRecording: boolean;
+    isPaused: boolean;
+    duration: number;
+    level: number;
+    peakLevel: number;
+    error: Error | null;
+    stream: MediaStream | null;
+    devices: MicrophoneDevice[];
+    hasPermission: boolean;
+    selectedDevice: string | null;
+    startRecording: () => void;
+    stopRecording: () => void;
+    pauseRecording: () => void;
+    resumeRecording: () => void;
+    requestMicAccess: () => Promise<void>;
+    changeDevice: (deviceId: string) => Promise<void>;
+    recordingPeaks: Int8Array | Int16Array;
+}
+
+/**
+ * Hook for managing keyboard shortcuts
+ *
+ * @param options - Configuration options
+ *
+ * @example
+ * ```tsx
+ * const { splitClipAtPlayhead } = useClipSplitting({ ... });
+ *
+ * useKeyboardShortcuts({
+ *   shortcuts: [
+ *     {
+ *       key: 's',
+ *       action: splitClipAtPlayhead,
+ *       description: 'Split clip at playhead',
+ *       preventDefault: true,
+ *     },
+ *     {
+ *       key: 'S',
+ *       shiftKey: true,
+ *       action: () => splitAtSelection(),
+ *       description: 'Split at selection boundaries',
+ *       preventDefault: true,
+ *     },
+ *   ],
+ * });
+ * ```
+ */
+export declare const useKeyboardShortcuts: (options: UseKeyboardShortcutsOptions) => void;
+
+declare interface UseKeyboardShortcutsOptions {
+    shortcuts: KeyboardShortcut[];
+    enabled?: boolean;
+}
+
+/**
+ * Hook for master effects with frequency analyzer
+ * Returns the analyser ref and the effects function to pass to WaveformPlaylistProvider
+ *
+ * For more advanced effects (reverb, delay, filters, etc.), use useDynamicEffects instead.
+ */
+export declare const useMasterAnalyser: (fftSize?: number) => {
+    analyserRef: MutableRefObject<any>;
+    masterEffects: EffectsFunction;
+};
+
+/**
+ * Hook for managing master volume control
+ *
+ * @example
+ * ```tsx
+ * const { masterVolume, setMasterVolume } = useMasterVolume({
+ *   playoutRef,
+ *   initialVolume: 1.0,
+ * });
+ *
+ * <MasterVolumeControl
+ *   volume={masterVolume}
+ *   onChange={setMasterVolume}
+ * />
+ * ```
+ */
+export declare function useMasterVolume({ playoutRef, initialVolume, onVolumeChange, }: UseMasterVolumeProps): MasterVolumeControls;
+
+declare interface UseMasterVolumeProps {
+    playoutRef: RefObject<TonePlayout | null>;
+    initialVolume?: number;
+    onVolumeChange?: (volume: number) => void;
+}
+
+export declare const usePlaybackAnimation: () => PlaybackAnimationContextValue;
+
+/**
+ * Hook that provides common playback keyboard shortcuts for the playlist.
+ *
+ * Default shortcuts:
+ * - `Space` - Toggle play/pause
+ * - `Escape` - Stop playback
+ * - `0` - Rewind to start (seek to time 0)
+ *
+ * @example
+ * ```tsx
+ * // Basic usage - enables default shortcuts
+ * usePlaybackShortcuts();
+ *
+ * // With additional custom shortcuts
+ * usePlaybackShortcuts({
+ *   additionalShortcuts: [
+ *     { key: 's', action: splitClipAtPlayhead, description: 'Split clip' },
+ *   ],
+ * });
+ *
+ * // Completely override shortcuts
+ * usePlaybackShortcuts({
+ *   shortcuts: [
+ *     { key: 'Home', action: rewindToStart, description: 'Go to start' },
+ *   ],
+ * });
+ * ```
+ */
+export declare const usePlaybackShortcuts: (options?: UsePlaybackShortcutsOptions) => UsePlaybackShortcutsReturn;
+
+export declare interface UsePlaybackShortcutsOptions {
+    /**
+     * Enable the shortcuts. Defaults to true.
+     */
+    enabled?: boolean;
+    /**
+     * Additional shortcuts to include alongside the default playback shortcuts.
+     */
+    additionalShortcuts?: KeyboardShortcut[];
+    /**
+     * Override default shortcuts. If provided, only these shortcuts will be used.
+     */
+    shortcuts?: KeyboardShortcut[];
+}
+
+export declare interface UsePlaybackShortcutsReturn {
+    /** Rewind to the beginning (time = 0) */
+    rewindToStart: () => void;
+    /** Toggle play/pause */
+    togglePlayPause: () => void;
+    /** Stop playback and return to start position */
+    stopPlayback: () => void;
+    /** The list of active keyboard shortcuts */
+    shortcuts: KeyboardShortcut[];
+}
+
+export declare const usePlaylistControls: () => PlaylistControlsContextValue;
+
+export declare const usePlaylistData: () => PlaylistDataContextValue;
+
+export declare const usePlaylistState: () => PlaylistStateContextValue;
+
+/**
+ * Hook to manage time format state
+ *
+ * @example
+ * ```tsx
+ * const { timeFormat, setTimeFormat, formatTime, parseTime } = useTimeFormat();
+ *
+ * <TimeFormatSelect
+ *   value={timeFormat}
+ *   onChange={setTimeFormat}
+ * />
+ * <span>{formatTime(currentTime)}</span>
+ * <input onChange={(e) => seekTo(parseTime(e.target.value))} />
+ * ```
+ */
+export declare function useTimeFormat(): TimeFormatControls;
+
+/**
+ * Hook for managing dynamic effects per track with real-time parameter updates
+ */
+export declare function useTrackDynamicEffects(): UseTrackDynamicEffectsReturn;
+
+export declare interface UseTrackDynamicEffectsReturn {
+    trackEffectsState: Map<string, TrackActiveEffect[]>;
+    addEffectToTrack: (trackId: string, effectId: string) => void;
+    removeEffectFromTrack: (trackId: string, instanceId: string) => void;
+    updateTrackEffectParameter: (trackId: string, instanceId: string, paramName: string, value: number | string | boolean) => void;
+    toggleBypass: (trackId: string, instanceId: string) => void;
+    clearTrackEffects: (trackId: string) => void;
+    getTrackEffectsFunction: (trackId: string) => TrackEffectsFunction | undefined;
+    /**
+     * Creates a fresh effects function for a track for offline rendering.
+     * This creates new effect instances that work in the offline AudioContext.
+     */
+    createOfflineTrackEffectsFunction: (trackId: string) => TrackEffectsFunction | undefined;
+    availableEffects: EffectDefinition[];
+}
+
+export declare const useWaveformPlaylist: () => WaveformPlaylistContextValue;
+
+export declare function useZoomControls({ initialSamplesPerPixel, zoomLevels, }: UseZoomControlsProps): ZoomControls;
+
+declare interface UseZoomControlsProps {
+    initialSamplesPerPixel: number;
+    zoomLevels?: number[];
+}
+
+/**
+ * Waveform visualization component that uses the playlist context
+ */
+export declare const Waveform: default_2.FC<WaveformProps>;
+
+/**
+ * Waveform color can be a simple string or a gradient configuration
+ */
+declare type WaveformColor = string | WaveformGradient;
+
+/**
+ * Convert WaveformData to our internal Peaks format
+ *
+ * @param waveformData - WaveformData instance from waveform-data.js
+ * @param channelIndex - Channel index (0 for mono/left, 1 for right)
+ * @returns Peaks data with alternating min/max values, preserving original bit depth
+ */
+export declare function waveformDataToPeaks(waveformData: default_3, channelIndex?: number): {
+    data: Int8Array | Int16Array;
+    bits: 8 | 16;
+    length: number;
+    sampleRate: number;
+};
+
+/**
+ * Waveform drawing mode determines how colors are applied:
+ * - 'inverted': Canvas draws waveOutlineColor in areas WITHOUT audio (current default).
+ *               waveFillColor shows through where audio peaks are. Good for gradient bars.
+ * - 'normal': Canvas draws waveFillColor bars where audio peaks ARE.
+ *             waveOutlineColor is used as background. Good for gradient backgrounds.
+ */
+declare type WaveformDrawMode = 'inverted' | 'normal';
+
+/**
+ * Gradient configuration for waveforms
+ * Can be applied vertically (top to bottom) or horizontally (left to right)
+ */
+declare interface WaveformGradient {
+    type: 'linear';
+    direction: 'vertical' | 'horizontal';
+    stops: GradientStop[];
+}
+
+export declare interface WaveformPlaylistContextValue {
+    isPlaying: boolean;
+    currentTime: number;
+    duration: number;
+    audioBuffers: AudioBuffer[];
+    peaksDataArray: TrackClipPeaks[];
+    trackStates: TrackState[];
+    annotations: AnnotationData[];
+    activeAnnotationId: string | null;
+    selectionStart: number;
+    selectionEnd: number;
+    isAutomaticScroll: boolean;
+    continuousPlay: boolean;
+    linkEndpoints: boolean;
+    annotationsEditable: boolean;
+    play: (startTime?: number, playDuration?: number) => Promise<void>;
+    pause: () => void;
+    stop: () => void;
+    setCurrentTime: (time: number) => void;
+    setTrackMute: (trackIndex: number, muted: boolean) => void;
+    setTrackSolo: (trackIndex: number, soloed: boolean) => void;
+    setTrackVolume: (trackIndex: number, volume: number) => void;
+    setTrackPan: (trackIndex: number, pan: number) => void;
+    setSelection: (start: number, end: number) => void;
+    timeFormat: string;
+    setTimeFormat: (format: TimeFormat) => void;
+    formatTime: (seconds: number) => string;
+    samplesPerPixel: number;
+    zoomIn: () => void;
+    zoomOut: () => void;
+    canZoomIn: boolean;
+    canZoomOut: boolean;
+    masterVolume: number;
+    setMasterVolume: (volume: number) => void;
+    setAutomaticScroll: (enabled: boolean) => void;
+    setScrollContainer: (element: HTMLDivElement | null) => void;
+    setContinuousPlay: (enabled: boolean) => void;
+    setLinkEndpoints: (enabled: boolean) => void;
+    setAnnotationsEditable: (enabled: boolean) => void;
+    setAnnotations: (annotations: AnnotationData[]) => void;
+    setActiveAnnotationId: (id: string | null) => void;
+    playoutRef: default_2.RefObject<TonePlayout | null>;
+    currentTimeRef: default_2.RefObject<number>;
+    sampleRate: number;
+    waveHeight: number;
+    timeScaleHeight: number;
+    minimumPlaylistHeight: number;
+    controls: {
+        show: boolean;
+        width: number;
+    };
+}
+
+export declare const WaveformPlaylistProvider: default_2.FC<WaveformPlaylistProviderProps>;
+
+declare interface WaveformPlaylistProviderProps {
+    tracks: ClipTrack[];
+    timescale?: boolean;
+    mono?: boolean;
+    waveHeight?: number;
+    samplesPerPixel?: number;
+    zoomLevels?: number[];
+    automaticScroll?: boolean;
+    theme?: Partial<WaveformPlaylistTheme>;
+    controls?: {
+        show: boolean;
+        width: number;
+    };
+    annotationList?: {
+        annotations?: any[];
+        editable?: boolean;
+        isContinuousPlay?: boolean;
+        linkEndpoints?: boolean;
+        controls?: any[];
+    };
+    effects?: EffectsFunction;
+    onReady?: () => void;
+    onAnnotationUpdate?: (annotations: AnnotationData[]) => void;
+    /** Width in pixels of waveform bars. Default: 1 */
+    barWidth?: number;
+    /** Spacing in pixels between waveform bars. Default: 0 */
+    barGap?: number;
+    /** Width in pixels of progress bars. Default: barWidth + barGap (fills gaps). */
+    progressBarWidth?: number;
+    children: ReactNode;
+}
+
+declare interface WaveformPlaylistTheme {
+    waveformDrawMode?: WaveformDrawMode;
+    waveOutlineColor: WaveformColor;
+    waveFillColor: WaveformColor;
+    waveProgressColor: string;
+    selectedWaveOutlineColor: WaveformColor;
+    selectedWaveFillColor: WaveformColor;
+    selectedTrackControlsBackground: string;
+    timeColor: string;
+    timescaleBackgroundColor: string;
+    playheadColor: string;
+    selectionColor: string;
+    clipHeaderBackgroundColor: string;
+    clipHeaderBorderColor: string;
+    clipHeaderTextColor: string;
+    clipHeaderFontFamily: string;
+    selectedClipHeaderBackgroundColor: string;
+    fadeOverlayColor: string;
+    backgroundColor: string;
+    surfaceColor: string;
+    borderColor: string;
+    textColor: string;
+    textColorMuted: string;
+    inputBackground: string;
+    inputBorder: string;
+    inputText: string;
+    inputPlaceholder: string;
+    inputFocusBorder: string;
+    buttonBackground: string;
+    buttonText: string;
+    buttonBorder: string;
+    buttonHoverBackground: string;
+    sliderTrackColor: string;
+    sliderThumbColor: string;
+    annotationBoxBackground: string;
+    annotationBoxActiveBackground: string;
+    annotationBoxHoverBackground: string;
+    annotationBoxBorder: string;
+    annotationBoxActiveBorder: string;
+    annotationLabelColor: string;
+    annotationResizeHandleColor: string;
+    annotationResizeHandleActiveColor: string;
+    annotationTextItemHoverBackground: string;
+    borderRadius: string;
+    fontFamily: string;
+    fontSize: string;
+    fontSizeSmall: string;
+}
+
+export declare interface WaveformProps {
+    renderTrackControls?: (trackIndex: number) => ReactNode;
+    renderTimestamp?: (timeMs: number, pixelPosition: number) => ReactNode;
+    /** Custom playhead render function. Receives position (pixels) and color from theme. */
+    renderPlayhead?: RenderPlayheadFunction;
+    annotationControls?: AnnotationAction[];
+    annotationListConfig?: AnnotationActionOptions;
+    annotationTextHeight?: number;
+    className?: string;
+    showClipHeaders?: boolean;
+    interactiveClips?: boolean;
+    showFades?: boolean;
+    recordingState?: {
+        isRecording: boolean;
+        trackId: string;
+        startSample: number;
+        durationSamples: number;
+        peaks: Int8Array | Int16Array;
+    };
+}
+
+export declare interface WaveformTrack {
+    src: string | AudioBuffer;
+    name?: string;
+    effects?: TrackEffectsFunction;
+}
+
+/**
+ * WAV file encoder
+ * Converts AudioBuffer to WAV format Blob
+ */
+declare interface WavEncoderOptions {
+    /** Bit depth: 16 or 32. Default: 16 */
+    bitDepth?: 16 | 32;
+}
+
+export declare interface ZoomControls {
+    samplesPerPixel: number;
+    zoomIn: () => void;
+    zoomOut: () => void;
+    canZoomIn: boolean;
+    canZoomOut: boolean;
+}
+
+export declare const ZoomInButton: default_2.FC<{
+    className?: string;
+    disabled?: boolean;
+}>;
+
+export declare const ZoomOutButton: default_2.FC<{
+    className?: string;
+    disabled?: boolean;
+}>;
+
+export { }