/**
 * `@quantize` CSS block parser and compiler.
 *
 * Parses custom `@quantize boundaryName { state { prop: value } }` blocks
 * from CSS source and compiles them into native `@container` queries using
 * resolved `BoundaryDef` thresholds.
 *
 * @module
 */
import { type Boundary } from '@czap/core';
/**
 * A nested `@supports` / `@media` group inside a `@quantize` state body.
 * Serialized inside the state's `@container` block as a real at-rule group.
 * Nested at-rule groups are preserved (depth ≥ 2); silent drop is forbidden (#110).
 */
export interface QuantizeAtRuleGroup {
    /** The at-rule prelude exactly as authored (e.g. `@supports (display: grid)`). */
    readonly prelude: string;
    /** Declarations authored directly inside the at-rule (no nested selector). */
    readonly bareProps: Record<string, string>;
    /** Nested selector rules inside the at-rule. */
    readonly rules: readonly QuantizeNestedRule[];
    /** Nested `@supports` / `@media` groups inside this at-rule (#110 depth ≥ 2). */
    readonly atRuleGroups?: readonly QuantizeAtRuleGroup[];
}
/**
 * A nested rule inside a `@quantize` state: a CSS selector plus the
 * property map applied to it when the state is active.
 */
export interface QuantizeNestedRule {
    /** CSS selector exactly as authored (e.g. `.grid`, `.hero__title`). */
    readonly selector: string;
    /** `{ cssProp: value }` declarations inside the nested rule. */
    readonly props: Record<string, string>;
}
/**
 * The non-CSS cast targets authored as nested `@<target> { … }` segments
 * inside a `@quantize` state. Each is a sibling of the CSS body
 * (`bareProps` / `rules`) and routes through its own compiler arm in the
 * build cast loop:
 *
 * - `aria` — `aria-*` / `role` attributes → `ARIACompiler`.
 * - `glsl` — numeric GLSL uniforms → `GLSLCompiler`.
 * - `wgsl` — numeric WGSL uniforms → `WGSLCompiler`.
 *
 * The marker name (`@aria` / `@glsl` / `@wgsl`) names the target; the nested
 * declarations are that target's per-state attribute/uniform map.
 */
export type CastTarget = 'aria' | 'glsl' | 'wgsl';
/** Ordered cast targets parsed from `@<target> { … }` segments. */
export declare const CAST_TARGETS: readonly CastTarget[];
/**
 * The parsed body of one `@quantize` state: bare declarations that apply
 * to the boundary element selector (the documented flat form) plus
 * nested per-selector rules (the adaptive per-element form).
 */
export interface QuantizeStateBody {
    /** Declarations written directly inside the state (flat form). */
    readonly bareProps: Record<string, string>;
    /** Nested `<selector> { ... }` rules written inside the state. */
    readonly rules: readonly QuantizeNestedRule[];
    /** Nested `@supports` / `@media` groups authored inside the state (#110). */
    readonly atRuleGroups?: readonly QuantizeAtRuleGroup[];
    /**
     * Authored per-state non-CSS cast attributes, keyed by cast target. Each
     * entry holds the raw `{ key: value }` declarations from a nested
     * `@<target> { … }` segment (quotes stripped). Generalized from the
     * original `@aria`-only form so adding a cast target is a registration in
     * {@link CAST_TARGETS}, not a new field. Targets the state did not author
     * are absent; the field itself is absent when no cast segment was authored.
     *
     * Downstream each target routes through its compiler arm via `dispatch`
     * (ARIA → `ARIACompiler`, GLSL → `GLSLCompiler`, WGSL → `WGSLCompiler`).
     */
    readonly castAttrs?: Partial<Record<CastTarget, Record<string, string>>>;
    /**
     * Authored per-state ARIA/data attributes from a nested `@aria { … }`
     * segment (e.g. `aria-expanded: false; role: button`). Quotes are stripped.
     * Validated downstream by `ARIACompiler` against `BoundaryAttribute.isAllowedKey`
     * (`aria-*` / `role`). Absent when the state declares no `@aria` block.
     *
     * Derived from `castAttrs.aria` and kept as a parallel field so existing
     * ARIA consumers/tests read it unchanged.
     */
    readonly ariaAttrs?: Record<string, string>;
}
/**
 * A single parsed `@quantize` block: the boundary being quantised, the
 * per-state bodies, and provenance info so HMR can emit
 * source-mapped warnings.
 */
