import type { Filter } from "@yaebal/core";
import type { AndAdd, BaseOf, CombinedBase, OrAdd } from "./types.js";
/**
 * the combinators. filters stage their data in a bag instead of touching the
 * context, so combination is safe by construction:
 *
 * - `and` shares one bag left to right — later members see what earlier ones
 *   staged; if any member rejects, the caller discards the bag and nothing
 *   ever reaches the context.
 * - `or` gives every branch a fresh bag and keeps only the winning branch's —
 *   a failed branch can't leave anything behind.
 * - `not` evaluates into a throwaway bag — its inner additions are never wanted.
 *
 * sync filters stay on the sync path (no promise allocation); one async member
 * switches the rest of the walk to await.
 */
/** the loosest filter shape — anything callable as a filter fits. */
type AnyFilter = Filter<never, object>;
/**
 * matches when every filter matches (evaluated left to right, short-circuits).
 * additions intersect: handlers see everything every member staged. `and()` of
 * nothing matches everything.
 */
export declare function and<F extends readonly AnyFilter[]>(...filters: F): Filter<CombinedBase<F>, AndAdd<F>>;
/**
 * matches when any filter matches (evaluated left to right, short-circuits).
 * additions unite: handlers see the union of what the branches stage — only
 * fields staged by *every* branch are safely typed. `or()` of nothing matches
 * nothing.
 */
export declare function or<F extends readonly AnyFilter[]>(...filters: F): Filter<CombinedBase<F>, OrAdd<F>>;
/** matches when the filter does NOT match. no additions. */
export declare function not<F extends AnyFilter>(filter: F): Filter<BaseOf<F>>;
export {};
//# sourceMappingURL=logic.d.ts.map