/**
 * ConditionNode Types and Helpers
 *
 * Core data structures for representing style conditions as an abstract syntax tree.
 * Used throughout the pipeline for parsing, simplification, and CSS generation.
 */
/**
 * Base interface for all state conditions (leaf nodes)
 */
interface BaseStateCondition {
    kind: 'state';
    negated: boolean;
    raw: string;
    uniqueId: string;
}
/**
 * Modifier condition: [data-attr] or [data-attr="value"]
 */
export interface ModifierCondition extends BaseStateCondition {
    type: 'modifier';
    attribute: string;
    value?: string;
    operator?: '=' | '^=' | '$=' | '*=';
}
/**
 * Pseudo-class condition: :hover, :focus-visible
 */
export interface PseudoCondition extends BaseStateCondition {
    type: 'pseudo';
    pseudo: string;
}
/**
 * Numeric bound for dimension queries
 */
export interface NumericBound {
    value: string;
    valueNumeric: number | null;
    inclusive: boolean;
}
/**
 * Media query condition
 */
export interface MediaCondition extends BaseStateCondition {
    type: 'media';
    subtype: 'dimension' | 'feature' | 'type';
    dimension?: 'width' | 'height' | 'inline-size' | 'block-size';
    lowerBound?: NumericBound;
    upperBound?: NumericBound;
    feature?: string;
    featureValue?: string;
    mediaType?: 'print' | 'screen' | 'all' | 'speech';
}
/**
 * Container query condition
 */
export interface ContainerCondition extends BaseStateCondition {
    type: 'container';
    subtype: 'dimension' | 'style' | 'raw';
    containerName?: string;
    dimension?: 'width' | 'height' | 'inline-size' | 'block-size';
    lowerBound?: NumericBound;
    upperBound?: NumericBound;
    property?: string;
    propertyValue?: string;
    rawCondition?: string;
}
/**
 * Root state condition: @root(theme=dark)
 */
export interface RootCondition extends BaseStateCondition {
    type: 'root';
    selector: string;
}
/**
 * Own state condition: @own(hovered)
 */
export interface OwnCondition extends BaseStateCondition {
    type: 'own';
    innerCondition: ConditionNode;
}
/**
 * Starting style condition: @starting
 */
export interface StartingCondition extends BaseStateCondition {
    type: 'starting';
}
/**
 * Supports query condition: @supports(display: grid), @supports($, :has(*))
 */
export interface SupportsCondition extends BaseStateCondition {
    type: 'supports';
    subtype: 'feature' | 'selector';
    condition: string;
}
/**
 * Union of all state condition types
 */
export type StateCondition = ModifierCondition | PseudoCondition | MediaCondition | ContainerCondition | RootCondition | OwnCondition | StartingCondition | SupportsCondition;
/**
 * Compound node: combines conditions with AND/OR
 */
export interface CompoundCondition {
    kind: 'compound';
    operator: 'AND' | 'OR';
    children: ConditionNode[];
}
/**
 * True condition (matches everything)
 */
export interface TrueCondition {
    kind: 'true';
}
/**
 * False condition (matches nothing - skip this rule)
 */
export interface FalseCondition {
    kind: 'false';
}
/**
 * Union of all condition node types
 */
export type ConditionNode = StateCondition | CompoundCondition | TrueCondition | FalseCondition;
/**
 * Create a TRUE condition (matches everything)
 */
export declare function trueCondition(): TrueCondition;
/**
 * Create a FALSE condition (matches nothing)
 */
export declare function falseCondition(): FalseCondition;
/**
 * Create an AND compound condition
 */
export declare function and(...children: ConditionNode[]): ConditionNode;
/**
 * Create an OR compound condition
 */
export declare function or(...children: ConditionNode[]): ConditionNode;
/**
 * Negate a condition
 */
export declare function not(node: ConditionNode): ConditionNode;
/**
 * Check if a condition is a compound condition
 */
export declare function isCompoundCondition(node: ConditionNode): node is CompoundCondition;
/**
 * Generate a normalized unique ID for a modifier condition
 */
export declare function modifierUniqueId(attribute: string, value?: string, operator?: string, negated?: boolean): string;
/**
 * Generate a normalized unique ID for a pseudo condition
 */
