@finbheara/archive-client 0.0.0-stage → 0.1.1

package/dist/config.js

@@ -0,0 +1,21 @@
+// @bun
+import {
+  expandHome2,
+  cacheRoot2,
+  configPath2,
+  readConfig2,
+  writeJsonAtomic2,
+  writeConfig2,
+  repoOf2,
+  requireRepo2
+} from "./chunks/index-hne1wadw.js";
+export {
+  cacheRoot2 as cacheRoot,
+  configPath2 as configPath,
+  expandHome2 as expandHome,
+  readConfig2 as readConfig,
+  repoOf2 as repoOf,
+  requireRepo2 as requireRepo,
+  writeConfig2 as writeConfig,
+  writeJsonAtomic2 as writeJsonAtomic
+};

package/dist/index.js

@@ -0,0 +1,99 @@
+// @bun
+import {
+  DATABASES2,
+  planAsset2,
+  sha256File2,
+  unzstdTo2,
+  NAME_LEVELS2,
+  nameLevel2,
+  FEIS_LOCAL_ID_FLOOR2,
+  ResultFinder2,
+  MajorsFinder2,
+  DancerResolver2,
+  canonicalOf2,
+  CompResolver2,
+  NO_CALENDAR2,
+  FeisFinder2,
+  StaffFinder2,
+  SchoolResolver2,
+  defaultBuilders2,
+  indexPath2,
+  indexKey2,
+  isCurrent2,
+  buildIndex2,
+  listIndexes2,
+  readPin2,
+  youngest2,
+  dancerResolverOf2,
+  RegistrationResolver2,
+  ghRemote2,
+  httpsRemote2,
+  fallbackRemote2,
+  setRemote2,
+  resolveTag2,
+  Release2,
+  openRelease2,
+  openCached2,
+  ReleaseManager2,
+  releases2
+} from "./chunks/index-zr8tfjk0.js";
+import {
+  cacheRoot2,
+  repoOf2
+} from "./chunks/index-hne1wadw.js";
+import {
+  ARCHIVE_TAG2,
+  parseArchiveTag2,
+  renderArchiveTag2,
+  cutOf2,
+  compareTagsNewestFirst2,
+  parseReleaseSpec2,
+  pickTag2
+} from "./chunks/index-hghdy980.js";
+export {
+  ARCHIVE_TAG2 as ARCHIVE_TAG,
+  CompResolver2 as CompResolver,
+  DATABASES2 as DATABASES,
+  DancerResolver2 as DancerResolver,
+  FEIS_LOCAL_ID_FLOOR2 as FEIS_LOCAL_ID_FLOOR,
+  FeisFinder2 as FeisFinder,
+  MajorsFinder2 as MajorsFinder,
+  NAME_LEVELS2 as NAME_LEVELS,
+  NO_CALENDAR2 as NO_CALENDAR,
+  RegistrationResolver2 as RegistrationResolver,
+  Release2 as Release,
+  ReleaseManager2 as ReleaseManager,
+  ResultFinder2 as ResultFinder,
+  SchoolResolver2 as SchoolResolver,
+  StaffFinder2 as StaffFinder,
+  buildIndex2 as buildIndex,
+  cacheRoot2 as cacheRoot,
+  canonicalOf2 as canonicalOf,
+  compareTagsNewestFirst2 as compareTagsNewestFirst,
+  cutOf2 as cutOf,
+  dancerResolverOf2 as dancerResolverOf,
+  defaultBuilders2 as defaultBuilders,
+  fallbackRemote2 as fallbackRemote,
+  ghRemote2 as ghRemote,
+  httpsRemote2 as httpsRemote,
+  indexKey2 as indexKey,
+  indexPath2 as indexPath,
+  isCurrent2 as isCurrent,
+  listIndexes2 as listIndexes,
+  nameLevel2 as nameLevel,
+  openCached2 as openCached,
+  openRelease2 as openRelease,
+  parseArchiveTag2 as parseArchiveTag,
+  parseReleaseSpec2 as parseReleaseSpec,
+  pickTag2 as pickTag,
+  planAsset2 as planAsset,
+  readPin2 as readPin,
+  releases2 as releases,
+  renderArchiveTag2 as renderArchiveTag,
+  repoOf2 as repoOf,
+  resolveTag2 as resolveTag,
+  setRemote2 as setRemote,
+  sha256File2 as sha256File,
+  unzstdTo2 as unzstdTo,
+  youngest2 as youngest
+};

