import { Option } from 'effect';
import type { VNode } from '../vdom.js';
type MatchMode = 'Exact' | 'StartsWith';
type AttributeMatcher = Readonly<{
    name: string;
    value: Option.Option<string>;
    mode: MatchMode;
}>;
type SimpleSelector = Readonly<{
    tag: Option.Option<string>;
    id: Option.Option<string>;
    classes: ReadonlyArray<string>;
    attributes: ReadonlyArray<AttributeMatcher>;
}>;
type Selector = ReadonlyArray<SimpleSelector>;
export declare const parseSelector: (input: string) => Selector;
/** Returns the ancestor chain of `target` within `root`, ordered from root to
 *  the immediate parent of `target` (exclusive). Returns an empty array when
 *  `target` is `root` itself or is not present in the subtree. */
export declare const ancestorsOf: (target: VNode) => (root: VNode) => ReadonlyArray<VNode>;
/** Computes the accessible name of an element. Resolves via
 *  `aria-labelledby`, `aria-label`, `<label for>`, native host language
 *  attributes and child elements (img/area alt, input value/alt,
 *  fieldset legend, figure figcaption, table caption), text content,
 *  then `title`. */
export declare const accessibleName: (root: VNode) => (vnode: VNode) => string;
/** Computes the accessible description of an element. Resolves via
 *  `aria-describedby` (joining referenced elements' text content). */
export declare const accessibleDescription: (root: VNode) => (vnode: VNode) => string;
/** Finds the first VNode matching the CSS selector. */
export declare const find: {
    (html: VNode, selectorString: string): Option.Option<VNode>;
    (selectorString: string): (html: VNode) => Option.Option<VNode>;
};
/** Finds all VNodes matching the CSS selector. */
export declare const findAll: {
    (html: VNode, selectorString: string): ReadonlyArray<VNode>;
    (selectorString: string): (html: VNode) => ReadonlyArray<VNode>;
};
/** Extracts all text content from a VNode tree, depth-first. */
export declare const textContent: (vnode: VNode) => string;
/** Reads an attribute or prop value from a VNode. */
export declare const attr: {
    (vnode: VNode, name: string): Option.Option<string>;
    (name: string): (vnode: VNode) => Option.Option<string>;
};
type RoleOptions = Readonly<{
    name?: string | RegExp;
    level?: number;
    checked?: boolean | 'mixed';
    selected?: boolean;
    pressed?: boolean | 'mixed';
    expanded?: boolean;
    disabled?: boolean;
}>;
/** Finds the first element with the given ARIA role and optional matching options.
 *  Supports `name` (accessible name), `level` (heading level), `checked`,
 *  `selected`, `pressed`, `expanded`, and `disabled` state filters. */
export declare const getByRole: (role: string, options?: RoleOptions) => (html: VNode) => Option.Option<VNode>;
/** Finds all elements with the given ARIA role and optional matching options. */
export declare const getAllByRole: (role: string, options?: RoleOptions) => (html: VNode) => ReadonlyArray<VNode>;
/** Finds the most specific element matching the given text content.
 *  Skips text VNodes (sel undefined) — only returns actual DOM elements. */
export declare const getByText: (target: string, options?: Readonly<{
    exact?: boolean;
}>) => (html: VNode) => Option.Option<VNode>;
/** Finds the first element with the given placeholder attribute. */
export declare const getByPlaceholder: (placeholderValue: string) => (html: VNode) => Option.Option<VNode>;
/** Finds the first element with the given label text. Checks `aria-label`
 *  first, then `<label for="id">` association, then `<label>` nesting,
 *  then `aria-labelledby` reverse lookup. */
export declare const getByLabel: (labelValue: string) => (html: VNode) => Option.Option<VNode>;
/** Finds every element with the given label text. Applies the same four
 *  resolution strategies as `getByLabel` (`aria-label`, `<label for="id">`,
 *  `<label>` nesting, `aria-labelledby`) and returns deduplicated matches. */
export declare const getAllByLabel: (labelValue: string) => (html: VNode) => ReadonlyArray<VNode>;
/** Finds the first element with the given `alt` attribute. */
export declare const getByAltText: (altValue: string) => (html: VNode) => Option.Option<VNode>;
/** Finds the first element with the given `title` attribute. */
export declare const getByTitle: (titleValue: string) => (html: VNode) => Option.Option<VNode>;
/** Finds the first element with the given `data-testid` attribute. */
export declare const getByTestId: (testIdValue: string) => (html: VNode) => Option.Option<VNode>;
/** Finds all elements matching the given text content.
 *  Includes nested ancestors — a `<div><p>hi</p></div>` with text "hi" yields both. */
export declare const getAllByText: (target: string, options?: Readonly<{
    exact?: boolean;
}>) => (html: VNode) => ReadonlyArray<VNode>;
/** Finds all elements with the given placeholder attribute. */
export declare const getAllByPlaceholder: (placeholderValue: string) => (html: VNode) => ReadonlyArray<VNode>;
/** Finds all elements with the given `alt` attribute. */
export declare const getAllByAltText: (altValue: string) => (html: VNode) => ReadonlyArray<VNode>;
/** Finds all elements with the given `title` attribute. */
export declare const getAllByTitle: (titleValue: string) => (html: VNode) => ReadonlyArray<VNode>;
/** Finds all elements with the given `data-testid` attribute. */
export declare const getAllByTestId: (testIdValue: string) => (html: VNode) => ReadonlyArray<VNode>;
/** Finds all form controls whose current value matches. */
export declare const getAllByDisplayValue: (displayValueString: string) => (html: VNode) => ReadonlyArray<VNode>;
/** Finds the first form control whose current value matches. Checks the `value`
 *  attribute on inputs, textareas, and selects. */
