/**
 * BlockSplitter — string-level block scanner shared across surfaces.
 *
 * Lifted from the edge proxy's `translate-html.ts` scanner (webhook Phase 10)
 * so non-DOM surfaces (edge Worker, webhook Worker) split HTML into the SAME
 * block boundaries instead of hand-rolling a second parser. The browser DOM
 * path (`browser/block-extractor.ts`) mirrors the same tag sets via
 * `querySelectorAll`.
 *
 * Structural only: finds innermost block elements (p, h1–h6, li, td, …) and
 * orphan inline `<a>` outside any block, returning each block's opening tag,
 * raw attribute string, and byte-exact innerHTML with source offsets. No
 * keying, no exclude filtering, no translation — callers layer their own
 * policy (edge: data-i18n precedence + ExcludeFilter + replacement stamping;
 * webhook P13: `toContentUnit(inner)` + `generateAutoKey` per block). Blocks
 * inside skip tags (`<script>`/`<style>`/`<pre>`/…), HTML comments, or
 * `data-no-translate` / `translate="no"` regions are not emitted.
 *
 * Pure string ops — Worker-safe and Node-safe (no DOM, no Node APIs).
 *
 * @module content/splitter/BlockSplitter
 */
export interface HtmlBlock {
    /** Lowercased tag name (`p`, `h2`, `a`, …). */
    tag: string;
    /** The exact opening-tag source text, e.g. `<p class="intro">`. */
    openTag: string;
    /** Raw attribute string from the opening tag (verbatim, may be empty). */
    attrs: string;
    /** The block's innerHTML, byte-exact as it appears in the input. */
    inner: string;
    /** Offset of `inner` within the input html. */
    innerStart: number;
    /** Offset just past `inner` — the `<` of the matching closing tag. */
    innerEnd: number;
}
export interface SplitBlocksResult {
    /** Captured blocks in document order; ranges never overlap. */
    blocks: HtmlBlock[];
}
/**
 * Find the matching close tag for a given tag name starting from pos.
 * Returns the index of the '<' of the closing tag, or -1 if not found.
 */
export declare function findCloseTag(html: string, pos: number, tagName: string): number;
/**
 * Split an HTML string into its translatable block elements.
 *
 * Walks the string once; each captured block is innermost (an outer block
 * whose innerHTML contains another block tag is skipped in favor of the
 * inner one) and non-overlapping, so replacing inners via
 * `replaceBlockInners` is always position-safe.
 */
export declare function splitBlocks(html: string): SplitBlocksResult;
/**
 * Splice replacement innerHTML into blocks previously returned by
 * `splitBlocks(html)` for the SAME html string. Blocks not listed keep
 * their source content; wrapper tags and attributes are never touched.
 *
 * Applied end-to-start so earlier offsets stay valid.
 */
export declare function replaceBlockInners(html: string, replacements: ReadonlyArray<{
    block: HtmlBlock;
    inner: string;
}>): string;
//# sourceMappingURL=BlockSplitter.d.ts.map