import { type Action, type Link, type Resolver, type Graph } from './types.js';
/**
 * Takes a `Graph` and returns a flat array of links by performing a topographical sort and
 * filter. For example, this graph
 * ```
 *                      ┌─ e ─ g ─┐
 *            ┌─ c ─ d ─┤         ├─ o(HEAD)
 *     a ─ b ─┤         └─── f ───┘
 *            └─ h ─ i(HEAD)
 * ```
 *  might be transformed to this sequence
 * ```
 *    [a, b, c, d, e, f, g, h, i]
 * ```
 *
 * The logic for merging concurrent branches is captured in a `resolver` function provided by the
 * caller. A resolver takes the graph as an argument, and returns two functions:
 * - `sort` is a comparator function that indicates how concurrent branches are to be ordered.
 * - `filter` is a predicate function that indicates which links to include in the resulting
 *   sequence.
 */
export declare const getSequence: <A extends Action, C>(graph: Graph<A, C>, resolver?: Resolver<A, C>) => {
    isInvalid: boolean;
    hash: import("@localfirst/crypto").Hash;
    body: import("./types.js").LinkBody<A, C>;
}[];
export declare const baseResolver: Resolver<any, any>;
export declare const noFilter: (_: Link<any, any>) => boolean;
//# sourceMappingURL=getSequence.d.ts.map