Frontend public contracts

Generated public TypeScript declarations and authored JSDoc/TSDoc-style comments. This is not formal TSDoc validation or a test-coverage report. Production implementations and tests are omitted.

/** Offline shell: demonstration data is never represented as server state. */
export declare function App(): import("solid-js").JSX.Element;

import { type AnalysisReportProps } from "./AnalysisReport";
/** Album imports retain order and render only the selected track's detailed measurements. */
export declare function AnalysisDocument(props: Omit<AnalysisReportProps, "analysis" | "title"> & {
    files: readonly unknown[];
}): import("solid-js").JSX.Element;

import type { AnalysisModel } from "./model";
import type { ReportTranslate } from "./presentation";
/** File-declared and signal-derived properties are labelled separately; absent data stays unknown. */
export declare function AnalysisIdentity(props: {
    data: AnalysisModel;
    tr: ReportTranslate;
    locale: string;
}): import("solid-js").JSX.Element;

import type { AnalysisModel } from "./model";
import { type ReportTranslate } from "./presentation";
/** Measured descriptors and retained positions; no synthetic waveform or inferred missing values. */
export declare function AnalysisMeasures(props: {
    data: AnalysisModel;
    expanded: boolean;
    onExpandedChange: (open: boolean) => void;
    tr: ReportTranslate;
    locale: string;
}): import("solid-js").JSX.Element;

import { type AnalysisSection } from "./disclosure";
import { type JSX } from "solid-js";
import { type ReportTranslate } from "./presentation";
import "./report.css";
/** Props-only report: no IPC, account, storage, network or source-file access. */
export interface AnalysisReportProps {
    analysis: unknown;
    /** Host-owned actions displayed before the disclosure control. */
    actions?: JSX.Element;
    title?: string | undefined;
    locale?: string | undefined;
    translate?: ReportTranslate | undefined;
    /** Initial-only expansion for standalone hosts; controlled sections take precedence. */
    initialDetail?: boolean | undefined;
    initialSections?: readonly AnalysisSection[] | undefined;
    sections?: readonly AnalysisSection[] | undefined;
    onSectionsChange?: ((sections: AnalysisSection[]) => void) | undefined;
}
/** Independent disclosures share retained evidence and may be controlled by host-owned preferences. */
export declare function AnalysisReport(props: AnalysisReportProps): JSX.Element;

import type { AnalysisModel } from "./model";
import type { ReportTranslate } from "./presentation";
/** Expandable measured evidence remains available through an independently controlled disclosure. */
export declare function AnalysisTechnical(props: {
    data: AnalysisModel;
    tr: ReportTranslate;
    locale: string;
    expanded: boolean;
    onExpandedChange: (open: boolean) => void;
}): import("solid-js").JSX.Element;

import type { Event } from "./measurements";
import type { ReportTranslate } from "./presentation";
/** Retained positions use one shared time axis; hover, keyboard and click/touch reveal exact evidence. */
export declare function EventTimeline(props: {
    events: readonly Event[];
    duration: number;
    locale: string;
    tr: ReportTranslate;
}): import("solid-js").JSX.Element;

import type { Gauge } from "./measurements";
import { type ReportTranslate } from "./presentation";
/** The entire rail is a touch target; values remain visible without interaction. */
export declare function MeasurementGauge(props: {
    gauge: Gauge;
    tr: ReportTranslate;
    locale: string;
}): import("solid-js").JSX.Element;

/** Mouse/focus hints can be pinned by click/touch and dismissed by a second click, Escape or outside touch. */
export declare function MeasurementMarker(props: {
    position: number;
    label: string;
    value: string;
    help: string;
}): import("solid-js").JSX.Element;

import { type ParentProps } from "solid-js";
/** Native details retain keyboard/touch behavior; rejected preference writes restore the current state. */
export declare function ReportDisclosure(props: ParentProps<{
    label: string;
    open: boolean;
    onChange: (open: boolean) => void;
    section?: boolean;
}>): import("solid-js").JSX.Element;

/** Explicit partial coverage overrides placeholder defaults retained by FlacCompagnon. */
export declare function selectedMeasurements(input: Record<string, unknown>): Record<string, unknown>;

/** Stable public section identities are shared by account preferences and website hosts. */
export declare const analysisSectionIds: readonly ["integrity", "detection", "identity", "measurements", "technical", "coverage", "fingerprints"];
export type AnalysisSection = (typeof analysisSectionIds)[number];
/** Reject unknown/duplicate entries instead of silently replacing an unreadable preference. */
export declare function validAnalysisSections(value: unknown): value is AnalysisSection[];
/** Preserve independent disclosures while keeping serialized order deterministic. */
export declare function changeAnalysisSection(current: readonly AnalysisSection[], id: AnalysisSection, open: boolean): AnalysisSection[];

import type { AnalysisSection } from "./disclosure";
export { analysisSectionIds } from "./disclosure";
export type { AnalysisSection } from "./disclosure";
import type { ReportTranslate } from "./presentation";
export { AnalysisReport } from "./AnalysisReport";
export { AnalysisDocument } from "./AnalysisDocument";
export { parseAnalysisDocument } from "./model";
export type { Gauge as AnalysisGauge, Event as AnalysisEvent } from "./measurements";
export type { AnalysisReportProps } from "./AnalysisReport";
/** Framework-neutral host contract. The bundle includes its small Solid runtime, with no app services. */
export interface AnalysisMountOptions {
    document: string;
    locale?: string;
    translate?: ReportTranslate;
    /** Initial-only compatibility alias: expands every disclosure rather than selecting a view. */
    detailed?: boolean;
    sections?: AnalysisSection[];
    onSectionsChange?: (sections: AnalysisSection[]) => void;
}
/** Mount into an empty, host-owned element; update atomically validates before replacing the current report. */
export declare function mountAnalysisReport(element: HTMLElement, options: AnalysisMountOptions): {
    update(next: AnalysisMountOptions): void;
    dispose(): void;
};

/** One measured descriptor and its explicitly descriptive display scale. */
export interface Gauge {
    label: string;
    unit: string;
    value: number;
    low: number;
    high: number;
}
/** One retained event position; independent from the report's complete count. */
export interface Event {
    start: number;
    duration: number;
    channel: number;
    kind: string;
}
/** Graph only retained measurements; missing values and truncated event lists remain explicit. */
export declare function analysisMeasurements(value: unknown): {
    gauges: Gauge[];
    missing: string[];
    events: Event[];
    duration: number | undefined;
    eventCount: number | undefined;
    retainedEvents: number;
    stale: boolean | undefined;
    summary: string;
    detail: string;
    error: string;
    md5: string;
    clipped: boolean | undefined;
};

export type AnalysisRecord = Record<string, unknown>;
/** Input size/track bounds are shared by browser/native imports; no imported path is opened. */
export declare const ANALYSIS_IMPORT_BYTES: number;
export declare const ANALYSIS_IMPORT_FILES = 2000;
export declare function record(value: unknown): AnalysisRecord;
export declare const text: (value: unknown) => string;
/** A report describes its analyzed bytes; absent freshness never certifies the current audio file. */
export declare function analysisModel(value: unknown): {
    gauges: import("./measurements").Gauge[];
    missing: string[];
    events: import("./measurements").Event[];
    duration: number | undefined;
    eventCount: number | undefined;
    retainedEvents: number;
    stale: boolean | undefined;
    summary: string;
    detail: string;
    error: string;
    md5: string;
    data: Record<string, unknown>;
    loudnessPeaks: {
        kind: string;
        lufs: number;
        start: number;
    }[];
    dc: number | undefined;
    lattice: number | undefined;
    filename: string;
    format: string;
    codec: string;
    channels: number | undefined;
    bits: number | undefined;
    effective: number | undefined;
    stored: number | undefined;
    integerDepthApplicable: boolean;
    bitMethod: string;
    checks: {
        key: string;
        label: string;
        name: string;
        value: boolean | undefined;
    }[];
    labels: string[];
    md5State: string;
    md5Detail: string;
    applicableMd5: boolean;
    extension: string | undefined;
    extensionMismatch: boolean | undefined;
    rate: number | undefined;
    size: number | undefined;
    bitrate: number | undefined;
    dualMono: boolean | undefined;
    inverted: boolean | undefined;
    correlation: number | undefined;
    balance: number | undefined;
    cutoff: number | undefined;
    clipped: boolean | undefined;
    clippedSamples: number | undefined;
    clipEvents: number | undefined;
    fileMd5: string;
    crc32: string;
    coverage: string[] | undefined;
};
export type AnalysisModel = ReturnType<typeof analysisModel>;
/** Accept current versioned exports, legacy folder reports and an individual FileAnalysis, never unrelated JSON. */
export declare function parseAnalysisDocument(document: string): unknown[];

import type { AnalysisModel } from "./model";
/** Hosts supply their own translator; source filenames and provider diagnostics remain literal. */
export type ReportTranslate = (message: string, ...parameters: unknown[]) => string;
export declare const french: ReportTranslate;
export interface ReportReading {
    tone: "good" | "warning" | "bad" | "unknown";
    label: string;
    detail: string;
    proof: string;
}
/** Embedded audio MD5, file hashes and Ogg page CRC remain separate controls. */
export declare function integrityReading(model: AnalysisModel): ReportReading;
/** Description scales are never quality scores or universal mastering targets. */
export declare const measureHelp: Record<string, string>;

import type { PlayableSelection } from "../library/playback-selection";
/** Session-only optical track references cannot be confused with Aède entities. */
export declare function cdReference(reference: string): {
    token: string;
    number: number;
} | undefined;
/** No path, credential, invented album metadata or imported catalogue fact is carried by this DTO. */
export interface CdDisc {
    token: string;
    title?: string | null;
    artist?: string | null;
    tracks: {
        reference: string;
        number: number;
        duration_ms: number;
        title?: string | null;
        artist?: string | null;
    }[];
}
/** An inserted disc remains distinct from a physically present empty/inaccessible drive. */
export interface CdDrive {
    id: string;
    name: string;
    image?: boolean;
    error: string | null;
    disc: CdDisc | null;
}
/** Admit the complete bounded native result before replacing a visible drive list. */
export declare function parseCd(value: unknown): CdDrive[];
/** A CD enters the ordinary logical queue without publishing a release or guessing track titles. */
export declare function cdSelection(disc: CdDisc): PlayableSelection[];
/** Translate the application-owned prefix while preserving OS diagnostic text verbatim. */
export declare function cdError(message: string): string;
/** Only the selected physical disc blocks its own ejection while audio is starting/playing. */
export declare function cdPlaying(token: string | undefined, reference: string, status: string): boolean;

/** Persistent access explanation belongs inside its view, separately from empty results. */
export declare function AccountNotice(props: {
    administrator?: boolean;
    connected?: boolean;
}): import("solid-js").JSX.Element;

import { type JSX } from "solid-js";
/** Form actions share icon/label geometry and replace their glyph during confirmed work. */
export declare function ActionButton(props: JSX.ButtonHTMLAttributes<HTMLButtonElement> & {
    icon?: string;
    busy?: boolean;
}): JSX.Element;

import type { Filters, Interval } from "../library/types";
/** A persistent summary makes every restriction reviewable without reopening its rail. */
export declare function ActiveFilters(props: {
    value: Filters;
    domain: Interval;
    setValue: (value: Filters) => void;
    catalog: boolean;
}): import("solid-js").JSX.Element;

/** Keep the spinner's box fixed; a cancellable action reveals Stop on hover or keyboard focus. */
export declare function ActivityGlyph(props: {
    cancellable?: boolean;
}): import("solid-js").JSX.Element;

import type { Album } from "../library/types";
/** Separate links and playback avoid nested interactive controls in grid and list layouts. */
export declare function AlbumCard(props: {
    album: Album;
    compact?: boolean | undefined;
    unplayed?: boolean | undefined;
    rating?: number | undefined;
    ratingFromArtist?: boolean | undefined;
}): import("solid-js").JSX.Element;

/** Text-only count preserves each caller's typography and reacts to count/language changes. */
export declare function AlbumCount(props: {
    value: number;
}): import("solid-js").JSX.Element;

import type { MissingAlbum } from "../library/missing";
import type { Album } from "../library/types";
/** Each local edition keeps its own identity and cover when opening details. */
export declare function AlbumGrid(props: {
    albums: readonly Album[];
    compact?: boolean | undefined;
    unplayed?: ((album: Album) => boolean) | undefined;
    coverSize?: number | undefined;
    missing?: readonly MissingAlbum[];
    reverse?: boolean;
    chronological?: boolean;
    emptyIcon?: string;
    rating?: (album: Album) => number;
    ratingFromArtist?: (album: Album) => boolean;
}): import("solid-js").JSX.Element;

/** A transient album check shares the heading's compact action geometry; no report export. */
export declare function AlbumIntegrity(props: {
    busy: boolean;
    enabled: boolean;
    cancellable: boolean;
    onStart: () => void;
    onCancel: () => void;
}): import("solid-js").JSX.Element;

import type { Album, Artist } from "../library/types";
/** Edition genres/labels and the principal artist's country remain separate sourced facts. */
export declare function AlbumMetadata(props: {
    album: Album;
    artist: Artist | undefined;
    onGenres: (genres: readonly string[]) => void;
    onCountry: (country: string) => void;
}): import("solid-js").JSX.Element;

/** Optional owner-private album marker; unknown completion never looks like an unplayed album. */
export declare function AlbumUnplayed(props: {
    visible?: boolean | undefined;
}): import("solid-js").JSX.Element;

import type { JSX } from "solid-js";
import type { AnalysisSection } from "../analysis-report/disclosure";
/** Native-independent wrapper; preference ownership stays with the calling App surface. */
export declare function AnalysisCharts(props: {
    analysis: unknown;
    actions?: JSX.Element;
    sections?: readonly AnalysisSection[];
    onSectionsChange?: (sections: AnalysisSection[]) => void;
}): JSX.Element;

/** Server-authored reports acknowledge only their exact captured reference and owner. */
export declare function AnalysisDownload(props: {
    reference: string;
    album?: boolean;
    available: boolean;
    onStatus?: (message: string, failure: boolean) => void;
}): import("solid-js").JSX.Element;

/** File selection is the only native boundary; imports do not require an Aède account. */
export declare function AnalysisImport(props: {
    onImport: (files: unknown[]) => void;
    onError: (message: string) => void;
}): import("solid-js").JSX.Element;

/** Native-independent admission surface, shared by the App and real browser import scenarios. */
export declare function AnalysisImportView(props: {
    select?: (() => Promise<string | null>) | undefined;
    onImport: (files: unknown[]) => void;
    onError: (message: string) => void;
}): import("solid-js").JSX.Element;

/** Icons save their own fields immediately; notes/tags stay in an explicit draft. */
export declare function AnnotationPanel(props: {
    reference: string;
    kind: "artist" | "album" | "track";
}): import("solid-js").JSX.Element;

import { type JSX } from "solid-js";
import { type WikipediaArticle } from "../encyclopedia/wikipedia";
/** Literal-text reading keeps private saves and file downloads as separate controlled actions. */
export declare function ArtistBiography(props: {
    article: WikipediaArticle;
    renderText?: (text: string) => JSX.Element;
    artist: string;
    photos: readonly string[];
    error?: string;
    onDismissError?: () => void;
    onSave?: ((article: WikipediaArticle) => void) | undefined;
    saved?: boolean;
    saving?: boolean;
    saveDisabled?: boolean;
    saveUnavailable?: string | undefined;
    saveError?: string;
    onDownload?: ((article: WikipediaArticle) => Promise<unknown>) | undefined;
}): JSX.Element;

import { type JSX } from "solid-js";
import type { ArtistView } from "../library/tool-preferences";
/** Shared card geometry accepts resident artwork and album navigation without a native import. */
export declare function ArtistCard(props: {
    view: ArtistView;
    name: string;
    href: string;
    metadata: string;
    albumCount: number;
    image?: string | undefined;
    logo?: string | undefined;
    fallback: JSX.Element;
    badge?: JSX.Element;
    play: JSX.Element;
    children?: JSX.Element;
}): JSX.Element;

import type { ArtistView } from "../library/tool-preferences";
import type { Artist } from "../library/types";
/** Resident art and owner-scoped annotated albums feed the two presentation surfaces. */
export declare function ArtistGallery(props: {
    artists: readonly Artist[];
    view: ArtistView;
}): import("solid-js").JSX.Element;

import type { ArtistView } from "../library/tool-preferences";
/** Mutually selected presentations remain available; choosing one never disables its neighbours. */
export declare function ArtistViewActions(props: {
    value: ArtistView;
    onChange: (value: ArtistView) => void;
}): import("solid-js").JSX.Element;

import type { Album } from "../library/types";
/** Stable squares reuse resident object URLs; scrolling never fetches a cover. */
export declare function Artwork(props: {
    album: Album;
    compact?: boolean;
    unplayed?: boolean | undefined;
    thumbnail?: boolean;
}): import("solid-js").JSX.Element;

import { type Scene } from "../visualizer/particles";
/** Perspective-projected 3D particles follow native consumed-sample RMS envelopes; pause holds the last pose. */
export declare function AudioScene(props: {
    scene: Scene;
    playing: boolean;
    levels: readonly number[];
}): import("solid-js").JSX.Element;

/** Inline continuation keeps the arrow and its replacement activity indicator in one fixed slot. */
export declare function BiographyMore(props: {
    busy: boolean;
    disabled: boolean;
    onOpen: () => void;
}): import("solid-js").JSX.Element;

import { type BiographyPart } from "../library/biography-links";
/** Stored prose remains unchanged; links resolve only names currently present in its source. */
export declare function BiographyText(props: {
    text: string;
    reference: string;
    linker?: (text: string) => BiographyPart[];
}): import("solid-js").JSX.Element;

/** Shared documentation-weight outlines; the dot follows the user's contrast colour. */
export declare function BrandWordmark(): import("solid-js").JSX.Element;

import { type JSX } from "solid-js";
/** Controlled catalog actions share order, spacing and exclusive list/Cover Flow selection. */
export declare function CatalogActions(props: {
    reverseLabel?: string;
    reverse: boolean;
    compact: boolean;
    coverFlow?: boolean;
    onReverse: () => void;
    onCompact: () => void;
    onCoverFlow?: (() => void) | undefined;
    children?: JSX.Element;
    presentations?: JSX.Element;
}): JSX.Element;

import type { Section } from "../navigation/routes";
/** One header search keeps the advanced link and explicit view-dependent search wording. */
export declare function CatalogSearch(props: {
    section?: Section | undefined;
    value: string;
    onInput: (value: string) => void;
}): import("solid-js").JSX.Element;

import { type CdDrive } from "../cd/model";
/** Props-only CD presentation is shared by the native page and component explorer. */
export declare function CdContent(props: {
    drives: readonly CdDrive[];
    selected: string;
    busy: boolean;
    error: string;
    native: boolean;
    playing: string;
    canPlay: boolean;
    transportBusy: boolean;
    discPlaying?: boolean;
    ejecting: boolean;
    onSelect: (id: string) => void;
    onPlay: (index: number) => void;
    onEject: () => void;
}): import("solid-js").JSX.Element;

/** Compact named selections retain native keyboard buttons and the existing modifier-selection policy. */
export declare function ChoiceChips(props: {
    label: string;
    choices: readonly {
        id: string | null;
        label: string;
    }[];
    selected: readonly (string | null)[];
    onSelect: (value: string | null | undefined, additive: boolean) => void;
}): import("solid-js").JSX.Element;

/** Themed single choice with keyboard selection, outside dismissal and a viewport-bound popup. */
export declare function ChoiceSelect(props: {
    value: string | number;
    options: readonly {
        value: string;
        label: string;
        disabled?: boolean;
    }[];
    onChange: (value: string) => void;
    label?: string;
    disabled?: boolean;
    onFocus?: () => void;
}): import("solid-js").JSX.Element;

import type { JSX } from "solid-js";
/** A persistent corner badge keeps Add separate from the centred circular Play hit target. */
export declare function CircularPlaybackActionsView(props: {
    play: JSX.Element;
    append: JSX.Element;
}): JSX.Element;

/** Optional collection expansion owns its loader and rejects replaced account/source answers. */
export declare function CollectionAlbums(props: {
    name: string;
    compact: boolean;
}): import("solid-js").JSX.Element;

import type { Concert, ConcertCache } from "../concerts/directory";
/** Bounded chronological provider rows retain source attribution and unknown fields. */
export declare function ConcertResults(props: {
    rows: readonly {
        event: Concert;
        claim: ConcertCache;
        artist: {
            name: string;
            references: string[];
        };
    }[];
}): import("solid-js").JSX.Element;

/** Connected-server actions expose their own request state. */
export declare function ConnectionActions(props: {
    syncing: boolean;
    disconnecting: boolean;
    onSync: () => void;
    onDisconnect: () => void;
}): import("solid-js").JSX.Element;

/** One stable slot for current-source outages; cached navigation remains available. */
export declare function ConnectionNotice(): import("solid-js").JSX.Element;

/** Successful login names are remembered; passwords and bearer credentials stay ephemeral. */
export declare function ConnectionPanel(props: {
    onClose: () => void;
    embedded?: boolean;
}): import("solid-js").JSX.Element;

import type { Country } from "../geography/projection";
import type { Artist } from "../library/types";
/** Keep the globe and keyboard country choices independent from the changing result list. */
export declare function CountryExplorer(props: {
    /** Local geometry injection makes isolated presentation independent of asset serving. */
    loadCountries?: (() => Promise<readonly Country[]>) | undefined;
    artists: readonly Artist[];
    selected: readonly (string | null)[];
    onSelect: (country: string | null | undefined, additive?: boolean) => void;
}): import("solid-js").JSX.Element;

import { type Country } from "../geography/projection";
import type { Artist } from "../library/types";
/** Locally bundled borders and a manual, keyboard-accessible globe. */
export declare function CountryGlobe(props: {
    directory?: boolean;
    focus?: string;
    onReset?: () => string;
    /** Optional local geometry loader; the app defaults to its bundled HTTP asset. */
    loadCountries?: (() => Promise<readonly Country[]>) | undefined;
    artists: readonly Artist[];
    selected: readonly (string | null)[];
    onSelect: (value: string | undefined, additive?: boolean) => void;
}): import("solid-js").JSX.Element;

import { type CoverPosition } from "../visualizer/cover-position";
import type { Album } from "../library/types";
/** A bounded perspective window follows an interruptible fractional viewport, independent of catalog size. */
export declare function CoverFlow(props: {
    albums: readonly Album[];
    position: CoverPosition;
    reverse: boolean;
    alphabetTitle?: ((album: Album) => string) | undefined;
    caption?: ((album: Album) => string) | undefined;
    unplayed?: ((album: Album) => boolean) | undefined;
}): import("solid-js").JSX.Element;

/** Lists use paired square actions; circular catalogue controls opt into a persistent corner badge. */
export declare function CoverPlay(props: {
    reference: string;
    title: string;
    class?: string;
    disabled?: boolean;
    append?: boolean | "badge" | undefined;
    detail?: boolean;
    label?: string;
    onPlay?: (() => void | Promise<void>) | undefined;
}): import("solid-js").JSX.Element;

/** Play admission is independent of cover/detail navigation and rejects overlapping starts. */
export declare function CoverPlayView(props: {
    reference: string;
    title: string;
    class?: string | undefined;
    variant?: "cover" | "detail" | "row" | undefined;
    label?: string | undefined;
    disabled?: boolean | undefined;
    onPlay: () => Promise<void>;
}): import("solid-js").JSX.Element;

import type { Album } from "../library/types";
/** Native dialog provides Escape, keyboard focus containment and trigger restoration. */
export declare function CoverPreview(props: {
    album: Album;
    onClose: () => void;
}): import("solid-js").JSX.Element;

/** Explicit pixel size; pointer double-click or keyboard activation restores the default. */
export declare function CoverSize(props: {
    value: number;
    resetValue?: number;
    disabled: boolean;
    onChange: (value: number) => void;
}): import("solid-js").JSX.Element;

/** Confirmation removes a saved rule only, never its albums or source files. */
export declare function DeleteCollection(props: {
    name: string;
    onDeleted: () => void;
}): import("solid-js").JSX.Element;

/** One account-scoped switch covers every source; runtime failure never pauses audio. */
export declare function DisplayAwakeSettings(props: {
    enabled: boolean;
    disabled?: boolean;
    error: string;
    onChange: (enabled: boolean) => void;
}): import("solid-js").JSX.Element;

/** Shared rounded download action: activity, confirmed green check and bounded feedback. */
export declare function DownloadButton(props: {
    label: string;
    onClick: () => unknown | Promise<unknown>;
    disabled?: boolean;
    busy?: boolean;
    completed?: boolean;
    confirmOnResolve?: boolean;
    icon?: string;
    onCancel?: () => unknown;
    cancelLabel?: string;
    onError?: (failure: unknown) => void;
    class?: string;
    identity?: unknown;
}): import("solid-js").JSX.Element;

/** The unavailable marker is inert; finite durations retain the elapsed/remaining switch. */
export declare function DurationToggle(props: {
    duration: number | null;
    position: number;
    remaining: boolean;
    onToggle: () => void;
}): import("solid-js").JSX.Element;

import type { JSX } from "solid-js";
/** A shared result state fills the remaining page space and keeps its message accessible. */
export declare function EmptyState(props: {
    icon?: string;
    children: JSX.Element;
}): JSX.Element;

/** A read-only path list permits selection/removal without typing or modifying folder names. */
export declare function ExcludedFolders(props: {
    disabled: boolean;
}): import("solid-js").JSX.Element;

/** Action acknowledgements share dismissal and bounded, wrappable presentation. */
export declare function Feedback(props: {
    message: string;
    /** The single shell notice displays transport errors suppressed in individual views. */
    connectionNotice?: boolean;
    error?: boolean;
    onClose?: () => void;
    class?: string;
    persistent?: boolean;
    durationMs?: number;
    pauseOnInteraction?: boolean;
}): import("solid-js").JSX.Element;

import type { Filters, Interval } from "../library/types";
import { type CountBin } from "../library/distribution";
/** Visible rails are explicit modes, rather than hidden active filters. */
export declare function FilterBar(props: {
    yearDomain: Interval;
    value: Filters;
    setValue: (value: Filters) => void;
    context: string;
    histogram: {
        years: CountBin[];
        alphabet: CountBin[];
    };
    countLabel: string;
    resultCount: number;
    hasUnknownYear: boolean;
}): import("solid-js").JSX.Element;

/** Consumed frequency energies with optional Aède terminal segmentation and held peaks. */
export declare function FrequencyBars(props: {
    levels: readonly number[];
    frequencies: readonly number[];
    rate: number;
    style?: "gradient" | "terminal";
    position: number;
    reference: string;
    playing: boolean;
}): import("solid-js").JSX.Element;

/** Explicit confirmation mirrors Aède's atomic history/counter reset for this owner only. */
export declare function HistoryReset(props: {
    onReset: () => void;
}): import("solid-js").JSX.Element;

/** Small local icon vocabulary; no runtime icon-library or network request. */
export declare function Icon(props: {
    name: string;
}): import("solid-js").JSX.Element;

import { type JSX } from "solid-js";
/** Labelled single-line fields and trailing actions share height and alignment; validation stays native. */
export declare function InlineActionForm(props: JSX.FormHTMLAttributes<HTMLFormElement>): JSX.Element;

import type { IntegrityCounts } from "../library/analysis-coverage";
/** Separate unsupported/unknown evidence from a successful checksum comparison. */
export declare function IntegrityStatus(props: {
    value: IntegrityCounts | undefined;
}): import("solid-js").JSX.Element;

import type { ConcertConfig } from "../concerts/config";
/** Native-free settings presentation; credentials are never populated from retained storage. */
export declare function JamBaseSettingsView(props: {
    status?: ConcertConfig | undefined;
    key: string;
    busy: boolean;
    native: boolean;
    removable: boolean;
    onKey: (key: string) => void;
    onSave: (remove: boolean) => void;
}): import("solid-js").JSX.Element;

/** Explicit launch, force option and cancellable server status. */
export declare function JobControls(props: {
    release: string;
    coverage?: {
        tracks: number;
        current: number;
        spectra: number;
    } | undefined;
}): import("solid-js").JSX.Element;

import { type GenerationStep } from "../library/generation-policy";
/** Whole-library actions share one admission gate and one loader owned by the active action. */
export declare function LibraryGenerations(props: {
    enabled: boolean;
    lyricsSupported?: boolean;
    reserved: boolean;
    action?: GenerationStep | "all" | undefined;
    onStart: (steps: readonly GenerationStep[]) => void;
    onCancel: () => void;
    cancellable: boolean;
}): import("solid-js").JSX.Element;

import { type JSX } from "solid-js";
/** Shared searchable catalogue row leaves its action and permission to the owning workflow. */
export declare function LibraryPickerRow(props: {
    title: string;
    detail: JSX.Element;
    detailTitle?: string | undefined;
    reason?: string | undefined;
    image?: string | undefined;
    icon?: string | undefined;
    action: JSX.Element;
}): JSX.Element;

/** Explicit LRCLIB acquisition delegates exact-track scope and sidecar preservation to Aède.
 * The download check follows confirmed completion, and replaced owners cannot inherit old jobs.
 */
export declare function LyricsDownload(props: {
    reference: string;
}): import("solid-js").JSX.Element;

/** A clock marks confirmed synchronized words; an unknown source is never labelled plain text. */
export declare function LyricsIcon(props: {
    synced?: boolean | undefined;
}): import("solid-js").JSX.Element;

import { type Lyrics } from "../library/lyrics";
/** Preserve complete words; timed lines seek only the already active native track. */
export declare function LyricsText(props: {
    lyrics: Lyrics;
    reference: string;
}): import("solid-js").JSX.Element;

/** Both stable album actions remain visible; existence permits download and prevents redundant publication. */
export declare function M3UActions(props: {
    available: boolean;
    canCreate: boolean;
    enabled: boolean;
    busy: boolean;
    identity: unknown;
    onCreate: () => void;
    onDownload: () => Promise<boolean>;
}): import("solid-js").JSX.Element;

import { type SourceId } from "../library/sources";
export interface M3UFile {
    source?: SourceId;
    id: string;
    name: string;
    filename: string;
    content: string;
    library_files?: string[];
}
/** Download exactly the M3U produced by Aède, retaining its server-side paths. */
export type M3UDownloadFile = Omit<M3UFile, "content"> & {
    content?: string;
};
export declare function downloadM3U(file: M3UDownloadFile): Promise<string>;
export declare function M3UExport(props: {
    release: string;
    title: string;
    onStatus?: (message: string, failed: boolean) => void;
}): import("solid-js").JSX.Element;

import type { MissingAlbum } from "../library/missing";
/** No cover is invented for unowned albums; a reduced cover preserves the distinction. */
export declare function MissingAlbumCard(props: {
    album: MissingAlbum;
}): import("solid-js").JSX.Element;

/** Reversible suggestions retain MusicBrainz evidence and the originating account. */
export declare function MissingAlbumsStatus(props: {
    artist?: string;
}): import("solid-js").JSX.Element;

