import type { AnyUpdate } from './custom-update.js';
/**
 * static metadata attached to every `Filter` — lets the dispatcher short-circuit
 * predicate eval and gives debug printers a readable name
 */
export interface FilterMeta {
    /** human-readable name, used by debug/inspect output and runtime conflict checks */
    readonly name: string;
    /**
     * kind hint — dispatcher skips this filter for updates whose `kind` isn't
     * listed. `undefined` = evaluate against any update
     */
    readonly kinds?: readonly string[];
}
/**
 * the public filter shape — a callable type-guard plus metadata, a structural
 * `Mod` refinement marker, and fluent composition methods
 *
 * `Base` and `Mod` are independent: kind/structural filters narrow `Base`,
 * presence and value filters narrow `Mod`. `tg.on(filter, handler)` sees the
 * arg typed as `Base & Mod`; raw `if (filter(u))` checks narrow only `Base`
 *
 * @example
 * ```ts
 * tg.on(kind.message.and(hasText), (m) => {
 *   // m: MessageUpdate & { text: string } — `text` is no longer `string | undefined`
 *   m.text.toLowerCase()
 * })
 * ```
 */
export interface Filter<Base = unknown, Mod = unknown> extends FilterMeta {
    (update: AnyUpdate): update is AnyUpdate & Base;
    /** intersect — match when both match; intersects `Base` and `Mod` */
    and: <B2, M2>(other: Filter<B2, M2>) => Filter<Base & B2, Mod & M2>;
    /** union — match when either matches; unions `Base` and `Mod` */
    or: <B2, M2>(other: Filter<B2, M2>) => Filter<Base | B2, Mod | M2>;
    /** negate — drops both narrowings */
    not: () => Filter<unknown, unknown>;
}
/**
 * async variant — predicate returns `Promise<boolean>` instead of a sync
 * type-guarded boolean. composes with sync filters; result is async if any operand is
 */
export interface AsyncFilter<Base = unknown, Mod = unknown> extends FilterMeta {
    (update: AnyUpdate): Promise<boolean>;
    and: <B2, M2>(other: Filter<B2, M2> | AsyncFilter<B2, M2>) => AsyncFilter<Base & B2, Mod & M2>;
    or: <B2, M2>(other: Filter<B2, M2> | AsyncFilter<B2, M2>) => AsyncFilter<Base | B2, Mod | M2>;
    not: () => AsyncFilter<unknown, unknown>;
}
/** structural type for the composition method set, exposed for filter shim authors */
export type FilterMethods<Base, Mod> = Pick<Filter<Base, Mod>, 'and' | 'or' | 'not'>;
/** extract the `Base` narrowing from a filter type — used by `tg.on(filter, handler)` to type the handler arg */
export type ExtractBase<F> = F extends Filter<infer B, infer _M> ? B : F extends AsyncFilter<infer B, infer _M> ? B : never;
/** extract the structural `Mod` refinement from a filter type */
export type ExtractMod<F> = F extends Filter<infer _B, infer M> ? M : F extends AsyncFilter<infer _B, infer M> ? M : never;
/** combine `Base` and `Mod` into the type a handler sees for the matched update */
export type FilterMatch<F> = ExtractBase<F> & ExtractMod<F>;
/**
 * structural runtime check — any callable with `and`/`or`/`not` function props
 * counts as a filter, so userland shims work without going through `defineFilter`
 */
export declare function isFilter(value: unknown): value is Filter;
interface DefineMeta {
    kinds?: readonly string[];
}
/**
 * build a `Filter<Base, Mod>` from a sync predicate. predicate may be a plain
 * `boolean` returner or a type-guard `(u): u is Base` — type-guards make raw
 * `if (filter(u))` narrow `u` to `Base`; `tg.on(filter, h)` always sees `Base & Mod`
 */
export declare function defineFilter<Base = unknown, Mod = unknown>(name: string, predicate: (update: AnyUpdate) => boolean, meta?: DefineMeta): Filter<Base, Mod>;
/**
 * async variant of `defineFilter` — predicate returns `Promise<boolean>` and
 * doesn't narrow at the call site (TS has no async type-guard)
 */
export declare function defineAsyncFilter<Base = unknown, Mod = unknown>(name: string, predicate: (update: AnyUpdate) => Promise<boolean>, meta?: DefineMeta): AsyncFilter<Base, Mod>;
type AnyFilter = Filter | AsyncFilter;
/** intersection — short-circuits on the first false operand. intersects `Base` and `Mod` */
export declare function and<B1, M1>(a: Filter<B1, M1>): Filter<B1, M1>;
export declare function and<B1, M1, B2, M2>(a: Filter<B1, M1>, b: Filter<B2, M2>): Filter<B1 & B2, M1 & M2>;
export declare function and<B1, M1, B2, M2, B3, M3>(a: Filter<B1, M1>, b: Filter<B2, M2>, c: Filter<B3, M3>): Filter<B1 & B2 & B3, M1 & M2 & M3>;
export declare function and<B1, M1, B2, M2, B3, M3, B4, M4>(a: Filter<B1, M1>, b: Filter<B2, M2>, c: Filter<B3, M3>, d: Filter<B4, M4>): Filter<B1 & B2 & B3 & B4, M1 & M2 & M3 & M4>;
export declare function and(...filters: readonly AnyFilter[]): Filter<unknown, unknown>;
/** union — short-circuits on the first true operand. unions `Base` and `Mod` */
export declare function or<B1, M1>(a: Filter<B1, M1>): Filter<B1, M1>;
export declare function or<B1, M1, B2, M2>(a: Filter<B1, M1>, b: Filter<B2, M2>): Filter<B1 | B2, M1 | M2>;
export declare function or<B1, M1, B2, M2, B3, M3>(a: Filter<B1, M1>, b: Filter<B2, M2>, c: Filter<B3, M3>): Filter<B1 | B2 | B3, M1 | M2 | M3>;
export declare function or<B1, M1, B2, M2, B3, M3, B4, M4>(a: Filter<B1, M1>, b: Filter<B2, M2>, c: Filter<B3, M3>, d: Filter<B4, M4>): Filter<B1 | B2 | B3 | B4, M1 | M2 | M3 | M4>;
export declare function or(...filters: readonly AnyFilter[]): Filter<unknown, unknown>;
/** negation — match when the operand does not match. drops both `Base` and `Mod` narrowing */
export declare function not(filter: AnyFilter): Filter<unknown, unknown>;
/** alias for `and` — reads more naturally for "every operand must match" intents */
export declare const every: typeof and;
/** alias for `or` — reads more naturally for "any operand may match" intents */
export declare const some: typeof or;
export {};
//# sourceMappingURL=filter-runtime.d.ts.map