package/dist/tag.js

@@ -0,0 +1,19 @@
+// @bun
+import {
+  ARCHIVE_TAG2,
+  parseArchiveTag2,
+  renderArchiveTag2,
+  cutOf2,
+  compareTagsNewestFirst2,
+  parseReleaseSpec2,
+  pickTag2
+} from "./chunks/index-hghdy980.js";
+export {
+  ARCHIVE_TAG2 as ARCHIVE_TAG,
+  compareTagsNewestFirst2 as compareTagsNewestFirst,
+  cutOf2 as cutOf,
+  parseArchiveTag2 as parseArchiveTag,
+  parseReleaseSpec2 as parseReleaseSpec,
+  pickTag2 as pickTag,
+  renderArchiveTag2 as renderArchiveTag
+};

package/dist/types/assets.d.ts

@@ -0,0 +1,40 @@
+export interface ReleaseManifest {
+    corpusRelease?: string;
+    archiveCommit?: string;
+    archiveFraction?: number;
+    databases?: Record<string, {
+        file?: string;
+        bytes?: number;
+        sha256?: string;
+    }>;
+    parquet?: {
+        files?: Record<string, {
+            sha256?: string;
+            rows?: number;
+            table?: string;
+        }>;
+    };
+    [k: string]: unknown;
+}
+export declare const DATABASES: readonly ["results", "majors"];
+export type DatabaseName = (typeof DATABASES)[number];
+export declare const isDatabase: (name: string) => name is DatabaseName;
+export interface AssetPlan {
+    asked: string;
+    published: string[];
+    local: string;
+    decompress: boolean;
+    contentSha256: string | null;
+}
+export declare function planAsset(name: string, manifest: ReleaseManifest | null): AssetPlan;
+export interface LandedFile {
+    from: string;
+    sha256: string;
+    bytes: number;
+    verified: ("host-digest" | "manifest")[];
+}
+export interface Receipt {
+    tag: string;
+    source: string;
+    files: Record<string, LandedFile>;
+}

package/dist/types/bytes.d.ts

@@ -0,0 +1,3 @@
+export declare function sha256File(path: string): Promise<string>;
+export declare function unzstdTo(src: string, dest: string): Promise<string>;
+export declare function sha256OfDigest(digest: string | null | undefined): string | null;

package/dist/types/cli.d.ts