import type { Job } from "../library/jobs";
import type { MoodPage } from "../library/moods";
/** Shared descriptors are explicit background work; private labels remain owned by the current account. */
export declare function MoodFeatures(props: {
    coverage: MoodPage["acoustic"];
    job?: Job;
    admin: boolean;
    submitting: boolean;
    onStart: () => unknown;
    onStop: () => void;
}): import("solid-js").JSX.Element;

/** A bounded original-file queue is sent directly by the selected Aède engine. */
export declare function NetworkAudio(): import("solid-js").JSX.Element;

/** The editor is loaded only on detail pages and destroyed on navigation. */
export declare function NoteEditor(props: {
    value: string;
    disabled: boolean;
    viewOnly?: boolean;
    onChange: (value: string) => void;
    onRead: (read: () => string) => void;
    onUnavailable: (value: boolean) => void;
}): import("solid-js").JSX.Element;

/** An activity indicator centred inside its positioned view leaves status text to accessibility rather than page chrome. */
export declare function PageLoader(props: {
    label?: string;
    inline?: boolean;
}): import("solid-js").JSX.Element;

/** Bounded result navigation uses the same arrows, spacing and disabled admission in every view. */
export declare function Pagination(props: {
    offset: number;
    size: number;
    total?: number;
    /** Unknown totals use the provider's next-page fact without inventing a total. */
    more?: boolean;
    /** Picker footers retain common arrows without the result-range summary. */
    compact?: boolean;
    count: number;
    busy?: boolean;
    onOffset: (offset: number) => void;
}): import("solid-js").JSX.Element;

import type { Artist, Album } from "../library/types";
import { type SourceId } from "../library/sources";
/** The same row as queue search selects group restrictions, with no playback or append dependency. */
export declare function ParentalArtistPicker(props: {
    artists: readonly Artist[];
    albums: readonly Album[];
    source: SourceId;
    blocked: readonly string[];
    disabled: boolean;
    image: (reference: string) => string | undefined;
    onChange: (references: string[]) => void;
}): import("solid-js").JSX.Element;

/** Explain the selected account's server-owned limits without turning the notice into an authority. */
export declare function ParentalNotice(): import("solid-js").JSX.Element;

import { type ParentalPolicy } from "../library/parental-controls";
import type { Artist, Album } from "../library/types";
import type { SourceId } from "../library/sources";
/** Controlled policy form writes nothing by itself and can be exercised independently of account IO. */
export declare function ParentalPolicyForm(props: {
    policy: ParentalPolicy;
    source: SourceId;
    artists: readonly Artist[];
    albums: readonly Album[];
    image: (reference: string) => string | undefined;
    busy: boolean;
    readOnly?: boolean;
    dirty: boolean;
    onChange: (policy: ParentalPolicy) => void;
    onSave: () => unknown;
    onReset: () => void;
}): import("solid-js").JSX.Element;

import type { ParentalDay } from "../library/parental-controls";
export declare const parentalWeekdays: readonly ["Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi", "Dimanche"];
/** Explicit zero limits are kept distinct from unlimited; Aède validates civil-time windows on save. */
export declare function ParentalLimit(props: {
    value: number | null;
    maximum: number;
    disabled: boolean;
    label: string;
    onChange: (seconds: number | null) => void;
}): import("solid-js").JSX.Element;
export declare function ParentalSchedule(props: {
    days: readonly ParentalDay[];
    disabled: boolean;
    onChange: (days: ParentalDay[]) => void;
}): import("solid-js").JSX.Element;

import type { JSX } from "solid-js";
/** One positioned cluster keeps Add immediately before the final Play action. */
export declare function PlaybackActionsView(props: {
    class?: string | undefined;
    append: JSX.Element;
    play: JSX.Element;
}): JSX.Element;

import type { BassSample } from "../visualizer/bass-pulse";
import type { LyricTypography } from "../visualizer/lyric-treatment";
/** Pointer capture keeps the translucent lyric block visible throughout its move. */
export declare function PlaybackLyrics(props: {
    text: string;
    cue?: string | number;
    floating?: boolean;
    hidden?: boolean;
    typography?: LyricTypography;
    audio?: BassSample;
    playing?: boolean;
}): import("solid-js").JSX.Element;

import { type JSX } from "solid-js";
/** Occurrence edits share the native queue generation and leave the current audio untouched. */
export declare function PlaybackQueue(props: {
    onClose?: (() => void) | undefined;
    standalone?: boolean;
    query?: string;
    navigation?: JSX.Element;
}): JSX.Element;

import { type JSX } from "solid-js";
/** Drawer and dedicated workspace share controls and occurrence rows, never queue ownership. */
export declare function PlaybackQueueView(props: {
    standalone?: boolean | undefined;
    /** Only the dedicated workspace header follows connection visibility; drawer controls stay available. */
    headerVisible?: boolean | undefined;
    count: number;
    matchedCount?: number | undefined;
    duration?: string;
    actions: JSX.Element;
    search?: JSX.Element;
    notices?: JSX.Element;
    children: JSX.Element;
    navigation?: JSX.Element;
    onClose?: (() => void) | undefined;
}): JSX.Element;

import type { Scene } from "../visualizer/particles";
/** Overlay controls leave scene geometry unchanged; one frequency action cycles all band modes. */
export declare function PlaybackVisualControls(props: {
    scene: Scene;
    lyricsVisible: boolean;
    synced: boolean | undefined;
    spectrum: boolean;
    barStyle: "gradient" | "terminal";
    bandsAvailable: boolean;
    onScene: (scene: Scene) => void;
    onLyrics: () => void;
    onBands: () => void;
}): import("solid-js").JSX.Element;

/** The transport follows native consumed frames, independent of the open catalog page. */
export declare function PlayerBar(): import("solid-js").JSX.Element;

import type { JSX } from "solid-js";
/** Fixed footer rows preserve the Play and volume axes across music, podcasts and live radio. */
export declare function PlayerTransport(props: {
    controls: JSX.Element;
    timeline: JSX.Element;
}): JSX.Element;

import type { PlayerVolume } from "../library/players";
/** Initial discovery and refresh share one page-centred activity; canceled reads can reveal retained volumes. */
export declare function PlayersContent(props: {
    busy: boolean;
    error?: unknown;
    volumes: readonly PlayerVolume[] | undefined;
    selected: string;
    disabled?: boolean;
    onSelect: (path: string) => void;
    ejecting?: string;
    onEject?: (id: string) => void;
    onRemove?: (id: string) => void;
    removing?: string;
}): import("solid-js").JSX.Element;

/** Measured RMS with distinct response envelopes and FlacCompagnon's centred dimensions. */
export declare function PlayingBars(props: {
    reference: string;
}): import("solid-js").JSX.Element;

/** Owner-private favourite of the playing track, synchronized with the detail annotation. */
export declare function PlayingFavourite(props: {
    reference: string;
}): import("solid-js").JSX.Element;

import { type JSX } from "solid-js";
/** File browsing is secondary; switching presentations never resets or owns the session queue. */
export declare function PlaylistsView(props: {
    queue: (navigation: JSX.Element) => JSX.Element;
    files: (navigation: JSX.Element) => JSX.Element;
}): JSX.Element;

/** Finite podcast transport shares the footer axis, volume and attached Stop shape. */
export declare function PodcastPlayerBar(): import("solid-js").JSX.Element;

/** Controlled RSS acquisition form; account and transport admission stay with its caller. */
export declare function PodcastSubscribeForm(props: {
    url: string;
    busy: boolean;
    disabled: boolean;
    onInput: (value: string) => void;
    onSubscribe: () => void;
}): import("solid-js").JSX.Element;

/** Product links and reported versions share one compact accessible presentation. */
export declare function ProductVersions(props: {
    rows: readonly {
        name: string;
        version: string;
        url?: string;
    }[];
    onOpen: (url: string) => void;
}): import("solid-js").JSX.Element;

import { type PlayableSelection } from "../library/playback-selection";
/** Search lifetime is independent of the queue and audio-clock polls. */
export declare function QueueAdd(props: {
    onClose?: () => void;
    onSelect?: (rows: readonly PlayableSelection[]) => void;
    disabled?: boolean;
}): import("solid-js").JSX.Element;

import { type QueueCategory, type QueueSearchItem } from "../library/queue-search";
/** Compact queue composer presentation; admission and authenticated reads belong to its controller. */
export declare function QueueAddView(props: {
    title?: string | undefined;
    footer?: string | undefined;
    actionLabel?: ((row: QueueSearchItem) => string) | undefined;
    category: QueueCategory;
    query: string;
    rows: readonly QueueSearchItem[];
    loading: boolean;
    pending: string;
    added: string;
    error: string;
    more: boolean;
    offset: number;
    origins: boolean;
    image: (row: QueueSearchItem) => string | undefined;
    disabled: (row: QueueSearchItem) => string;
    onQuery: (value: string) => void;
    onSearch?: (() => void) | undefined;
    onCategory: (value: QueueCategory) => void;
    onAdd: (row: QueueSearchItem) => void;
    onOffset: (offset: number) => void;
    onClose?: (() => void) | undefined;
    onRefresh: () => void;
    onCancel: () => void;
}): import("solid-js").JSX.Element;

/** Account admission and native append are shared by square list actions and circular catalogue badges. */
export declare function QueueAppend(props: {
    reference: string;
    title: string;
    class?: string | undefined;
    disabled?: boolean | undefined;
    load?: ((current: () => boolean) => Promise<unknown>) | undefined;
}): import("solid-js").JSX.Element;

/** Add is separate from Play/navigation; its acknowledgement never moves surrounding controls. */
export declare function QueueAppendView(props: {
    reference: string;
    title: string;
    class?: string | undefined;
    scope?: object | undefined;
    disabled?: boolean | undefined;
    reason?: string | undefined;
    onAppend: () => Promise<number>;
}): import("solid-js").JSX.Element;

/** Clearing is unavailable for an empty queue; native acknowledgement owns the pending state. */
export declare function QueueClearButton(props: {
    count: number;
    busy: boolean;
    clearing: boolean;
    onClear: () => void;
}): import("solid-js").JSX.Element;

/** Capture the shared queue membership as an owner-private collection, independently of playback. */
export declare function QueueCollection(): import("solid-js").JSX.Element;

import type { createQueueLyrics } from "../library/queue-lyrics-controller";
/** This drawer displays the shared download operation without owning its lifetime. */
export declare function QueueLyrics(props: {
    feedbackHost: () => HTMLElement | undefined;
    controller?: ReturnType<typeof createQueueLyrics>;
    tracks?: readonly {
        reference: string;
    }[];
    label?: string;
}): import("solid-js").JSX.Element;

/** Remove one queue occurrence without activating the containing playable row. */
export declare function QueueRemoveButton(props: {
    title: string;
    disabled: boolean;
    reason?: string | undefined;
    onRemove: () => void;
}): import("solid-js").JSX.Element;

/** Align the number with the title and optional lyric acquisition underneath it. */
export declare function QueueTrackLeading(props: {
    number: number;
    albumTotal: number;
    available: boolean;
    synced?: boolean | undefined;
    busy: boolean;
    disabled: boolean;
    onAction: () => void;
}): import("solid-js").JSX.Element;

import { type JSX } from "solid-js";
import type { PlayableSelection } from "../library/playback-selection";
import type { QueueDrag } from "./queue-drag";
/** Queue occurrence presentation keeps remove, lyric acquisition and transport independent. */
export declare function QueueTrackRow(props: {
    row: PlayableSelection & {
        index: number;
    };
    /** Resident decorative artwork is supplied by the standalone editor only. */
    cover?: JSX.Element;
    status?: "playing" | "paused" | "connecting" | undefined;
    reorderable: boolean;
    playable: boolean;
    drag: QueueDrag;
    onGrip: (button: HTMLButtonElement) => () => void;
    onPlay: () => void;
    removeDisabled: boolean;
    removeReason?: string | undefined;
    onRemove: () => void;
    words: {
        synced?: boolean | undefined;
        available: boolean;
        busy: boolean;
        disabled: boolean;
        onAction: () => void;
    };
}): JSX.Element;

import type { Station } from "../radio/directory";
import type { createAccountRadioFavourites } from "../radio/account-favourites";
/** Saved stations play by UUID without searching the directory first. */
export declare function RadioFavourites(props: {
    favourites: Pick<ReturnType<typeof createAccountRadioFavourites>, "error" | "stations" | "toggle">;
    play: (station: Station) => void;
    busy: boolean;
    writable: boolean;
}): import("solid-js").JSX.Element;

/** Live radio releases the stream on pause and rejoins the current broadcast on resume. */
export declare function RadioPlayerBar(): import("solid-js").JSX.Element;

/** Presentation-only radio footer; callbacks belong to the active transport owner. */
export declare function RadioPlayerBarView(props: {
    station: {
        name: string;
        country: string;
    } | undefined;
    status: "idle" | "connecting" | "playing" | "paused" | "error";
    error: string;
    volume: number;
    onPause: () => void;
    onResume: () => void;
    onStop: () => void;
    onMute: () => void;
    onVolume: (value: number) => void;
}): import("solid-js").JSX.Element;

import { type RadioCriteria } from "../radio/search";
/** All three text fields share explicit native Enter submission; HTTPS is below the fields. */
export declare function RadioSearch(props: {
    value: RadioCriteria;
    change: (value: Partial<RadioCriteria>) => void;
    submit: () => void;
    busy: boolean;
    available: boolean;
}): import("solid-js").JSX.Element;

/** One resident 8 KiB sample buffer, 30 Hz drawing only while the dial is visible; no sound generation. */
export declare function RadioWave(props: {
    sample: (target: Float32Array<ArrayBuffer>) => boolean;
}): import("solid-js").JSX.Element;

import type { Interval } from "../library/types";
import type { CountBin } from "../library/distribution";
interface Props {
    label: string;
    domain: Interval;
    value: Interval;
    ticks: readonly number[];
    format: (value: number) => string;
    onChange: (value: Interval) => void;
    bins: readonly CountBin[];
    countLabel: string;
    resultCount?: number | undefined;
}
/** Two native bounds plus a draggable/keyboard-movable selected band. */
export declare function RangeRail(props: Props): import("solid-js").JSX.Element;
export {};

/** A reversible album-only catalog filter; release years do not imply recent additions. */
export declare function RecentAlbumsFilter(props: {
    active: boolean;
    onToggle: () => void;
}): import("solid-js").JSX.Element;

/** A controlled read action exposes Stop only when the caller can retire its current admission. */
export declare function RefreshButton(props: {
    label?: string;
    busy: boolean;
    /** A page-wide indicator can own activity while this action remains an immediate Stop. */
    busyIndicator?: "spinner" | "stop";
    /** Keep the arrows visible for a complete turn, including immediately completed reads. */
    rotate?: boolean;
    disabled?: boolean;
    onRefresh: () => unknown;
    onCancel?: () => void;
}): import("solid-js").JSX.Element;

export interface RelationNode {
    reference: string;
    name: string;
    weight: number;
    source: string;
    kind: "artist" | "album";
    href?: string;
}
/** Rotatable 3D geometry with SVG perspective, accessible neighbours and no idle animation. */
export declare function RelationGraph(props: {
    name: string;
    edges: readonly RelationNode[];
    onSelect: (reference: string) => void;
}): import("solid-js").JSX.Element;

/** Inline focused name editing keeps the existing rule and dates on the authenticated owner. */
export declare function RenameCollection(props: {
    name: string;
    onRenamed: (name: string) => void;
}): import("solid-js").JSX.Element;

/** Counts describe all matched items, rather than the current pagination window. */
export declare function ResultCount(props: {
    value: number;
}): import("solid-js").JSX.Element;

/** Role help reflects server permissions; administrative routes additionally require local HTTP. */
export declare function RoleHelp(): import("solid-js").JSX.Element;

import type { RoonMapping } from "../imports/roon-plan";
/** Explicit column choices keep editorial ratings separate from personal stars. */
export declare function RoonImportMapping(props: {
    headers: readonly string[];
    mapping: RoonMapping;
    disabled: boolean;
    onChange: (value: RoonMapping) => void;
}): import("solid-js").JSX.Element;

import { type RoonRow } from "../imports/roon-plan";
/** Preview never writes; bounded visible rows retain an explicit total and skipped reasons. */
export declare function RoonImportPreview(props: {
    rows: readonly RoonRow[];
}): import("solid-js").JSX.Element;

import type { JSX } from "solid-js";
/** Account-owned expansion is synchronized by the existing preferences controller, outside the reusable report. */
export declare function SavedAnalysisCharts(props: {
    analysis: unknown;
    actions?: JSX.Element;
}): JSX.Element;

/** Floating reader action follows the real scroll container and releases its observers on disposal. */
export declare function ScrollToTop(props: {
    target: () => HTMLElement | undefined;
    contained?: boolean;
}): import("solid-js").JSX.Element;

import { type JSX } from "solid-js";
/** Thin native keyboard/pointer range shared by Cover Flow and artwork sizing. */
export declare function ScrubRange(props: JSX.InputHTMLAttributes<HTMLInputElement>): JSX.Element;

import type { SourceId } from "../library/sources";
import type { Filters } from "../library/types";
/** Freeze the criteria at opening; Aède evaluates their future catalog matches. */
export declare function SelectionCollection(props: {
    section?: string;
    filters?: Filters;
    expression?: string;
    disabled?: boolean;
    reason?: string | undefined;
    source?: SourceId;
}): import("solid-js").JSX.Element;

/** Device-wide public cache controls never delete remote music or personal account data. */
export declare function ServerCacheSettings(): import("solid-js").JSX.Element;

/** Aède owns remote folders; Phémios displays confirmed roots without maintaining an editable copy. */
export declare function ServerRoots(props: {
    busy: boolean;
    revision: number;
    scan: () => void;
}): import("solid-js").JSX.Element;

/** Origin labels appear only where two retained catalogs can otherwise be confused. */
export declare function SourceBadge(props: {
    reference: string;
}): import("solid-js").JSX.Element;

import type { SourceReviewItem, ReviewDecision } from "../library/source-review";
/** Local names, external evidence and explicit human decisions remain visibly distinct. */
export declare function SourceReviewCard(props: {
    row: SourceReviewItem;
    busy: boolean;
    disabled: boolean;
    biographyAvailable: boolean;
    onDecision: (decision: ReviewDecision) => void;
    onBiography: () => void;
}): import("solid-js").JSX.Element;

/** Explicit confirmed spectrum export never starts an analysis job. */
export declare function SpectrumDownload(props: {
    reference: string;
}): import("solid-js").JSX.Element;

/** Shared compact rating glyphs; the floor preserves a nonempty minimum filter. */
export declare function StarRating(props: {
    value: number | null;
    label: string;
    onChange: (value: number | null) => void;
    floor?: number;
}): import("solid-js").JSX.Element;

/** Keep localized measurement/unit strings complete without widening an individual statistics cell. */
export declare function StatValue(props: {
    value: string | number | undefined;
}): import("solid-js").JSX.Element;

import { type JSX } from "solid-js";
/** All statistics reads settle before revealing one coherent body; only one page activity is rendered. */
export declare function StatisticsContent(props: {
    busy: boolean;
    children: JSX.Element;
}): JSX.Element;

import { type Page, type Statistics } from "../library/statistics";
export interface StatRow {
    label: string;
    count: number;
    extra?: string;
    reference?: string | null;
    /** A catalog selection is prepared before the internal link is followed. */
    browse?: {
        href: string;
        select: () => void;
    };
}
/** Independent bounded pagination keeps every ranking accessible without rendering all rows. */
export declare function StatisticsTable(props: {
    title: string;
    unit: string;
    first: Statistics;
    read: (offset: number) => Promise<Statistics>;
    rows: (report: Statistics) => Page<StatRow>;
}): import("solid-js").JSX.Element;

import { type ParentProps } from "solid-js";
/** Shared headers may explicitly reserve no space; shell measurements follow their actual visibility. */
export declare function StickyHeader(props: ParentProps<{
    shell?: boolean;
    class?: string;
    separator?: boolean;
    visible?: boolean | undefined;
}>): import("solid-js").JSX.Element;

/** Token editor with a current-owner saved vocabulary and a readable pending fragment on save. */
export declare function TagInput(props: {
    value: readonly string[];
    vocabulary: readonly string[];
    disabled: boolean;
    resetKey: string;
    onChange: (tags: string[]) => void;
    autofocus?: boolean;
    onEntered?: (tags: string[]) => void;
    onPending: (pending: boolean) => void;
    onRead: (read: () => string[]) => void;
}): import("solid-js").JSX.Element;

/** Aggregate the complete loaded album, preserving unknown durations rather than calling them zero. */
export declare function TrackDurationTotal(props: {
    tracks: readonly {
        reference: string;
        duration_ms: number | null;
    }[] | undefined;
}): import("solid-js").JSX.Element;

import type { IntegrityResult } from "../library/album-integrity";
/** Equal slots preserve title alignment; only failures with a disclosure callback are interactive. */
export declare function TrackIntegrity(props: {
    result: IntegrityResult | undefined;
    id?: string;
    controls?: string;
    expanded?: boolean;
    onToggle?: () => void;
}): import("solid-js").JSX.Element;

import type { IntegrityResult } from "../library/album-integrity";
/** Display the current verifier's text literally, without fetching or exporting a report. */
export declare function TrackIntegrityError(props: {
    id: string;
    result: IntegrityResult | undefined;
    onClose: () => void;
}): import("solid-js").JSX.Element;

import { type MetadataBrowse } from "../library/track-metadata-links";
import type { TrackDetail } from "../library/track-detail";
/** File metadata preserves its original text while linking source-qualified catalogue identities. */
export declare function TrackMetadataValue(props: {
    field: string;
    value: string;
    detail: TrackDetail;
    onBrowse: (target: MetadataBrowse) => void;
}): import("solid-js").JSX.Element;

import { type IntegrityResult } from "../library/album-integrity";
import type { JSX } from "solid-js";
import type { Track } from "../library/server";
/** Compact actions independently open retained analyses, spectra and existing lyrics. */
export declare function TrackResults(props: {
    track: Track & {
        spectrum_available: boolean;
    };
    number: number;
    onPlay: () => void;
    context?: JSX.Element;
    expanded?: boolean;
    origin?: boolean;
    integrity?: IntegrityResult | undefined;
}): JSX.Element;

import type { JSX } from "solid-js";
/** Page size and read admission stay above the independent track scroller. */
export declare function TracksHeader(props: {
    total: number;
    children?: JSX.Element;
    filters?: JSX.Element;
    offset: number;
    size: number;
    sizes: readonly number[];
    busy: boolean;
    pending: boolean;
    onRefresh: () => void;
    onCancel: () => void;
    onSize: (size: number) => void;
}): JSX.Element;

import type { ComponentProps } from "solid-js";
import { PlayersContent } from "./PlayersContent";
/** Destination controls remain separate from source selection; only an explicit native dialog can grant a folder. */
export declare function TransferDestination(props: ComponentProps<typeof PlayersContent> & {
    canChoose: boolean;
    choosing?: boolean;
    chooseError?: string;
    warning?: string;
    onChoose: () => void;
    onDismissError?: () => void;
}): import("solid-js").JSX.Element;

import type { PlayableSelection } from "../library/playback-selection";
import { type TransferOptions, type TransferPreview, type TransferStatus } from "../library/transfers";
/** Reviewable copy recipe and retained native progress; no device writes occur while selecting. */
export declare function TransferPanel(props: {
    rows: readonly PlayableSelection[];
    destination: string;
    ipod: boolean;
    mtp?: boolean;
    options: TransferOptions;
    preview: TransferPreview | undefined;
    status: TransferStatus;
    preparing: boolean;
    disabled?: boolean;
    error: string;
    onOptions: (value: TransferOptions) => void;
    onPreview: () => void;
    onStart: () => void;
    onCancel: () => void;
}): import("solid-js").JSX.Element;

import type { PlayableSelection } from "../library/playback-selection";
/** Music selection remains available before a destination is discovered or chosen. */
export declare function TransferSelection(props: {
    rows: readonly PlayableSelection[];
    disabled: boolean;
    onRemove: (reference: string) => void;
}): import("solid-js").JSX.Element;

/** Manual navigation exposes supplied untimed lines without coupling them to the audio clock. */
export declare function UntimedLyricsControls(props: {
    index: number;
    total: number;
    previous: () => void;
    next: () => void;
}): import("solid-js").JSX.Element;

/** Retains the full envelope on pause; an ordinary keyboard range supplies accessible seeking. */
export declare function WaveformSeek(): import("solid-js").JSX.Element;

import { type JSX } from "solid-js";
import type { ResourcePart, ResourceLink } from "../encyclopedia/resource-links";
/** Only literal text and validated external anchors enter the reader, never remote HTML. */
export declare function WikipediaResourceText(props: {
    parts: readonly ResourcePart[];
    renderText?: ((text: string) => JSX.Element) | undefined;
}): JSX.Element;
/** Preserve access even when the plain extract spells a provider differently from the rendered article. */
export declare function WikipediaUnmatchedResources(props: {
    links: readonly ResourceLink[];
}): JSX.Element;

type Pointer = PointerEvent & {
    currentTarget: HTMLButtonElement;
};
/** One bounded row preview follows the pointer; only a confirmed, current-scope drop edits the order. */
export declare function createQueueDrag(options: {
    enabled: () => boolean;
    order: () => readonly number[];
    id: () => number;
    onReorder: (order: number[], id: number, focus?: number) => void;
}): {
    dragged: import("solid-js").Accessor<number | undefined>;
    target: import("solid-js").Accessor<number | undefined>;
    edge: (index: number) => "after" | "before" | undefined;
    cancel: () => void;
    pointerDown(event: Pointer, index: number): void;
    pointerMove(event: Pointer): void;
    pointerUp(event: Pointer): void;
    nativeStart(event: DragEvent & {
        currentTarget: HTMLLIElement;
    }, index: number): void;
    nativeOver(event: DragEvent, index: number): void;
    nativeDrop(event: DragEvent, index: number): void;
    key(event: KeyboardEvent, index: number): void;
};
export type QueueDrag = ReturnType<typeof createQueueDrag>;
export {};

/** Native budget is device-wide; removing a key never resets these counters. */
export interface ConcertConfig {
    ready: boolean;
    limit: number;
    used: number;
    remaining: number;
    resetAt: number | null;
}
/** Refuse inconsistent or unbounded IPC counters before enabling paid-provider search controls. */
export declare function concertConfig(raw: unknown): ConcertConfig;

import type { Artist, Album } from "../library/types";
export interface Concert {
    id: string;
    title: string;
    url: string | null;
    date: string | null;
    time: string | null;
    timezone: string | null;
    status: string | null;
    venue: string | null;
    city: string | null;
    country: string | null;
    countryCode: string | null;
    address: string | null;
    info: string | null;
    notice: string | null;
    price: {
        min: number | null;
        max: number | null;
        currency: string | null;
    } | null;
}
export interface ConcertCache {
    artist: string;
    events: Concert[];
    at: number;
    partial: boolean;
}
type Store = Pick<Storage, "getItem" | "setItem">;
/** Public event cache contains no key or account data; unreadable stores remain intact. */
export declare function readConcertCache(storage: Pick<Storage, "getItem">): ConcertCache[];
/** Retain each completed lookup atomically; only disposable oldest cache entries may expire. */
export declare function retainConcerts(storage: Store, entry: ConcertCache): ConcertCache[];
/** Principal album artists only; two connected origins contribute one provider lookup per name. */
export declare function concertArtists(artists: readonly Artist[], albums: readonly Album[]): {
    name: string;
    references: string[];
}[];
/** Explicit sequential pagination stops at the provider's 1000-row window and stale-view boundary. */
export declare function collectConcerts(artist: string, current: () => boolean, request: (name: string, page: number) => Promise<unknown>): Promise<Omit<ConcertCache, "at"> | undefined>;
export {};

import type { Album, Artist, Interval } from "../library/types";
/** Entirely fictional catalog; no service fixture or private library data. */
export declare const demoArtists: readonly Artist[];
export declare const demoAlbums: readonly Album[];
/** Rails use available years, never a guessed current-year upper bound. */
export declare const demoYearDomain: Interval;

/** Ignore initialization/normalization; untouched notes retain their exact server bytes. */
export declare function markdownDraft(value: string, publish: (value: string) => void): {
    initialized(markdown: string): void;
    differs(value: string): boolean;
    replace(value: string, update: () => string): void;
    read(value: string): string;
    changed(value: string): void;
};

import { Editor } from "@milkdown/kit/core";
export type NoteCommand = "bold" | "italic" | "heading" | "paragraph" | "bullet" | "ordered" | "quote" | "undo" | "redo";
/** Host-neutral visual editing; stored content remains Markdown, never executable HTML. */
export declare function mountNoteEditor(element: HTMLElement, initial: string, disabled: boolean, publish: (value: string) => void, changed: () => void): Promise<{
    command: (name: NoteCommand) => void;
    read: () => string;
    set(value: string, readOnly: boolean): void;
    active(name: NoteCommand): boolean;
    destroy: () => Promise<Editor>;
}>;

/** Flat category navigation replaces boxed filter buttons; ordinary keyboard buttons remain accessible. */
export declare function ReferenceCategories(props: {
    query: string;
    selected: string;
    onSelect: (category: string) => void;
}): import("solid-js").JSX.Element;

import { type Language } from "../i18n";
/** Public exploration is explicit and account-independent; saved reading performs no request. */
export declare function WikipediaPanel(props: {
    query: string;
    mode: "search" | "saved";
    language: Language;
    onLanguageUnavailable: (language: Language) => void;
    onBusy: (busy: boolean) => void;
}): import("solid-js").JSX.Element;

import { type WikipediaArticle } from "./wikipedia";
/** Plain-text reading retains revision, author history and licence even when offline. */
export declare function WikipediaReader(props: {
    article: WikipediaArticle;
    retained: boolean;
    busy: boolean;
    loading: boolean;
    downloading: boolean;
    native: boolean;
    writable: boolean;
    saving: boolean;
    onBack: () => void;
    onSave: () => void;
    onDownload: () => Promise<boolean>;
    onRefresh: () => void;
    onRemove: () => void;
}): import("solid-js").JSX.Element;

import type { AccountSession } from "../library/server";
import type { SourceId } from "../library/sources";
import { type WikipediaArticle } from "./wikipedia";
interface Api {
    read(source: SourceId, owner: AccountSession): Promise<unknown>;
    update(action: "save" | "remove", payload: unknown, source: SourceId, owner: AccountSession): Promise<unknown>;
}
/** Shared admission for native saved copies and explicit portable backup records. */
export declare function parseAccountArticles(raw: unknown): WikipediaArticle[];
/** Private copies use native exact-session admission, never the old device-wide localStorage document. */
export declare function createAccountSavedArticles(session: () => AccountSession | undefined, source: () => SourceId, api: Api): {
    rows: () => WikipediaArticle[];
    loading: import("solid-js").Accessor<boolean>;
    pending: import("solid-js").Accessor<boolean>;
    error: () => string;
    available: () => boolean;
    writable: () => boolean;
    save: (row: WikipediaArticle) => Promise<boolean>;
    remove: (row: WikipediaArticle) => Promise<boolean>;
};
export {};