export interface QuantizeBlock {
    /** Boundary name referenced in the at-rule preamble. */
    readonly boundaryName: string;
    /** `{ stateName: { bareProps, rules } }` mapping. */
    readonly states: Record<string, QuantizeStateBody>;
    /** Absolute path of the CSS source file. */
    readonly sourceFile: string;
    /** 1-based source line where the block begins. */
    readonly line: number;
}
/**
 * Parse every `@quantize` block from CSS source text.
 *
 * Grammar (states accept bare declarations, nested selector rules, or
 * both):
 *
 * ```css
 * @quantize boundaryName {
 *   stateName {
 *     property: value;
 *     .selector {
 *       property: value;
 *     }
 *   }
 * }
 * ```
 *
 * Parsing is fully character-level: upstream compilers (e.g. the Astro
 * compiler re-serializing a `<style>` block) emit at-rules mid-line and
 * collapse whole sheets onto a single line, so no line structure is
 * assumed. At-rule markers are located on a comment- and string-blanked
 * copy of the source (same offsets) so neither commented-out blocks nor
 * marker text inside string values or data URLs ever match; bodies are
 * parsed from the original source with comment / string / functional-
 * notation awareness, including multi-line values and nested
 * `<selector> { ... }` rules.
 */
export declare function parseQuantizeBlocks(css: string, sourceFile: string): readonly QuantizeBlock[];
/**
 * Sheet-level aggregation context shared across every
 * {@link compileQuantizeBlock} call for one stylesheet.
 *
 * `container-name` is a replaced (non-accumulating) property: when two
 * viewport-based boundaries in the same sheet each emitted their own
 * `:root { container-name: X }` rule, the last rule won and the earlier
 * boundary's `@container` queries matched nothing. Aggregating the
 * names here lets the caller emit ONE `:root` rule in the
 * space-separated multi-name form
 * (`container-name: viewport-width viewport-height`) via
 * {@link viewportContainmentRule}, so every query keeps a matching
 * container.
 */
export interface QuantizeSheetContext {
    /** Viewport container names collected across the sheet's blocks. */
    readonly viewportContainerNames: Set<string>;
}
/**
 * The container-query axis a viewport input compiles to, or `null` when
 * the input is not a dimension the auto-emitted `:root` containment can
 * honestly serve: `viewport` / `viewport.width` compile to `(width ...)`
 * queries and `viewport.height` to `(height ...)` queries (the compiler
 * derives the same axis from the input). Any other `viewport.*` path and
 * every non-viewport input return `null` — there is no dimension query
 * that measures them.
 */
export declare function viewportQueryAxis(input: string): 'width' | 'height' | null;
/**
 * Build the single `:root` containment rule for a sheet's viewport-based
 * boundaries: a `container-type` declaration plus every collected
 * container name in CSS's space-separated multi-name form, so each
 * compiled `@container <name> (...)` query finds its container.
 *
 * Width-only sheets keep `container-type: inline-size`. The
 * `viewport-height` name — the only height-axis name the containment
 * path can collect (sanitized from `viewport.height`) — upgrades the
 * rule to `container-type: size`, because `inline-size` containment
 * leaves `(height ...)` queries unevaluable. Size containment computes
 * `:root`'s block size as if it had no content, so the rule pins it to
 * `100dvh` — the same dynamic-viewport measure the runtime's
 * `readSignalValue('viewport.height')` reads.
 *
 * Returns `null` when no viewport container names were collected
 * (non-viewport boundaries declare their own containers; see the
 * `container-not-declared` diagnostic).
 *
 * `selector` is the element the containment is declared on — `:root` by
 * default. A host whose layout can't have `:root` be a container (a
 * size-contained `:root` removes it from its parent's size calc, which a
 * fixed/absolute viewport-locked wrapper conflicts with) sets the plugin's
 * `quantize.container` to a named selector (e.g. `.czap-vp`) and is then
 * responsible for sizing that element to the viewport. Width-only sheets
 * stay `inline-size`; a `viewport-height` name upgrades to `size` + a
 * `100dvh` block-size on the chosen selector.
 */
export declare function viewportContainmentRule(names: Iterable<string>, selector?: string): string | null;
/**
 * Compile a parsed {@link QuantizeBlock} plus its resolved
 * {@link Boundary.Shape} into CSS `@container` query rules. Delegates
 * to the canonical `CSSCompiler` to avoid duplicating threshold-to-query
 * logic.
 *
 * Bare declarations keep the default `.czap-boundary` selector; nested
 * rules each compile to their own selector inside the state's
 * `@container` block.
 *
 * Containment: pass a shared {@link QuantizeSheetContext} when
 * compiling multiple blocks from one stylesheet — viewport container
 * names are collected on it and the caller emits ONE aggregated `:root`
 * rule via {@link viewportContainmentRule} (`container-name` is a
 * replaced property, so per-block `:root` rules would overwrite each
 * other). Without a context, a viewport-based block inlines its own
 * `:root` rule (single-block convenience form). Non-viewport inputs
 * emit a `container-not-declared` diagnostic naming the declaration to
 * add.
 */
export declare function compileQuantizeBlock(block: QuantizeBlock, boundary: Boundary.Shape, sheet?: QuantizeSheetContext): string;
//# sourceMappingURL=css-quantize.d.ts.map