export declare function pseudoUniqueId(pseudo: string, negated?: boolean): string;
/**
 * Generate a normalized unique ID for a media condition
 */
export declare function mediaUniqueId(subtype: 'dimension' | 'feature' | 'type', props: {
    dimension?: string;
    lowerBound?: NumericBound;
    upperBound?: NumericBound;
    feature?: string;
    featureValue?: string;
    mediaType?: string;
}, negated?: boolean): string;
/**
 * Generate a normalized unique ID for a container condition
 */
export declare function containerUniqueId(subtype: 'dimension' | 'style' | 'raw', props: {
    containerName?: string;
    dimension?: string;
    lowerBound?: NumericBound;
    upperBound?: NumericBound;
    property?: string;
    propertyValue?: string;
    rawCondition?: string;
}, negated?: boolean): string;
/**
 * Generate a normalized unique ID for a root condition
 */
export declare function rootUniqueId(selector: string, negated?: boolean): string;
/**
 * Generate a normalized unique ID for an own condition
 */
export declare function ownUniqueId(innerUniqueId: string, negated?: boolean): string;
/**
 * Generate a normalized unique ID for a starting condition
 */
export declare function startingUniqueId(negated?: boolean): string;
/**
 * Generate a normalized unique ID for a supports condition
 */
export declare function supportsUniqueId(subtype: 'feature' | 'selector', condition: string, negated?: boolean): string;
/**
 * Create a modifier condition
 */
export declare function createModifierCondition(attribute: string, value?: string, operator?: '=' | '^=' | '$=' | '*=', negated?: boolean, raw?: string): ModifierCondition;
/**
 * Create a pseudo condition
 */
export declare function createPseudoCondition(pseudo: string, negated?: boolean, raw?: string): PseudoCondition;
/**
 * Create a media dimension condition
 */
export declare function createMediaDimensionCondition(dimension: 'width' | 'height' | 'inline-size' | 'block-size', lowerBound?: NumericBound, upperBound?: NumericBound, negated?: boolean, raw?: string): MediaCondition;
/**
 * Create a media feature condition
 */
export declare function createMediaFeatureCondition(feature: string, featureValue?: string, negated?: boolean, raw?: string): MediaCondition;
/**
 * Create a media type condition
 */
export declare function createMediaTypeCondition(mediaType: 'print' | 'screen' | 'all' | 'speech', negated?: boolean, raw?: string): MediaCondition;
/**
 * Create a container dimension condition
 */
export declare function createContainerDimensionCondition(dimension: 'width' | 'height' | 'inline-size' | 'block-size', lowerBound?: NumericBound, upperBound?: NumericBound, containerName?: string, negated?: boolean, raw?: string): ContainerCondition;
/**
 * Create a container style condition
 */
export declare function createContainerStyleCondition(property: string, propertyValue?: string, containerName?: string, negated?: boolean, raw?: string): ContainerCondition;
/**
 * Create a container raw function condition (e.g., scroll-state(), style(), etc.)
 * The condition string is passed through to CSS verbatim.
 */
export declare function createContainerRawCondition(rawCondition: string, containerName?: string, negated?: boolean, raw?: string): ContainerCondition;
/**
 * Create a root condition
 */
export declare function createRootCondition(selector: string, negated?: boolean, raw?: string): RootCondition;
/**
 * Create an own condition
 */
export declare function createOwnCondition(innerCondition: ConditionNode, negated?: boolean, raw?: string): OwnCondition;
/**
 * Create a starting condition
 */
export declare function createStartingCondition(negated?: boolean, raw?: string): StartingCondition;
/**
 * Create a supports condition
 *
 * @param subtype 'feature' for @supports(display: grid), 'selector' for @supports($, :has(*))
 * @param condition The condition string (e.g., "display: grid" or ":has(*)")
 */
export declare function createSupportsCondition(subtype: 'feature' | 'selector', condition: string, negated?: boolean, raw?: string): SupportsCondition;
/**
 * Get the unique ID for any condition node
 */
export declare function getConditionUniqueId(node: ConditionNode): string;
export {};