import type { Language } from "../i18n";
/** Search the bundled original editorial content; never issue external requests on navigation. */
export declare function encyclopediaRows(query: string, category: string, language: Language): {
    id: string;
    category: string;
    title: {
        fr: string;
        en: string;
    };
    body: {
        fr: string;
        en: string;
    };
    source: {
        title: string;
        url: string;
    };
}[];

import { type WikipediaArticle } from "./wikipedia";
/** Portable UTF-8 text preserves the selected edition, full extract and attribution without another request. */
export declare function wikipediaDocument(value: WikipediaArticle): string;

import { type Language } from "../i18n";
import { type ArticleStorage, type SavedArticleCollection } from "./saved";
import { type WikipediaHit, type WikipediaArticle } from "./wikipedia";
interface WikipediaApi {
    search(language: Language, query: string): Promise<unknown>;
    read(language: Language, pageId: number): Promise<unknown>;
    download?(article: WikipediaArticle): Promise<string>;
    translate?(language: Language, pageId: number, target: Language): Promise<unknown>;
}
/** Requests happen only on explicit actions; generation guards prevent late views/languages replacing results. */
export declare function createWikipediaExplorer(api: WikipediaApi, language: () => Language, storage: ArticleStorage | SavedArticleCollection): {
    saved: SavedArticleCollection;
    hits: import("solid-js").Accessor<WikipediaHit[]>;
    article: import("solid-js").Accessor<WikipediaArticle | null>;
    busy: import("solid-js").Accessor<"" | "article" | "download" | "search">;
    error: import("solid-js").Accessor<string>;
    notice: import("solid-js").Accessor<string>;
    searched: import("solid-js").Accessor<boolean>;
    search: (query: string) => Promise<void>;
    open: (hit: WikipediaHit, refresh?: boolean) => Promise<void>;
    changeEdition: (query: string) => Promise<boolean>;
    download: () => Promise<boolean>;
    back(): void;
    reset(): void;
    dispose(): void;
    save(): Promise<void> | undefined;
    retained(): boolean;
};
export {};

export interface ResourceLink {
    label: string;
    url: string;
}
/** Optional labelled resources stay inert and bounded across IPC, saved copies and backups. */
export declare function parseResourceLinks(value: unknown): ResourceLink[];
export interface ResourcePart {
    text: string;
    url?: string;
}
/** Match source labels only inside the external-links section; never infer a URL from a name.
 * Each link occurrence is consumed once. Unmatched labels remain available as an explicit list.
 */
export declare function linkResourceBlocks(blocks: readonly {
    heading: boolean;
    text: string;
}[], links?: readonly ResourceLink[]): {
    blocks: {
        heading: boolean;
        text: string;
        parts: ResourcePart[];
    }[];
    unmatched: ResourceLink[];
};

import { type WikipediaArticle } from "./wikipedia";
export type ArticleStorage = Pick<Storage, "getItem" | "setItem">;
/** Exploration accepts a private native collection or an explicitly supplied legacy/test store. */
export interface SavedArticleCollection {
    rows: () => readonly WikipediaArticle[];
    error: () => string;
    save: (value: WikipediaArticle) => boolean | Promise<boolean>;
    remove: (value: WikipediaArticle) => boolean | Promise<boolean>;
}
/** The retained edition must contain this exact revision and text, not only the same page title. */
export declare function articleRetained(row: WikipediaArticle, copies: readonly WikipediaArticle[]): boolean;
/** Explicit legacy/test access only: desktop saved articles never adopt this unowned device store. */
export declare function createSavedArticles(storage: ArticleStorage): {
    rows: import("solid-js").Accessor<WikipediaArticle[]>;
    error: import("solid-js").Accessor<string>;
    save(value: WikipediaArticle): boolean;
    remove(row: WikipediaArticle): boolean;
};

import { type ResourceLink } from "./resource-links";
import type { Language } from "../i18n";
export interface WikipediaHit {
    pageId: number;
    title: string;
}
export interface WikipediaArticle extends WikipediaHit {
    language: Language;
    revision: number;
    text: string;
    retrievedAt: number;
    externalLinks?: ResourceLink[];
}
/** IPC and retained copies must carry bounded text, positive identities and provenance. */
export declare function wikipediaArticle(value: unknown): WikipediaArticle;
/** Titles are plain text, never HTML snippets. Reject mismatched languages and duplicate pages. */
export declare function wikipediaSearch(value: unknown, expected: Language): WikipediaHit[];
/** Attribution addresses are constructed from verified identities, never remote URL fields. */
export declare function wikipediaLinks(row: WikipediaArticle): {
    article: string;
    revision: string;
    authors: string;
    license: string;
};
/** Preserve the API's text; headings are interpreted only as non-executable presentation. */
export declare function wikipediaBlocks(text: string): {
    heading: boolean;
    text: string;
}[];

import { type Country, type Point } from "./projection";
/** Draw only the front hemisphere, without a permanent animation loop. */
export declare function drawGlobe(canvas: HTMLCanvasElement, countries: readonly Country[], center: Point, zoom: number, selected: ReadonlySet<string>, available: ReadonlySet<string>, keyboardFocus?: boolean): void;

import type { Country, Point } from "./projection";
type Geometry = {
    type: "MultiPolygon";
    coordinates: number[][][][];
};
/** Normalize the bundled small-country rings to D3's spherical winding, preserving holes and source bytes. */
export declare function countryGeometry(country: Country): Geometry;
/** Match the manual inverse/picking convention while clipping complete polygons at the visible horizon. */
export declare function globeProjection(center: Point, radius: number, offset: Point): import("d3-geo").GeoProjection;
export {};

/** Degrees and normalized sphere coordinates, independent of canvas pixels. */
export type Point = readonly [number, number];
export interface Country {
    code: string;
    name: string;
    polygons: Point[][][];
}
export declare function wrapLongitude(value: number): number;
/** Orthographic projection; negative z is hidden behind the sphere. */
export declare function project(point: Point, center: Point): {
    x: number;
    y: number;
    z: number;
};
/** Returns only the front hemisphere; outside the circle is not a country. */
export declare function unproject(point: Point, center: Point): Point | null;
/** Polygon holes and antimeridian crossings are preserved during picking. */
export declare function countryAt(point: Point, countries: readonly Country[]): Country | undefined;
/** Canvas margins are inert; picking and dragging use the same visible sphere radius. */
export declare function globePoint(point: Point, width: number, height: number, zoom: number): Point | null;

export type Language = "fr" | "en";
/** Current presentation language; account and catalog identities remain untouched. */
export declare const locale: import("solid-js").Accessor<Language>;
/** Apply only supported locales; no reload or playback interruption is needed. */
export declare function changeLanguage(value: Language): void;
/** Exact message lookup and placeholder replacement never translate inserted user data. */
export declare function translate(value: Language, message: string, ...parameters: unknown[]): string;
/** Use in reactive rendering and controls, never on catalog titles, tags or notes. */
export declare function t(message: string, ...parameters: unknown[]): string;
/** Display a country label without changing its filter identity; reuse one formatter per locale. */
export declare function countryName(code: string | undefined, fallback: string | null): string;

/** Bounded UTF-8 CSV/TSV table; fields stay text and spreadsheet formulae are never evaluated. */
export interface ImportCsv {
    headers: string[];
    rows: string[][];
}
/** Accept common spreadsheet delimiters, RFC-style quoting and multiline cells; reject shifted fields. */
export declare function readImportCsv(input: string): ImportCsv;

import type { Album, Artist } from "../library/types";
import type { Annotation } from "../library/server";
import type { AnnotationPatch } from "../library/annotation-writes";
import type { ImportCsv } from "./csv";
/** Only identity columns are suggested; personal fields always require explicit user mapping. */
export interface RoonMapping {
    artist: number;
    album: number;
    year: number;
    rating: number;
    loved: number;
    tags: number;
    note: number;
    favourites: boolean;
    tagSeparator: "," | ";" | "|";
}
export type ImportStatus = "ready" | "missing" | "ambiguous" | "invalid" | "duplicate" | "conflict" | "unchanged";
export interface RoonRow {
    line: number;
    title: string;
    artist: string;
    status: ImportStatus;
    reference?: string;
    desired?: AnnotationPatch;
}
export declare function suggestRoonMapping(headers: readonly string[]): RoonMapping;
/** Missing values never erase annotations; different saved notes/stars make the whole row a conflict. */
export declare function additiveImportPatch(desired: AnnotationPatch, saved: Annotation | null | undefined): AnnotationPatch | undefined;
/** Exact normalized album/artist and optional year matching never silently chooses another edition. */
export declare function planRoonImport(table: ImportCsv, mapping: RoonMapping, albums: readonly Album[], artists: readonly Artist[], annotations: Readonly<Record<string, Annotation | undefined>>): RoonRow[];
export declare function importStatusLabel(status: ImportStatus): string;

import type { AnnotationPatch } from "../library/annotation-writes";
import type { Annotation } from "../library/server";
import { type RoonRow } from "./roon-plan";
/** Serial explicit import; recheck current saved values and captured account before every mutation.
 * Confirmed rows stay saved after cancellation/failure. No request is retried automatically.
 */
export declare function writeRoonImport(rows: readonly RoonRow[], ports: {
    active: () => boolean;
    cancelled?: () => boolean;
    read: (reference: string) => Promise<unknown>;
    write: (reference: string, patch: AnnotationPatch) => Promise<unknown>;
    publish: (reference: string, annotation: Annotation | null) => void;
    progress: (saved: number, skipped: number) => void;
}): Promise<{
    saved: number;
    skipped: number;
    stopped: boolean;
}>;

import type { AccountSession } from "./server";
import type { SourceId } from "./sources";
/** Account-management drafts remain ephemeral and never enter saved preferences. */
export declare function createAccountDrafts(session: () => AccountSession | undefined, source: () => SourceId): import("solid-js/store").StoreReturn<{
    username: string;
    password: string;
    role: string;
    error: string;
    currentPassword: string;
    newPassword: string;
}>;

import type { AccountSession } from "./server";
import type { SourceId } from "./sources";
export interface Account {
    id: string;
    username: string;
    role: "admin" | "user" | "auditor";
    enabled: boolean;
    parental_locked_by?: string;
}
/** Only the application-owned local principal is protected by client-side account controls. */
export declare function managedLocalAccount(account: Pick<Account, "username">, source: SourceId): boolean;
export declare function parseAccounts(raw: unknown): Account[];
/** Read only the captured administrator, retaining read errors inside the optional settings tab. */
export declare function createAccountList(session: () => AccountSession | undefined, source: () => SourceId): {
    values: () => Account[];
    error: () => string;
    loading: () => boolean;
    refresh: (info?: unknown) => Promise<{
        session: AccountSession;
        source: SourceId;
        values: Account[];
        error: string;
    } | undefined> | {
        session: AccountSession;
        source: SourceId;
        values: Account[];
        error: string;
    } | null | undefined;
};

import type { AccountSession } from "./server";
/** A password change and its follow-up logout belong to the exact captured server login. */
export declare function changePasswordForSession(options: {
    session: () => AccountSession | undefined;
    change: (owner: AccountSession) => Promise<unknown>;
    disconnect: () => Promise<void>;
}): Promise<boolean>;

/** Only these non-secret interface settings participate in owner profiles and portable backups. */
export declare const accountSettingKeys: readonly ["phemios.appearance", "phemios.navigation.v1", "phemios.tools.v1", "phemios.duration", "phemios.keep-awake", "phemios.visualizer", "phemios.spectrum", "phemios.spectrum-style", "phemios.shortcuts.v1", "phemios.audio.v1"];

import type { AccountSession } from "./server";
import type { SourceId } from "./sources";
type Store = Pick<Storage, "getItem" | "setItem">;
type Projection = Record<string, unknown>;
type Validate = (values: Projection) => Projection;
/** The managed-local authority survives its ephemeral port; remote authorities remain distinct. */
export declare function accountPreferenceOwner(session: AccountSession | undefined, source: SourceId): string | undefined;
/** Profiles occupy new keys; legacy global settings are neither read nor attributed implicitly.
 * Switching clears the projection before validating a stored profile. Invalid bytes remain intact
 * and block writes while their visible projection stays neutral. Anonymous choices use a separate
 * device profile. One JSON write precedes publication, so quota failure cannot acknowledge half a profile.
 */
export declare function createAccountPreferenceProfiles(backing: Store): {
    storage: {
        getItem(name: string): string | null;
        setItem(name: string, raw: string): void;
        removeItem(name: string): void;
    };
    activate: (nextOwner: string | undefined, validate?: Validate) => void;
    owner: () => string | undefined;
    identity: () => {
        owner: string | undefined;
    };
    replace(expected: object, next: Projection): boolean;
};
/** Readers and writers use the active interface projection, never the preceding owner's legacy keys. */
export declare const interfacePreferences: {
    getItem: (key: string) => string | null;
    setItem: (key: string, raw: string) => void;
    removeItem: (key: string) => void;
};
/** Synchronous owner switching must precede both rendering refresh and asynchronous account reads. */
export declare function activateInterfaceProfile(owner: string | undefined, validate: Validate): void;
/** A captured generation can replace only its current projection; missing keys return to defaults. */
export declare function replaceInterfaceProfile(identity: object, values: Projection): boolean;
/** Announcements capture the profile that performed the acknowledged local write. */
export declare const interfaceProfileOwner: () => string | undefined;
/** Full projection identity changes even for Alice → Bob → Alice and replaced same-account sessions. */
export declare const interfaceProfileIdentity: () => {
    owner: string | undefined;
};
export {};

import type { AccountSession } from "./server";
import type { SourceId } from "./sources";
/** Trophy refresh belongs to the captured account/source, including its retained unlock write. */
export declare function createAchievementLoading(session: () => AccountSession | undefined, source: () => SourceId): {
    current: () => import("./achievements").Achievements | undefined;
    loading: () => boolean;
    pending: () => boolean;
    error: () => string;
    cancel(): void;
    refetch: () => void | Promise<void | undefined> | null;
};

export interface Achievement {
    slot: number;
    unlocked_at: number | null;
    title?: {
        fr: string;
        en: string;
    };
    description?: {
        fr: string;
        en: string;
    };
    icon?: string;
}
export interface Achievements {
    items: Achievement[];
    total: number;
    unlocked: number;
}
/** Refuse leaked locked details, duplicated slots and inconsistent confirmed counts. */
export declare function parseAchievements(raw: unknown): Achievements;

export interface SearchCriteria {
    text: Record<string, string>;
    ranges: Record<string, [string, string]>;
    formats: readonly string[];
    scope: "any" | "track" | "album" | "artist";
    favourite: "" | "true" | "false";
    lossless: "" | "true" | "false";
    compilation: "" | "true" | "false";
}
export declare const blankSearch: () => SearchCriteria;
export declare const searchTextFields: readonly ["title", "artist", "album", "albumartist", "genre", "label", "path", "comment", "work", "composer", "performer", "instrument", "tag", "note"];
export declare const searchRanges: readonly ["year", "samplerate", "bitdepth", "channels", "bitrate", "duration", "size", "played", "rating"];
/** Adjacent quoted segments preserve both quote characters in Aède's existing tokenizer. */
export declare const quoteQuery: (value: string) => string;
/** Serialize controls to the engine grammar; never evaluate personal/audio rules in the UI. */
export declare function advancedExpression(criteria: SearchCriteria): string;
/** A queue collection retains membership; M3U retains its order and repeated occurrences. */
export declare function queueExpression(references: readonly string[]): string;

import type { AccountSession } from "./server";
import type { SourceId } from "./sources";
type Request = (path: string, query: Record<string, string>, method: string, body: unknown, source: SourceId, owner?: AccountSession) => Promise<unknown>;
/** One explicit advanced-search page and its optional first-page achievement. */
export declare function readAdvancedTrackPage(request: Request, source: SourceId, expression: string, at: number, session: () => AccountSession | undefined, current: () => boolean): Promise<unknown>;
export {};

import type { SourceId } from "./sources";
/** Readable diagnostics never expose the JavaScript Error wrapper. */
export declare function errorMessage(value: unknown): string;
/** Recognize only the bridge's transport refusal, not permissions, cache failures or other services. */
export declare function isAedeConnectionError(value: unknown): boolean;
/** Reachability belongs to the exact native login; old replies cannot affect another account. */
export declare function createAedeAvailability(): {
    owner(source: SourceId, ticket?: string): void;
    success(source: SourceId, ticket: string | undefined): void;
    recovery: import("solid-js").Accessor<number>;
    failure(source: SourceId, ticket: string | undefined, failure: unknown): void;
    ownsSession: () => boolean;
    unavailable: () => ("local" | "server")[];
};
/** Shared by typed IPC and the application-wide outage notice, including both catalogue sources. */
export declare const aedeAvailability: {
    owner(source: SourceId, ticket?: string): void;
    success(source: SourceId, ticket: string | undefined): void;
    recovery: import("solid-js").Accessor<number>;
    failure(source: SourceId, ticket: string | undefined, failure: unknown): void;
    ownsSession: () => boolean;
    unavailable: () => ("local" | "server")[];
};
/** Shared outage notices replace only transport messages; actionable refusals stay beside the action. */
export declare function inlineAedeError(value: unknown, centralized: boolean): string;
/** Only failed reads opt in: a confirmed recovery retries them once, never a write or playback action. */
export declare function retryAedeReadOnRecovery(error: () => unknown, retry: () => unknown): void;

import type { Album } from "./types";
import type { Annotation } from "./server";
/** Keep sourced genre tags distinct from owner annotations; personal tags remain searchable. */
export declare function annotateAlbum(album: Album, personal: Annotation | undefined): Album;

import { type Language } from "../i18n";
/** Shared standalone album count; exactly one uses the singular, including in French. */
export declare function albumCount(value: number, language: Language): string;

import { type SourceId } from "./sources";
import type { AccountSession } from "./server";
import type { Job } from "./jobs";
/** Aède track keys are literal file paths; unwrap only Phémios's leading source qualifier. */
export declare function integrityPath(reference: string): string | undefined;
export interface IntegrityResult {
    status: "ok" | "ko" | "no_hash";
    verifier: string;
    message?: string;
}
/** Exact current files must all be represented; truncated/foreign output never becomes a verdict. */
export declare function parseIntegrityResults(output: NonNullable<Job["result"]>, paths: readonly string[], partial?: boolean): Map<string, IntegrityResult>;
/** One mounted album owns only the check it explicitly starts; historical task results stay invisible. */
export declare function createAlbumIntegrity(options: {
    release: () => string;
    session: () => AccountSession | undefined;
    paths: () => readonly string[];
    jobs: () => readonly Job[];
    start: (release: string) => Promise<number>;
    cancel: (id: number, source: SourceId) => Promise<unknown>;
}): {
    busy: () => boolean;
    canCancel: () => boolean;
    enabled: () => boolean;
    result: (path: string | undefined) => IntegrityResult | undefined;
    error: () => string;
    start(): Promise<void>;
    cancel(): Promise<void>;
};
/** A disclosure belongs to one failed verdict object; a fresh result never inherits its open state. */
export declare function createIntegrityDisclosure(result: () => IntegrityResult | undefined): {
    open: () => boolean;
    toggle(): void;
    close(): void;
};

import type { AccountSession } from "./server";
import { type SourceId } from "./sources";
interface ListeningPage {
    total: number;
    offset: number;
    items: {
        reference: string;
        completed: boolean;
    }[];
}
/** A completion answer is private, bounded and source-qualified; an absent answer is unknown. */
export declare function parseAlbumListening(raw: unknown, source: SourceId, offset: number): ListeningPage;
/** Refresh only on account or confirmed transport milestones, never on clock/volume ticks. */
export declare function createAlbumListening(options: {
    enabled: () => boolean;
    session: (source: SourceId) => AccountSession | undefined;
    checkpoint: () => string;
}): {
    completed: (reference: string) => boolean | undefined;
    error: () => string;
};
export {};

import { createQueueLyrics } from "./queue-lyrics-controller";
/** The app owns an album batch, so navigating away never interrupts its remaining downloads. */
export declare function createAlbumLyrics(options: Omit<Parameters<typeof createQueueLyrics>[0], "queue">): {
    controller: {
        busy: import("solid-js").Accessor<boolean>;
        bulkOperation: () => boolean;
        bulkBusy: () => boolean;
        trackBusy: (reference: string) => boolean;
        message: () => string;
        failed: () => boolean;
        eligible: (reference?: string) => boolean;
        available: (reference: string) => boolean | undefined;
        synced: (reference: string) => boolean | undefined;
        acquiring: () => string;
        retained: () => {
            complete: boolean;
            error: string;
        } | undefined;
        retainedLoading: () => boolean;
        acquire: (reference?: string) => Promise<void>;
        cancel: () => Promise<void>;
        clear: () => "";
    };
    target: () => string;
    select(release: string, tracks: readonly {
        reference: string;
        title: string;
    }[]): boolean;
};

import type { AccountSession } from "./server";
/** Admit only the edition's explicit, bounded, same-origin label associations. */
export declare function albumLabelReferences(raw: unknown, reference: string): string[];
/** Existing catalogue detail reads resolve display names; no external enrichment or raw-tag guesses. */
export declare function albumLabels(reference: string, admission?: {
    owner: AccountSession;
    current: () => boolean;
}): Promise<{
    reference: string;
    name: string;
}[]>;

import { type MissingAlbum } from "./missing";
import type { Album } from "./types";
export interface AlbumEntry {
    album: Album;
    missing?: MissingAlbum;
}
/** Discographies interleave attributed gaps by year; ordinary lists retain their caller's order. */
export declare function albumEntries(albums: readonly Album[], missing?: readonly MissingAlbum[], chronological?: boolean, reverse?: boolean): AlbumEntry[];

import type { Track, AccountSession } from "./server";
export interface AlbumTrack extends Track {
    disc_no: number | null;
    track_no: number | null;
    album_position: number;
    analysis_available: boolean;
    spectrum_available: boolean;
}
/** Unknown disc numbers do not establish a multi-disc release. */
export declare function hasMultipleDiscs(tracks: readonly Pick<AlbumTrack, "disc_no">[]): boolean;
/** Fetch lightweight album-order pages; analyses are loaded only when explicitly expanded. */
export declare function albumTracks(reference: string, admission?: {
    owner: AccountSession;
    current: () => boolean;
}): Promise<AlbumTrack[]>;
/** Preserve server queue order and absolute play indices, including identical titles on different CDs. */
export declare function discGroups(tracks: readonly AlbumTrack[]): {
    disc: number | null;
    tracks: {
        track: AlbumTrack;
        index: number;
        number: number;
    }[];
}[];

export interface CoverageCounts {
    current: number;
    stale: number;
    failed: number;
    missing: number;
}
export interface IntegrityCounts {
    ok: number;
    ko: number;
    no_hash: number;
    unchecked: number;
    unsupported: number;
    stale: number;
    md5: number;
    crc: number;
}
export interface CoverageAlbum extends CoverageCounts {
    reference: string;
    title: string;
    artist: string | null;
    tracks: number;
    spectra: number;
    integrity?: IntegrityCounts;
}
export interface CoveragePage {
    items: CoverageAlbum[];
    total: number;
    offset: number;
    scanned_at: number;
    summary: CoverageCounts & {
        files: number;
    };
}
/** Complete lightweight pages distinguish unavailable/stale data from measured zero coverage. */
export declare function parseCoverage(value: unknown, offset: number, epoch: number | undefined): CoveragePage;

/** Compatibility entry point for the retained-measurement projection. */
export { analysisMeasurements as analysisGraphs } from "../analysis-report/measurements";

interface Report {
    md5: string;
    stale: boolean | undefined;
    error: string;
    summary: string;
    eventCount: number | undefined;
    clipped: boolean | undefined;
}
/** Integrity and detection conclusions are independent of artistic/audio quality. */
export declare function analysisReading(data: Report): {
    tone: string;
    label: string;
    detail: string;
}[];
export declare const measurementHelp: Record<string, string>;
export {};

import type { AccountSession, Annotation } from "./server";
import { type SourceId } from "./sources";
interface Options {
    session: (source: SourceId) => AccountSession | undefined;
    request: (source: SourceId, offset: number) => Promise<unknown>;
    clear: (source: SourceId) => void;
    publish: (source: SourceId, rows: readonly Annotation[]) => void;
    error: (failure: string) => void;
}
/** Accept all canonical Aède entity kinds, even without a dedicated detail view.
 * Validate private values without interpreting note markup or fabricating absent ratings.
 */
export declare function parseAnnotation(raw: unknown, reference?: string): Annotation;
/** Aède always identifies the requested target outside the nullable annotation.
 * Validate that identity even for an empty response; a nested annotation must agree too.
 */
export declare function parseAnnotationResponse(raw: unknown, reference: string): Annotation | null;
/** Complete source snapshots are published only for the captured session/read generation.
 * Reset clears that source immediately; another source's private rows remain untouched.
 * Paging has a 1M-row / 100 MiB serialized bound and preserves confirmed concurrent edits.
 */
export declare function createAnnotationLoader(options: Options): {
    load: (source: SourceId) => Promise<void>;
    reset(source: SourceId): void;
    updated(reference: string, row: Annotation | null): void;
    dispose(): void;
};
export {};

import type { AccountSession } from "./server";
/** Detail reads expose only their exact reference/session scope, including after logout.
 * Solid resources may retain a previous value while disabled or loading; this facade hides it.
 * Errors stay inside the optional panel. Refetch preserves same-owner drafts in the caller.
 */
export declare function createAnnotationRead(reference: () => string, session: () => AccountSession | undefined, request: (reference: string) => Promise<unknown>): {
    scope: import("solid-js").Accessor<{
        reference: string;
        session: AccountSession | undefined;
    }>;
    current: () => import("./server").Annotation | null | undefined;
    loading: () => boolean;
    error: () => string;
    refetch: (info?: unknown) => Promise<{
        scope: {
            reference: string;
            session: AccountSession | undefined;
        };
        annotation: import("./server").Annotation | null;
        error: string;
    } | {
        scope: {
            reference: string;
            session: AccountSession | undefined;
        };
        annotation: undefined;
        error: string;
    } | undefined> | {
        scope: {
            reference: string;
            session: AccountSession | undefined;
        };
        annotation: import("./server").Annotation | null;
        error: string;
    } | {
        scope: {
            reference: string;
            session: AccountSession | undefined;
        };
        annotation: undefined;
        error: string;
    } | null | undefined;
};

import type { AccountSession } from "./server";
/** Presentation object changes must not restart an entity's private reads or write queue. */
export declare function annotationScope(reference: () => string, session: () => AccountSession | undefined): import("solid-js").Accessor<{
    reference: string;
    session: AccountSession | undefined;
}>;

import type { Annotation } from "./server";
export type AnnotationPatch = Partial<Pick<Annotation, "rating" | "loved" | "note" | "tags">>;
/** Serialize explicit field patches; validate exact targets only while the captured session is active. */
export declare function annotationWriter(options: {
    reference: string;
    active: () => boolean;
    request: (patch: AnnotationPatch) => Promise<unknown>;
    publish: (annotation: Annotation | null) => void;
    pending: (count: number) => void;
}): {
    write(patch: AnnotationPatch): Promise<Annotation | null | undefined>;
};

import type { AccountSession } from "./server";
import type { SourceId } from "./sources";
import { type PersonalBackup } from "./application-backup";
import { type PreferenceBackup } from "./preference-backup";
type StoragePort = Pick<Storage, "getItem" | "setItem" | "removeItem">;
interface Options {
    identity: () => object;
    session: () => AccountSession | undefined;
    source: () => SourceId;
    storage: StoragePort;
    readPersonal: (source: SourceId, owner: AccountSession) => Promise<unknown>;
    restorePersonal: (payload: PersonalBackup, source: SourceId, owner: AccountSession) => Promise<void>;
    export: (raw: string, source?: SourceId, owner?: AccountSession) => Promise<string | null>;
    import: () => Promise<string | null>;
    preferencesApplied: (values: PreferenceBackup) => void;
    personalRestored: () => void;
}
/** Retain both projection generation and exact native account across private reads/dialogs/restore. */
export declare function createApplicationBackupTransfer(options: Options): {
    action: import("solid-js").Accessor<"export" | "import" | "restore" | undefined>;
    pending: () => import("./application-backup").ApplicationBackup | undefined;
    error: import("solid-js").Accessor<string>;
    message: import("solid-js").Accessor<string>;
    run: (exporting: boolean) => Promise<void>;
    changed: () => void;
    clearPending: () => undefined;
    clearError: () => "";
    clearMessage: () => "";
    apply(): Promise<void>;
    dispose(): void;
};
export {};

import { type PodcastAccountState } from "../podcasts/account-store";
import type { WikipediaArticle } from "../encyclopedia/wikipedia";
import { type PreferenceBackup } from "./preference-backup";
export interface PersonalBackup {
    origin: {
        source: "local" | "server";
        authority: string;
        accountId: string;
        name: string;
    };
    podcasts: PodcastAccountState;
    articles: WikipediaArticle[];
}
export interface ApplicationBackup {
    values: PreferenceBackup;
    personal?: PersonalBackup;
}
/** Attribution describes the source of the backup only; it never selects an import owner. */
export declare function parsePersonalBackup(raw: unknown): PersonalBackup;
/** Preferences stay compatible with v1; authenticated private records are explicit in v2. No legacy/device-private store is read. */
export declare function exportApplicationBackup(storage: Pick<Storage, "getItem">, personal?: unknown): string;
/** Validate all portable data before review, bounded by the same UTF-8 file budget as native transport. */
export declare function parseApplicationBackup(raw: string): ApplicationBackup;

import type { Artist, Album } from "./types";
/** Principal discography and credited appearances remain distinct; people without principal editions show their credits first. */
export declare function artistCatalogue(artist: Artist, albums: readonly Album[]): {
    principal: Album[];
    appearances: Album[];
    featured: Album[];
    credited: boolean;
};

/** Serial resident-art recovery for visible legacy cards; a scope is one source session/snapshot. */
export declare function createArtistLogoRecovery(options: {
    enabled: () => boolean;
    scope: (reference: string) => object | undefined;
    cached: (reference: string) => boolean;
    load: (reference: string) => Promise<void>;
    failed: (failure: unknown) => void;
}): {
    refresh: () => void;
    visibility(reference: string, active: boolean): void;
    dispose(): void;
};

import type { Album, Artist } from "./types";
import type { ArtistView } from "./tool-preferences";
/** Only principal releases form artist previews, matching chronological discography playback. */
export declare function artistDiscography(artist: Artist, related: readonly Album[]): Album[];
/** Rank the current owner's known opinions, never adding missing releases or shared ratings. */
export declare function featuredArtistAlbums(albums: readonly Album[]): Album[];
/** Read only resident art; source selection never performs enrichment or changes asset bytes. */
export declare function artistPresentationImage(view: ArtistView, read: (kind: "portrait" | "background" | "banner") => string | undefined): string | undefined;

export declare const audioPreferenceKey = "phemios.audio.v1";
export interface AudioPreferences {
    volume: number;
    crossfadeMs: number;
    repeat: "off" | "one" | "all";
    policy: "dsp" | "without-effects";
}
export declare const defaultAudioPreferences: AudioPreferences;
/** Only bounded non-secret transport policies synchronize with the account. */
export declare function parseAudioPreferences(raw: string | null): AudioPreferences;

