export declare function loadPersistedLinkBps(): number;
/**
 * Where to start when nothing has been measured yet.
 *
 * A stored measurement wins — it is the only number that came from timing this
 * app's own bytes. Failing that, the browser's own estimate is a far better
 * answer than the smallest rung: a probe that comes up empty (a proxy that
 * bursts before it paces is where that happens) used to open on 144p over a
 * link that turned out to be tens of megabits.
 *
 * Deliberately NOT part of loadPersistedLinkBps(). That one means "what we
 * measured", and raiseLinkBps() compares against it — seeding it from the
 * browser would stop any real measurement below the estimate from ever being
 * stored.
 *
 * It is a floor, not a reading. `downlink` is recently observed application
 * throughput rounded to 25kbps, absent on Safari and Firefox, and on a fresh
 * link derived from the connection type rather than measured at all. Safe here
 * only because the caller confirms it: the pre-play confirm pass reads the head
 * of the rung it intends to open and steps down if the link cannot hold it.
 */
export declare function linkSeedBps(): number;
/**
 * Record a measurement, replacing whatever was there.
 *
 * For a DEDICATED measurement only — the pre-play probe, which clears the proxy
 * burst and times a tail specifically to find out what the link can do. It
 * replaces rather than raises because a link that has genuinely slowed has to
 * be able to bring the number down.
 */
export declare function persistLinkBps(bps: number): void;
/**
 * Record a measurement only if it beats what's already known.
 *
 * For throughput observed WHILE PLAYING, which is a floor rather than a
 * capability: a CDN paces each stream to roughly its own bitrate, and once the
 * buffer is full the engine stops pulling at all, so a 40 Mbps link watching an
 * 8 Mbps rung measures about 8. Letting that replace the record would teach the
 * next load — and the pre-play probe that reads the same record — that the link
 * is a fifth of what it is, and every future pick would open lower for it.
 *
 * Raising is still worth doing: on a plain DASH/HLS source the probe never
 * runs, so an engine's own numbers are the only thing that will ever populate
 * the record. A floor that beats the stored value is real news; one that
 * doesn't tells us nothing we didn't have.
 *
 * The link-change listener and the signature check are what clear a number that
 * has stopped being true — not a paced reading from a stream that was never
 * trying to go faster.
 */
export declare function raiseLinkBps(bps: number): void;
/**
 * Record that the link could NOT carry `bps`, if what's stored says it could.
 *
 * The one playback reading that is a ceiling rather than a floor: a rung the
 * link failed to sustain. raiseLinkBps() can never bring the record down, and
 * the confirm pass that should have caught a stale seed learns nothing when
 * the rung's head is already in the HTTP cache — so a 140.9Mbps record on a
 * ~40Mbps line opened 8K, stepped down to 4K and then 1440p in front of the
 * viewer, and was left standing to do the same on the next load. Capping at
 * the failed rung's bitrate puts the next opening pick (55% of the seed) well
 * under it; the ABR climbs from there if the link was only briefly short.
 */
export declare function lowerLinkBps(bps: number): void;
//# sourceMappingURL=LinkRate.d.ts.map