@@ -0,0 +1,24 @@
+#!/usr/bin/env bun
+import type { OpenOptions } from "./release.js";
+export declare const USAGE = "usage: idq <verb> [--cache <dir>] [--repo <owner/name>] [--json]\n\n  config repo <owner/name>          set the user-local repository the releases come from\n  list [--remote]                   the cached releases (size, files, indexes, the pin), and\n                                    with --remote the published tags\n  fetch [--release <spec>] [--assets results,majors,<file>...]\n                                    download, verify and cache a release (default: results)\n  pin <spec>                        the user-local pin: what a bare open (spec \"pinned\") opens\n  unpin                             remove the pin (a bare open is then \"latest\")\n  current                           the pin, and whether it is cached\n  add <dir> --tag <tag>             add a release built locally (its MANIFEST.json and files)\n                                    to the cache under its tag\n  index [--release <spec>] [<name>...] [--force]\n                                    build the per-tag indexes (default: every one)\n  verify [--release <spec>]         re-hash every cached file against its receipt\n  prune [--keep N] [--dry-run]      remove all but the N newest cached releases (default 1)\n                                    and the pinned one\n  rm <tag> [--dry-run]              remove one cached release (not the pinned one)\n  drop-indexes [<tag>] [--dry-run]  remove the index files (of one release, or of every one)\n  feis [--release <spec>] [--platform <p>] [--code <c>] [--id <id>] [--name <glob>] [--year <y>]\n                                    the feises a query names\n  series [--release <spec>] <name|host code|feis id>\n                                    the series a name, a host code (fweb:ABC) or any feis id\n                                    names: its years, hosts, codes and next instance\n  school [--release <spec>] <print|school_id> [--region <code>]\n                                    a school print or id to the published schools\n  dancer [--release <spec>] <name> | --surname <s> | --like <glob> | --id <dancer_id>\n         [--order surname-first|given-first] [--school <print|id>]\n         [--yob <y> | --band <U10> [--year <y>] | --comp <competition>] [--as-of <date>]\n         [--rows]                   the dancers a name reaches, each with its evidence\n                                    (name level, age, school) and the arm; the results of\n                                    the one dancer where one answers (or --rows for each)\n  results [--release <spec>] [--dancer <id>] [--feis <id>] [--comp <competition>]\n          [--school <print|id>] [--year <y>] [--limit <n>]\n                                    the published result rows, prints and ids\n  majors [--release <spec>] [--event <e>] [--year <y>] [--comp <competition>] [--dancer <id>]\n                                    the majors: every event and its years; an event's\n                                    competitions; a competition's, an event's or a dancer's rows\n  teacher [--release <spec>] <name|TD number>\n                                    the staff lists' people: where they taught, the register,\n                                    where they sat\n  adjudicator [--release <spec>] <name|TD number>\n                                    the register's and the panels' people: the same answer\n  comp [--release <spec>] <feis> <code> [--year <y>] [--title <t>]\n                                    a feis's own comp code to the comp it names, through that\n                                    feis's syllabus (or the prior year's)\n  syllabus [--release <spec>] <feis> [year]\n                                    one feis-year's comps, in printed order\n  syllabus [--release <spec>] --for <series> [year]\n                                    a series' syllabus for a year: that year's where held,\n                                    else the newest, saying which and what it is read from\n  resolve comp [<feis> <code>] [--year <y>] [--title <t>]\n  resolve dancer [<name>] [--school <s>] [--comp <feis>/<code> | --yob <y> | --band <b> --year <y>]\n                 [--order <o>] [--as-of <date>]\n  resolve registrations\n                                    JSONL out, one answer per line; with no positional the\n                                    questions are JSONL on stdin, one per line (a comp:\n                                    {feis, code, year?, title?}, a dancer: {name, school?, age?},\n                                    a registration: {name, school?, codes[], feis, year?})\n\n  <spec>: pinned (the default) | latest | a cut (42, 42.1) | a tag (archive-YYYY.MM.DD-N)";
+export interface Parsed {
+    positional: string[];
+    flags: Map<string, string>;
+    bools: Set<string>;
+}
+export declare function parseArgs(argv: readonly string[]): Parsed;
+type Line<T> = {
+    line: number;
+    value: T;
+} | {
+    line: number;
+    error: string;
+};
+export declare function jsonLines<T>(text: string, check: (v: T) => string | null): Line<T>[];
+export declare function main(argv: readonly string[], io?: {
+    say?: (s: string) => void;
+    log?: (s: string) => void;
+    opts?: OpenOptions;
+    stdin?: () => Promise<string>;
+}): Promise<number>;
+export {};

package/dist/types/comps.d.ts

@@ -0,0 +1,127 @@
+import { type AgeRelation } from "@finbheara/domain/age";
+import { type Population, type PopulationRelation } from "@finbheara/domain/title";
+import type { IndexBuilder } from "./indexes.js";
+import type { Release } from "./release.js";
+export type CompKind = "championship" | "grade" | "unrated";
+export type CompSource = "syllabus" | "prior-year" | "title";
+export type SyllabusSource = "syllabus-document" | "results";
+export interface Comp {
+    competition: string;
+    feis_id: string;
+    year: number | null;
+    code: string;
+    title: string | null;
+    kind: CompKind;
+    feis_level: number | null;
+    level: string | null;
+    age: string | null;
+    population: Population | null;
+    round: string | null;
+    canonical: string | null;
+    platform: string;
+    captures: number;
+}
+export interface CompQuery {
+    feis: string;
+    code: string;
+    year?: number;
+    title?: string;
+}
+export interface FeisPlace {
+    asked: string;
+    feis_ids: string[];
+    brand_id: string | null;
+    year: number | null;
+    held: boolean;
+    via: "id" | "series" | "code-stem" | "name" | null;
+    series?: string[];
+}
+export interface TitleCheck {
+    title: string;
+    agrees: boolean;
+    age: AgeRelation;
+    population: PopulationRelation;
+}
+export interface CompAnswer {
+    tag: string;
+    asked: CompQuery;
+    arm: "unique" | "ambiguous" | "none";
+    source: CompSource | null;
+    kind: CompKind | null;
+    level: string | null;
+    feis_level: number | null;
+    age: string | null;
+    population: Population | null;
+    round: string | null;
+    canonical: string | null;
+    title: string | null;
+    competition: string | null;
+    candidates: Comp[];
+    feis: FeisPlace;
+    from?: {
+        feis_ids: string[];
+        year: number;
+    };
+    check?: TitleCheck | "unchecked";
+    syllabus_source: SyllabusSource | null;
+    why?: string;
+}
+export interface SyllabusForAnswer {
+    tag: string;
+    asked: {
+        series: string;
+        year: number | null;
+    };
+    arm: "unique" | "ambiguous" | "none";
+    series_id: string | null;
+    feis: FeisPlace;
+    year: number | null;
+    held: boolean;
+    source: SyllabusSource | null;
+    feis_ids: string[];
+    entries: Comp[];
+    years: number[];
+    championships: number;
+    why?: string;
+    note?: string;
+}
+export interface SyllabusAnswer {
+    tag: string;
+    feis: FeisPlace;
+    year: number | null;
+    held: boolean;
+    entries: Comp[];
+    years: number[];
+}
+export declare const compsIndex: IndexBuilder;
+interface CompRow {
+    competition: string;
+    feis_id: string;
+    brand_id: string | null;
+    year: number | null;
+    code: string;
+    title: string | null;
+    age: string | null;
+    gender: string | null;
+    feis_level: number | null;
+    round: string | null;
+    platform: string;
+    captures: number;
+}
+export declare function compOf(r: CompRow): Comp;
+export declare function canonicalOf(level: number | null, age: string | null): string | null;
+export declare class CompResolver {
+    private readonly rel;
+    constructor(rel: Release);
+    place(feis: string, year?: number): Promise<FeisPlace>;
+    private ofSeries;
+    private years;
+    private compsOf;
+    private idsOf;
+    syllabus(feis: string, year?: number): Promise<SyllabusAnswer>;
+    syllabusFor(series: string | {
+        series_id: string | null;
+    }, year?: number): Promise<SyllabusForAnswer>;
+    resolve(q: CompQuery): Promise<CompAnswer>;
+}
+export {};