type Scope = {
    lifetime: number;
    profile: object;
};
/** Coalesce unsent numeric audio settings within one transport/profile lifetime.
 * Retired IPC may finish; it cannot block a successor or drain its pending choice.
 * Apply must admit acknowledgements and errors with current(), and handle its failures.
 * settled() waits for the current scope only, without changing nonblocking coalesced calls.
 */
export declare function createAudioSettingQueue(scope: () => Scope, apply: (value: number, current: () => boolean, pending: () => boolean) => Promise<void>): ((value: number) => Promise<void>) & {
    settled: () => Promise<void>;
};
export {};

import type { AccountSession } from "./server";
import type { SourceId } from "./sources";
import type { Job } from "./jobs";
/** Short, owner-scoped leases protect WebKit/external audio while a native feature task is active.
 * Each source/login has its own renewal worker and lease key, with one request in flight.
 * A retired request may finish, but never delays its successor or changes its lease.
 */
export declare function createBackgroundPriority(input: {
    jobs: () => readonly Job[];
    sessions: Record<SourceId, () => AccountSession | undefined>;
    playing: () => boolean;
}): void;

export interface BiographyPart {
    text: string;
    reference?: string;
}
/** Link unambiguous full artist names only within this source; prose stays plain, escaped text. */
export declare function biographyLinker(artists: readonly {
    name: string;
    reference: string;
}[], current: string): (text: string) => BiographyPart[];
/** Single-paragraph convenience; long readers retain one compiled linker for all paragraphs. */
export declare function biographyLinks(text: string, artists: readonly {
    name: string;
    reference: string;
}[], current: string): BiographyPart[];

/** A child reader temporarily replaces the shell return action without changing catalogue history. */
export interface BiographyReturn {
    label: string;
    back: () => void;
}
export type BiographyNavigation = (value: BiographyReturn | undefined) => void;

import { type Accessor } from "solid-js";
import type { Artist } from "./types";
import { type WikipediaArticle } from "../encyclopedia/wikipedia";
import type { Language } from "../i18n";
/** One explicit attributed-title request; artist replacement/disposal cannot publish stale prose. */
export declare function createBiographyReading(artist: Accessor<Pick<Artist, "reference" | "biographyCredit">>, request: (language: Language, title: string) => Promise<unknown>, cached?: (language: Language, title: string) => Promise<unknown | null>): {
    reading: Accessor<WikipediaArticle | undefined>;
    busy: Accessor<boolean>;
    error: Accessor<string>;
    target: () => {
        language: Language;
        title: string;
    } | undefined;
    back: () => void;
    clearError: () => "";
    open(): Promise<void>;
};

import type { Language } from "../i18n";
/** An attributed Wikipedia URL identifies an exact title, never a search by artist name. */
export declare function biographyTarget(value: string | undefined): {
    language: Language;
    title: string;
} | undefined;
/** Presentation only: preserve existing NBSP and keep French punctuation with its preceding word. */
export declare function readingTypography(text: string, language: Language): string;

import type { AccountSession } from "./server";
import type { SourceId } from "./sources";
interface Options<T> {
    session: (source: SourceId) => AccountSession | undefined;
    read: (source: SourceId) => Promise<T | null>;
    publish: (source: SourceId, value: T) => void;
    failed: (failure: unknown) => void;
}
/** One startup cache per source cannot replace a subsequently engaged/synchronized projection.
 * Native IPC may finish after login, sync or disposal. Source revisions and exact session
 * objects guard data, errors and automatic startup; the other source stays independent.
 * Publishers retain responsibility for validating the admitted projection's schema.
 */
export declare function createCatalogBootstrap<T>(options: Options<T>): {
    /** Native identity is process-only and may outlive a frontend reload; never restore over an explicit action. */
    restoreSession(source: SourceId, read: (source: SourceId) => Promise<AccountSession | undefined>, publish: (source: SourceId, session: AccountSession) => void): Promise<boolean>;
    load(source: SourceId): Promise<boolean>;
    invalidate(source: SourceId): void;
    capture(source: SourceId): () => boolean;
    unused: (source: SourceId) => boolean;
    active: () => boolean;
    dispose(): void;
};
export {};

import type { AccountSession } from "./server";
import { type ReadAdmission } from "./diagnostic-read";
/** Detail facts and errors belong to one reference/login generation, including logout and re-login. */
export declare function createCatalogDetail<Value>(reference: () => string | false | null | undefined, session: () => AccountSession | undefined, read: (reference: string, session: AccountSession, admission: ReadAdmission) => Promise<Value>): {
    current: () => Value | undefined;
    loading: () => boolean;
    pending: () => boolean;
    error: () => string;
    cancel(): void;
    refetch: () => void | Promise<void | undefined> | null;
};

import type { AccountSession } from "./server";
import type { SourceId } from "./sources";
/** Poll only connected authorities; publication changes reload data without remounting views.
 * One pending probe per source, exact-login admission and disposal discard late replies.
 * Failed probes retain the cache; the existing connection monitor owns connectivity feedback.
 */
export declare function createCatalogWatch(options: {
    session: (source: SourceId) => AccountSession | undefined;
    busy: () => boolean;
    read: (source: SourceId, owner: AccountSession) => Promise<unknown>;
    refresh: (source: SourceId) => Promise<boolean>;
}): void;

/** Circular keyboard movement skips unavailable choices and never selects an absent row. */
export declare function nextChoice(options: readonly {
    disabled?: boolean;
}[], current: number, delta: 1 | -1): number;
/** Bounded, accent-insensitive typeahead with prefix expiry and repeated-letter cycling. */
export declare function createChoiceTypeahead(options: () => readonly {
    label: string;
    disabled?: boolean;
}[]): {
    reset: () => void;
    find: (key: string, at: number, current: number) => number;
};

import { type SourceId } from "./sources";
import type { AccountSession } from "./server";
import type { Album } from "./types";
/** Resolve the latest private rule into exact matching tracks, without expanding matching releases. */
export declare function readCollectionPlayback(name: string, source: SourceId, session: AccountSession, albums: readonly Album[], scannedAt: number | undefined, current: () => boolean): Promise<{
    items: {
        reference: string;
        title: string;
        release: string | null;
        number: number;
        album_total: number;
    }[];
} | undefined>;

import type { SourceId } from "./sources";
/** One atomic owner-scoped name edit, never a create/delete sequence or an expression replacement. */
export declare function renameSavedCollection(name: string, next: string, source: SourceId, isCurrent: () => boolean): Promise<boolean>;

/** A legacy API must not receive a newer browsing expression or a cross-session write. */
export declare function saveBrowsingCollection(name: string, expression: string, isCurrent: () => boolean, source?: import("./sources").SourceId): Promise<void>;
/** The caller confirms deletion and captures its owner before invoking this non-replayed mutation. */
export declare function deleteSavedCollection(name: string, source: import("./sources").SourceId, isCurrent: () => boolean): Promise<boolean>;
/** Create a new owner collection; an existing rule must not be replaced implicitly. */
export declare function createSavedCollection(name: string, expression: string, isCurrent: () => boolean, source?: import("./sources").SourceId): Promise<boolean>;

import { type CatalogTrack } from "./track-page";
import type { SourceId } from "./sources";
export interface TrackSource {
    source: SourceId;
    identity: string;
    scannedAt?: number;
}
/** Stable source order and bounded windows keep both catalogs navigable without downloading all tracks. */
export declare function combinedTrackReader(sources: readonly TrackSource[], read: (source: SourceId, offset: number, current: () => boolean) => Promise<unknown>): (offset: number, size?: number, current?: () => boolean) => Promise<{
    items: CatalogTrack[];
    total: number;
    unavailable: {
        source: SourceId;
        error: string;
    }[];
}>;

import type { Filters } from "./types";
import { type SourceId } from "./sources";
/** A collection belongs to one source, and keeps original stable composer identities. */
export declare function composerExpression(filters: Filters, source: SourceId): string;
/** The same primary credited name orders albums, identifies their alphabet landmark and labels the front cover. */
export declare function composerAlbumNames(albums: readonly import("./types").Album[], artists: readonly import("./types").Artist[], selected?: readonly string[]): ReadonlyMap<string, string>;
/** The first selected credited name orders editions; titles break ties deterministically. */
export declare function composerAlbumOrder(albums: readonly import("./types").Album[], artists: readonly import("./types").Artist[], selected?: readonly string[], reverse?: boolean): import("./types").Album[];

/** Admit an explicit native key-removal attempt from the retained configuration status. */
export declare function canRemoveConcertKey(native: boolean, busy: boolean, status: {
    ready: boolean;
    error?: string;
} | undefined): boolean;

/** An older native host may still own a login after the interface reloads. Keep an explicit exit. */
export declare function activeNativeSessionConflict(value: unknown): boolean;

/** Probe only an explicitly opened session; stop ignores late answers and cancels polling. */
export declare function connectionMonitor(probe: () => Promise<void>, changed: (online: boolean) => void): {
    start(): void;
    stop(): void;
};

import { createNetworkAudio } from "../network-audio/controller";
import { createDisplayAwake } from "./display-awake";
import { createAlbumLyrics } from "./album-lyrics";
import { createParentalAccess } from "./parental-access";
import { createRetainedSearch } from "./retained-search";
import { createQueueLyrics } from "./queue-lyrics-controller";
import { createSavedSettings } from "./saved-settings";
import { createTagPreferences } from "./tag-preferences";
import { createMissingCoverLoader } from "./missing-artwork";
import { createMissingCatalog } from "./missing";
import { type SourceId } from "./sources";
import { type ParentProps, type Accessor } from "solid-js";
import { createAccountPodcasts } from "../podcasts/account-store";
import { createPodcastPlayback } from "../podcasts/playback";
import { createRadioPlayback } from "../radio/playback";
import { createPlayback } from "./playback";
import { createJobs } from "./jobs";
import { type AccountSession, type Snapshot, type Annotation } from "./server";
import type { Artist, Album } from "./types";
interface Library {
    displayAwake: ReturnType<typeof createDisplayAwake>;
    parental: ReturnType<typeof createParentalAccess>;
    queueLyrics: ReturnType<typeof createQueueLyrics>;
    albumLyrics: ReturnType<typeof createAlbumLyrics>;
    savedSettings: ReturnType<typeof createSavedSettings>;
    missing: ReturnType<typeof createMissingCatalog>;
    missingArtwork: {
        image: (row: import("./missing").MissingAlbum) => string | undefined;
        error: (row: import("./missing").MissingAlbum) => string | undefined;
        load: (row: import("./missing").MissingAlbum, retry?: boolean) => Promise<void>;
        status: (row: import("./missing").MissingAlbum) => ReturnType<ReturnType<typeof createMissingCoverLoader>["status"]>;
    };
    networkAudio: ReturnType<typeof createNetworkAudio>;
    player: ReturnType<typeof createPlayback>;
    radio: ReturnType<typeof createRadioPlayback>;
    podcast: ReturnType<typeof createPodcastPlayback>;
    podcastListened: ReturnType<typeof createAccountPodcasts>;
    podcastSubscriptions: ReturnType<typeof createAccountPodcasts>;
    tasks: ReturnType<typeof createJobs>;
    artists: Accessor<readonly Artist[]>;
    albums: Accessor<readonly Album[]>;
    demo: boolean;
    session: Accessor<AccountSession | undefined>;
    serverSession: Accessor<AccountSession | undefined>;
    localSession: Accessor<AccountSession | undefined>;
    source: Accessor<SourceId>;
    origins: Accessor<readonly SourceId[]>;
    advancedSearch: ReturnType<typeof createRetainedSearch>;
    trackSources: Accessor<readonly import("./combined-tracks").TrackSource[]>;
    chooseSource: (source: SourceId) => void;
    sessionFor: (reference: string) => AccountSession | undefined;
    enableLocal: () => Promise<void>;
    disableLocal: () => Promise<void>;
    busy: Accessor<boolean>;
    connected: Accessor<boolean>;
    error: Accessor<string>;
    snapshot: Accessor<Snapshot | undefined>;
    /** Public projection remains readable after logout, without private annotations. */
    publicSnapshot: (source: SourceId) => Snapshot | undefined;
    serverCache: Accessor<Snapshot | undefined>;
    serverCacheHidden: Accessor<boolean>;
    setServerCacheHidden: (hidden: boolean) => void;
    clearServerCache: () => Promise<void>;
    connect: (server: string, username: string, password: string, certificate?: number[]) => Promise<void>;
    sync: (source?: SourceId) => Promise<void>;
    disconnect: () => Promise<void>;
    image: (reference: string, kind: string) => string | undefined;
    imageError: (reference: string, kind: string) => string | undefined;
    warmImage: (reference: string, kind: string) => Promise<void>;
    mediaProgress: Accessor<readonly [number, number]>;
    mediaErrors: Accessor<number>;
    updateAnnotation: (reference: string, value: Annotation | null) => void;
    annotations: Record<string, Annotation | undefined>;
    tagPreferences: ReturnType<typeof createTagPreferences>;
}
/** Public catalog is cached; own annotations and session secrets remain separate. */
export declare function LibraryProvider(props: ParentProps): import("solid-js").JSX.Element;
export declare function useLibrary(): Library;
export {};

export type CoverageColumn = "title" | "current" | "missing" | "stale" | "failed" | "spectra" | "integrity";
export interface CoverageSort {
    column: CoverageColumn;
    direction: "asc" | "desc";
}
/** Missing counts descend on opening; clicking the selected column reverses its order. */
export declare const initialCoverageSort: CoverageSort;
export declare function nextCoverageSort(current: CoverageSort, column: CoverageColumn): CoverageSort;

/** Decimal file sizes match Finder; unknown facts never become zero. */
export declare function fileSize(bytes: number): string;
/** Use FlacCompagnon's rounded minute/second clock for a singular track. */
export declare function trackDuration(ms: number | null): string;
/** Unknown aggregates stay blank; complete hours use H:MM:SS without wrapping at 24 hours. */
export declare function collectionDuration(ms: number | null | undefined): string;

/** Read cancellation retires presentation admission; an already dispatched native request may finish. */
export interface ReadAdmission {
    current: () => boolean;
}
/** Reads retain owner-scoped confirmations, handle errors locally and refuse overlapping explicit retries. */
export declare function createDiagnosticRead<Scope extends object, Value>(scope: () => Scope | false, request: (scope: Scope, admission: ReadAdmission) => Promise<Value>): {
    current: () => Value | undefined;
    loading: () => boolean;
    pending: () => boolean;
    error: () => string;
    cancel(): void;
    refetch: () => void | Promise<void | undefined> | null;
};

import { openAwakeScope, updateAwakeScope } from "../platform/desktop";
/** Only confirmed playing states inhibit idle; connection attempts and pauses never do. */
export declare const anyAudioPlaying: (...statuses: readonly string[]) => boolean;
/** Global playback-owned lease, separate from view navigation and serialized through final release. */
export declare function createDisplayAwake(input: {
    native: boolean;
    playing: () => boolean;
}, backend?: {
    open: typeof openAwakeScope;
    update: typeof updateAwakeScope;
}): {
    enabled: import("solid-js").Accessor<boolean>;
    active: import("solid-js").Accessor<boolean>;
    error: () => string;
    setEnabled(value: boolean): void;
};

import type { Album, Artist, Filters, RailMode } from "./types";
export interface CountBin {
    value: number;
    count: number;
}
/** Each icon independently toggles its rail; none disables both interval filters. */
export declare function toggleRail(mode: RailMode, rail: "years" | "alphabet"): RailMode;
/** Each histogram ignores its own interval and respects the other visible filters.
 * Artist counts deduplicate multiple releases from the same artist in a year.
 */
export declare function distributions(artists: readonly Artist[], albums: readonly Album[], filters: Filters, artistView: boolean, nowSeconds?: number): {
    years: CountBin[];
    alphabet: CountBin[];
};

export type Severity = "error" | "warning" | "info";
export interface DoctorIssue {
    type: string;
    label: string;
    severity: Severity;
    detail: string;
    files: string[];
    file_count: number;
    files_truncated: boolean;
}
/** Validate diagnostic pages before showing findings; no repair is implied by a diagnosis. */
export declare function parseDoctor(value: unknown, offset: number): {
    items: DoctorIssue[];
    total: number;
    offset: number;
    limit: number;
    scanned_at: number;
    summary: {
        error: number;
        warning: number;
        info: number;
    };
    unverified_files: number;
    pending_analyses: number;
};
export declare const severityLabels: Record<Severity, string>;
export declare const issueLabels: Record<string, string>;

/** One bounded success timer; late completions cannot acknowledge a replaced target. */
export declare function createDownloadFeedback(): {
    phase: import("solid-js").Accessor<"busy" | "complete" | "idle">;
    reset: () => void;
    complete: () => void;
    run(action: () => unknown | Promise<unknown>, confirm?: boolean): Promise<void>;
};

import type { Job } from "./jobs";
import type { SourceId } from "./sources";
/** Explicit operations share one configuration but report every source's independent outcome. */
export declare function startEnrichment(sources: readonly SourceId[], start: (source: SourceId) => Promise<{
    task_id: number;
}>): Promise<({
    source: SourceId;
    task: number;
} | {
    source: SourceId;
    error: string;
})[]>;
/** Explicit job flags plus bounded engine-owned selectors; the server validates supported combinations. */
export type EnrichmentOptions = Record<string, boolean | string | string[]>;
/** Confirm additive enrichment capabilities before submitting a non-replayed job on the captured login. */
export declare function startSourceEnrichment(source: SourceId, options: EnrichmentOptions, isCurrent: () => boolean): Promise<{
    task_id: number;
}>;
/** Unknown tracking outcomes remain active until Aède confirms completion or the session changes. */
export declare function hasActiveEnrichment(jobs: readonly Job[]): boolean;
/** Keep active work visible and limit completed diagnostics without deleting Aède task records. */
export declare function visibleEnrichmentJobs(jobs: readonly Job[]): Job[];
/** Settings display the initiating profile's launch result; accepted jobs retain their own lifetime. */
export declare function completeEnrichmentLaunch(options: {
    current: () => boolean;
    launch: () => Promise<Awaited<ReturnType<typeof startEnrichment>> | undefined>;
    confirm: (results: Awaited<ReturnType<typeof startEnrichment>>) => void;
    failure: (failure: unknown) => void;
}): Promise<void>;

/** Four decorative envelopes of actual output RMS, never random or a frequency spectrum. */
export declare function equalizerHeights(previous: readonly number[], level: number): number[];

import type { AccountSession } from "./server";
/** The engine owns exclusions; the UI retains only a selection and admitted operation feedback. */
export declare function createExcludedFolders(options: {
    session: () => AccountSession | undefined;
    page: (offset: number, owner: AccountSession) => Promise<unknown>;
    pick: (current: () => boolean) => Promise<string[]>;
    change: (path: string, action: "exclude" | "include") => Promise<void>;
}): {
    read: {
        current: () => string[] | undefined;
        loading: () => boolean;
        pending: () => boolean;
        error: () => string;
        cancel(): void;
        refetch: () => void | Promise<void | undefined> | null;
    };
    busy: import("solid-js").Accessor<boolean>;
    error: import("solid-js").Accessor<string>;
    selection: () => string | undefined;
    select: import("solid-js").Setter<string | undefined>;
    add: () => Promise<void>;
    remove: (path?: string | undefined) => Promise<void>;
};

/** Local export metadata and feedback belong to one exact owner/target projection.
 * Replaced projections hide synchronously; captured actions cannot revive them after a round trip.
 */
export declare function createExportState<Scope, File>(scope: () => Scope): {
    file: () => File | undefined;
    busy: () => boolean;
    message: () => string;
    failed: () => boolean;
    dismiss: () => void;
    begin(): {
        scope: Scope;
        current: () => boolean;
        file(file: File): void;
        feedback(message: string, failed?: boolean): void;
        finish(): void;
    } | undefined;
};

/** Explicitly integrated providers, independent of whether a key or account is configured. */
export declare const externalServices: {
    name: string;
    url: string;
}[];
/** The component explorer can render product rows without loading a native application manifest. */
export declare const dependencyCredits: readonly {
    name: string;
    version: string;
    ecosystem: string;
    url: string;
}[];

import type { AccountSession, Annotation } from "./server";
/** A footer heart writes only the captured track, never the current page or a later account. */
export declare function createFavouriteControl(reference: () => string, session: () => AccountSession | undefined, loved: () => boolean, publish: (reference: string, annotation: Annotation | null) => void): {
    toggle: () => Promise<void>;
    blocked: () => boolean;
    busy: () => boolean;
    error: () => string;
};

import type { Album } from "./types";
import type { Annotation } from "./server";
/** Favourite artists contribute owned principal discography, not every supporting credit. */
export declare function favouriteAlbums(albums: readonly Album[], annotations: Readonly<Record<string, Annotation | undefined>>): Album[];

/** Transient feedback pauses for reading; each new message owns its own timer. */
export declare function createFeedback(message: () => string, delay: () => number): {
    visible: import("solid-js").Accessor<boolean>;
    close: () => void;
    pause(value: boolean): void;
};

import type { Album, Artist, Filters, Interval } from "./types";
/** Accent/case/Latin-ligature folding used only for presentation search. */
export declare function normalizeName(value: string): string;
/** Nonletter or empty initials belong to the explicit # bucket. */
export declare function initialIndex(name: string): number;
/** Shift an interval without resizing it, clamping at either domain edge. */
export declare function shiftInterval(range: Interval, delta: number, domain: Interval): Interval;
/** Inclusive year matching; unknown years remain an explicit opt-in. */
export declare function matchesYear(album: Album, filters: Filters): boolean;
/** Alphabet intervals apply to the entity names in the current list. */
export declare function matchesAlphabet(name: string, filters: Filters): boolean;
/** Search indexes cover supplied tags, fetched presentation fields and loaded own annotations. */
export declare function searchAlbum(album: Album, artist: Artist | undefined, query: string): boolean;
export declare function searchArtist(artist: Artist, query: string): boolean;
/** Facets remain visible in the filter bar when the navigation view changes. */
export declare function matchesFacets(artist: Artist, filters: Filters): boolean;
/** Contributions retain the credited artist without changing an album's primary artist. */
export declare function belongsToArtist(album: Album, artist: Artist): boolean;
/** Artist year matching uses its releases; alphabet matching uses its own name. */
export declare function filterArtists(artists: readonly Artist[], albums: readonly Album[], filters: Filters): Artist[];
/** Album filtering never mutates the catalog and preserves each edition. */
export declare function filterAlbums(albums: readonly Album[], artists: readonly Artist[], filters: Filters, nowSeconds?: number): Album[];
/** Legacy scalar and current multi-selection share union semantics. */
export declare function selectedGenres(filters: Filters): readonly string[];
/** A union of exact, source-qualified composer identities; never inferred from album artists. */
export declare function matchesComposers(album: Album, filters: Filters): boolean;

import type { SourceId } from "./sources";
import type { AccountSession } from "./server";
import type { GenerationStep } from "./generation-policy";
import type { Job } from "./jobs";
/** Generation command feedback belongs to its settings view, not the server-owned job. */
export declare function createGenerationActions(options: {
    source: () => SourceId;
    session: (source: SourceId) => AccountSession | undefined;
    active: () => Job | undefined;
    start: (source: SourceId, steps: readonly GenerationStep[]) => Promise<unknown>;
    cancel: (id: number, source: SourceId) => Promise<unknown>;
}): {
    error: () => string;
    start(steps: readonly GenerationStep[]): Promise<void>;
    cancel(): Promise<void>;
};

import type { AccountSession } from "./server";
import type { SourceId } from "./sources";
import type { Job } from "./jobs";
import { type GenerationStep } from "./generation-policy";
/** Server-owned plans survive view closure; admission stays tied to the captured authenticated source. */
export declare function createGenerations(options: {
    jobs: () => readonly Job[];
    session: (source: SourceId) => AccountSession | undefined;
    recover?: (source: SourceId) => Promise<unknown>;
    accepted: (task: {
        task_id: number;
        status: "queued";
    }, kind: string, source: SourceId) => void;
}): {
    start: (source: SourceId, input: readonly GenerationStep[]) => Promise<number>;
    pending: import("solid-js").Accessor<{
        source: SourceId;
        owner: AccountSession;
        steps: readonly GenerationStep[];
    } | undefined>;
};

import type { Job } from "./jobs";
/** Fixed server stages in the default whole-library sequence. */
export declare const generationSteps: readonly ["analyze", "spectrum", "m3u", "lyrics"];
export type GenerationStep = (typeof generationSteps)[number];
/** Reject empty, duplicate and unknown work instead of silently changing a plan. */
export declare function validGenerationSteps(value: readonly string[]): value is readonly GenerationStep[];
/** Queued and interrupted tracking still reserve admission until the server confirms termination. */
export declare function administrativeWorkActive(jobs: readonly Job[]): boolean;
/** Restored server kinds retain which action owns the button loader without private client state. */
export declare function generationForJob(job: Job): GenerationStep | "all" | undefined;

import type { HistoryRow } from "./personal-reads";
/** History visits retain their underlying playback identity independently of album membership. */
export declare function historyTrackAction(row: Pick<HistoryRow, "track" | "release" | "error">): {
    href: string;
    reference: string;
    disabled: boolean;
};

import type { AccountSession } from "./server";
import type { PlayableSelection } from "./playback-selection";
/** Current output is a separate ephemeral row, never a confirmed listen or an extra history write. */
export declare function currentHistoryListen(input: {
    item: PlayableSelection | undefined;
    owner: AccountSession | undefined;
    session: AccountSession | undefined;
    status: string;
    offset: number;
}): PlayableSelection | undefined;

export interface HqPlayerSettings {
    host: string;
    port: number;
    from: string;
    to: string;
}
export declare const hqPlayerKey = "phemios.hqplayer.v1";
export declare const defaultHqPlayer: HqPlayerSettings;
/** Device-bound non-secret settings are retained locally, never replayed as a connection. */
export declare function readHqPlayer(raw: string | null): HqPlayerSettings;

import type { Album, Artist } from "./types";
interface Index {
    artistsByAlbum: Map<string, Artist[]>;
    albumsByArtist: Map<string, Album[]>;
}
/** Index immutable snapshots once; typing and scrolling never scan the cross product. */
export declare function catalogIndex(artists: readonly Artist[], albums: readonly Album[]): Index;
/** Artist cards play the artist's principal discography; illustration never selects the queue. */
export declare function artistCardSelection(artist: Artist, related: readonly Album[]): {
    reference: string;
    title: string;
    cover: Album | undefined;
};
export {};

import type { SourceId } from "./sources";
/** Serialize catalog refreshes outside task polling, with at most one queued read per source.
 * Captured owners guard queued work; later completions get a fresh read after the active one.
 */
export declare function createJobRefresh(changed: (source: SourceId) => Promise<void>): {
    request(source: SourceId, current: () => boolean): Promise<void>;
    dispose(): void;
};

import type { EnrichmentOptions } from "./enrichment";
import { type FeatureProgress } from "./mood-features";
import type { AccountSession } from "./server";
import { type SourceId } from "./sources";
export interface Job {
    source?: SourceId;
    task_id: number;
    status: "queued" | "running" | "completed" | "failed" | "cancelled";
    kind?: string;
    release?: string;
    task_kind?: string;
    result?: {
        exit_code: number;
        stdout: string;
        stderr: string;
        output_truncated: boolean;
    };
    partial_result?: Job["result"];
    error?: {
        message: string;
    };
    tracking_error?: string;
    progress?: FeatureProgress;
}
/** Activity is sourced from confirmed tasks, not a timer pretending to measure progress. */
export declare function activeReleaseJob(jobs: readonly Job[], release: string): Job | undefined;
/** Retain task IDs across navigation; source generations and task revisions reject late reads. */
export declare function createJobs(connected: () => boolean, options?: {
    session: (source: SourceId) => AccountSession | undefined;
    changed: (source: SourceId) => Promise<void>;
}): {
    jobs: import("solid-js").Accessor<Job[]>;
    error: () => string;
    start: (kind: "analyze" | "spectrum" | "lyrics" | "check", release: string, force: boolean) => Promise<number>;
    cancel: (id: number, source?: SourceId) => Promise<void>;
    track: (result: {
        task_id: number;
        status?: Job["status"];
    }, kind: string, source: SourceId, release?: string) => void;
    restore: (source: SourceId) => Promise<void>;
    enrich: (sources: readonly SourceId[], input: EnrichmentOptions) => Promise<({
        source: SourceId;
        task: number;
    } | {
        source: SourceId;
        error: string;
    })[] | undefined>;
    enrichmentPending: import("solid-js").Accessor<boolean>;
    features: (source: SourceId) => Promise<number>;
    generate: (source: SourceId, input: readonly import("./generation-policy").GenerationStep[]) => Promise<number>;
    generationPending: import("solid-js").Accessor<{
        source: SourceId;
        owner: AccountSession;
        steps: readonly import("./generation-policy").GenerationStep[];
    } | undefined>;
};

import type { Album, Artist, Filters, Interval } from "./types";
import type { CountBin } from "./distribution";
/** Label histograms count editions, including compilations with no principal artist. */
export declare function labelHistogram(albums: readonly Album[], artists: readonly Artist[], filters: Filters): {
    years: CountBin[];
    alphabet: CountBin[];
};
/** The scoped domain never inherits another catalogue view's retained intervals. */
export declare function labelYearDomain(albums: readonly Album[]): Interval;
/** Expressions hold original Aède identities; the caller separately captures their source. */
export declare function labelExpression(reference: string, filters: Filters): string;

import { type SourceId } from "./sources";
/** Aède resolves names and ambiguity; the client admits only its exact same-origin label identity. */
export declare function labelDestination(raw: unknown, name: string, source: SourceId): string;

import type { Filters, Album } from "./types";
/** Label navigation/login replacement resets intervals; edits survive unchanged-label refreshes. */
export declare function createLabelSelection(scope: () => unknown, albums: () => readonly Album[], ready: () => boolean): {
    filters: import("solid-js").Accessor<Filters>;
    setFilters: import("solid-js").Setter<Filters>;
    reverse: import("solid-js").Accessor<boolean>;
    setReverse: import("solid-js").Setter<boolean>;
};

import { type SourceId } from "./sources";
export interface LabelSummary {
    reference: string;
    name: string;
    releaseCount: number;
}
export interface LabelDetail {
    reference: string;
    name: string;
    releases: string[];
    biography?: {
        text: string;
        url: string;
        lang: string;
        licence: string;
        source: string;
    };
}
/** Labels retain their exact source-qualified identity and their known album count. */
export declare function parseLabel(raw: unknown): LabelSummary;
/** Licensed prose is inseparable from its attribution; HTML is never rendered from it. */
export declare function parseLabelDetail(raw: unknown, reference: string): LabelDetail;
/** One bounded list window per source; invalid epochs and duplicate identities fail explicitly. */
export declare function parseLabelPage(raw: unknown, offset: number, source: SourceId, epoch?: number): {
    items: LabelSummary[];
    total: number;
};