export declare const getByDisplayValue: (displayValue: string) => (html: VNode) => Option.Option<VNode>;
/** A deferred element query that resolves against a VNode tree. Callable as a
 *  function (`locator(html)`) so it composes directly in `flow` and `pipe` chains.
 *  Used by interaction steps (`click`, `type`, `submit`, `keydown`) to
 *  target elements by accessible attributes instead of CSS selectors. */
export type Locator = ((html: VNode) => Option.Option<VNode>) & Readonly<{
    description: string;
}>;
/** A deferred multi-element query that resolves to all matching VNodes.
 *  Produced by `all*` locator factories and by `filter(...)`. Convert to a
 *  single-match `Locator` via `first`, `last`, or `nth(n)`. */
export type LocatorAll = ((html: VNode) => ReadonlyArray<VNode>) & Readonly<{
    description: string;
}>;
/** Creates a Locator that finds an element by ARIA role. Supports matching on
 *  `name`, `level`, `checked`, `selected`, `pressed`, `expanded`, and `disabled`. */
export declare const role: (roleValue: string, options?: RoleOptions) => Locator;
/** Creates a Locator that finds an element by placeholder attribute. */
export declare const placeholder: (placeholderValue: string) => Locator;
/** Creates a Locator that finds an element by aria-label. */
export declare const label: (labelValue: string) => Locator;
/** Creates a Locator that finds an element by its `alt` attribute. */
export declare const altText: (altValue: string) => Locator;
/** Creates a Locator that finds an element by its `title` attribute. */
export declare const title: (titleValue: string) => Locator;
/** Creates a Locator that finds an element by its `data-testid` attribute. */
export declare const testId: (testIdValue: string) => Locator;
/** Creates a Locator that finds a form control by its current `value`. */
export declare const displayValue: (valueString: string) => Locator;
/** Creates a Locator that finds the most specific element matching the given text content. */
export declare const text: (target: string, options?: Readonly<{
    exact?: boolean;
}>) => Locator;
/** Creates a Locator that wraps a CSS selector. Escape hatch for cases
 *  where no accessible attribute is available. */
export declare const selector: (css: string) => Locator;
/** Creates a scoped Locator that finds the child within the parent.
 *  Composes via `Option.flatMap` — the parent is resolved first, then
 *  the child is searched within the parent's subtree. */
export declare const within: {
    (parent: Locator, child: Locator): Locator;
    (child: Locator): (parent: Locator) => Locator;
};
/** Creates a LocatorAll that finds every element matching the role. */
export declare const allRole: (roleValue: string, options?: RoleOptions) => LocatorAll;
/** Creates a LocatorAll that finds every element matching the text. */
export declare const allText: (target: string, options?: Readonly<{
    exact?: boolean;
}>) => LocatorAll;
/** Creates a LocatorAll that finds every element with the given label. */
export declare const allLabel: (labelValue: string) => LocatorAll;
/** Creates a LocatorAll that finds every element with the given placeholder. */
export declare const allPlaceholder: (placeholderValue: string) => LocatorAll;
/** Creates a LocatorAll that finds every element with the given alt text. */
export declare const allAltText: (altValue: string) => LocatorAll;
/** Creates a LocatorAll that finds every element with the given title. */
export declare const allTitle: (titleValue: string) => LocatorAll;
/** Creates a LocatorAll that finds every element with the given data-testid. */
export declare const allTestId: (testIdValue: string) => LocatorAll;
/** Creates a LocatorAll that finds every form control with the given value. */
export declare const allDisplayValue: (valueString: string) => LocatorAll;
/** Creates a LocatorAll from a CSS selector — returns every match. */
export declare const allSelector: (css: string) => LocatorAll;
/** Picks the first match from a LocatorAll, producing a single-match Locator. */
export declare const first: (locatorAll: LocatorAll) => Locator;
/** Picks the last match from a LocatorAll, producing a single-match Locator. */
export declare const last: (locatorAll: LocatorAll) => Locator;
/** Picks the nth match (0-indexed) from a LocatorAll, producing a Locator. */
export declare const nth: {
    (locatorAll: LocatorAll, index: number): Locator;
    (index: number): (locatorAll: LocatorAll) => Locator;
};
type FilterOptions = Readonly<{
    has?: Locator;
    hasNot?: Locator;
    hasText?: string;
    hasNotText?: string;
}>;
/** Filters a LocatorAll's matches. Supports `has`/`hasNot` to keep entries
 *  that do/don't contain a matching descendant, and `hasText`/`hasNotText`
 *  to keep entries whose text content does/doesn't include a substring. */
export declare const filter: {
    (locatorAll: LocatorAll, options: FilterOptions): LocatorAll;
    (options: FilterOptions): (locatorAll: LocatorAll) => LocatorAll;
};
/** Resolves a target (CSS selector string or Locator) against a VNode tree. */
export declare const resolveTarget: (html: VNode, target: string | Locator) => Readonly<{
    maybeElement: Option.Option<VNode>;
    description: string;
}>;
export {};
//# sourceMappingURL=query.d.ts.map