import type { Axis, Orderer, Pin, Resolvable } from "./Types";
type Planning = {
    strategy: "product";
    orderer?: Orderer | undefined;
} | {
    strategy: "cycle";
    orderer: Orderer;
};
/**
 * Enumerable shape of a built Fabricator tree: how many distinct combinations,
 * and how to reproduce the `index`-th as a `Pin`. Exhaustive kind dispatch
 * lives in `axisFor`; this wrapper applies `"cycle"` permutation uniformly,
 * once, to whatever axis `axisFor` computes — so every recursive call
 * (`axisFor` cases call back into `plan`, never `axisFor` directly) gets its
 * _own_ independent permutation, decorrelating equal-width siblings without any
 * per-kind case needing to know strategy beyond `Strategy`'s own widen/narrow
 * rules.
 *
 * Width is a function of schema shape _and_ weights: a zero-weighted outcome is
 * not fabricable, so `axisFor` filters through `isDrawable` /
 * `drawableOutcomes` rather than treating the declared branch set as the axis.
 * Without that, `coverage()` would pin a value `fabricate()` can never produce.
 * Defaulting of unspecified keyed weights goes through `drawableOutcomes` so
 * the `?? 1` baseline is never re-implemented here.
 *
 * Skipped for width-1 axes (nothing to permute) and under `"product"`
 * (mixed-radix decode already visits every combination, so permuting would only
 * reorder identical output — see `Orderer`). `orders` is therefore only ever
 * read when `strategy === "cycle"` and is safe to omit otherwise.
 */
export declare function plan(node: Resolvable, planning: Planning): Axis;
/**
 * Reproduce the value a `Pin` describes against the built Fabricator it was
 * planned from. `pin === undefined` is universal — `plan()` gave this node a
 * width-1 axis, so there is nothing to pin and it fabricates normally. Every
 * other case only arises for kinds `plan()` treats as enumerable axes, so this
 * switch does not need to be exhaustive the way `plan()`'s is.
 */
export declare function resolve(node: Resolvable, pin: Pin): unknown;
export {};