import type { createJobs } from "./jobs";
import type { AccountSession } from "./server";
import type { SourceId } from "./sources";
/** One settings projection selects a scan; the library owns its tracking across navigation. */
export declare function createLibraryScan(options: {
    session: (source: SourceId) => AccountSession | undefined;
    tasks: Pick<ReturnType<typeof createJobs>, "jobs" | "track" | "restore" | "cancel">;
}): {
    task: () => import("./jobs").Job | undefined;
    source: () => SourceId;
    start(source: SourceId, submit: (owner: AccountSession) => Promise<{
        task_id: number;
        status: "queued";
    }>): Promise<boolean>;
    refresh(): Promise<void>;
    cancel(): Promise<void>;
};

interface Storage {
    getItem(key: string): string | null;
    setItem(key: string, value: string): void;
}
interface LoginPreference {
    server: string;
    username: string;
}
/** Remember only public login metadata; malformed stored data is preserved and reported. */
export declare function readLoginPreference(storage: Storage): LoginPreference | undefined;
/** Store a successful login name, never the password, bearer token or private annotations. */
export declare function saveLoginPreference(storage: Storage, server: string, username: string): void;
export {};

export interface Lyrics {
    source: string;
    synced: boolean;
    lines: {
        at_ms: number | null;
        text: string;
    }[];
}
/** Preserve supplied timestamps and untimed lines without inventing synchronization. */
export declare function parseLyrics(raw: unknown, reference: string): Lyrics | null;
export declare function activeLyricTime(lyrics: Lyrics | null | undefined, position: number): number | null;
/** Only supplied timed groups may drive the Playback phrase; plain text has no invented clock. */
export declare function currentLyricText(lyrics: Lyrics | null | undefined, position: number): string;

import { type Accessor } from "solid-js";
import type { AccountSession } from "./server";
import type { SourceId } from "./sources";
import { type M3UKind } from "./m3u-files";
export interface M3UScope {
    session: AccountSession;
    source: SourceId;
    kind: M3UKind;
    offset: number;
    query: string;
}
type Request = (path: string, query: Record<string, string>, source: SourceId) => Promise<unknown>;
/** Resolved failures keep recovery controls mounted; owner/category/page changes hide retained details immediately. */
export declare function createM3UBrowser(scope: Accessor<M3UScope | undefined>, request: Request): {
    page: () => import("./m3u-files").M3UPageData | undefined;
    error: () => string;
    loading: () => boolean;
    refreshing: () => boolean;
    selected: () => string;
    select: (id: string) => void;
    detail: () => {
        titles: string[];
        path?: string;
        id: string;
        name: string;
        filename: string;
        content: string;
        library_files?: string[];
        source: SourceId;
    } | undefined;
    detailError: () => string;
    detailLoading: () => boolean;
    /** A delayed download may acknowledge only the exact selection that started it. */
    captureFile(input: M3UScope, id: string): () => boolean;
    refetch: () => void | Promise<void | undefined> | null;
    retryDetail: () => void | Promise<void | undefined> | null;
    pending: () => boolean;
    cancel(): void;
};
export {};

import type { M3UFile } from "../components/M3UExport";
export type M3UKind = "files" | "exports";
export interface M3URow {
    id: string;
    name: string;
    track_count: number | null;
    path?: string;
}
export interface M3UPageData {
    items: M3URow[];
    total: number;
    unavailable_roots: number;
    unreadable_directories: number;
}
/** Metadata-only file rows never invent a track count or resolve untrusted paths. */
export declare function parseM3UPage(raw: unknown, offset: number, kind: M3UKind): M3UPageData;
/** A detail must identify exactly the selected file; its text stays inert, including BOM/CRLF. */
export declare function parseM3UDetail(raw: unknown, id: string, kind: M3UKind): M3UFile & {
    titles: string[];
    path?: string;
};

import type { M3UDownloadFile } from "../components/M3UExport";
/** Metadata-only lookup distinguishes confirmed absence from failed inspection and retires replaced owners. */
export declare function lookupAlbumM3U(release: string, current: () => boolean): Promise<M3UDownloadFile | null | undefined>;

/** Playlist entries are display-only; paths and URLs never become playback or native file requests. */
export declare function m3uTitles(content: string, allowSimple?: boolean): string[];

import type { M3UFile } from "../components/M3UExport";
/** Explicit library publication requires its server capability and the unchanged owner session. */
export declare function saveLibraryM3U(release: string, name: string, isCurrent: () => boolean): Promise<M3UFile | undefined>;

import type { MissingAlbum } from "./missing";
import type { AccountSession } from "./server";
/** One source queue deduplicates cards and discographies and discards stale account replies. */
export declare function createMissingCoverLoader(sessionFor: (artist: string) => AccountSession | undefined, supported: (artist: string) => boolean, request: (artist: string, group: string, download: boolean) => Promise<ArrayBuffer>, changed: () => void): {
    status: (row: MissingAlbum) => "idle" | "loading" | "ready" | "absent" | "failed" | "unsupported";
    image: (row: MissingAlbum) => string | undefined;
    error: (row: MissingAlbum) => string | undefined;
    load: (row: MissingAlbum, retry?: boolean) => Promise<void>;
    prune: () => void;
    dispose: () => void;
};

import { type Accessor } from "solid-js";
import { type SourceId } from "./sources";
import type { AccountSession } from "./server";
import type { Album } from "./types";
export interface MissingAlbum {
    artist: string;
    artist_name: string;
    release_group: string;
    title: string;
    year: number | null;
    set_aside: boolean;
    source: string;
    url: string;
}
/** A missing release group is an attributed claim, never an owned release edition. */
export declare function parseMissing(raw: unknown): MissingAlbum;
/** Presentation-only filter projection; its identity can never be sent to album/playback routes. */
export declare function missingAlbum(row: MissingAlbum): Album;
/** Read each authenticated source once per catalog/session; private decisions never enter the public cache. */
export declare function createMissingCatalog(local: Accessor<AccountSession | undefined>, server: Accessor<AccountSession | undefined>, epoch: (source: SourceId) => unknown): {
    supportsCover: (artist: string) => boolean;
    rows: () => MissingAlbum[];
    errors: () => string[];
    loading: () => boolean;
    refetch: () => Promise<[{
        source: SourceId;
        session: AccountSession | undefined;
        scope: {
            session: AccountSession | undefined;
            epoch: unknown;
        };
        rows: MissingAlbum[];
        error: string;
        covers: boolean;
    } | null | undefined, {
        source: SourceId;
        session: AccountSession | undefined;
        scope: {
            session: AccountSession | undefined;
            epoch: unknown;
        };
        rows: MissingAlbum[];
        error: string;
        covers: boolean;
    } | null | undefined]> | undefined;
    decide: (row: MissingAlbum, setAside: boolean) => Promise<void>;
};

/** Confirmed native extraction progress; counts never estimate the remaining work. */
export interface FeatureProgress {
    phase: "" | "analyzing" | "waiting_for_playback" | "finished";
    done: number;
    total: number;
    analyzed: number;
    reused: number;
    failed: number;
}
/** Legacy task replies omit progress; malformed new progress must not become a success indicator. */
export declare function validFeatureProgress(raw: unknown): raw is FeatureProgress | undefined;

import type { AccountSession } from "./server";
import type { SourceId } from "./sources";
/** A capability probe and its private page form one captured-owner read. */
export declare function readMoodReply(key: {
    session: AccountSession;
    source: SourceId;
    selected: string;
    offset: number;
    expected: string;
}, current: () => boolean): Promise<{
    page: import("./moods").MoodPage;
    audio: boolean;
    extractable: boolean;
} | undefined>;

export interface MoodRule {
    id: string;
    name: string;
    tags: string[];
    genres: string[];
    acoustic?: "slow" | "fast" | "dark" | "bright";
}
export interface MoodPage {
    moods: {
        rule: MoodRule;
        count: number;
        model?: {
            examples: number;
            radius: number;
        } | null;
    }[];
    items: {
        reference: string;
        title: string;
        release: string | null;
        number: number;
        album_total: number;
        reason: {
            tag: string | null;
            genre: string | null;
            scope?: "track" | "album" | "artist" | "genre" | "acoustic";
            audio?: {
                kind: "neighbor";
                distance: number;
                examples: number;
            } | {
                kind: "descriptor";
                value: number;
                unit: "bpm" | "hz";
            };
        };
    }[];
    total: number;
    offset: number;
    scanned_at: number;
    selection_revision?: string;
    acoustic?: {
        profile: number;
        ready: number;
        missing: number;
        cache_errors: number;
        warming: boolean;
    };
}
/** Atmospheres remain explainable personal rules, not inferred emotions. */
export declare function parseMoods(raw: unknown): MoodPage;
/** Localize untouched presets while preserving explicit owner-defined names. */
export declare function moodName(rule: MoodRule): string;
/** Explain the most specific retained evidence; old servers remain readable without a source label. */
export declare function moodReason(reason: MoodPage["items"][number]["reason"]): string;

import type { Snapshot } from "./server";
import type { SourceId } from "./sources";
import type { TrackSource } from "./combined-tracks";
export interface PublicCatalogSource extends TrackSource {
    online: boolean;
    snapshot?: Snapshot;
}
/** Public cached catalogs outlive authenticated sessions; current live authority remains explicit. */
export declare function publicCatalogSources(snapshot: (source: SourceId) => Snapshot | undefined, connected: readonly TrackSource[]): PublicCatalogSource[];
/** Cached search matches only retained track/album titles, never invented raw-tag or credit facts. */
export declare function cachedTrackPage(snapshot: Snapshot | undefined, query: string, offset: number): {
    items: import("./track-page").CatalogTrack[];
    total: number;
    offset: number;
    limit: number;
    scanned_at: number;
};
/** Sort complete authoritative label associations before taking a bounded presentation page. */
export declare function cachedLabelPage(snapshot: Snapshot | undefined, query: string, offset: number, sort: "name" | "albums", descending: boolean): {
    items: import("./server").CachedLabel[];
    total: number;
};

import { requestAede } from "../platform/desktop";
import { type ParentalStatus, type ParentalReason } from "./parental-controls";
import type { AccountSession, Snapshot } from "./server";
import type { SourceId } from "./sources";
export type ExternalParentalMedia = {
    kind: "radio";
} | {
    kind: "podcast";
    feed: string;
};
export declare function parentalMessage(reason: ParentalReason | null): string;
/** Policy reads belong to an exact session; private drafts and public snapshots are never an authority. */
export declare function createParentalAccess(input: {
    session: (source: SourceId) => AccountSession | undefined;
    source: () => SourceId;
    changed: (source: SourceId, status: ParentalStatus) => void;
    unavailable: (source: SourceId) => void;
    request?: typeof requestAede;
}): {
    viewScope: import("solid-js").Accessor<string>;
    status: (source?: SourceId) => ParentalStatus | undefined;
    refresh: (source: SourceId, owner?: AccountSession | undefined) => Promise<ParentalStatus | undefined>;
    available: (source?: SourceId) => boolean;
    radioAllowed: () => boolean;
    podcastAllowed: (feed: string) => boolean;
    podcastsAllowed: () => boolean;
    supported: (source?: SourceId) => boolean;
    error: () => string;
    catalogVisible(source: SourceId, snapshot: Snapshot | undefined): boolean;
    check(media: ExternalParentalMedia, source?: SourceId, owner?: AccountSession | undefined): Promise<{
        source: SourceId;
        owner: AccountSession;
        status: ParentalStatus;
    } | undefined>;
};

import type { AccountSession } from "./server";
/** Validate the retained named principal without adopting a successor or inventing a legacy policy. */
export declare function liveParentalCapability(raw: unknown, owner: AccountSession): boolean;

import { requestAede } from "../platform/desktop";
import type { Account } from "./account-list";
import type { AccountSession } from "./server";
import type { SourceId } from "./sources";
import { type ParentalPolicy } from "./parental-controls";
/** Administration has a captured source, administrator generation and immutable target identity. */
export interface ParentalAdminScope {
    source: SourceId;
    session: AccountSession;
    target: Account;
}
export declare function parentalAdministrative(session: AccountSession | undefined): boolean;
type Request = typeof requestAede;
/** Explicit policy writes retain their draft on conflicts; no child-editable preference store is involved. */
export declare function createParentalAdmin(input: () => ParentalAdminScope | undefined, request?: Request): {
    draft: () => ParentalPolicy | undefined;
    loading: import("solid-js").Accessor<boolean>;
    saving: import("solid-js").Accessor<boolean>;
    locked: () => boolean;
    error: import("solid-js").Accessor<string>;
    message: import("solid-js").Accessor<string>;
    dirty: import("solid-js").Accessor<boolean>;
    update(next: ParentalPolicy): void;
    reset(): void;
    load: () => Promise<void>;
    save: () => Promise<boolean>;
    dismiss: () => "";
};
export {};

/** Server-owned civil-time windows use Monday=0; overnight windows are split across days. */
export interface ParentalDay {
    windows: {
        start_minute: number;
        end_minute: number;
    }[];
    limit_seconds: number | null;
}
/** Parental policies never participate in child-editable interface preferences or backups. */
export interface ParentalPolicy {
    enabled: boolean;
    timezone: string;
    blocked_artists: string[];
    radio_allowed: boolean;
    podcasts_allowed: boolean;
    blocked_podcasts: string[];
    days: ParentalDay[];
    week_limit_seconds: number | null;
}
export interface ParentalPolicySnapshot {
    owner: string;
    revision: number;
    locked_by?: string | null;
    policy: ParentalPolicy;
}
export type ParentalReason = "outside_schedule" | "daily_limit" | "weekly_limit" | "radio_blocked" | "podcast_blocked" | "artist_blocked" | "policy_unavailable";
export interface ParentalStatus extends ParentalPolicySnapshot {
    day_used_seconds: number;
    week_used_seconds: number;
    remaining_seconds: number | null;
    allowed: boolean;
    reason: ParentalReason | null;
    next_change_at: number | null;
}
/** A valid saved timezone is kept literal; Aède owns clock, DST boundaries and quota accounting. */
export declare function parentalTimezone(raw: unknown): raw is string;
/** Defensive parsing rejects malformed policies instead of inventing unrestricted defaults. */
export declare function parseParentalPolicy(raw: unknown): ParentalPolicy;
/** Stable target ownership and optimistic revision prevent cross-account and stale writes. */
export declare function parseParentalPolicySnapshot(raw: unknown, expectedOwner?: string): ParentalPolicySnapshot;
/** Status is authoritative; the client displays deadlines and never recomputes authorization locally. */
export declare function parseParentalStatus(raw: unknown): ParentalStatus;
/** Fresh editor defaults remain inactive until the administrator explicitly saves them. */
export declare function defaultParentalPolicy(timezone?: string): ParentalPolicy;
/** Canonical presentation identity ignores JSON key ordering without dropping any policy field. */
export declare function parentalPolicyStamp(policy: ParentalPolicy | undefined): string;
/** A restriction stores an inert canonical feed identifier; it never fetches the URL. */
export declare function parentalPodcastFeed(value: string): string;

/** Consumption counts only observed audible playback, using a monotonic clock within one grant. */
export declare function createParentalConsumption(seconds: number, carry?: number): {
    read: () => number;
    playing(value: boolean): void;
};

import { requestAede } from "../platform/desktop";
import type { ExternalParentalMedia } from "./parental-access";
import type { ParentalStatus } from "./parental-controls";
import type { AccountSession } from "./server";
import type { SourceId } from "./sources";
type Admission = {
    source: SourceId;
    owner: AccountSession;
    status: ParentalStatus;
};
/** External media reserve short server-owned listening leases; a separate deadline stops audio even if renewal hangs. */
export declare function createParentalMedia(input: {
    access: {
        check: (media: ExternalParentalMedia, source?: SourceId, owner?: AccountSession) => Promise<Admission | undefined>;
    };
    source: () => SourceId;
    session: (source: SourceId) => AccountSession | undefined;
    request?: typeof requestAede;
    stop: () => void;
    error: (message: string) => void;
}): {
    capture: () => (media: ExternalParentalMedia) => Promise<void>;
    authorize: (media: ExternalParentalMedia) => Promise<void>;
    stop: () => void;
    source: () => SourceId | undefined;
    owner: () => AccountSession | undefined;
    applies: (source: SourceId) => boolean;
    observe(next: "idle" | "connecting" | "playing" | "paused" | "ended" | "error"): void;
};
export {};

import type { Route } from "../navigation/routes";
import { type SourceId } from "./sources";
/** Dispose/refuse account resources on policy failure while preserving access to recovery settings. */
export declare function parentalRouteAllowed(route: Route, available: (source?: SourceId) => boolean): boolean;

/** The active action owns its indicator; overlapping native dialogs are never submitted. */
export declare function createPendingAction<Action extends string>(): {
    pending: import("solid-js").Accessor<Action | undefined>;
    run<Result>(action: Action, task: () => Promise<Result>): Promise<Result | undefined>;
};

import type { Section } from "../navigation/routes";
import type { AccountSession } from "./server";
import type { SourceId } from "./sources";
/** Reset retained drafts and capture admission for delayed personal action acknowledgements. */
export declare function createPersonalActions(section: () => Section, session: () => AccountSession | undefined, source: () => SourceId, reset: () => void): {
    capture: () => () => boolean;
};

/** The same owner-private query/rating interval is evaluated again by Aède as annotations evolve. */
export declare function personalCollectionExpression(view: "rated" | "favourites", query: string, minimum?: number, maximum?: number): string;
/** Tagged artists contribute principal albums; tagged tracks remain track-only in the engine. */
export declare function tagCollectionExpression(tags: readonly string[], query: string): string;

import { type Accessor } from "solid-js";
import type { Section } from "../navigation/routes";
import type { AccountSession } from "./server";
interface Page {
    items: unknown[];
    total: number;
}
export interface HistoryRow {
    track: string;
    at: number;
    ms_played: number | null;
    completed: boolean | null;
    title: string;
    release: string | null;
    error?: string;
}
type Request = (path: string, query: Record<string, string>, owner: AccountSession) => Promise<unknown>;
/** Reads resolve to data or an explicit error; rejected resources never break shell navigation. */
export declare function createPersonalReads(section: Accessor<Section>, session: Accessor<AccountSession | undefined>, offset: Accessor<number>, request: Request): {
    page: () => {
        scope: {
            path: string;
            account: AccountSession;
            offset: number;
        };
        data?: Page;
        error?: string;
    } | undefined;
    history: () => HistoryRow[];
    loading: () => boolean;
    refetch: () => Promise<void>;
};
export {};

import type { MoodRule } from "./moods";
/** Presentation filtering preserves occurrence identities and never searches opaque references. */
export declare function queueSearch<T extends {
    title: string;
    artist: string;
    album: {
        title: string;
    } | null;
}>(rows: readonly T[], query: string): readonly T[];
/** Rule names and their visible recipe metadata are searched without a server request. */
export declare function moodSearch(rule: Pick<MoodRule, "name" | "tags" | "genres">, query: string): boolean;

import type { Album, Artist } from "./types";
export interface PlayableSelection {
    reference: string;
    title: string;
    album: Album | null;
    artist: string;
    /** Known duration for temporary native sources outside the catalogue. */
    durationMs?: number;
    number: number;
    albumTotal: number;
}
/** Resolve server-ordered stable references without guessing missing editions or positions. */
export declare function playbackSelection(value: unknown, albums: readonly Album[], artists: readonly Artist[]): PlayableSelection[];
/** Track additions admit exactly one matching identity; album/artist and explicit lists retain their order. */
export declare function queueAdditionSelection(value: unknown, albums: readonly Album[], artists: readonly Artist[], reference?: string): PlayableSelection[];

/** Public native playback state. Its clock counts source frames consumed by the callback. */
export interface PlaybackState {
    /** Physical CD playback never inherits a remote account/reference namespace. */
    source?: "aede" | "cd";
    spectrum?: readonly number[];
    spectrum_hz?: readonly number[];
    shuffled: boolean;
    repeat: "off" | "one" | "all";
    queue: readonly number[];
    protected_occurrences?: readonly number[];
    status: "idle" | "connecting" | "playing" | "paused" | "ended" | "error";
    reference: string;
    index: number;
    /** Slot bound for stable occurrence ids; visible queue size is queue.length. */
    total: number;
    position_ms: number;
    duration_ms: number | null;
    sample_rate: number;
    volume: number;
    history_confirmed: boolean;
    device: string;
    error: string;
    seek_id: number;
    queue_id: number;
    level: number;
    levels: readonly number[];
}
export interface AudioOutput {
    id: string;
    name: string;
    default: boolean;
}
export declare const idlePlayback: PlaybackState;
/** Reject malformed native responses rather than inventing a playback clock or output. */
export declare function parsePlayback(value: unknown): PlaybackState;
/** Outputs are explicitly discovered on the native host, never guessed from the catalog. */
export declare function parseOutputs(value: unknown): AudioOutput[];

import { type CdDisc } from "../cd/model";
import { type Accessor } from "solid-js";
import { type AudioOutput } from "./playback-state";
import type { AccountSession, Track } from "./server";
import { type PlayableSelection } from "./playback-selection";
import type { Artist, Album } from "./types";
import { type SourceId } from "./sources";
/** Explicit playback owns one serialized poll; it never starts during offline browsing. */
export declare function createPlayback(ready: Accessor<boolean>, catalog?: () => {
    albums: readonly Album[];
    artists: readonly Artist[];
}, beforeStart?: () => void, sessionFor?: (reference: string) => AccountSession | undefined, availableFor?: (reference: string) => boolean, localCd?: {
    native: Accessor<boolean>;
    allowed: Accessor<boolean>;
}): {
    isCd: () => boolean;
    setDiscTarget: import("solid-js").Setter<CdDisc | undefined>;
    startDisc: (disc: CdDisc, index?: number) => Promise<void>;
    canStart: (reference?: string) => boolean;
    clearing: Accessor<boolean>;
    clearQueue: () => Promise<boolean>;
    revoke: () => Promise<boolean>;
    removeOccurrence: (occurrence: number) => Promise<boolean>;
    appending: Accessor<boolean>;
    appendSelection: (load: (current: () => boolean) => Promise<unknown>, source: SourceId, reference?: string) => Promise<number>;
    appendReference: (reference: string, load?: (current: () => boolean) => Promise<unknown>) => Promise<number>;
    ownsSource: (source: SourceId) => boolean;
    playQueueOccurrence: (occurrence: number) => Promise<void | boolean>;
    togglePlayback: () => Promise<void | boolean>;
    canTogglePlayback: () => boolean;
    seek: (position: number) => Promise<void>;
    previewSeek: (position: number) => {
        reference: string;
        position: number;
    };
    clearSeekPreview: () => undefined;
    seekPosition: () => number;
    seeking: () => boolean;
    target: Accessor<string>;
    setTarget: import("solid-js").Setter<string>;
    startReference: (reference?: string) => Promise<void>;
    startSelection: (value: unknown) => Promise<void>;
    readSelection: (load: (current: () => boolean) => Promise<unknown>, source: SourceId) => Promise<void>;
    identify: (key: string) => void;
    remaining: Accessor<boolean>;
    toggleTime: () => void;
    policy: Accessor<string>;
    choosePolicy: (value: string) => Promise<void>;
    chooseCrossfade: (ms: number) => Promise<void>;
    crossfade: Accessor<number>;
    toggleMute: () => Promise<void>;
    state: Accessor<import("./playback-state").PlaybackState>;
    outputs: Accessor<AudioOutput[]>;
    discovering: Accessor<boolean>;
    device: Accessor<string>;
    error: Accessor<string>;
    busy: Accessor<boolean>;
    ready: () => boolean;
    start: (tracks: readonly Track[], album: Album, artist: string, index?: number) => Promise<void>;
    action: (command: string, value?: unknown) => Promise<void | boolean>;
    discover: () => Promise<void>;
    chooseOutput: (id: string) => Promise<void>;
    volume: (value: number) => Promise<void>;
    settledVolume: () => Promise<number>;
    /** Last confirmed positive gain of the current interface profile, shared by browser media. */
    unmutedVolume: () => number;
    rememberVolume: (value: number) => void;
    reset: () => void;
    queue: Accessor<{
        reference: string;
        title: string;
        album: Album | null;
        artist: string;
        durationMs?: number;
        number: number;
        albumTotal: number;
        index: number;
    }[]>;
    current: () => PlayableSelection | undefined;
};

export interface PlayerVolume {
    id?: string;
    adapter?: "mounted" | "ipod" | "mtp";
    available?: boolean;
    free?: number;
    model?: string | null;
    icon?: string;
    ipodSupported?: boolean | null;
    ejectable?: boolean;
    unavailableReason?: string;
    name: string;
    path: string;
    format: string;
    kind: "volume" | "network" | "removable" | "folder";
}
/** Discovery is bounded mount evidence, never a claimed codec profile or write permission. */
export declare function parsePlayers(value: unknown): PlayerVolume[];
/** New native discovery retains separate warnings so one unavailable MTP backend cannot hide mounts. */
export declare function parsePlayerDiscovery(value: unknown): {
    volumes: PlayerVolume[];
    warning: string;
};

type Store = Pick<Storage, "getItem" | "setItem" | "removeItem">;
export type PreferenceBackup = Record<string, unknown>;
/** Complete interface snapshot; native folders, secrets, accounts and personal library data are excluded. */
export declare function exportPreferenceBackup(storage: Pick<Storage, "getItem">): string;
/** Validate the entire explicit import before any browser preference can be changed. */
export declare function parsePreferenceBackup(raw: string): PreferenceBackup;
/** Roll back already-written keys on a storage failure; never acknowledge a partial restoration. */
export declare function applyPreferenceBackup(storage: Store, values: PreferenceBackup): PreferenceBackup;
export {};

type Store = Pick<Storage, "getItem" | "setItem" | "removeItem">;
/** Persist a validated preference projection together; failed writes restore the captured bytes.
 * Callers own key/value admission. Unrelated personal stores are never touched. Browser storage
 * is synchronous, so this is rollback protection, not a transaction across other processes.
 */
export declare function writePreferenceEntries(storage: Store, values: Record<string, unknown>): void;
export {};

/** Native dialogs and their review belong to the projection that requested them, including ABA changes. */
export declare function createPreferenceTransfer<T>(options: {
    identity: () => object;
    read: () => string | Promise<string>;
    export: (raw: string) => Promise<string | null>;
    import: () => Promise<string | null>;
    parse: (raw: string) => T;
    apply: (value: T) => void | Promise<void>;
}): {
    action: import("solid-js").Accessor<"export" | "import" | "restore" | undefined>;
    pending: () => T | undefined;
    error: import("solid-js").Accessor<string>;
    message: import("solid-js").Accessor<string>;
    run: (exporting: boolean) => Promise<void>;
    changed: () => void;
    clearPending: () => undefined;
    clearError: () => "";
    clearMessage: () => "";
    apply(): Promise<void>;
    dispose(): void;
};

export interface Preferences {
    language: "fr" | "en";
    background: string;
    accent: string;
    surface: string;
    text: string;
    muted: string;
    border: string;
    sidebar: string;
    player: string;
}
export declare const defaultPreferences: Preferences;
/** Corrupt preferences are reported; secrets never belong in browser settings. */
export declare function readPreferences(storage: Pick<Storage, "getItem">): Preferences;
export declare function applyPreferences(value: Preferences): void;

/** Older engines may omit version metadata; malformed supplied values remain errors. */
export declare function engineVersions(value: unknown): {
    aede: string;
    flaccompagnon: string;
} | undefined;

/** A visible refusal never silently switches native authority or replaces the queue. */
export declare function queueAppendReason(reference: string, state: {
    role: string | undefined;
    busy: boolean;
    device: string;
    first: string | undefined;
}): string;

/** Sum occurrences, including repeats, without treating an unavailable duration as zero. */
export declare function queueDuration(rows: readonly {
    reference: string;
}[], durations: ReadonlyMap<string, number | null>): {
    milliseconds: number;
    unknown: number;
};

import type { Job } from "./jobs";
import type { AccountSession } from "./server";
/** Probe all distinct occurrences serially and admit each answer only to its exact queue owners.
 * A later exact-track read supersedes an earlier retained-state probe of that same track.
 */
export declare function createQueueLyricAvailability(library: {
    queue: () => readonly {
        reference: string;
    }[];
    sessionFor: (reference: string) => AccountSession | undefined;
    jobs: () => readonly Job[];
}): {
    read: (reference: string, owner: AccountSession | undefined) => Promise<boolean>;
    available: (reference: string) => boolean | undefined;
    synced: (reference: string) => boolean | undefined;
    retained: () => {
        complete: boolean;
        error: string;
    } | undefined;
    loading: () => boolean;
    refresh: () => undefined;
};

import type { AccountSession } from "./server";
import type { createJobs } from "./jobs";
/** The library owns downloads; closing a drawer never cancels the captured authenticated batch.
 * Retained availability and title-bearing feedback are visible only to their captured owners.
 */
export declare function createQueueLyrics(library: {
    queue: () => readonly {
        reference: string;
        title: string;
    }[];
    sessionFor: (reference: string) => AccountSession | undefined;
    tasks: Pick<ReturnType<typeof createJobs>, "start" | "jobs"> & Partial<Pick<ReturnType<typeof createJobs>, "cancel">>;
}): {
    busy: import("solid-js").Accessor<boolean>;
    bulkOperation: () => boolean;
    bulkBusy: () => boolean;
    trackBusy: (reference: string) => boolean;
    message: () => string;
    failed: () => boolean;
    eligible: (reference?: string) => boolean;
    available: (reference: string) => boolean | undefined;
    synced: (reference: string) => boolean | undefined;
    acquiring: () => string;
    retained: () => {
        complete: boolean;
        error: string;
    } | undefined;
    retainedLoading: () => boolean;
    acquire: (reference?: string) => Promise<void>;
    cancel: () => Promise<void>;
    clear: () => "";
};

export interface QueueLyricsProgress {
    done: number;
    total: number;
    failed: number;
}
/** Deduplicate occurrences, preserve order and acquire one missing track at a time. */
export declare function acquireQueueLyrics(references: readonly string[], options: {
    current: () => boolean;
    available: (ref: string) => Promise<boolean>;
    acquire: (ref: string) => Promise<void>;
    progress: (value: QueueLyricsProgress) => void;
    failure?: (reference: string, reason: string) => void;
}): Promise<{
    done: number;
    total: number;
    failed: number;
}>;
/** Stop at the first missing reference; never infer availability from a download-button click. */
export declare function queueHasLyrics(references: readonly string[], current: () => boolean, read: (reference: string) => Promise<boolean>): Promise<boolean>;

/** Move one occurrence onto another's position; repeated track references stay distinct. */
export declare function moveQueueOccurrence(order: readonly number[], from: number, to: number): number[];
/** Restore original logical occurrence indices, including repeated references and multiple albums. */
export declare function originalQueueOrder(order: readonly number[]): number[];
/** The insertion edge follows edited list positions, never numeric occurrence ids. */
export declare function queueDropEdge(order: readonly number[], from: number | undefined, to: number | undefined): "before" | "after" | undefined;