package/dist/types/config.d.ts

@@ -0,0 +1,16 @@
+export interface ClientOptions {
+    cache?: string;
+    repo?: string;
+    env?: Readonly<Record<string, string | undefined>>;
+}
+export declare function expandHome(p: string): string;
+export declare function cacheRoot(opts?: ClientOptions): string;
+export interface UserConfig {
+    repo?: string;
+}
+export declare const configPath: (root: string) => string;
+export declare function readConfig(root: string): UserConfig;
+export declare function writeJsonAtomic(path: string, value: unknown): void;
+export declare function writeConfig(root: string, patch: UserConfig): UserConfig;
+export declare function repoOf(opts?: ClientOptions): string | null;
+export declare function requireRepo(opts?: ClientOptions): string;

package/dist/types/dancers-names.d.ts

@@ -0,0 +1,5 @@
+import { type PersonName, type TransitiveLevel } from "@finbheara/names/normalize";
+export type NameLevel = TransitiveLevel | "initial" | "middle" | "surname" | "like";
+export declare const NAME_LEVELS: readonly NameLevel[];
+export declare const finer: (a: NameLevel, b: NameLevel) => NameLevel;
+export declare function nameLevel(q: PersonName, c: PersonName): NameLevel | null;

package/dist/types/dancers.d.ts

