@jbrowse/plugin-bed 4.3.0 → 5.0.0-beta.2

package/esm/BedTabixAdapter/BedTabixAdapter.js

@@ -1,103 +1,114 @@
-import BED from '@gmod/bed';
 import { TabixIndexedFile } from '@gmod/tabix';
-import { BaseFeatureDataAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
-import { SimpleFeature, updateStatus } from '@jbrowse/core/util';
-import { openLocation } from '@jbrowse/core/util/io';
+import { readConfObject } from '@jbrowse/core/configuration';
+import { BaseFeatureDataAdapter, cachedSetup, } from '@jbrowse/core/data_adapters/BaseAdapter';
+import { SimpleFeature, downloadStatus } from '@jbrowse/core/util';
+import { sharedBgzfWorkerPool } from '@jbrowse/core/util/bgzfWorkerPool';
+import { decompressedBytesBudget } from '@jbrowse/core/util/cacheBudgets';
+import { openLocation, openTabixIndexFilehandle } from '@jbrowse/core/util/io';
 import { ObservableCreate } from '@jbrowse/core/util/rxjs';
-import { checkStopToken } from '@jbrowse/core/util/stopToken';
-import { featureData } from "../util.js";
+import { checkStopTokenThrottled, checkStopToken, createStopTokenChecker, withStopTokenSignal, } from '@jbrowse/core/util/stopToken';
+import { readTabixHeaderLines } from '@jbrowse/core/util/tabix';
+import { featureData, makeParser, parseNamesFromHeader } from '../util.js';
 export default class BedTabixAdapter extends BaseFeatureDataAdapter {
-    parser;
+    // the parser needs the column names, which come from the file's header, so
+    // it cannot be built in the constructor
+    getParser = cachedSetup({
+        setup: async () => makeParser({
+            autoSql: readConfObject(this.config, 'autoSql'),
+            columnNames: await this.getNames(),
+        }),
+    });
+    bedGzLoc;
     bed;
-    columnNames;
-    scoreColumn;
     static capabilities = ['getFeatures', 'getRefNames'];
-    setupP;
+    // `label` because the index metadata download narrates nothing itself; the
+    // helper shows it only while the first attempt is in flight, so pan/zoom
+    // re-entry (every getFeatures awaits it) doesn't re-flash "Downloading index"
+    getMetadata = cachedSetup({
+        label: 'Downloading index',
+        setup: () => this.bed.getMetadata(),
+    });
+    // Memoized: getFeatures needs the names on every query, and reading them goes
+    // to the file's leading blocks — a fetch and a decompress that was being
+    // repeated on every pan and zoom. Resolves undefined when the file declares
+    // no column names — parseNamesFromHeader's answer for a header it can't read
+    // names out of.
+    getNames = cachedSetup({ setup: () => this.readNames() });
     constructor(config, getSubAdapter, pluginManager) {
         super(config, getSubAdapter, pluginManager);
-        const bedGzLoc = this.getConf('bedGzLocation');
-        const type = this.getConf(['index', 'indexType']);
-        const loc = this.getConf(['index', 'location']);
-        const autoSql = this.getConf('autoSql');
+        this.bedGzLoc = readConfObject(this.config, 'bedGzLocation');
+        const type = readConfObject(this.config, ['index', 'indexType']);
+        const loc = readConfObject(this.config, ['index', 'location']);
         const pm = this.pluginManager;
         this.bed = new TabixIndexedFile({
-            filehandle: openLocation(bedGzLoc, pm),
-            csiFilehandle: type === 'CSI' ? openLocation(loc, pm) : undefined,
-            tbiFilehandle: type !== 'CSI' ? openLocation(loc, pm) : undefined,
-            chunkCacheSize: 50 * 2 ** 20,
+            filehandle: openLocation(this.bedGzLoc, pm),
+            ...openTabixIndexFilehandle(loc, type, pm),
+            chunkCacheBudget: decompressedBytesBudget,
+            bgzfWorkerPool: sharedBgzfWorkerPool(),
         });
-        this.columnNames = this.getConf('columnNames');
-        this.scoreColumn = this.getConf('scoreColumn');
-        this.parser = new BED({ autoSql });
     }
     async getRefNames(opts = {}) {
-        return this.bed.getReferenceSequenceNames(opts);
+        return downloadStatus('Downloading index', opts.statusCallback, onProgress => this.bed.getReferenceSequenceNames({ ...opts, onProgress }));
     }
     async getHeader(opts) {
         return this.bed.getHeader(opts);
     }
-    async getMetadataPre2(_opts) {
-        if (!this.setupP) {
-            this.setupP = this.getMetadataPre().catch((e) => {
-                this.setupP = undefined;
-                throw e;
-            });
-        }
-        return this.setupP;
-    }
-    async getMetadataPre() {
-        const meta = await this.bed.getMetadata();
-        return { meta };
-    }
-    async getMetadata(opts) {
-        const { statusCallback = () => { } } = opts || {};
-        return updateStatus('Downloading index', statusCallback, () => this.getMetadataPre2(opts));
+    /**
+     * Estimate compressed bytes for regions straight from the tabix index — no
+     * feature download. Lets wrapping adapters (e.g. MafTabix) byte-budget a
+     * fetch before pulling the (potentially huge) per-line payload.
+     */
+    async getRegionByteSize(regions, opts) {
+        return this.bed.bytesForRegions(regions, opts);
     }
-    async getNames() {
-        if (this.columnNames.length) {
-            return this.columnNames;
+    async readNames() {
+        const columnNames = readConfObject(this.config, 'columnNames');
+        if (columnNames.length) {
+            return columnNames;
         }
-        const header = await this.getHeader();
-        const defs = header.split(/\n|\r\n|\r/).filter(f => !!f);
-        const defline = defs.at(-1);
-        return defline?.includes('\t')
-            ? defline
-                .slice(1)
-                .split('\t')
-                .map(f => f.trim())
-            : undefined;
+        // readTabixHeaderLines covers both ways a tabix file keeps a header: a
+        // `#`-commented block, which getHeader() returns, and a plain row skipped
+        // via `tabix -S N`, which it does not.
+        return parseNamesFromHeader((await readTabixHeaderLines(this.bed)).join('\n'));
     }
     getFeatures(query, opts) {
-        const { stopToken, statusCallback = () => { } } = opts || {};
+        const { stopToken, statusCallback } = opts ?? {};
         return ObservableCreate(async (observer) => {
-            const { meta } = await this.getMetadata();
-            const { columnNumbers } = meta;
-            const colRef = columnNumbers.ref - 1;
-            const colStart = columnNumbers.start - 1;
-            const colEnd = columnNumbers.end - 1;
+            // warms the index under its own status label — getLines would otherwise
+            // download it under "Downloading features"
+            await this.getMetadata(opts);
             const names = await this.getNames();
-            const disableGeneHeuristic = this.getConf('disableGeneHeuristic');
-            let start = performance.now();
+            const parser = await this.getParser();
+            const scoreColumn = readConfObject(this.config, 'scoreColumn');
+            const disableGeneHeuristic = readConfObject(this.config, 'disableGeneHeuristic');
+            const stopTokenCheck = createStopTokenChecker(stopToken);
             checkStopToken(stopToken);
-            await updateStatus('Downloading features', statusCallback, () => this.bed.getLines(query.refName, query.start, query.end, {
-                lineCallback: (line, fileOffset) => {
-                    if (performance.now() - start > 500) {
-                        checkStopToken(stopToken);
-                        start = performance.now();
-                    }
+            await withStopTokenSignal(stopToken, signal => downloadStatus('Downloading features', statusCallback, onProgress => 
+            // start/end come from @gmod/tabix rather than being re-derived from
+            // the line: it located the coordinate columns to find these lines at
+            // all, and already applied the index's coordinate offset (-1 for a
+            // 1-based-closed preset) and its no-end-column convention (a single
+            // position becomes start..start+1). refName is likewise the query's
+            // — getLines only calls back for lines whose ref column matches it.
+            this.bed.getLines(query.refName, query.start, query.end, {
+                lineCallback: (line, fileOffset, start, end) => {
+                    checkStopTokenThrottled(stopTokenCheck);
+                    const splitLine = line.split('\t');
                     observer.next(new SimpleFeature(featureData({
-                        line,
-                        colRef,
-                        colStart,
-                        colEnd,
-                        scoreColumn: this.scoreColumn,
-                        parser: this.parser,
+                        splitLine,
+                        refName: query.refName,
+                        start,
+                        end,
+                        scoreColumn,
+                        parser,
                         uniqueId: `${this.id}-${fileOffset}`,
                         names,
                         disableGeneHeuristic,
                     })));
                 },
-            }));
+                onProgress,
+                signal,
+            })));
             observer.complete();
         }, stopToken);
     }

package/esm/BedTabixAdapter/configSchema.d.ts

@@ -1,44 +1,86 @@
+import type { Instance } from '@jbrowse/mobx-state-tree';
+export declare function normalizeSnapshot(snap: Record<string, unknown>): Record<string, unknown>;
+/**
+ * #config BedTabixAdapter
+ * #trackType FeatureTrack
+ * #fileFormat feature | BED (tabix)
+ *
+ * #example
+ * The `uri` shorthand auto-resolves the `.tbi` index; add `csi: true` for a
+ * `.csi` index instead:
+ * ```js
+ * {
+ *   type: 'BedTabixAdapter',
+ *   uri: 'https://example.com/features.bed.gz',
+ * }
+ * ```
+ */
 declare const BedTabixAdapter: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
-    bedGzLocation: {
-        type: string;
-        defaultValue: {
-            uri: string;
-            locationType: string;
+    readonly densityAdapter: {
+        readonly type: 'frozen';
+        readonly defaultValue: null;
+        readonly description: 'optional quantitative sub-adapter (e.g. a BigWigAdapter over a features-per-bin bigWig) drawn as a density band where the region is too large to fetch features; null disables it';
+    };
+    /**
+     * #slot
+     * location of the bgzip-compressed BED, sorted by position. Must be bgzip
+     * rather than plain gzip, which tabix cannot index.
+     */
+    readonly bedGzLocation: {
+        readonly type: "fileLocation";
+        readonly defaultValue: {
+            readonly uri: "/path/to/my.bed.gz";
+            readonly locationType: "UriLocation";
         };
     };
-    index: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
-        indexType: {
-            model: import("@jbrowse/mobx-state-tree").ISimpleType<"TBI" | "CSI">;
-            type: string;
-            defaultValue: string;
+    readonly index: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+        readonly indexType: {
+            readonly model: import("@jbrowse/mobx-state-tree").ISimpleType<"CSI" | "TBI">;
+            readonly type: 'stringEnum';
+            readonly defaultValue: 'TBI';
+            readonly description: '`TBI` is the usual `tabix` output. `CSI` is required for a reference longer than 512 Mb, which TBI cannot address.';
         };
-        location: {
-            type: string;
-            defaultValue: {
-                uri: string;
-                locationType: string;
+        readonly location: {
+            readonly type: 'fileLocation';
+            readonly defaultValue: {
+                readonly uri: '/path/to/my.gz.tbi';
+                readonly locationType: 'UriLocation';
             };
+            readonly description: 'location of the tabix index. Only needed when it is not named `<file>.tbi` (or `.csi`), which is what the `uri` shorthand assumes.';
         };
     }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
-    columnNames: {
-        type: string;
-        description: string;
-        defaultValue: never[];
+    /**
+     * #slot
+     */
+    readonly columnNames: {
+        readonly type: "stringArray";
+        readonly description: "List of column names. A column named like a standard BED column is parsed as that column's type (chromStart numeric, blockSizes a numeric list); any other column is text";
+        readonly defaultValue: readonly [];
     };
-    scoreColumn: {
-        type: string;
-        description: string;
-        defaultValue: string;
+    /**
+     * #slot
+     */
+    readonly scoreColumn: {
+        readonly type: "string";
+        readonly description: "The column to use as a \"score\" attribute";
+        readonly defaultValue: "";
     };
-    autoSql: {
-        type: string;
-        description: string;
-        defaultValue: string;
+    /**
+     * #slot
+     */
+    readonly autoSql: {
+        readonly type: "string";
+        readonly description: "The autoSql definition for the data fields in the file";
+        readonly defaultValue: "";
     };
-    disableGeneHeuristic: {
-        type: string;
-        description: string;
-        defaultValue: boolean;
+    /**
+     * #slot
+     */
+    readonly disableGeneHeuristic: {
+        readonly type: "boolean";
+        readonly description: "Disable the heuristic that auto-detects BED12 features as gene/transcript structures. Useful for files that have BED12-like structure but are not genes (e.g. tandem duplications)";
+        readonly defaultValue: false;
     };
 }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
+export type BedTabixAdapterConfig = Instance<typeof BedTabixAdapter>;
 export default BedTabixAdapter;

package/esm/BedTabixAdapter/configSchema.js

@@ -1,7 +1,29 @@
-import { ConfigurationSchema } from '@jbrowse/core/configuration';
-import { types } from '@jbrowse/mobx-state-tree';
-function x() { }
+import { ConfigurationSchema, expandTabixShorthand, tabixIndexFields, } from '@jbrowse/core/configuration';
+import { densityAdapterConfigSchemaFields } from '@jbrowse/core/data_adapters/BaseAdapter';
+export function normalizeSnapshot(snap) {
+    return expandTabixShorthand(snap, 'bedGzLocation');
+}
+/**
+ * #config BedTabixAdapter
+ * #trackType FeatureTrack
+ * #fileFormat feature | BED (tabix)
+ *
+ * #example
+ * The `uri` shorthand auto-resolves the `.tbi` index; add `csi: true` for a
+ * `.csi` index instead:
+ * ```js
+ * {
+ *   type: 'BedTabixAdapter',
+ *   uri: 'https://example.com/features.bed.gz',
+ * }
+ * ```
+ */
 const BedTabixAdapter = ConfigurationSchema('BedTabixAdapter', {
+    /**
+     * #slot
+     * location of the bgzip-compressed BED, sorted by position. Must be bgzip
+     * rather than plain gzip, which tabix cannot index.
+     */
     bedGzLocation: {
         type: 'fileLocation',
         defaultValue: {
@@ -9,58 +31,54 @@ const BedTabixAdapter = ConfigurationSchema('BedTabixAdapter', {
             locationType: 'UriLocation',
         },
     },
-    index: ConfigurationSchema('TabixIndex', {
-        indexType: {
-            model: types.enumeration('IndexType', ['TBI', 'CSI']),
-            type: 'stringEnum',
-            defaultValue: 'TBI',
-        },
-        location: {
-            type: 'fileLocation',
-            defaultValue: {
-                uri: '/path/to/my.bed.gz.tbi',
-                locationType: 'UriLocation',
-            },
-        },
-    }),
+    index: ConfigurationSchema('TabixIndex', { ...tabixIndexFields }),
+    /**
+     * #slot
+     */
     columnNames: {
         type: 'stringArray',
-        description: 'List of column names',
+        description: "List of column names. A column named like a standard BED column is parsed as that column's type (chromStart numeric, blockSizes a numeric list); any other column is text",
         defaultValue: [],
     },
+    /**
+     * #slot
+     */
     scoreColumn: {
         type: 'string',
         description: 'The column to use as a "score" attribute',
         defaultValue: '',
     },
+    /**
+     * #slot
+     */
     autoSql: {
         type: 'string',
         description: 'The autoSql definition for the data fields in the file',
         defaultValue: '',
     },
+    /**
+     * #slot
+     */
     disableGeneHeuristic: {
         type: 'boolean',
         description: 'Disable the heuristic that auto-detects BED12 features as gene/transcript structures. Useful for files that have BED12-like structure but are not genes (e.g. tandem duplications)',
         defaultValue: false,
     },
+    ...densityAdapterConfigSchemaFields,
 }, {
     explicitlyTyped: true,
-    preProcessSnapshot: snap => {
-        return snap.uri
-            ? {
-                ...snap,
-                bedGzLocation: {
-                    uri: snap.uri,
-                    baseUri: snap.baseUri,
-                },
-                index: {
-                    location: {
-                        uri: `${snap.uri}.tbi`,
-                        baseUri: snap.baseUri,
-                    },
-                },
-            }
-            : snap;
-    },
+    /**
+     * #preProcessSnapshot
+     *
+     *
+     * preprocessor to allow minimal config, assumes yourfile.bed.gz.tbi:
+     * ```json
+     * {
+     *   "type": "BedTabixAdapter",
+     *   "uri": "yourfile.bed.gz"
+     * }
+     * ```
+     */
+    preProcessSnapshot: normalizeSnapshot,
 });
 export default BedTabixAdapter;

package/esm/BedTabixAdapter/index.js

@@ -1,10 +1,12 @@
 import AdapterType from '@jbrowse/core/pluggableElementTypes/AdapterType';
-import configSchema from "./configSchema.js";
+import configSchema, { normalizeSnapshot } from './configSchema.js';
 export default function BedTabixAdapterF(pluginManager) {
     pluginManager.addAdapterType(() => new AdapterType({
         name: 'BedTabixAdapter',
         displayName: 'BED tabix adapter',
         configSchema,
-        getAdapterClass: () => import("./BedTabixAdapter.js").then(r => r.default),
+        getAdapterClass: () => import('./BedTabixAdapter.js').then(r => r.default),
+        locationKey: 'bedGzLocation',
+        normalizeSnapshot,
     }));
 }

package/esm/BedpeAdapter/BedpeAdapter.d.ts

@@ -1,18 +1,12 @@
 import { BaseFeatureDataAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
-import { IntervalTree } from '@jbrowse/core/util';
+import type { BedpeAdapterConfig } from './configSchema.ts';
 import type { BaseOptions } from '@jbrowse/core/data_adapters/BaseAdapter';
-import type { Feature, Region } from '@jbrowse/core/util';
-export default class BedpeAdapter extends BaseFeatureDataAdapter {
-    protected bedpeFeatures?: Promise<{
-        header: string;
-        feats1: Record<string, string[]>;
-        feats2: Record<string, string[]>;
-        columnNames: string[];
-    }>;
+import type { Feature, IntervalTree, Region } from '@jbrowse/core/util';
+export default class BedpeAdapter extends BaseFeatureDataAdapter<BedpeAdapterConfig> {
+    private loadData;
     protected intervalTrees: Record<string, Promise<IntervalTree<Feature> | undefined> | undefined>;
     static capabilities: string[];
     private loadDataP;
-    private loadData;
     getRefNames(opts?: BaseOptions): Promise<string[]>;
     getHeader(opts?: BaseOptions): Promise<string>;
     getNames(): Promise<string[] | undefined>;

package/esm/BedpeAdapter/BedpeAdapter.js

@@ -1,54 +1,39 @@
-import { BaseFeatureDataAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
-import { IntervalTree, fetchAndMaybeUnzipText } from '@jbrowse/core/util';
+import { BaseFeatureDataAdapter, cachedSetup, } from '@jbrowse/core/data_adapters/BaseAdapter';
+import { fetchAndMaybeUnzip } from '@jbrowse/core/util';
 import { openLocation } from '@jbrowse/core/util/io';
-import { ObservableCreate } from '@jbrowse/core/util/rxjs';
-import { featureData } from "./util.js";
+import { parseLineByLine } from '@jbrowse/core/util/parseLineByLine';
+import { buildPairedIntervalTree, intervalTreeFeatures, } from '../adapterUtil.js';
+import { resolveColumnNames } from '../util.js';
+import { featureData } from './util.js';
 export default class BedpeAdapter extends BaseFeatureDataAdapter {
-    bedpeFeatures;
+    // No `label`: `fetchAndMaybeUnzip` narrates the download from inside.
+    loadData = cachedSetup({ setup: opts => this.loadDataP(opts) });
     intervalTrees = {};
     static capabilities = ['getFeatures', 'getRefNames'];
     async loadDataP(opts) {
-        const data = await fetchAndMaybeUnzipText(openLocation(this.getConf('bedpeLocation'), this.pluginManager), opts);
-        const lines = data.split(/\n|\r\n|\r/).filter(f => !!f);
+        const buffer = await fetchAndMaybeUnzip(openLocation(this.getConf('bedpeLocation'), this.pluginManager), opts);
         const headerLines = [];
-        let i = 0;
-        for (; i < lines.length && lines[i].startsWith('#'); i++) {
-            headerLines.push(lines[i]);
-        }
-        const header = headerLines.join('\n');
         const feats1 = {};
         const feats2 = {};
-        for (; i < lines.length; i++) {
-            const line = lines[i];
-            const cols = line.split('\t');
-            const r1 = cols[0];
-            const r2 = cols[3];
-            if (!feats1[r1]) {
-                feats1[r1] = [];
+        parseLineByLine(buffer, line => {
+            if (line.startsWith('#')) {
+                headerLines.push(line);
             }
-            if (!feats2[r2]) {
-                feats2[r2] = [];
+            else if (!line.startsWith('track') && !line.startsWith('browser')) {
+                const cols = line.split('\t');
+                const r1 = cols[0];
+                const r2 = cols[3];
+                (feats1[r1] ??= []).push(line);
+                (feats2[r2] ??= []).push(line);
             }
-            feats1[r1].push(line);
-            feats2[r2].push(line);
-        }
-        const columnNames = this.getConf('columnNames');
+            return true;
+        }, opts?.statusCallback);
         return {
-            header,
+            header: headerLines.join('\n'),
             feats1,
             feats2,
-            columnNames,
         };
     }
-    async loadData(opts = {}) {
-        if (!this.bedpeFeatures) {
-            this.bedpeFeatures = this.loadDataP(opts).catch((e) => {
-                this.bedpeFeatures = undefined;
-                throw e;
-            });
-        }
-        return this.bedpeFeatures;
-    }
     async getRefNames(opts = {}) {
         const { feats1, feats2 } = await this.loadData(opts);
         return [...new Set([...Object.keys(feats1), ...Object.keys(feats2)])];
@@ -58,47 +43,21 @@ export default class BedpeAdapter extends BaseFeatureDataAdapter {
         return header;
     }
     async getNames() {
-        const { header, columnNames } = await this.loadData();
-        if (columnNames.length) {
-            return columnNames;
-        }
-        const defs = header.split(/\n|\r\n|\r/).filter(f => !!f);
-        const defline = defs.at(-1);
-        return defline?.includes('\t')
-            ? defline
-                .slice(1)
-                .split('\t')
-                .map(field => field.trim())
-            : undefined;
+        return resolveColumnNames(this.getConf('columnNames'), async () => (await this.loadData()).header);
     }
     async loadFeatureTreeP(refName) {
         const { feats1, feats2 } = await this.loadData();
         const names = await this.getNames();
-        const intervalTree = new IntervalTree();
-        const ret1 = feats1[refName]?.map((f, i) => featureData(f, `${this.id}-${refName}-${i}-r1`, false, names)) ?? [];
-        const ret2 = feats2[refName]?.map((f, i) => featureData(f, `${this.id}-${refName}-${i}-r2`, true, names)) ?? [];
-        for (const obj of [...ret1, ...ret2]) {
-            intervalTree.insert([obj.get('start'), obj.get('end')], obj);
-        }
-        return intervalTree;
+        return buildPairedIntervalTree(feats1, feats2, refName, this.id, (line, uniqueId, flip) => featureData(line, uniqueId, flip, names));
     }
     async loadFeatureTree(refName) {
-        if (!this.intervalTrees[refName]) {
-            this.intervalTrees[refName] = this.loadFeatureTreeP(refName).catch((e) => {
-                this.intervalTrees[refName] = undefined;
-                throw e;
-            });
-        }
+        this.intervalTrees[refName] ??= this.loadFeatureTreeP(refName).catch((e) => {
+            this.intervalTrees[refName] = undefined;
+            throw e;
+        });
         return this.intervalTrees[refName];
     }
     getFeatures(query, opts = {}) {
-        return ObservableCreate(async (observer) => {
-            const { start, end, refName } = query;
-            const intervalTree = await this.loadFeatureTree(refName);
-            for (const f of intervalTree?.search([start, end]) || []) {
-                observer.next(f);
-            }
-            observer.complete();
-        }, opts.stopToken);
+        return intervalTreeFeatures(query, opts, refName => this.loadFeatureTree(refName));
     }
 }

package/esm/BedpeAdapter/configSchema.d.ts

@@ -1,16 +1,39 @@
+import type { Instance } from '@jbrowse/mobx-state-tree';
+export declare function normalizeSnapshot(snap: Record<string, unknown>): Record<string, unknown>;
+/**
+ * #config BedpeAdapter
+ * #trackType VariantTrack
+ * #fileFormat variants | BEDPE | Paired/breakend records, e.g. SV calls or Hi-C loops
+ * intended for SVs in a single assembly
+ *
+ * #example
+ * ```js
+ * {
+ *   type: 'BedpeAdapter',
+ *   uri: 'https://example.com/sv.bedpe',
+ * }
+ * ```
+ */
 declare const BedpeAdapter: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
-    bedpeLocation: {
-        type: string;
-        description: string;
-        defaultValue: {
-            uri: string;
-            locationType: string;
+    /**
+     * #slot
+     */
+    readonly bedpeLocation: {
+        readonly type: "fileLocation";
+        readonly description: "can be plaintext or gzipped, not indexed so loaded into memory on startup";
+        readonly defaultValue: {
+            readonly uri: "/path/to/my.bedpe.gz";
+            readonly locationType: "UriLocation";
         };
     };
-    columnNames: {
-        type: string;
-        description: string;
-        defaultValue: never[];
+    /**
+     * #slot
+     */
+    readonly columnNames: {
+        readonly type: "stringArray";
+        readonly description: "List of column names";
+        readonly defaultValue: readonly [];
     };
 }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
+export type BedpeAdapterConfig = Instance<typeof BedpeAdapter>;
 export default BedpeAdapter;