import { searchQueue, type QueueCategory, type QueueSearchScope } from "./queue-search";
/** Search owns a debounced scope independently of playback polling and admitted additions. */
export declare function createQueueSearch(context: () => Omit<QueueSearchScope, "category" | "query" | "offset">, request: Parameters<typeof searchQueue>[1]): {
    query: () => string;
    setQuery: import("solid-js").Setter<string>;
    category: import("solid-js").Accessor<"albums" | "all" | "artists" | "collections" | "m3u" | "tracks">;
    offset: import("solid-js").Accessor<number>;
    setOffset: import("solid-js").Setter<number>;
    read: {
        current: () => import("./queue-search").QueueSearchPage | undefined;
        loading: () => boolean;
        pending: () => boolean;
        error: () => string;
        cancel(): void;
        refetch: () => void | Promise<void | undefined> | null;
    };
    waiting: () => boolean;
    chooseCategory(value: QueueCategory): void;
    submit(): void;
};

/** Match human metadata without random fragments of UUIDs; a complete typed identifier stays searchable. */
export declare function matchesQueueMetadata(values: readonly string[], query: string): boolean;

import type { Album, Artist } from "./types";
import type { AccountSession } from "./server";
import type { SourceId } from "./sources";
export declare const queueCategoryLabels: {
    readonly all: "Tous";
    readonly tracks: "Pistes";
    readonly albums: "Albums";
    readonly artists: "Artistes";
    readonly m3u: "M3U";
    readonly collections: "Collections";
};
export type QueueCategory = keyof typeof queueCategoryLabels;
export interface QueueSearchItem {
    key: string;
    category?: Exclude<QueueCategory, "all">;
    title: string;
    detail: string;
    source: SourceId;
    reference?: string;
    album?: string;
    collection?: string;
    playlist?: {
        id: string;
        kind: "files" | "exports";
    };
}
export interface QueueSearchScope {
    category: QueueCategory;
    query: string;
    offset: number;
    owners: readonly {
        source: SourceId;
        session: AccountSession;
    }[];
    albums: readonly Album[];
    artists: readonly Artist[];
}
type Request = (path: string, query: Record<string, string>, source: SourceId, owner: AccountSession) => Promise<unknown>;
/** One bounded page retains usable results when another source is unavailable. */
export interface QueueSearchPage {
    items: QueueSearchItem[];
    more: boolean;
    errors: string[];
}
/** Bounded explicit search uses public cached metadata and exact current-owner remote pages. */
export declare function searchQueue(scope: QueueSearchScope, request: Request, current: () => boolean): Promise<QueueSearchPage>;
export {};

import type { Album } from "./types";
import type { Annotation } from "./server";
/** A supporting performer rating never changes the principal discography selection. */
export declare function albumRating(album: Album, annotations: Readonly<Record<string, Annotation | undefined>>): number;
/** Equivalent to favourites: direct album ratings or a rated principal artist, once per edition. */
export declare function ratedAlbums(albums: readonly Album[], annotations: Readonly<Record<string, Annotation | undefined>>, minimum: number, maximum?: number): Album[];

import type { Album } from "./types";
/** Unknown/future timestamps never imply a recent catalog addition. */
export declare function isRecentAlbum(album: Album, nowSeconds: number): boolean;
/** Rolling thirty days use observed catalog entry timestamps, never release years or file mtimes. */
export declare function recentAlbums(albums: readonly Album[], nowSeconds: number): Album[];

/** Perspective projection of a bounded Fibonacci sphere; coordinates carry no music meaning. */
export declare function relationSpace(count: number, yaw: number, pitch: number, zoom: number): {
    index: number;
    x: number;
    y: number;
    depth: number;
    scale: number;
}[];
interface ProjectedNode {
    index: number;
    x: number;
    y: number;
}
/** Perimeter labels reserve one readable row per node when projected names would overlap. */
export declare function relationLabels(points: readonly ProjectedNode[]): {
    index: number;
    x: number;
    y: number;
    anchor: "middle";
}[] | {
    index: number;
    x: number;
    y: number;
    anchor: "start" | "end";
}[];
/** Darkness follows projected spatial distance only, never inferred musical proximity. */
export declare function relationBrightness(x: number, y: number): number;
/** Explicit depth and radial shading remain visible even where rear nodes project near the centre. */
export declare function relationTone(depth: number, x: number, y: number): {
    brightness: number;
    highlight: string;
    middle: string;
    edge: string;
};
export {};

import type { Artist } from "./types";
export interface Neighbour {
    artist: Artist;
    weight: number;
    kind: string;
    source: string;
}
/** Keep catalog-proven neighbours, deduplicate and bound SVG work independently of library size. */
export declare function neighbours(artists: readonly Artist[], selected: Artist, limit?: number): Neighbour[];

import type { Filters } from "./types";
/** The year rail precedes the alphabet rail; hidden rails never duplicate a count. */
export declare function countRail(mode: Filters["mode"]): "years" | "alphabet" | undefined;

import type { AccountSession } from "./server";
import type { SourceId } from "./sources";
import type { MoodPage } from "./moods";
/** Captured ownership and paging identity of one confirmed mood reply. */
export interface MoodKey {
    session: AccountSession | undefined;
    source: SourceId;
    selected: string;
    offset: number;
    owner?: object;
}
/** Capabilities are retained alongside the exact page they authorized. */
export interface MoodReply extends MoodKey {
    page?: MoodPage;
    error?: string;
    audio: boolean;
    extractable: boolean;
}
/** Keep a confirmed same-owner page during progress refreshes; reject stale source/selection pages. */
export declare function retainedMoodReply(resource: {
    (): MoodReply | undefined;
    readonly latest: MoodReply | undefined;
}, key: MoodKey): MoodReply | undefined;
/** Keep page-only callers on the same admission predicate as capabilities and diagnostics. */
export declare function retainedMoodPage(resource: {
    (): MoodReply | undefined;
    readonly latest: MoodReply | undefined;
}, key: MoodKey): MoodPage | undefined;

import { combinedTrackReader } from "./combined-tracks";
export type SearchResult = Awaited<ReturnType<ReturnType<typeof combinedTrackReader>>>;
/** One account/session-scoped search survives route disposal; no result enters disk/public cache. */
export declare function createRetainedSearch(scope: () => string): {
    criteria: import("solid-js").Accessor<import("./advanced-search").SearchCriteria>;
    setCriteria: import("solid-js").Setter<import("./advanced-search").SearchCriteria>;
    submitted: import("solid-js").Accessor<{
        expression: string;
    } | undefined>;
    setSubmitted: import("solid-js").Setter<{
        expression: string;
    } | undefined>;
    offset: import("solid-js").Accessor<number>;
    setOffset: import("solid-js").Setter<number>;
    reset: () => void;
    /** Explicit submissions refresh even unchanged criteria; remounts keep their confirmed window. */
    submit(expression: string): void;
    cached(expression: string, at: number): {
        items: import("./track-page").CatalogTrack[];
        total: number;
        unavailable: {
            source: import("./sources").SourceId;
            error: string;
        }[];
    } | undefined;
    remember(held: string, expression: string, at: number, result: SearchResult, request?: {
        expression: string;
    } | undefined): void;
    scope: import("solid-js").Accessor<string>;
};

import type { AccountSession } from "./server";
import type { SourceId } from "./sources";
export { accountSettingKeys } from "./account-preference-keys";
/** Publish only explicitly supported non-secret settings after a successful local write. */
export declare function announceSetting(key: string, raw: string): void;
/** Parse the account projection without admitting native roots, credentials or arbitrary storage keys. */
export declare function parseAccountSettings(raw: unknown): Record<string, unknown>;
/** Load once per authenticated identity; serialized patches never cross a replaced account/source. */
export declare function createSavedSettings(session: () => AccountSession | undefined, source: () => SourceId): {
    error: import("solid-js").Accessor<string>;
    status: import("solid-js").Accessor<string>;
};

import { type Accessor } from "solid-js";
import type { PlaybackState } from "./playback-state";
/** Keep a committed cursor stable until the actor acknowledges its seek ticket, coalescing rapid choices. */
export declare function createSeekProgress(state: Accessor<PlaybackState>, send: (position: number) => Promise<unknown>, failure: (message: string) => void): {
    seek: (position: number) => Promise<void>;
    reset: () => void;
    preview: (position: number) => {
        reference: string;
        position: number;
    };
    clearPreview: () => undefined;
    pending: () => boolean;
    position: () => number;
};

import type { SourceId } from "./sources";
import type { AccountSession } from "./server";
/** Own the collection dialog's private draft and deferred save feedback independently of rendering. */
export declare function createSelectionCollection(source: () => SourceId, session: (source: SourceId) => AccountSession | undefined): {
    draft: import("solid-js").Accessor<string | undefined>;
    setDraft: import("solid-js").Setter<string | undefined>;
    draftSource: import("solid-js").Accessor<SourceId>;
    name: import("solid-js").Accessor<string>;
    setName: import("solid-js").Setter<string>;
    error: import("solid-js").Accessor<string>;
    setError: import("solid-js").Setter<string>;
    busy: import("solid-js").Accessor<boolean>;
    message: import("solid-js").Accessor<string>;
    setMessage: import("solid-js").Setter<string>;
    writable: () => boolean;
    save: () => Promise<void>;
    open(expression: string): void;
};

import type { QueueSearchItem } from "./queue-search";
import type { AccountSession } from "./server";
import type { Album } from "./types";
/** Playback and external transfers resolve the same exact library/collection/M3U selection without starting audio. */
export declare function readLibrarySelection(row: QueueSearchItem, owner: AccountSession, albums: readonly Album[], scannedAt: number | undefined, valid: () => boolean): Promise<unknown>;

import type { Album, Artist, Filters } from "./types";
/** A detail year opens all albums from that year, independent of stale browse facets. */
export declare function selectAlbumYear(previous: Filters, year: number): Filters;
/** Visible album artists use Aède's canonical release association, not personnel roles. */
export declare function browseArtists(artists: readonly Artist[], albums: readonly Album[]): Artist[];
/** Ordinary activation replaces; additive activation toggles one country in a union. */
export declare function selectCountries(current: readonly (string | null)[], value: string | null | undefined, additive: boolean): readonly (string | null)[];
/** Command is the platform modifier on Mac; Control is used elsewhere. */
export declare function additiveCountrySelection(event: {
    metaKey: boolean;
    ctrlKey: boolean;
}, mac: boolean): boolean;
export declare const isMac: () => boolean;
/** Tag clicks replace a selection; platform-modified clicks toggle a union. */
export declare function selectTags(current: readonly string[], value: string | undefined, additive: boolean): readonly string[];

/** Root reads keep exclusions separate and refuse changing epochs or incomplete pages.
 * Retiring admission drops partial rows and prevents any subsequent page dispatch.
 */
export declare function readServerRoots(request: (offset: number) => Promise<unknown>, current?: () => boolean, status?: "watched" | "excluded"): Promise<string[]>;

import { type ParentalPolicy } from "./parental-controls";
import { type CatalogTrack } from "./track-page";
import { type LabelSummary, type LabelDetail } from "./labels";
import type { Album, Artist } from "./types";
export type CachedLabel = LabelSummary & LabelDetail;
export interface Snapshot {
    artists: Artist[];
    albums: Album[];
    /** Absent in legacy caches; an empty array means a complete synchronized empty projection. */
    tracks?: CatalogTrack[];
    labels?: CachedLabel[];
    server: string;
    accountId: string;
    scannedAt: number;
    cachedAt?: string;
    parentalEnabled?: boolean;
    parentalRevision?: number;
    parentalPolicy?: ParentalPolicy;
}
export interface Annotation {
    reference: string;
    loved: boolean;
    rating: number | null;
    note: string | null;
    tags: string[];
}
export interface Track {
    reference: string;
    title: string;
    duration_ms: number | null;
    analyses: unknown[];
    analysis_available?: boolean;
    /** Presence hint only; the explicit lyrics read validates content and source identity. */
    lyrics_available?: boolean;
    path?: string;
}
export interface AccountSession {
    /** Non-secret native process generation for private-file admission. */
    nativeSession?: string;
    server: string;
    account: {
        id: string;
        username: string;
        role: string;
        parental_enabled?: boolean;
    };
}
/** Reject malformed snapshots instead of silently hiding entities or inventing origins. */
export declare function parseSnapshot(value: unknown): Snapshot;
/** Only validated attributed web links may be made clickable. */
export declare function sourceLink(value: string): string | undefined;

import type { Job } from "./jobs";
import type { AccountSession } from "./server";
import type { SourceId } from "./sources";
/** Stop requests retain source/login ownership and never replay mutations automatically. */
export declare function createServiceCancellation(options: {
    session: (source: SourceId) => AccountSession | undefined;
    cancel: (id: number, source: SourceId) => Promise<void>;
}): {
    error: () => string;
    clear: () => {};
    pending: () => boolean;
    pendingJob: (id: number, source: SourceId) => boolean;
    cancel: (id: number, source: SourceId) => Promise<void>;
    stopEnrichment(jobs: readonly Job[]): Promise<void>;
};

/** Shared native keys are device-wide; their completion must not change another profile's enrichment choices. */
export declare function completeServiceKeySave(options: {
    current: () => boolean;
    save: () => Promise<unknown>;
    refresh: () => Promise<unknown>;
    commit: () => void;
}): Promise<void>;

import type { SourceReviewItem, ReviewDecision } from "./source-review";
import type { EnrichmentOptions } from "./enrichment";
/** Review persistence and explicit background work are separate: a failed launch never undoes consent. */
export declare function applySourceReview(options: {
    row: SourceReviewItem;
    decision?: ReviewDecision;
    biography: boolean;
    current: () => boolean;
    decide: (decision: ReviewDecision) => Promise<SourceReviewItem>;
    launch: (options: EnrichmentOptions) => Promise<{
        task: number;
    } | {
        error: string;
    } | undefined>;
    saved: (row: SourceReviewItem) => void;
}): Promise<string>;

import type { AccountSession } from "./server";
import type { SourceId } from "./sources";
/** Reading stored candidates never initiates an external MusicBrainz request. */
export declare function readSourceReviews(key: {
    source: SourceId;
    owner: AccountSession;
    query: string;
    all: boolean;
    offset: number;
}, current: () => boolean): Promise<{
    items: import("./source-review").SourceReviewItem[];
    total: number;
    offset: number;
    limit: number;
    biographies: boolean;
} | undefined>;

import type { AccountSession } from "./server";
import type { SourceId } from "./sources";
/** Shared source claims are administrative catalogue data, never personal annotations or tag edits. */
export interface SourceReviewItem {
    id: string;
    revision: string;
    reference: string;
    name: string;
    kind: "artist" | "release" | "track" | "label";
    source_id: string | null;
    url: string | null;
    score: number | null;
    decision: "accepted" | "rejected" | null;
    local_mbid: string | null;
    details: [string, string][];
}
export interface SourceReviewPage {
    items: SourceReviewItem[];
    total: number;
    offset: number;
    limit: number;
}
/** Only canonical MusicBrainz entity links can leave the review; arbitrary service URLs stay inert. */
export declare function parseSourceReview(value: unknown): SourceReviewItem;
export declare function parseSourceReviewPage(value: unknown): SourceReviewPage;
export type ReviewDecision = "accept" | "reject" | "undo";
/** Exact optimistic revisions prevent an old card from accepting a refreshed or replaced identity. */
export declare function decideSourceReview(source: SourceId, owner: AccountSession, row: SourceReviewItem, decision: ReviewDecision): Promise<SourceReviewItem>;
/** Keep review navigation reachable when decisions shrink the pending queue. */
export declare function hasSourceReviewPages(page: Pick<SourceReviewPage, "total" | "offset" | "limit">): boolean;

/** Application references retain catalog ownership without changing Aède identities. */
export type SourceId = "local" | "server";
/** Only the qualifier after the entity kind chooses an owner; engine keys remain literal. */
export declare function referenceSource(reference: string): SourceId;
export declare const sourceLabel: (source: SourceId) => string;
/** Origins reflect the retained catalog, so a disconnected source does not lose its label. */
export declare function catalogOrigins(references: readonly string[]): SourceId[];
/** Personal views follow the sole active source; an explicit choice applies only when necessary. */
export declare function effectiveSource(selected: SourceId, active: readonly SourceId[], retained: readonly SourceId[]): SourceId;

/** Repeating a star clears a personal rating or returns a minimum filter to its floor. */
export declare function nextStarSelection(current: number | null, clicked: number, floor?: number | null): number | null;

/** Fit the measured whole value to its available cell width, retaining the ordinary 24 px maximum. */
export declare function statValueSize(available: number, natural: number): number;

import type { Statistics } from "./statistics";
export type CsvRow = readonly [string, string, string | number, string];
/** Quote delimiters/newlines and neutralize spreadsheet formulas in untrusted labels. */
export declare function csvDocument(rows: readonly CsvRow[]): string;
/** Export every paged dimension from one scan epoch; fail rather than publish a partial report. */
export declare function statisticsCsv(read: (offset: number) => Promise<Statistics>, extra: readonly CsvRow[], current?: () => boolean): Promise<string>;

import type { Artist, Filters } from "./types";
/** Statistics labels are Aède's canonical country names and decade start years; other labels stay unlinked. */
export declare function statisticsSelection(kind: "country" | "decade", label: string, artists?: readonly Artist[]): {
    section: "countries" | "albums";
    filters: Partial<Filters>;
} | undefined;

export interface Page<T> {
    items: T[];
    total: number;
    offset: number;
    limit: number;
    scanned_at: number;
}
export interface Bucket {
    label: string;
    count: number;
    bytes: number;
}
export interface RoleCount {
    role: string;
    artists: number;
    credits: number;
}
export interface ArtistCount {
    reference: string | null;
    name: string;
    tracks: number;
}
export interface Statistics {
    scanned_at: number;
    files: number;
    tracks: number;
    albums: number;
    compilations: number;
    artists: number;
    album_artists: number;
    labels: number;
    genres: number;
    duration_ms: number;
    bytes: number;
    tracks_without_album: number;
    completeness: {
        covers: number;
        years: number;
        genres: number;
        mbid: number;
    };
    by_codec: Page<Bucket>;
    by_quality: Page<Bucket>;
    by_sample_rate: Page<Bucket>;
    by_decade: Page<Bucket>;
    by_country: Page<Bucket>;
    roles: Page<RoleCount>;
    top: {
        artists: Page<ArtistCount>;
        writers: Page<ArtistCount>;
    };
}
/** Validate real server measurements; malformed or partial pages cannot imply zero. */
export declare function parseStatistics(value: unknown, offset: number): Statistics;
/** Each table has independent paging; tables at the same offset share one bounded read. */
export declare function statisticsReader(read: (offset: number) => Promise<unknown>): (offset: number) => Promise<Statistics>;
export declare const numberLabel: (value: number) => string;
export declare function bytesLabel(value: number): string;
export declare function durationLabel(ms: number): string;
/** Doctor is read-only; absent measurements stay an error rather than invented zeroes. */
export declare function parseDiagnosis(value: unknown): {
    summary: {
        error: number;
        warning: number;
        info: number;
    };
    unverified_files: number;
    pending_analyses: number;
};

import type { Album, Artist } from "./types";
export interface TagCard {
    reference: string;
    label: string;
    kind: "artist" | "album" | "track";
    cover: string | null;
}
/** Uniform cards keep directly tagged targets distinct, including contributor-only artists. */
export declare function cachedTagCard(reference: string, artists: readonly Artist[], albums: readonly Album[]): TagCard | undefined;
/** A missing cached target is resolved by its exact owner-qualified identity, never hidden or inferred. */
export declare function parseTagCard(value: unknown, reference: string): TagCard;

import type { Annotation } from "./server";
/** Current-account annotations alone define the vocabulary; colliding source identities stay distinct. */
export declare function tagCatalog(rows: readonly (Annotation | undefined)[]): {
    key: string;
    label: string;
    count: number;
}[];
/** Tag search is explicit in this view; assigning a tag to an artist never assigns it to their releases. */
export declare function taggedEntries(rows: readonly (Annotation | undefined)[], selected: string | readonly string[], query: string): Annotation[];
/** Resolve at most ten visible track details, with two workers and per-item failures. */
export declare function taggedTrackWindow<T>(references: readonly string[], offset: number, read: (reference: string) => Promise<T>, current?: () => boolean): Promise<({
    reference: string;
    track: T;
} | {
    reference: string;
    error: string;
})[]>;

import type { SourceId } from "./sources";
import type { AccountSession } from "./server";
type Store = Pick<Storage, "getItem" | "setItem">;
interface Entry {
    scope: string;
    tags: string[];
}
/** Excluded suggestions never remove annotations; partitions retain authority and account identity. */
export declare function readTagPreferences(storage: Pick<Storage, "getItem">): Entry[];
export declare function excludedTags(entries: readonly Entry[], session: AccountSession | undefined, source?: SourceId): readonly string[];
/** Saved suppression is reversible and changes autocomplete only. */
export declare function setTagExcluded(storage: Store, session: AccountSession, tag: string, excluded: boolean, source?: SourceId): Entry[];
/** Explicitly re-entered, successfully saved tags become suggestions again in this scope only. */
export declare function rememberEnteredTags(storage: Store, session: AccountSession, tags: readonly string[], source?: SourceId): Entry[];
export declare function suggestionVocabulary(vocabulary: readonly string[], entries: readonly Entry[], session: AccountSession | undefined, source?: SourceId): string[];
/** Failed storage writes leave the previous confirmed vocabulary intact. */
export declare function createTagPreferences(storage?: Store): {
    entries: import("solid-js").Accessor<Entry[]>;
    error: import("solid-js").Accessor<string>;
    remember: (session: AccountSession, tags: readonly string[], source?: SourceId) => void;
    update: (session: AccountSession, tag: string, excluded: boolean, source?: SourceId) => void;
};
export {};

import type { Annotation } from "./server";
/** Split committed separators, trim whitespace and preserve the first spelling of a tag. */
export declare function commitTags(selected: readonly string[], draft: string): string[];
/** Choosing a suggestion replaces only the final fragment; earlier comma-separated input stays pending. */
export declare function completeTagDraft(draft: string, suggestion: string): string;
/** Suggestions use only saved annotations loaded for the current account, never other owners. */
export declare function tagVocabulary(annotations: readonly (Annotation | undefined)[]): string[];
/** Prefix matching is accent/case insensitive, bounded and excludes already selected tokens. */
export declare function tagSuggestions(vocabulary: readonly string[], draft: string, selected: readonly string[]): string[];

import { type Preferences } from "./preferences";
export declare const colorKeys: Exclude<keyof Preferences, "language">[];
/** Portable colour-only themes never import account, language or service credentials. */
export declare function readTheme(raw: string, language: Preferences["language"]): Preferences;
export declare function writeTheme(name: string, value: Preferences): string;

import { type AnalysisSection } from "../analysis-report/disclosure";
export declare const pageSizes: readonly [25, 50, 100, 200];
export type ArtistView = "discography" | "editorial";
export interface ToolPreferences {
    analysisSections: AnalysisSection[];
    artistView: ArtistView;
    full: boolean;
    threads: number;
    summaries: boolean;
    covers: boolean;
    fanart: boolean;
    lyrics: boolean;
    discogs: boolean;
    excluded: ("local" | "server")[];
    trackPageSize: number;
    showMissingAlbums: boolean;
    coverSize: number;
    coverSizes: Partial<Record<"albums" | "compilations" | "genres" | "composers", number>>;
}
export declare const defaultToolPreferences: ToolPreferences;
type Store = Pick<Storage, "getItem" | "setItem">;
/** Read non-secret scan, enrichment and browsing choices; preserve invalid stores. */
export declare function readToolPreferences(storage: Store): ToolPreferences;
/** Merge independent sections before writing; a failed write never claims a saved choice. */
export declare function saveToolPreferences(storage: Store, patch: Partial<ToolPreferences>): ToolPreferences;
/** Reactive settings update only after persistence; callers display the returned error. */
export declare function createToolPreferences(storage?: Store): {
    value: import("solid-js").Accessor<{
        analysisSections: AnalysisSection[];
        artistView: ArtistView;
        full: boolean;
        threads: number;
        summaries: boolean;
        covers: boolean;
        fanart: boolean;
        lyrics: boolean;
        discogs: boolean;
        trackPageSize: number;
        showMissingAlbums: boolean;
        coverSize: number;
        coverSizes: Partial<Record<"albums" | "compilations" | "genres" | "composers", number>>;
        excluded: ToolPreferences["excluded"];
    }>;
    error: import("solid-js").Accessor<string>;
    update: (patch: Partial<ToolPreferences>) => void;
};
export {};

import type { CatalogTrack } from "./track-page";
import type { Filters, Album } from "./types";
/** Dynamic criteria keep track membership on Aède instead of expanding matching albums. */
export declare function trackCollectionExpression(filters: Filters, reverse?: boolean): string;
/** Offline projections use only retained titles and edition years; unknown facts remain explicit. */
export declare function trackBrowseRows(tracks: readonly CatalogTrack[], albums: readonly Pick<Album, "reference" | "year">[], filters: Filters): CatalogTrack[];
export declare function trackBrowsePage(tracks: readonly CatalogTrack[], albums: readonly Pick<Album, "reference" | "year">[], filters: Filters, reverse: boolean, offset: number): {
    items: CatalogTrack[];
    total: number;
};

import type { Track } from "./server";
export interface TrackDetail extends Track {
    release: string | null;
    disc_no: number | null;
    track_no: number | null;
    size: number;
    spectrum_available: boolean;
    properties: {
        codec: string;
        container: string;
        sample_rate: number | null;
        bit_depth: number | null;
        channels: number | null;
        bitrate_kbps: number | null;
        lossless: boolean | null;
    };
    tags: Record<string, string[]>;
    credits: {
        reference: string;
        name: string;
        role: string;
        source: string;
    }[];
}
/** Validate the attributed metadata returned by Aède's track detail, without inference. */
export declare function parseTrackDetail(value: unknown, reference: string): TrackDetail;

import type { AccountSession } from "./server";
import type { Job } from "./jobs";
/** Load words on explicit expansion; probe only a completed acquisition or a legacy detail page. */
export declare function createTrackLyrics(options: {
    reference: () => string;
    available: () => boolean | undefined;
    session: () => AccountSession | undefined;
    jobs: () => readonly Job[];
    detail?: boolean;
}): {
    visible: import("solid-js").Accessor<boolean>;
    toggle: () => boolean;
    available: () => boolean;
    lyrics: () => import("./lyrics").Lyrics | null | undefined;
    loading: () => boolean;
    error: () => string;
    refresh: () => undefined;
};

import type { Artist, Album } from "./types";
import type { TrackDetail } from "./track-detail";
import { type SourceId } from "./sources";
export type MetadataBrowse = {
    kind: "browse";
    section: "artists" | "albums" | "genres" | "labels";
    query: string;
    year?: number;
};
export type MetadataTarget = {
    kind: "route";
    href: string;
} | {
    kind: "label";
    name: string;
    source: SourceId;
} | MetadataBrowse;
/** Match exact source-owned identities; raw names without a unique entity open an explicit catalogue search. */
export declare function trackMetadataTarget(key: string, value: string, detail: Pick<TrackDetail, "reference" | "release" | "credits">, artists: readonly Artist[], albums: readonly Album[]): MetadataTarget | undefined;

import type { Track } from "./server";
export interface CatalogTrack extends Track {
    release: string | null;
    album_title: string | null;
    disc_no: number | null;
    track_no: number | null;
    album_position: number | null;
    spectrum_available: boolean;
}
export declare const record: (v: unknown) => Record<string, unknown>;
/** Validate server windows and stable track identities, including tracks outside any release. */
export declare function parseTrackPage(value: unknown, offset: number): {
    items: CatalogTrack[];
    total: number;
    scannedAt: number;
};
/** Shared lightweight row validation; full analysis payloads are fetched separately. */
export declare function parseCatalogTrack(value: unknown): CatalogTrack;

import type { SourceId } from "./sources";
/** Explicit repair reconnects only a managed local source; remote authority must already exist. */
export declare function restoreTrackCache(source: SourceId, ports: {
    connected: boolean;
    connectLocal: () => Promise<void>;
    sync: (source: SourceId) => Promise<void>;
    hasTracks: (source: SourceId) => boolean;
    failure: () => string;
}, current: () => boolean): Promise<true | undefined>;

import type { TransferStatus } from "./transfers";
/** Poll without overlapping reads; private progress/diagnostics belong to one exact account generation.
 * Account replacement retains only the device-wide running lock until the next native confirmation.
 */
export declare function createTransferMonitor(scope: () => unknown, read: () => Promise<TransferStatus>, native: () => boolean, error: (failure: unknown) => void): {
    status: import("solid-js").Accessor<TransferStatus>;
    poll: () => Promise<void>;
    command: (work: () => Promise<unknown>, accepted?: () => void) => Promise<void>;
};

import type { PlayerVolume } from "./players";
import type { TransferOptions } from "./transfers";
/** Destination-dependent conversion recipe; no filesystem or native writes. */
export declare function createTransferRecipe(volumes: () => readonly PlayerVolume[] | undefined, pending: () => boolean): {
    selected: import("solid-js").Accessor<string>;
    options: import("solid-js").Accessor<TransferOptions>;
    setOptions: import("solid-js").Setter<TransferOptions>;
    select(value: string): void;
};

import type { PlayableSelection } from "./playback-selection";
export interface TransferOptions {
    format: "original" | "mp3" | "aac" | "opus" | "flac" | "wav";
    verify: boolean;
    replace: boolean;
}
export interface TransferPreview {
    id: string;
    tracks: number;
    bytes: number;
    destination: string;
    ipod: boolean;
    files: string[];
}
export interface TransferStatus {
    phase: string;
    running: boolean;
    done?: number;
    total?: number;
    current?: string;
    file_bytes?: number;
    file_total?: number;
    error?: string;
}
/** Transfers are sets of source files; repeated queue occurrences must not copy/convert the same file again. */
export declare function addTransferSelection(existing: readonly PlayableSelection[], added: readonly PlayableSelection[]): PlayableSelection[];
/** Overall progress counts completed tracks plus the currently downloaded original, never a false completed copy. */
export declare function transferProgress(status: TransferStatus): number;
export declare const transferPhases: Readonly<Record<string, string>>;

/** Presentation records; server entities will retain their stable Aède references. */
export interface Artist {
    reference: string;
    name: string;
    genre: string;
    country: string | null;
    countryCode?: string;
    /** Unlocalized MusicBrainz area retained for Aède country/region statistics navigation. */
    originArea?: string;
    biography: string;
    artwork: boolean;
    genres?: readonly string[];
    releaseRefs?: readonly string[];
    searchFields?: readonly string[];
    biographyCredit?: {
        url: string;
        lang: string;
        licence: string;
    };
    media?: {
        banner: boolean;
        background: boolean;
        portrait: boolean;
        logo?: boolean;
    };
    relations?: readonly {
        reference: string;
        name: string;
        weight: number;
        kind: string;
        source: string;
    }[];
}
/** A release edition, kept distinct from a recording or composition. */
export interface Album {
    reference: string;
    artist: string | null;
    title: string;
    year: number | null;
    compilation: boolean;
    /** Sourced genre labels in Aède’s presentation; owner tags belong to annotations/search fields. */
    tags: readonly string[];
    contributors?: readonly string[];
    /** Exact composer credit identities projected by Aède; absent in older caches. */
    composers?: readonly string[];
    searchFields?: readonly string[];
    cover?: boolean;
    trackCount?: number;
    addedAt?: number | null;
    note?: string;
    rating?: number;
    favourite?: boolean;
}
export type Interval = readonly [number, number];
export type RailMode = "years" | "alphabet" | "both" | "none";
/** Both active intervals intersect; hidden rails do not filter results. */
export interface Filters {
    recentOnly?: boolean | undefined;
    composers?: readonly string[];
    mode: RailMode;
    years: Interval;
    alphabet: Interval;
    includeUnknownYear: boolean;
    query: string;
    countries?: readonly (string | null)[];
    genre?: string | undefined;
    genres?: readonly string[];
}