@@ -0,0 +1,138 @@
+import { type NameLevel } from "./dancers-names.js";
+import type { IndexBuilder } from "./indexes.js";
+import type { Release } from "./release.js";
+import { FEIS_LOCAL_ID_FLOOR } from "./results.js";
+export { FEIS_LOCAL_ID_FLOOR };
+export type NameOrderAsked = "surname-first" | "given-first" | "unknown";
+export type AgeAsked = {
+    comp: string;
+    year?: number;
+} | {
+    yob: number;
+} | {
+    band: string;
+    year?: number | null;
+};
+export declare function nameOrderOf(s: string | undefined): NameOrderAsked | undefined;
+export interface DancerQuery {
+    name: string;
+    order?: NameOrderAsked;
+    school?: string;
+    age?: AgeAsked;
+    asOf?: string;
+}
+export type AgeEvidence = "fits" | "overlaps" | "contradicts" | "unknown" | "unasked";
+export type SchoolEvidence = "same" | "moved" | "none" | "unresolved" | "unasked";
+export interface DancerSchool {
+    school_id: string | null;
+    print: string;
+    rows: number;
+    year_lo: number | null;
+    year_hi: number | null;
+}
+export interface DancerCandidate {
+    dancer_id: number;
+    display: string;
+    scope: "per-release" | "stable";
+    kind: string | null;
+    score: number;
+    evidence: {
+        nameLevel: NameLevel;
+        age: AgeEvidence;
+        school: SchoolEvidence;
+    };
+    prints: {
+        print: string;
+        rows: number;
+        level: NameLevel;
+    }[];
+    rows: number;
+    year_lo: number | null;
+    year_hi: number | null;
+    birth: {
+        lo: number | null;
+        hi: number | null;
+        source: string;
+        conflict: boolean;
+    };
+    school: DancerSchool | null;
+}
+export interface ExcludedCandidate {
+    candidate: DancerCandidate;
+    why: "age";
+}
+export interface DancerAnswer {
+    tag: string;
+    asked: DancerQuery;
+    arm: "unique" | "ambiguous" | "none";
+    candidates: DancerCandidate[];
+    excluded: ExcludedCandidate[];
+    preferred?: {
+        dancer_id: number;
+        why: string;
+    };
+    unlinked: {
+        print: string;
+        rows: number;
+    }[];
+    age?: {
+        read: string | null;
+        birth: {
+            from: number | null;
+            to: number | null;
+        } | null;
+        note?: string;
+    };
+    school?: {
+        arm: string;
+        ids: string[];
+    };
+    refused?: string;
+}
+export interface DancerSearchQuery extends Omit<DancerQuery, "name"> {
+    name?: string;
+    surname?: string;
+    like?: string;
+    limit?: number;
+}
+export interface DancerRecord {
+    tag: string;
+    dancer_id: number;
+    display: string;
+    scope: "per-release" | "stable";
+    kind: string | null;
+    names_printed: string[];
+    genders: string;
+    appearances: number;
+    rows: number;
+    year_lo: number | null;
+    year_hi: number | null;
+    birth: {
+        lo: number | null;
+        hi: number | null;
+        source: string;
+        conflict: boolean;
+    };
+    prints: {
+        print: string;
+        rows: number;
+        year_lo: number | null;
+        year_hi: number | null;
+    }[];
+    schools: DancerSchool[];
+}
+export declare const PACKAGE_KEY_PARTS: readonly string[];
+export declare const dancersIndex: IndexBuilder;
+export declare function yearOf(asOf: string | undefined): number | null;
+export declare class DancerResolver {
+    private readonly rel;
+    private readonly printIds;
+    constructor(rel: Release);
+    resolve(q: DancerQuery): Promise<DancerAnswer>;
+    search(q: DancerSearchQuery): Promise<DancerAnswer>;
+    private capped;
+    get(dancerId: number): Promise<DancerRecord | null>;
+    private answer;
+    private schoolEvidence;
+    private readAge;
+}

package/dist/types/feises.d.ts