import { type Accessor } from "solid-js";
/** Pointer targeting never moves the consumed clock; a new track or unavailable seek clears it. */
export declare function createWaveformHover(reference: Accessor<string>, disabled: Accessor<boolean>): {
    position: () => number | undefined;
    move(x: number, left: number, width: number, duration: number): void;
    clear: () => undefined;
};

import type { PlaybackState } from "./playback-state";
type Pointer = PointerEvent & {
    currentTarget: HTMLInputElement;
};
/** Pointer seeking keeps preview and commit separate from keyboard range input. */
export declare function createWaveformPointer(options: {
    state: () => PlaybackState;
    disabled: () => boolean;
    position: (event: Pointer) => number;
    hover: (event: Pointer) => void;
    preview: (position: number) => void;
    seek: (position: number) => void;
    clear: () => void;
}): {
    down(event: Pointer): void;
    move(event: Pointer): void;
    up(event: Pointer): void;
    cancel: (event?: Event) => void;
};
export {};

import { type Accessor } from "solid-js";
import type { PlaybackState } from "./playback-state";
import { waveformPath, type Waveform } from "./waveform";
export interface WaveformResult {
    reference: string;
    waveform?: Waveform;
    error?: string;
}
/** Separate immutable envelope geometry from clock/seek updates; never draw a previous track's data. */
export declare function createWaveformPresentation(state: Accessor<PlaybackState>, latest: Accessor<WaveformResult | undefined>, draw?: typeof waveformPath): Accessor<{
    path: string;
    error: string;
    duration_ms: number;
}>;

export interface Waveform {
    reference: string;
    duration_ms: number;
    sample_rate: number;
    bucket_frames: number;
    peaks: number[];
}
/** Only complete, attributed bounded envelopes may represent a track's timeline. */
export declare function parseWaveform(raw: unknown, reference: string): Waveform;
/** Bucket positions follow decoded frames, including the shorter final bucket. */
export declare function waveformPath(waveform: Waveform): string;
/** A pointer addresses the full SVG width; native range thumbs have a shorter travel. */
export declare function waveformPosition(x: number, left: number, width: number, duration: number): number;

import "./styles.css";

import type { createPlayback } from "../library/playback";
import type { createRadioPlayback } from "../radio/playback";
import type { createPodcastPlayback } from "../podcasts/playback";
type Audio = {
    player: Pick<ReturnType<typeof createPlayback>, "busy" | "state" | "toggleMute" | "action">;
    radio: Pick<ReturnType<typeof createRadioPlayback>, "station" | "mute" | "stop">;
    podcast: Pick<ReturnType<typeof createPodcastPlayback>, "episode" | "mute" | "stop">;
};
/** Route global transport shortcuts without changing page-specific Play selection. */
export declare function controlAudioShortcut(action: "mute" | "stop" | "next" | "previous", audio: Audio): Promise<void>;
type ToggleAudio = {
    player: Pick<ReturnType<typeof createPlayback>, "busy" | "state" | "queue" | "action" | "togglePlayback" | "startReference">;
    radio: Pick<ReturnType<typeof createRadioPlayback>, "station" | "status" | "pause" | "resume">;
    podcast: Pick<ReturnType<typeof createPodcastPlayback>, "episode" | "status" | "pause" | "resume">;
};
/** Prepared-list priority is independent of the visible page's contextual Play target. */
export declare function toggleAudioShortcut(audio: ToggleAudio, reference: string): Promise<void>;
export {};

import type { Route } from "./routes";
/** An empty artist graph is valid for albumless tracks and is never a connection failure. */
export declare function needsCatalogPrompt(route: Route, artists: number, connected: boolean, busy: boolean): boolean;

import type { Route } from "./routes";
/** A detail selection wins; Cover Flow's front album precedes other visible Play controls. */
export declare function contextualReference(detail: string, rows: readonly {
    reference: string;
    disabled: boolean;
    central: boolean;
    visible: boolean;
}[]): string;
/** Repeat belongs to an active local transport, never just an authenticated library. */
export declare function repeatDisabled(status: string, busy: boolean, ready: boolean, external: boolean): boolean;
/** A prepared playlist must be launchable even while an external stream owns the other views. */
export declare function footerTransport(input: {
    queueView: boolean;
    queued: boolean;
    podcast: boolean;
    radio: boolean;
}): "catalog" | "podcast" | "radio";
/** Detail routes retain their origin menu; only the actual workspace owns prepared-list controls. */
export declare function isQueueWorkspace(route: Route): boolean;

interface ExternalActivation {
    href: string;
    button: number;
    preventDefault: () => void;
}
/** Native source links leave the WebView only through the validated system-browser IPC; preview uses ordinary links. */
export declare function activateExternalLink(action: ExternalActivation, native: boolean, open: (url: string) => Promise<void>, failure: (message: string) => void): boolean;
export {};

import { type Section } from "./routes";
/** Host adapter keeps navigation policy testable without a DOM or a second router. */
export interface NavigationHost {
    current: () => {
        hash: string;
        state: unknown;
    };
    push: (hash: string, state: unknown) => void;
    replace: (state: unknown) => void;
    back: () => void;
    top: () => number;
    restore: (top: number) => void;
    defer: (fn: () => void) => void;
    listen: (fn: () => void) => () => void;
}
/** Each detail remembers its actual preceding page; Back restores that history entry's scroll. */
export declare function createNavigation(host: NavigationHost, labelFor: (hash: string) => string): {
    route: import("solid-js").Accessor<import("./routes").Route>;
    section: import("solid-js").Accessor<Section>;
    backLink: () => {
        href: string;
        label: string;
    } | undefined;
    navigate: (hash: string) => boolean;
    goBack: () => void;
};
/** Native and browser hash histories share the same origin/scroll contract. */
export declare function browserNavigationHost(): NavigationHost;

import { type Section } from "./routes";
type Store = Pick<Storage, "getItem" | "setItem">;
export type MenuItem = Section | "heading:library" | "heading:personal" | "heading:sources" | "heading:tools" | `separator:${string}`;
export interface MenuPreferences {
    order: MenuItem[];
    hidden: MenuItem[];
    labels?: Partial<Record<MenuItem, string>>;
}
export declare function menuHeading(id: Section): MenuItem;
export declare function menuItem(id: MenuItem): {
    id: Section;
    label: string;
    symbol: string;
    kind: "section";
} | {
    id: MenuItem;
    kind: "heading" | "separator";
    label: string;
    symbol: string;
};
export declare const defaultMenuOrder: () => MenuItem[];
/** New sections remain visible by default; corrupt preferences are never replaced implicitly. */
export declare function readMenuPreferences(storage: Pick<Storage, "getItem">): MenuPreferences;
/** Check the retained store before publishing a validated device-local menu configuration. */
export declare function saveMenuPreferences(storage: Store, value: MenuPreferences): MenuPreferences;
/** Move one item before a target; invalid or self targets retain the complete original order. */
export declare function moveMenu(order: readonly MenuItem[], item: MenuItem, before: MenuItem): MenuItem[];
/** The shell and Settings share this confirmed state; saving failure leaves navigation unchanged. */
export declare function createMenuPreferences(storage?: Store): {
    value: import("solid-js").Accessor<MenuPreferences>;
    error: import("solid-js").Accessor<string>;
    update(next: MenuPreferences): void;
    reset(): void;
};
/** Empty groups disappear while explicit spacers retain their chosen position. */
export declare function visibleMenu(value: MenuPreferences, unavailable?: ReadonlySet<MenuItem>): MenuItem[];
/** Custom names are literal in both languages; absent overrides use the translated default. */
export declare function menuLabel(id: MenuItem, preferences: MenuPreferences): string;
export {};

import type { Route } from "./routes";
/** Catalog bounds stay available when returning to lists, but never filter detail pages. */
export declare function catalogRails(route: Route): boolean;

export type Section = "cd" | "concerts" | "encyclopedia" | "achievements" | "artists" | "albums" | "tracks" | "compilations" | "countries" | "genres" | "composers" | "labels" | "moods" | "playback" | "rated" | "tags" | "favourites" | "collections" | "history" | "playlists" | "podcasts" | "radio" | "doctor" | "analysis" | "relations" | "players" | "statistics" | "settings" | "advanced-search";
export type Route = {
    kind: "section";
    section: Section;
    tab?: "services";
} | {
    kind: "artist" | "album" | "track" | "label";
    reference: string;
} | {
    kind: "not-found";
};
export declare const sections: readonly {
    id: Section;
    label: string;
    symbol: string;
}[];
/** Hash navigation works in native packaged assets without server rewrites. */
export declare function parseRoute(hash: string): Route;
/** Result states use the same semantic glyph as their navigation section. */
export declare function sectionIcon(section: Section): string;
/** Country browsing groups artists; Genres browses their album editions and title initials. */
export declare function artistCatalog(section: Section): boolean;
/** Catalogue views that display the account-private album completion marker. */
export declare function albumListeningCatalog(section: Section): boolean;
/** Name an actual origin page; utilities have no sidebar item, and entity names stay untranslated. */
export declare function navigationLabel(route: Route, sectionName: (section: Section) => string, detailName: (detail: Extract<Route, {
    reference: string;
}>) => string | undefined): string;

import { type Accessor } from "solid-js";
import type { Filters, Interval } from "../library/types";
import type { Section } from "./routes";
/** Filters belong to their view and exact account/source generation, never a successor login. */
export declare function createScopedFilters(section: Accessor<Section>, domain: Accessor<Interval>, identity?: Accessor<unknown>): {
    value: () => Filters;
    set: (value: Filters) => {
        achievements?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        "advanced-search"?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        albums?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        analysis?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        artists?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        cd?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        collections?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        compilations?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        composers?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        concerts?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        countries?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        doctor?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        encyclopedia?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        favourites?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        genres?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        history?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        labels?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        moods?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        playback?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        players?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        playlists?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        podcasts?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        radio?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        rated?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        relations?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        settings?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        statistics?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        tags?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        tracks?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
    };
    select: (scope: Section, patch: Partial<Filters>) => {
        achievements?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        "advanced-search"?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        albums?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        analysis?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        artists?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        cd?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        collections?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        compilations?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        composers?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        concerts?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        countries?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        doctor?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        encyclopedia?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        favourites?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        genres?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        history?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        labels?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        moods?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        playback?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        players?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        playlists?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        podcasts?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        radio?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        rated?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        relations?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        settings?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        statistics?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        tags?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
        tracks?: {
            value: Filters;
            domain: Interval;
            identity: unknown;
        };
    };
};
export interface ActiveFilter {
    key: string;
    label: string;
}
/** Hidden rails do not restrict results and are omitted from the visible summary. */
export declare function activeFilters(value: Filters, domain: Interval): ActiveFilter[];
/** Remove only the chosen restriction, retaining rail visibility and unrelated selections. */
export declare function clearFilter(value: Filters, key: string, domain: Interval): Filters;

import type { Section } from "./routes";
/** Header search advertises only the filters consumed by the current view. */
export declare function searchContext(section?: Section): {
    disabled: boolean;
    contextual: boolean;
    label: string;
    placeholder: string;
};

export declare const shortcutKey = "phemios.shortcuts.v1";
export declare const defaultShortcuts: {
    toggle: string;
    stop: string;
    previous: string;
    next: string;
    mute: string;
    search: string;
    advanced: string;
    playback: string;
    settings: string;
    queue: string;
};
export type ShortcutAction = keyof typeof defaultShortcuts;
export type Shortcuts = Record<ShortcutAction, string>;
type KeyEvent = Pick<KeyboardEvent, "code" | "ctrlKey" | "metaKey" | "altKey" | "shiftKey" | "repeat"> & {
    defaultPrevented?: boolean;
};
/** Mod is portable: Command on macOS, Control elsewhere; typing contexts never trigger actions. */
export declare function keyBinding(event: KeyEvent): string | undefined;
export declare function parseShortcuts(raw: string | null): Shortcuts;
export declare function shortcutAction(event: KeyEvent, bindings: Shortcuts, editing: boolean): ShortcutAction | undefined;
export {};

import { type Shortcuts, type ShortcutAction } from "./shortcuts-policy";
export { shortcutKey, defaultShortcuts, parseShortcuts, keyBinding, shortcutAction, type Shortcuts, type ShortcutAction, } from "./shortcuts-policy";
/** Local persistence is acknowledged before the existing owner-private preference synchronizer runs. */
export declare function createShortcuts(): {
    value: import("solid-js").Accessor<Shortcuts>;
    error: import("solid-js").Accessor<string>;
    update: (action: ShortcutAction, binding: string) => void;
    reset: () => void;
};

import { type Accessor } from "solid-js";
/** Shell-owned page state survives detail remounts; new search/session scopes restart at zero. */
export declare function createTrackPaging(query: Accessor<string>, session: Accessor<unknown>, size?: Accessor<number>): {
    offset: Accessor<number>;
    setOffset: (value: number) => void;
};

import type { SourceId } from "../library/sources";
/** Only a literal private LAN host can prefill the server-side bind; never resolve DNS or use loopback. */
export declare function networkAudioAddress(source: SourceId, server: string | undefined): string;

import { type Device } from "./profiles";
import { type SourceId } from "../library/sources";
import type { AccountSession } from "../library/server";
interface Run {
    id: number;
    status: string;
}
/** Explicit network-device commands belong to one exact source/login; ordinary browsing never discovers LAN devices. */
export declare function createNetworkAudio(options: {
    source: () => SourceId;
    session: (source: SourceId) => AccountSession | undefined;
    queue: () => readonly {
        reference: string;
    }[];
    beforeStart: () => Promise<void>;
}): {
    devices: import("solid-js").Accessor<Device[]>;
    profiles: import("solid-js").Accessor<boolean>;
    observed: import("solid-js").Accessor<{
        key: string;
        sha256: string;
    } | undefined>;
    run: import("solid-js").Accessor<Run | undefined>;
    active: () => boolean;
    busy: import("solid-js").Accessor<boolean>;
    error: () => string;
    enabled: () => boolean;
    clearError: () => void;
    cancelRead(): void;
    discover: (bind: string) => Promise<void>;
    addSlimproto: (bind: string, ip: string) => Promise<void>;
    inspect: (key: string) => Promise<void>;
    start: (bind: string, endpoint: string, settings?: {
        pin?: string;
        replace?: boolean;
    }) => Promise<void>;
    stop: () => Promise<void>;
};
export {};

import type { createPlayback } from "../library/playback";
/** Confirm local transport shutdown before admitting another audio source. */
export declare function prepareNetworkPlayback(player: Pick<ReturnType<typeof createPlayback>, "busy" | "state" | "action">, failure: string): Promise<void>;

export type Protocol = "openhome" | "googlecast" | "slimproto" | "upnp";
export interface Device {
    name: string;
    endpoint: string;
    protocol: Protocol;
}
export declare const protocolNames: Record<Protocol, string>;
export declare const deviceKey: (device: Device) => string;
/** Versioned discovery stays bounded; a legacy response represents UPnP only. */
export declare function parseDevices(raw: unknown): Device[];
/** Manual SlimProto targets remain literal LAN IPv4 peers; the server repeats admission. */
export declare function slimprotoDevice(ip: string): Device;

import { type SourceId } from "../library/sources";
/** Versioned bridge metadata; no music folders or credentials are exposed. */
export interface RuntimeInfo {
    bridgeVersion: number;
    name: string;
    version: string;
    native: boolean;
    capabilities?: readonly string[];
    embedded?: {
        aede: string;
        flaccompagnon: string;
    };
}
/** Browser previews stay offline and report their lack of native capabilities. */
export declare function getRuntimeInfo(): Promise<RuntimeInfo>;
/** All native data operations carry the bridge version and stay on typed IPC. */
export declare const isNative: () => boolean;
/** Recover only a process-owned login; a newer login/logout always retires this read. */
export declare function restoreAedeSession(source: SourceId): Promise<import("../library/server").AccountSession | undefined>;
/** An imported public certificate applies only to this explicit local login. */
export interface LocalServerProfile {
    format: "aede-local-server";
    version: 1;
    address: string;
    username: string;
    certificate: number[];
}
export declare const importLocalServerProfile: () => Promise<LocalServerProfile | null>;
export declare function loginAede(server: string, username: string, password: string, certificate?: number[]): Promise<import("../library/server").AccountSession>;
export declare const downloadAede: (id: string, source?: SourceId) => Promise<string>;
/** Fetch the server-selected complete report and save it under the native Downloads folder. */
export declare const downloadAnalysisAede: (reference: string) => Promise<string>;
export declare function logoutAede(): Promise<void>;
export declare const syncAede: (source?: SourceId) => Promise<unknown>;
/** Clear only disposable remote data; older running hosts must be updated explicitly. */
export declare function clearServerCache(current?: () => boolean): Promise<void>;
export declare const cachedAede: (source?: SourceId) => Promise<unknown>;
export declare const artworkAede: (reference: string, kind: string) => Promise<ArrayBuffer>;
export declare function requestAede<T>(path: string, query?: Record<string, string>, method?: string, body?: unknown, source?: SourceId, expectedAccount?: import("../library/server").AccountSession): Promise<T>;
/** Optical access uses only opaque, previously discovered native selectors. */
export declare const scanCd: (id?: string) => Promise<unknown>;
/** Only the native file dialog can choose a CUE path and admit its bounded relative BIN files. */
export declare const openCdImage: () => Promise<string | null>;
export declare const ejectCd: (id: string) => Promise<unknown>;
export declare const startCd: (token: string, tracks: readonly string[], device: string, index: number) => Promise<void>;
/** PCM credentials and device callbacks stay native; only bounded transport controls cross IPC. */
export declare const playbackState: () => Promise<unknown>;
export declare const playbackOutputs: () => Promise<unknown>;
export declare const playbackStart: (tracks: readonly string[], device: string, index: number, policy?: string) => Promise<void>;
/** Append exact occurrences to the captured native queue, never restarting the current output. */
export declare const playbackAppend: (queueId: number, expectedTotal: number, tracks: readonly string[]) => Promise<void>;
export declare const playbackControl: (action: string, value?: unknown) => Promise<unknown>;
/** Save the authenticated server-selected spectrum without exposing filesystem writes. */
export declare const downloadSpectrumAede: (reference: string) => Promise<string>;
/** Explicit external radio requests never reuse Aède authority or credentials. */
export declare const searchRadio: (name: string, country: string, tag: string, offset: number, secureOnly: boolean) => Promise<unknown>;
export declare const radioStatistics: () => Promise<unknown>;
export declare const resolveRadio: (uuid: string) => Promise<unknown>;
/** Only ownerless requests use the explicitly selected personal-library scope. */
export declare function setRequestSource(source: SourceId): void;
export interface LocalStatus {
    enabled: boolean;
    running: boolean;
    roots: {
        path: string;
        available: boolean;
        mount: string | null;
    }[];
    keys: {
        fanart: boolean;
        acoustid: boolean;
    };
}
export declare const localStatus: () => Promise<LocalStatus>;
export declare function startLocal(): Promise<import("../library/server").AccountSession>;
export declare function stopLocal(): Promise<void>;
export declare const pickLocalRoots: () => Promise<void>;
/** Pick candidates only; exclusions are then applied explicitly to the captured local session. */
export declare function pickLocalExclusions(current?: () => boolean): Promise<string[]>;
export declare const scanLocal: (full: boolean, threads: number) => Promise<{
    task_id: number;
    status: "queued";
}>;
export declare const localRootAction: (path: string, action: "remove" | "exclude" | "include") => Promise<void>;
export declare const saveLocalKeys: (fanart: string, acoustid: string, removeFanart: boolean, removeAcoustid: boolean) => Promise<void>;
/** Automatic missing covers follow the user's chosen policy; credentials stay on their Aède source. */
export declare const missingCoverAede: (artist: string, group: string, download: boolean) => Promise<ArrayBuffer>;
/** Read mounted player/card/drive destinations; this command cannot mount or write them. */
export declare const discoverPlayers: () => Promise<unknown>;
/** Grant a destination through the native dialog only; cancellation leaves the current selection intact. */
export declare const pickTransferFolder: () => Promise<unknown>;
/** Forget a manual destination token without deleting its directory or files. */
export declare const forgetTransferFolder: (id: string) => Promise<void>;
/** Eject only an opaque native-discovered destination; never accepts an OS path. */
export declare const ejectPlayer: (id: string) => Promise<void>;
/** Explicit, bounded public RSS retrieval has no access to Aède credentials. */
export declare const readPodcastFeed: (url: string) => Promise<string>;
/** Native dialogs restrict theme exchange to a bounded user-selected JSON document. */
/** Read one user-selected JSON report without importing it into the catalogue. */
export declare const importAnalysis: () => Promise<string | null>;
export declare const importTheme: () => Promise<string | null>;
export declare const exportTheme: (document: string) => Promise<string | null>;
/** Save the complete CSV only to a native user-selected destination. */
export declare const exportStatistics: (document: string) => Promise<string | null>;
/** Explicit LAN HQPlayer probe, independent of Aède authentication and local audio processing. */
export declare const connectHqPlayer: (host: string, port: number, mappings: readonly {
    from: string;
    to: string;
}[]) => Promise<{
    connected: boolean;
    product: string;
    version: string;
    name: string;
}>;
export declare const disconnectHqPlayer: () => Promise<void>;
/** Explicit episode download streams directly to system Downloads, without overwriting prior files. */
export declare const downloadPodcastEpisode: (url: string, title: string) => Promise<string>;
/** Explicit public Wikipedia search, independent of library/account authority. */
export declare const searchEncyclopedia: (language: import("../i18n").Language, query: string) => Promise<unknown>;
/** Read one public main-namespace page as bounded plain text, never executable HTML. */
export declare const readEncyclopedia: (language: import("../i18n").Language, pageId: number) => Promise<unknown>;
/** Read only a public retained biography; never dispatch a network request. */
export declare const readCachedBiography: (language: import("../i18n").Language, title: string) => Promise<unknown>;
/** Read the exact attributed title, resolving canonical redirects without a name search. */
export declare const readEncyclopediaTitle: (language: import("../i18n").Language, title: string) => Promise<unknown>;
/** Explicit source-link activation uses a bounded HTTPS-only native browser handoff. */
export declare const openExternalLink: (url: string) => Promise<void>;
/** Follow a verified interlanguage link rather than searching by the displayed article title. */
export declare const translateEncyclopedia: (language: import("../i18n").Language, pageId: number, target: import("../i18n").Language) => Promise<unknown>;
/** Export the already-read edition under native Downloads; no arbitrary destination or network request. */
export declare const downloadEncyclopedia: (article: import("../encyclopedia/wikipedia").WikipediaArticle) => Promise<string>;
/** Device-private provider configuration returns only its presence, never the retained key. */
export declare const configureConcerts: (key?: string | null, remove?: boolean) => Promise<import("../concerts/config").ConcertConfig>;
/** Explicit fixed-provider page lookup independent of library login. */
export declare const searchConcerts: (artist: string, page: number) => Promise<unknown>;
/** Explicit native dialogs exchange bounded preferences and reviewed per-account personal backups. */
export declare const importPreferences: () => Promise<string | null>;
export declare const exportPreferences: (document: string, source?: SourceId, account?: import("../library/server").AccountSession) => Promise<string | null>;
/** Native identity selects the private podcast document; IPC supplies no account identifier or path. */
export declare function readPodcastState(source: SourceId, account: import("../library/server").AccountSession): Promise<unknown>;
/** Apply only a captured-session private podcast mutation. */
export declare function updatePodcastState(action: "save" | "remove" | "mark", payload: unknown, source: SourceId, account: import("../library/server").AccountSession): Promise<unknown>;
/** Read retained articles using only the captured process ticket and actual native source. */
export declare function readArticleState(source: SourceId, account: import("../library/server").AccountSession): Promise<unknown>;
/** Save/remove one article under exact native generation; no owner or pathname crosses IPC. */
export declare function updateArticleState(action: "save" | "remove", payload: unknown, source: SourceId, account: import("../library/server").AccountSession): Promise<unknown>;
/** Personal backup admission always captures the connected native account generation. */
export declare function readPersonalBackup(source: SourceId, account: import("../library/server").AccountSession): Promise<unknown>;
/** Explicitly reviewed restoration adds data only to the captured destination account. */
export declare function restorePersonalBackup(payload: unknown, source: SourceId, account: import("../library/server").AccountSession): Promise<void>;
/** Export the server-confirmed note for this exact source/session, never an unsaved draft. */
export declare function downloadNoteAede(reference: string): Promise<string>;
/** Destination selectors and preview tickets are issued natively; source files never enter JavaScript. */
export declare const prepareTransfer: (destination: string, references: readonly string[], options: import("../library/transfers").TransferOptions) => Promise<import("../library/transfers").TransferPreview>;
/** Only a reviewed preview can start one retained native transfer. */
export declare const startTransfer: (id: string) => Promise<unknown>;
export declare const transferStatus: () => Promise<import("../library/transfers").TransferStatus>;
export declare const cancelTransfer: () => Promise<void>;
/** Begin a new native display lease scope; a replaced controller cannot retain an older scope. */
export declare const openAwakeScope: () => Promise<string>;
/** Renew or release this exact scope; native expiry bounds lost UI/controller updates. */
export declare const updateAwakeScope: (scope: string, active: boolean) => Promise<void>;

/** Admission for explicit browser media: canonical HTTP(S), no credentials and no non-public literals.
 * This cannot validate DNS resolution or later redirects in a WebView. Native feed/download
 * clients separately guard the actual resolved socket; browser playback keeps that platform limit.
 * Public IPv6 media remains unsupported, matching the previous browser policy.
 */
export declare function publicMediaAddress(value: unknown, maxLength: number, base?: string): URL | undefined;

import type { AccountSession } from "../library/server";
import type { SourceId } from "../library/sources";
import { type Podcast } from "./feed";
export interface PodcastAccountState {
    feeds: Podcast[];
    episodes: {
        feed: string;
        id: string;
    }[];
}
/** Shared admission for native projections and explicit portable backup records. */
export declare function parsePodcastAccountState(raw: unknown): PodcastAccountState;
/** No legacy device store is read; scopes admit exact sessions and serialize narrow native mutations. */
export declare function createAccountPodcasts(session: () => AccountSession | undefined, source: () => SourceId): {
    /** Explicit restoration reload; stale reads/mutation replies cannot replace the new snapshot. */
    reload: () => number;
    feeds: () => Podcast[];
    has: (feed: string, id: string) => boolean;
    error: import("solid-js").Accessor<string>;
    loading: import("solid-js").Accessor<boolean>;
    pending: import("solid-js").Accessor<boolean>;
    capture: () => {
        current: () => boolean;
        save: (feed: Podcast) => Promise<boolean>;
        remove: (url: string) => Promise<boolean>;
        mark: (feed: string, id: string) => Promise<boolean>;
    };
    ready: () => boolean;
    writable: () => boolean;
    save: (feed: Podcast) => Promise<boolean>;
    remove: (url: string) => Promise<boolean>;
    mark: (feed: string, id: string) => Promise<boolean>;
};

/** One explicit transfer per scope; owner replacement and closing cannot publish old episode feedback. */
export declare function createEpisodeDownloads(download: (url: string, title: string) => Promise<string>, scope?: () => unknown): {
    busy: () => string;
    message: () => string;
    failed: () => boolean;
    dismiss: () => "";
    save(url: string, title: string): Promise<boolean>;
};

export interface Episode {
    id: string;
    title: string;
    url: string;
    date: string | null;
    duration: number | null;
    summary: string;
}
export interface Podcast {
    url: string;
    title: string;
    author: string;
    episodes: Episode[];
}
/** Public media addresses only: no local files, embedded credentials or private literal hosts. */
export declare function podcastUrl(value: string, base?: string): string;
/** Podcast clocks may be seconds, MM:SS or HH:MM:SS; missing/invalid durations remain unknown. */
export declare function podcastDuration(value: string): number | null;
/** Browser-native XML parsing never inserts provider HTML into the application or evaluates DTDs. */
export declare function parsePodcastFeed(xml: string, url: string): Podcast;
/** Validate retained subscriptions as strictly as fetched metadata, preserving unreadable stores. */
export declare function validatedPodcast(value: unknown): Podcast;

type Store = Pick<Storage, "getItem" | "setItem">;
/** Device-local evidence survives feed refresh/removal; unreadable data is never overwritten. */
export declare function createListenedEpisodes(storage?: Store): {
    error: import("solid-js").Accessor<string>;
    has: (feed: string, id: string) => boolean;
    mark(feed: string, id: string): void;
};
/** Union actual media TimeRanges; repeated ranges and skipped time never inflate evidence. */
export declare function episodeListened(ranges: readonly (readonly [number, number])[], duration: number): boolean;
export {};

import type { ExternalParentalMedia } from "../library/parental-access";
import { type Episode, type Podcast } from "./feed";
export interface PodcastMedia {
    played?: () => readonly (readonly [number, number])[];
    source: (url: string) => void;
    play: () => Promise<void>;
    pause: () => void;
    release: () => void;
    volume: (n: number) => void;
    seek: (seconds: number) => void;
    callbacks: (change: (status: "playing" | "connecting" | "ended" | "error") => void, time: (position: number, duration: number) => void) => void;
}
/** Finite episodes retain their media element on pause so resume does not rejoin a live stream. */
export declare function browserPodcastMedia(): PodcastMedia;
/** Explicit episode ownership and play-attempt tickets reject late completions after pause/restart.
 * Pause retains its finite media and clock; a superseded play rejection cannot release it.
 * Podcast playback never records catalogue music history.
 */
export declare function createPodcastPlayback(beforePlay: () => Promise<void>, createMedia?: typeof browserPodcastMedia, completed?: (feed: string, id: string) => void, initialVolume?: () => number | Promise<number>, captureOwner?: () => () => boolean, authorize?: (media: ExternalParentalMedia) => Promise<void>, rememberVolume?: (value: number) => void, unmutedVolume?: () => number): {
    episode: import("solid-js").Accessor<Episode | undefined>;
    podcast: import("solid-js").Accessor<Podcast | undefined>;
    status: import("solid-js").Accessor<"connecting" | "ended" | "error" | "idle" | "paused" | "playing">;
    error: import("solid-js").Accessor<string>;
    position: import("solid-js").Accessor<number>;
    duration: import("solid-js").Accessor<number>;
    volume: import("solid-js").Accessor<number>;
    start: (feed: Podcast, row: Episode) => Promise<void>;
    pause: () => void;
    resume: () => Promise<void>;
    stop: () => void;
    seek: (n: number) => void;
    changeVolume: (n: number, remember?: boolean) => void;
    mute: () => void;
};

import { type Podcast } from "./feed";
type Store = Pick<Storage, "getItem" | "setItem">;
/** Subscription metadata is local/offline, independent of Aède accounts; no audio file is cached here. */
export declare function readSubscriptions(storage: Store): Podcast[];
/** Publish UI changes only after persistence succeeds; a corrupt store is never overwritten implicitly. */
export declare function createSubscriptions(storage?: Store): {
    feeds: import("solid-js").Accessor<Podcast[]>;
    error: import("solid-js").Accessor<string>;
    save: (feed: Podcast) => boolean;
    remove: (url: string) => boolean;
};
export {};

import type { Podcast } from "./feed";
/** Capture the intended feed before confirmation; cancellation cannot mutate retained subscriptions. */
export declare function createUnsubscribe(remove: (url: string) => boolean): {
    pending: import("solid-js").Accessor<Pick<Podcast, "title" | "url"> | undefined>;
    ask: (feed: Pick<Podcast, "url" | "title">) => {
        url: string;
        title: string;
    };
    cancel: () => undefined;
    confirm(): boolean;
};

import type { AccountSession } from "../library/server";
import type { SourceId } from "../library/sources";
import type { Station } from "./directory";
export declare const radioAccountKey = "phemios.radio-favourites";
/** Stable source/authority/account identity; login renames do not create another favourite owner. */
export declare function radioFavouriteOwner(source: SourceId, session: AccountSession | undefined): string | undefined;
/** Current-owner preferences retain only public station metadata; playback never uses this service. */
export declare function createAccountRadioFavourites(owner: () => string | undefined, request: (owner: string, method: "GET" | "PATCH", body?: unknown) => Promise<unknown>): {
    stations: import("solid-js").Accessor<Station[]>;
    error: import("solid-js").Accessor<string>;
    busy: import("solid-js").Accessor<boolean>;
    available: () => boolean;
    has: (uuid: string) => boolean;
    toggle: (row: Station) => Promise<void>;
    importDevice: (rows: Station[]) => Promise<void>;
};

import type { DirectorySnapshot } from "./directory-search";
import type { RadioCriteria } from "./search";
interface BrowseSnapshot {
    draft: RadioCriteria;
    directory: DirectorySnapshot;
}
/** Retain one bounded public directory page for this process, never credentials, favourites or media.
 * Submitted criteria remain distinct from unsent fields; view disposal cannot mutate saved rows.
 */
export declare function createRadioBrowseSession(): {
    read: () => BrowseSnapshot | undefined;
    remember(draft: RadioCriteria, directory: DirectorySnapshot): void;
};
/** Account-independent browsing survives ordinary route remounts and resets when the app exits. */
export declare const radioBrowseSession: {
    read: () => BrowseSnapshot | undefined;
    remember(draft: RadioCriteria, directory: DirectorySnapshot): void;
};
export {};

import type { RadioMedia } from "./playback";
/** One disposable radio voice. CORS refusal retries ordinary media once; HLS keeps its native path. */
export declare function browserRadioMedia(options?: {
    audio?: () => HTMLAudioElement;
    context?: () => AudioContext;
}): RadioMedia;

import type { Station } from "./directory";
import type { createRadioPlayback } from "./playback";
/** The dial controls its selected station, sharing Stop and cancellation with the footer. */
export declare function createRadioDialTransport(selected: () => Station | undefined, radio: Pick<ReturnType<typeof createRadioPlayback>, "station" | "status" | "start" | "stop">, busy: () => boolean): {
    stopping: () => boolean;
    disabled: () => boolean;
    activate(): void;
};

/** Optional directory metadata never owns or delays the station search busy state. */
export declare function createDirectoryCount(fetch: () => Promise<unknown>): {
    value: import("solid-js").Accessor<number | undefined>;
    error: import("solid-js").Accessor<string>;
    refresh: () => void;
};

import { type Station } from "./directory";
import type { RadioCriteria } from "./search";
/** One already-validated public page retained in process memory, without owner data or media URLs. */
export interface DirectorySnapshot {
    criteria: RadioCriteria;
    stations: readonly Station[];
    more: boolean;
    offset: number;
    selected: number;
    loaded: boolean;
    error: string;
}
/** Account-independent searches serialize provider reads and keep only the latest submitted criteria.
 * A fresh selection immediately clears unrelated results; pagination failures retain the same selection.
 * Queued requests capture their submitted fields, and disposal permanently refuses new provider reads.
 */
export declare function createDirectorySearch(draft: () => RadioCriteria, fetch: (criteria: RadioCriteria, offset: number) => Promise<unknown>, completed: () => void, remember: (country: string) => void, retained?: DirectorySnapshot): {
    snapshot: () => DirectorySnapshot;
    stations: import("solid-js").Accessor<Station[]>;
    more: import("solid-js").Accessor<boolean>;
    offset: import("solid-js").Accessor<number>;
    selected: import("solid-js").Accessor<number>;
    busy: import("solid-js").Accessor<boolean>;
    error: import("solid-js").Accessor<string>;
    loaded: import("solid-js").Accessor<boolean>;
    search: (page?: number, fresh?: boolean, persist?: boolean) => Promise<void>;
    setSelected: import("solid-js").Setter<number>;
    clearError: () => "";
    clear: () => void;
};

export interface Station {
    uuid: string;
    name: string;
    country: string;
    countryCode?: string;
    tags: string;
    codec: string;
    bitrate: number;
}
/** Page through the live directory, never claiming every entry is a unique or available broadcast. */
export declare function parseStations(value: unknown): {
    stations: Station[];
    more: boolean;
};
/** Streams are explicitly selected HTTP(S) media; reject credentials, local literals and pseudo-protocols. */
export declare function streamUrl(value: unknown): string;
/** The click response must still identify the station the user selected. */
export declare function parseResolved(value: unknown, uuid: string): string;
export declare function stationCount(value: unknown): number;

import { type Station } from "./directory";
type Store = Pick<Storage, "getItem" | "setItem">;
/** Persist public station identities, never stream URLs, bearer tokens or Aède annotations. */
export declare function readRadioFavourites(storage: Store): Station[];
/** Storage is updated before the favourite state; an unreadable store is never reset implicitly. */
export declare function createRadioFavourites(storage?: Store): {
    stations: import("solid-js").Accessor<Station[]>;
    error: import("solid-js").Accessor<string>;
    has: (uuid: string) => boolean;
    toggle: (selected: Station) => void;
};
export {};

/** Use only an explicit system region; language alone is not location evidence. */
export declare function systemRadioCountry(languages: readonly string[]): string;
export declare const radioCountryKey = "phemios.radio-country.v1";
/** User choice wins over the OS region, including an explicit all-countries blank. */
export declare function radioCountryPreference(storage: Pick<Storage, "getItem">, languages: readonly string[]): string;
/** Returning home discards station text filters but preserves the transport preference. */
export declare function resetRadioCriteria(languages: readonly string[], secureOnly: boolean): {
    country: string;
    name: string;
    tag: string;
    secureOnly: boolean;
};

import type { ExternalParentalMedia } from "../library/parental-access";
import { browserRadioMedia } from "./browser-media";
export { browserRadioMedia } from "./browser-media";
import { type Station } from "./directory";
export interface RadioMedia {
    /** Prepare a silent optional measurement context while explicit user activation is available. */
    prepare?: () => void;
    /** Pre-output samples from this radio only; false means no readable signal. */
    sample?: (target: Float32Array<ArrayBuffer>) => boolean;
    source: (url: string) => void;
    volume: (value: number) => void;
    play: () => Promise<void>;
    release: () => void;
    callbacks: (playing: () => void, waiting: () => void, failure: () => void) => void;
}
/** Latest explicit selection owns the media; captured authorization binds its owner before preparation.
 * Admission remains immediately before play. Disposal closes media permanently; uninterrupted stalls share one deadline.
 */
export declare function createRadioPlayback(resolve: (uuid: string) => Promise<unknown>, beforePlay: () => Promise<void>, createMedia?: typeof browserRadioMedia, initialVolume?: () => number | Promise<number>, authorize?: ((media: ExternalParentalMedia) => Promise<void>) | {
    capture: () => (media: ExternalParentalMedia) => Promise<void>;
}, rememberVolume?: (value: number) => void, unmutedVolume?: () => number): {
    station: import("solid-js").Accessor<Station | undefined>;
    sample(target: Float32Array<ArrayBuffer>): boolean;
    status: import("solid-js").Accessor<"connecting" | "error" | "idle" | "paused" | "playing">;
    revision: import("solid-js").Accessor<number>;
    error: import("solid-js").Accessor<string>;
    volume: import("solid-js").Accessor<number>;
    start: (selected: Station) => Promise<void>;
    stop: () => void;
    pause: () => void;
    resume: () => void;
    changeVolume: (value: number, remember?: boolean) => void;
    mute: () => void;
};

export interface RadioCriteria {
    name: string;
    country: string;
    tag: string;
    secureOnly: boolean;
}
/** WebKit gets explicit Enter submission on text fields, preserving IME and checkbox/button keys. */
export declare function radioEnterSearch(key: string, composing: boolean, type: string): boolean;

import type { Station } from "./directory";
interface Options {
    stations: () => readonly Station[];
    selected: () => number;
    select: (index: number) => void;
    station: () => Station | undefined;
    status: () => string;
    /** Each explicit transport action replaces a pending dial commitment. */
    revision: () => number;
    pause: () => void;
    /** Stop optional local feedback when a gesture loses its transport ownership. */
    cancelled?: () => void;
    /** The existing transport owns stream resolution and visible playback failures. */
    start: (station: Station) => Promise<void>;
}
/** Commit only the final explicit dial/row choice, including from idle.
 * An actual pointer drag interrupts an engaged stream once; cancellation leaves it paused.
 * Directory replacement, later transport actions and disposal refuse stale commitments.
 */
export declare function createRadioTuner(options: Options): {
    begin: (manual?: boolean) => void;
    preview: (index: number) => void;
    interrupt: () => void;
    finish: () => void;
    cancel: () => void;
    choose: (index: number) => void;
    change(): void;
};
/** Native range keys adjust station selection; other shortcuts retain their usual meaning. */
export declare function radioTuningKey(key: string): boolean;
export {};

import type { RadioTuningAudio } from "./tuning-sound";
/** A page owns one lazy context, at most three 64 KB mono loops, and two live/fading voices.
 * Sources fade for 40 ms; a bounded wall-clock cleanup also retires a suspended context's nodes.
 * Master gain makes mute immediate even during release, without touching Internet media.
 */
export declare function createRadioTuningAudio(createContext?: () => AudioContext): RadioTuningAudio;

/** Three original local feedback textures, not recordings or station frequencies. */
export declare const radioTuningPresets: readonly ["static", "whistle", "flutter"];
export type RadioTuningPreset = (typeof radioTuningPresets)[number];
/** One second of mono PCM; a short silent seam avoids clicks when looping the noise. */
export declare function radioTuningLoop(preset: RadioTuningPreset, rate: number): Float32Array<ArrayBuffer>;

import { type RadioTuningPreset } from "./tuning-loop";
export interface RadioTuningVoice {
    /** Fade and retire this voice; repeated calls have no effect. */
    stop: () => void;
}
export interface RadioTuningAudio {
    /** Prepare silently during pointerdown to retain WebKit's user activation. */
    ready: () => Promise<void>;
    /** Optional PCM inspection reads only this controller’s active feedback voice. */
    sample?: (target: Float32Array<ArrayBuffer>) => boolean;
    loop: (preset: RadioTuningPreset, volume: number) => RadioTuningVoice;
    /** Master gain also controls voices finishing their release fade. */
    volume: (value: number) => void;
    /** Suspend a prepared context once its release voice has retired. */
    idle: () => void;
    dispose: () => void;
}
interface Pointer {
    id: number;
    x: number;
}
/** Pointer-only feedback never calls the station transport; late resumes cannot revive a gesture. */
export declare function createRadioTuningSound(options: {
    volume: () => number;
    audio: RadioTuningAudio;
    random?: () => number;
    /** An explicit choice bypasses random selection and caches only its own buffer. */
    preset?: RadioTuningPreset;
    error?: (failure: unknown) => void;
}): {
    begin: (pointer: Pointer) => void;
    move(pointer: Pointer): boolean;
    finish: (id?: number) => void;
    volume(value: number): void;
    dispose(): void;
};
export {};

/** Bound measured PCM to the dial; silence/unavailable samples retain its gently travelling idle wave. */
export declare function radioWaveform(samples: Float32Array, phase: number): {
    path: string;
    measured: boolean;
};
/** Visual sampling is optional: a transient Web Audio failure must not stop the draw loop. */
export declare function sampleRadioWave(samples: Float32Array<ArrayBuffer>, sample: (target: Float32Array<ArrayBuffer>) => boolean): boolean;

/** The engine exposes only anonymous locks until owner-private evidence unlocks them. */
export declare function AchievementsPage(): import("solid-js").JSX.Element;

/** Explicit submissions share Aède's owner-private evaluator and bounded catalog paging. */
export declare function AdvancedSearchPage(): import("solid-js").JSX.Element;

import type { Album } from "../library/types";
/** Read/edit current-account annotations; save failure never discards the draft. */
export declare function AlbumPage(props: {
    album: Album;
    onYear: (year: number) => void;
    onGenres: (genres: readonly string[]) => void;
    onCountry: (country: string) => void;
}): import("solid-js").JSX.Element;

/** Retained-result coverage is read separately from explicit acquisition and recomputation jobs. */
export declare function AnalysisPage(props: {
    query: string;
}): import("solid-js").JSX.Element;

import type { BiographyNavigation } from "../library/biography-navigation";
import type { Artist } from "../library/types";
/** Present local editions and contributions without inventing a principal credit. */
export declare function ArtistPage(props: {
    artist: Artist;
    compact: boolean;
    onBiographyNavigation: BiographyNavigation;
    onGenres: (genres: readonly string[]) => void;
    onCountry: (country: string) => void;
}): import("solid-js").JSX.Element;

/** Native optical discovery never connects to Aède or imports audio into the catalogue. */
export declare function CdPage(): import("solid-js").JSX.Element;

/** Explicit provider lookups keep partial batch progress; offline navigation reads only cached claims. */
export declare function ConcertsPage(props: {
    query: string;
}): import("solid-js").JSX.Element;

/** Read the existing Aède Doctor contract with severity filters and bounded pagination. */
export declare function DoctorPage(): import("solid-js").JSX.Element;

/** Curated bilingual reference material stays available without an Aède account. */
export declare function EncyclopediaPage(props: {
    query: string;
}): import("solid-js").JSX.Element;

import type { BiographyNavigation } from "../library/biography-navigation";
/** Attributed label biography precedes its owned albums, with explicit missing-cache feedback. */
export declare function LabelPage(props: {
    reference: string;
    onTitle: (name: string) => void;
    compact: boolean;
    onBiographyNavigation: BiographyNavigation;
    onCompact: () => void;
}): import("solid-js").JSX.Element;

/** Explicit bounded browsing never fetches biographies from external providers. */
export declare function LabelsPage(props: {
    query: string;
}): import("solid-js").JSX.Element;

import type { ArtistView } from "../library/tool-preferences";
import type { CoverPosition } from "../visualizer/cover-position";
import type { Filters } from "../library/types";
import { type Section } from "../navigation/routes";
/** Group only sourced origins; catalog indexes preserve credits and cover placement. */
export declare function LibraryPage(props: {
    section: Section;
    compact: boolean;
    now: number;
    artistView: ArtistView;
    filters: Filters;
    setFilters: (filters: Filters) => void;
    reverse: boolean;
    coverFlow?: boolean;
    coverSize?: number;
    coverPosition: CoverPosition;
}): import("solid-js").JSX.Element;

import { type JSX } from "solid-js";
/** Existing folder files and owner-private exports stay distinct, with inert previews and exact downloads. */
export declare function M3UPage(props: {
    query: string;
    navigation?: JSX.Element;
}): JSX.Element;

/** Personal editable recipes expose every matching criterion and play only matched tracks. */
export declare function MoodsPage(props: {
    query: string;
}): import("solid-js").JSX.Element;

import { type Section } from "../navigation/routes";
/** Existing owner-scoped services, with explicit save and download actions. */
export declare function PersonalPage(props: {
    section: Section;
    query: string;
    catalogCompact: boolean;
}): import("solid-js").JSX.Element;

/** Optional playback workspace; the queue and visuals use the same native clock as the footer. */
export declare function PlaybackPage(): import("solid-js").JSX.Element;

/** Discovery is public; transfer sources remain bound to their exact native account sessions. */
export declare function PlayersPage(): import("solid-js").JSX.Element;

/** The shared session queue is the default; file inventory is loaded only on explicit navigation. */
export declare function PlaylistsPage(props: {
    query: string;
}): import("solid-js").JSX.Element;

/** RSS subscriptions stay usable offline; adding/updating is explicit and never starts an episode. */
export declare function PodcastsPage(props: {
    query: string;
}): import("solid-js").JSX.Element;

/** An Internet-station dial indexes the current directory page, without inventing FM frequencies. */
export declare function RadioPage(props: {
    query: string;
}): import("solid-js").JSX.Element;

/** Ratings remain distinct from favourites, scoped to the selected authenticated owner. */
export declare function RatedPage(props: {
    query: string;
}): import("solid-js").JSX.Element;

/** A bounded, keyboard-accessible view of Aède's actual local collaborations. */
export declare function RelationsPage(props: {
    query: string;
    compact: boolean;
}): import("solid-js").JSX.Element;

/** Report only the app and its embedded components; account/server connections add no rows. */
export declare function SettingsAbout(): import("solid-js").JSX.Element;

/** Aède retains password, role and last-administrator policy. The owned local principal is protected. */
export declare function SettingsAccounts(): import("solid-js").JSX.Element;

/** Every accepted plan lives on Aède; leaving Settings never cancels it or starts another stage client-side. */
export declare function SettingsAede(): import("solid-js").JSX.Element;

/** Colours apply live; portable theme documents contain no language or credentials. */
export declare function SettingsAppearance(): import("solid-js").JSX.Element;

/** A native chosen file is reviewed before an explicit all-settings restore. */
export declare function SettingsBackup(): import("solid-js").JSX.Element;

/** Imports exist only in memory until explicit review/confirmation for the current private account. */
export declare function SettingsImports(): import("solid-js").JSX.Element;

/** Retained keys and quota are native-only; opening settings performs no provider request. */
export declare function SettingsJamBase(): import("solid-js").JSX.Element;

export declare function SettingsLanguage(): import("solid-js").JSX.Element;

/** Registered folders, availability and explicit tasks are kept distinct. */
export declare function SettingsLibraries(): import("solid-js").JSX.Element;

import { type createMenuPreferences } from "../navigation/menu-preferences";
/** Visibility and order apply immediately, with native drag and equivalent keyboard buttons. */
export declare function SettingsNavigation(props: {
    menu: ReturnType<typeof createMenuPreferences>;
}): import("solid-js").JSX.Element;

import type { createMenuPreferences } from "../navigation/menu-preferences";
export declare function SettingsPage(props: {
    menu: ReturnType<typeof createMenuPreferences>;
    tab?: string;
}): import("solid-js").JSX.Element;

/** Administrator-only policy editor; target, source and process session delimit every read and write. */
export declare function SettingsParental(): import("solid-js").JSX.Element;

/** Saving a machine endpoint never sends playback or modifies the external engine's queue. */
export declare function SettingsPlayback(): import("solid-js").JSX.Element;

/** One private native key store serves explicit jobs on either library; no automatic enrichment. */
export declare function SettingsServices(): import("solid-js").JSX.Element;

export declare function SettingsShortcuts(): import("solid-js").JSX.Element;

/** Administrators review the common catalogue independently on each connected engine. */
export declare function SettingsSourceReview(): import("solid-js").JSX.Element;

/** Current-owner vocabulary management leaves tags already written on music intact. */
export declare function SettingsTags(): import("solid-js").JSX.Element;

import { statisticsSelection } from "../library/statistics-navigation";
/** Server totals stay distinct from public snapshot coverage and current-owner annotations. */
export declare function StatisticsPage(props: {
    onBrowse: (selection: NonNullable<ReturnType<typeof statisticsSelection>>) => void;
}): import("solid-js").JSX.Element;

/** Every personal tagged target gets a card; unavailable references remain visible in the result count. */
export declare function TagsPage(props: {
    query: string;
    selected: readonly string[];
    onSelect: (tags: readonly string[]) => void;
    offset: number;
    setOffset: (offset: number) => void;
}): import("solid-js").JSX.Element;

import type { MetadataBrowse } from "../library/track-metadata-links";
/** Track facts, credits, annotations and retained results share the catalog detail conventions. */
export declare function TrackPage(props: {
    reference: string;
    onBrowse: (target: MetadataBrowse) => void;
}): import("solid-js").JSX.Element;

import type { Filters, Interval } from "../library/types";
/** All catalog placements, including albumless tracks, use bounded server search pages. */
export declare function TracksPage(props: {
    query: string;
    filters: Filters;
    onFilters: (value: Filters) => void;
    reverse: boolean;
    onReverse: () => void;
    yearDomain: Interval;
    size: number;
    setSize: (size: number) => void;
    preferenceError: string;
    offset: number;
    setOffset: (value: number) => void;
}): import("solid-js").JSX.Element;

import { type Section } from "../navigation/routes";
import { StatisticsPage } from "./StatisticsPage";
/** Section services stay reactive while navigation keeps the same workspace owner. */
export declare function WorkspacePage(props: {
    section: Section;
    query: string;
    compact: boolean;
    onStatisticsBrowse: Parameters<typeof StatisticsPage>[0]["onBrowse"];
}): import("solid-js").JSX.Element;

/** A consumed-output spectrum sample; position is in milliseconds, not wall-clock time. */
export interface BassSample {
    levels: readonly number[];
    frequencies: readonly number[];
    position: number;
    reference: string;
}
/** Relative low-band attacks, capped to one echo per 300 ms; no random beat or extra polling. */
export declare function createBassPulse(): {
    reset: () => void;
    observe(sample: BassSample): number;
};

import { type Accessor } from "solid-js";
interface Cover {
    reference: string;
}
/** Index unique canonical references once per result; metadata-only replacements retain the viewport. */
export declare function createCoverCatalog(rows: Accessor<readonly Cover[]>, reverse: Accessor<boolean>, selected: Accessor<string>): {
    positions: Accessor<Map<string, number>>;
    index: Accessor<number>;
    order: Accessor<string>;
};
export {};

/** Only the two outer neighbours fade; sorting starts at the new first album. */
export declare function coverOpacity(distance: number): number;
/** Horizontal dragging moves one album per 90 CSS pixels and clamps at either edge. */
export declare function draggedCover(start: number, dx: number, total: number): number;
/** A tap retains the original cover link; pointer capture starts only after a real drag. */
export declare function coverDragTarget(start: number, dx: number, total: number): number | undefined;

/** Claim keyboard navigation once per mounted region, without interrupting typing or a modal. */
export declare function focusCoverOnMount(region: HTMLElement): void;

type CoverKey = Pick<KeyboardEvent, "key" | "defaultPrevented" | "metaKey" | "ctrlKey" | "altKey" | "shiftKey" | "preventDefault"> & {
    currentTarget: Pick<HTMLElement, "focus">;
};
/** Cover navigation is independent of the transient card or button that originated the key. */
export declare function createCoverKeyboard(options: {
    index: () => number;
    total: () => number;
    cancel: () => void;
    choose: (index: number) => void;
}): (event: CoverKey) => void;
export {};

/** A fractional viewport keeps entering and leaving covers alive throughout long moves. */
export declare function coverWindow(position: number, total: number): number[];
/** Interruptible compositor positions use the current pose rather than snapping to the previous target. */
export declare function createCoverMotion(publish: (position: number) => void, clock?: {
    request: (frame: (time: number) => void) => number;
    cancel: (id: number) => void;
    now: () => number;
}): {
    reset(value: number): void;
    move(target: number): void;
    dispose(): void;
};

interface Cover {
    reference: string;
    title: string;
}
/** Session memory survives view remounts; explicit reverse starts at its new first album. */
export declare function createCoverPosition(): {
    restore(rows: readonly Cover[], reverse: boolean): string;
    select(value: string): void;
};
/** Letter landmarks reflect the real order, including reverse and nonalphabetical sorting. */
export declare function coverLetterStops<Row extends Pick<Cover, "title">>(rows: readonly Row[], name?: (row: Row) => string): {
    letter: string;
    index: number;
}[];
export type CoverPosition = ReturnType<typeof createCoverPosition>;
export {};

/** All explicit movement retains the cover transition, including large slider jumps. */
export declare function animateCoverMove(from: number, to: number): boolean;
/** Coalesce high-rate slider input into one bounded cover window per frame; release commits the latest target. */
export declare function createCoverScrub(publish: (target: number) => void, request?: (callback: () => void) => number, cancel?: (id: number) => void): {
    cancel: () => void;
    move(target: number): void;
    finish: () => void;
    dispose(): void;
};

import type { Particle } from "./particles";
/** Perspective uses one bounded camera for the sparse stage; nearer geometry is larger and clearer. */
export declare function depthProjection(point: Particle, width: number, height: number): {
    x: number;
    y: number;
    perspective: number;
    alpha: number;
};
/** A fixed 14-line floor establish depth without a new renderer or particle workload. */
export declare function drawFloatingDepth(ctx: CanvasRenderingContext2D, width: number, height: number, clock: number, yaw: number, pitch: number, color: string): void;

import type { Particle } from "./particles";
/** Bounded orbital objects expand with native audible energy; no synthetic random meters. */
export declare function floatingObjects(time: number, levels: readonly number[], count?: number): Particle[];
/** Visibility, user disable and accessibility preferences stop animation work altogether. */
export declare function animationRuns(enabled: boolean, playing: boolean, hidden: boolean, reduced: boolean): boolean;
/** Deterministic cue orientation alternates both signs and never fabricates lyric timing. */
export declare function phraseOrientation(text: string): number;

import type { Scene } from "./particles";
/** Frequency visibility is independent of the selected decorative scene. */
export declare function playbackLayers(scene: Scene, spectrum: boolean, available: boolean): {
    canvas: boolean;
    frequencies: boolean;
};
/** Each lyric presentation retains its own visibility when switching decorative scenes. */
export declare function playbackWords(scene: Scene, ordinary: boolean, floating?: boolean): boolean;
/** One control cycles both retained styles before hiding the independent frequency layer. */
export declare function nextFrequencyMode(visible: boolean, style: "gradient" | "terminal"): {
    visible: boolean;
    style: "gradient";
} | {
    visible: boolean;
    style: "terminal";
};

import { type BassSample } from "./bass-pulse";
/** One reusable visual-only copy follows consumed bass attacks; hidden, paused and reduced motion cancel it. */
export declare function createLyricEcho(input: {
    phrase: () => object | undefined;
    ready: () => boolean;
    enabled: () => boolean;
    audio: () => BassSample | undefined;
}): (node: HTMLSpanElement) => void;

/** Scale the final rotated phrase into its actual stage, reserving space for the upward arrival. */
export declare function lyricFit(input: {
    width: number;
    height: number;
    angle: number;
    stageWidth: number;
    stageHeight: number;
    x: number;
    y: number;
}): number;

import { type Accessor } from "solid-js";
import { type LyricTypography } from "./lyric-treatment";
/** Clock polls retain one phrase node; a distinct supplied cue (even repeated words) restarts its arrival. */
export declare function createLyricPhrase(text: Accessor<string>, cue: Accessor<string | number>, floating: Accessor<boolean>, typography?: Accessor<LyricTypography>): Accessor<{
    text: string;
    cue: string | number;
    angle: number;
    treatment: {
        angle: number;
        font: number;
        size: number;
        duration: number;
        yaw: number;
        composition: number;
        chunks: {
            text: string;
            emphasis: boolean;
            size: number;
            tilt: number;
            depth: number;
            yaw: number;
            offset: number;
        }[];
    } | undefined;
} | undefined>;

import { type Accessor } from "solid-js";
/** Reveal only the fitted current cue; delayed measurements cannot reveal a replacement phrase. */
export declare function createLyricReadiness<T extends object>(phrase: Accessor<T | undefined>): {
    ready: () => boolean;
    measured(value: T | undefined): void;
};

export interface LyricTypography {
    track: string;
    phase: number;
}
/** Three contiguous acts permit at most two font changes in ordinary cue order; unknown counts stay in act one. */
export declare function lyricAct(index: number, count: number): number;
/** Cue compositions vary while a track keeps its font within each act. System fonts require no downloaded assets. */
export declare function lyricTreatment(text: string, cue: string | number, typography?: LyricTypography): {
    angle: number;
    font: number;
    size: number;
    duration: number;
    yaw: number;
    composition: number;
    chunks: {
        text: string;
        emphasis: boolean;
        size: number;
        tilt: number;
        depth: number;
        yaw: number;
        offset: number;
    }[];
};

import type { Particle } from "./particles";
/** Rigid camera rotation preserves the audio deformation and keeps depth projection bounded. */
export declare function orbit(point: Particle, yaw: number, pitch: number): Particle;
export declare function orbitDrag(yaw: number, pitch: number, dx: number, dy: number): [number, number];
/** Rotate the canvas-local pool in place with one camera matrix, avoiding a second point array. */
export declare function orbitField(points: Particle[], yaw: number, pitch: number): Particle[];

/** Deterministic 3D geometry, deformed only by audible native band levels. */
export type Scene = "sphere" | "waves" | "landscape" | "floating" | "off";
export interface Particle {
    x: number;
    y: number;
    z: number;
    energy: number;
}
/** Canvas-local mutable points are overwritten on every update; depth sorting preserves the next frame's geometry.
 * Retain an independent snapshot when a caller needs an earlier frame. Fixed trigonometric bases live only with this field.
 */
export declare function createParticleField(count?: number): {
    update(scene: Scene, time: number, levels: readonly number[]): Particle[];
};
/** Independent snapshots are available for callers that do not retain a canvas-local field. */
export declare function particles(scene: Scene, time: number, levels: readonly number[], count?: number): Particle[];

interface Band {
    level: number;
    peak: number;
    held: number;
}
/** Aède terminal policy: 24 independent consumed bands, 350 ms peak hold, .45/s decay. */
export declare function createTerminalBands(): {
    observe(levels: readonly number[] | undefined, position: number, reference: string): readonly Band[];
};
export {};

import { type Accessor } from "solid-js";
import type { Lyrics } from "../library/lyrics";
/** Manual words have no invented timing; keep the chosen line until the track changes. */
export declare function createUntimedLyrics(reference: Accessor<string | undefined>, lyrics: Accessor<Lyrics | null | undefined>): {
    lines: Accessor<string[]>;
    index: Accessor<number>;
    previous: () => number;
    next: () => number;
};

/** Self-contained website component: no native bridge, app entry or environment injection. */
declare const _default: import("vite").UserConfig;
export default _default;

declare const _default: import("vite").UserConfig;
export default _default;