@@ -0,0 +1,84 @@
+import type { IndexBuilder } from "./indexes.js";
+import type { Release } from "./release.js";
+export interface Feis {
+    feis_id: string;
+    source: string;
+    token: string;
+    host_id: string;
+    name: string;
+    date_lo: string | null;
+    date_hi: string | null;
+    date_printed: string | null;
+    year: number | null;
+    location: string | null;
+    instance_id: string | null;
+    brand_id: string | null;
+    regions: string[];
+    competitions: number;
+    rows: number;
+    captures: number;
+}
+export interface FeisQuery {
+    platform?: string;
+    code?: string;
+    id?: string;
+    name?: string;
+    year?: number;
+}
+export interface FeisAnswer {
+    tag: string;
+    feises: Feis[];
+    redirected?: {
+        from: string;
+        to: string;
+    };
+}
+export declare function readJsonl<T>(path: string): T[];
+export declare const feisesIndex: IndexBuilder;
+export interface SeriesInstance {
+    year: number | null;
+    feis_ids: string[];
+    date_lo: string | null;
+    name: string;
+}
+export interface Series {
+    series_id: string;
+    name: string;
+    host: string;
+    hosts: string[];
+    codes: string[];
+    years: number[];
+    instances: SeriesInstance[];
+}
+export interface SeriesNext {
+    feis_id: string | null;
+    date: string;
+}
+export interface SeriesAnswer {
+    tag: string;
+    asked: string;
+    arm: "unique" | "ambiguous" | "none";
+    via: "id" | "code-stem" | "name" | null;
+    series_id: string | null;
+    name: string | null;
+    host: string | null;
+    years: number[];
+    instances: SeriesInstance[];
+    next: SeriesNext | null;
+    next_why?: string;
+    candidates: Series[];
+    redirected?: {
+        from: string;
+        to: string;
+    };
+    why?: string;
+}
+export declare const NO_CALENDAR = "the release holds a feis-year once its results are captured and carries no calendar of scheduled feiseanna";
+export declare class FeisFinder {
+    private readonly rel;
+    constructor(rel: Release);
+    find(q: FeisQuery): Promise<FeisAnswer>;
+    codeStem(token: string, stem: string): Promise<string[]>;
+    seriesOf(brand: string): Promise<Series>;
+    series(q: string): Promise<SeriesAnswer>;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,17 @@
+export { type AssetPlan, DATABASES, type DatabaseName, type LandedFile, type Receipt, type ReleaseManifest, planAsset, } from "./assets.js";
+export { sha256File, unzstdTo } from "./bytes.js";
+export { type AgeAsked, type AgeEvidence, type DancerAnswer, type DancerCandidate, type DancerQuery, type DancerRecord, DancerResolver, type DancerSchool, type DancerSearchQuery, type ExcludedCandidate, FEIS_LOCAL_ID_FLOOR, type SchoolEvidence, } from "./dancers.js";
+export { NAME_LEVELS, type NameLevel, nameLevel } from "./dancers-names.js";
+export { type Comp, type CompAnswer, type CompKind, type CompQuery, CompResolver, type CompSource, type FeisPlace, type SyllabusAnswer, type SyllabusForAnswer, type SyllabusSource, type TitleCheck, canonicalOf, } from "./comps.js";
+export { type ClientOptions, cacheRoot, repoOf } from "./config.js";
+export { type Feis, type FeisAnswer, FeisFinder, type FeisQuery, NO_CALENDAR, type Series, type SeriesAnswer, type SeriesInstance, type SeriesNext, } from "./feises.js";
+export { type IndexBuilder, type IndexFile, buildIndex, defaultBuilders, indexKey, indexPath, isCurrent, listIndexes, } from "./indexes.js";
+export { type CachedRelease, type ReleaseList, ReleaseManager, type RemovalPlan, releases, } from "./manager.js";
+export { type Registered, type Sat, type StaffAnswer, StaffFinder, type StaffPerson, type Taught, type TdLink, } from "./people.js";
+export { type Pin, readPin } from "./pin.js";
+export { type Remote, type RemoteAsset, fallbackRemote, ghRemote, httpsRemote, setRemote, } from "./remote.js";
+export { type OpenOptions, Release, openCached, openRelease, resolveTag, } from "./release.js";
+export { type MajorCompetition, type MajorEvent, MajorsFinder, type ResultAnswer, ResultFinder, type ResultQuery, type ResultRow, } from "./results.js";
+export { type DancerAnswerLike, type DancerQueryLike, type DancerResolverLike, type DancerUnavailable, type RegistrationRow, type ResolvedDancer, RegistrationResolver, type ResolvedRegistration, dancerResolverOf, youngest, } from "./registrations.js";
+export { type SchoolAnswer, type SchoolCandidate, type SchoolQuery, SchoolResolver, type SchoolRung, } from "./schools.js";
+export { ARCHIVE_TAG, type ArchiveTag, type ReleaseSpec, compareTagsNewestFirst, cutOf, parseArchiveTag, parseReleaseSpec, pickTag, renderArchiveTag, } from "./tag.js";

package/dist/types/indexes.d.ts

@@ -0,0 +1,31 @@
+import { Database } from "bun:sqlite";
+import type { Release } from "./release.js";
+export interface IndexBuilder {
+    readonly name: string;
+    readonly version: string;
+    readonly inputs: readonly string[];
+    readonly says: string;
+    keyParts?(rel: Release): string[];
+    build(rel: Release, out: Database): void;
+}
+export declare function defaultBuilders(): IndexBuilder[];
+export declare const indexDir: (rel: {
+    dir: string;
+}) => string;
+export declare const indexPath: (rel: {
+    dir: string;
+}, name: string) => string;
+export declare function indexKey(rel: Release, b: IndexBuilder): string;
+export declare function keyOf(path: string): string | null;
+export declare function isCurrent(rel: Release, b: IndexBuilder): boolean;
+export declare function buildIndex(rel: Release, b: IndexBuilder, o: {
+    force: boolean;
+    log?: (line: string) => void;
+}): string;
+export interface IndexFile {
+    name: string;
+    path: string;
+    bytes: number;
+    current: boolean | null;
+}
+export declare function listIndexes(rel: Release): IndexFile[];