export declare type AnySelector<isDefinition extends DefinitionAST | BlockAST> = ComplexSelector<isDefinition> | ContextCompoundSelector<isDefinition> | KeyCompoundSelector<isDefinition> | ScopeSelector | ClassSelector | AttributeSelector | ForeignAttributeSelector | PseudoClassSelector | PseudoElementSelector;
export declare type TopLevelNode<isDefinition extends DefinitionAST | BlockAST> = BlockSyntaxVersion | BlockReference | LocalBlockExport | BlockExport | Rule<isDefinition> | GlobalDeclaration;
export declare type Node<isDefinition extends DefinitionAST | BlockAST> = Root<isDefinition> | TopLevelNode<isDefinition> | AnySelector<isDefinition> | Declaration;
export interface Name {
    name: string;
    asName?: undefined;
}
export interface Rename {
    name: string;
    asName: string;
}
export interface Root<isDefinition extends DefinitionAST | BlockAST = BlockAST> {
    type: "Root";
    children: Array<TopLevelNode<isDefinition>>;
}
export declare type DefinitionAST = "definition";
export declare type BlockAST = "block";
export declare type DefinitionRoot = Root<DefinitionAST>;
export interface BlockSyntaxVersion {
    type: "BlockSyntaxVersion";
    version: number;
}
export interface BlockReference {
    type: "BlockReference";
    references?: Array<Name | Rename>;
    defaultName?: string;
    fromPath: string;
}
export interface LocalBlockExport {
    type: "LocalBlockExport";
    exports: Array<Name | Rename>;
}
export interface BlockExport {
    type: "BlockExport";
    exports: Array<Name | Rename>;
    fromPath: string;
}
export declare type KeyCompoundSelector<isDefinition extends DefinitionAST | BlockAST> = CompoundSelector<isDefinition, AttributeSelector, PseudoClassSelector, PseudoElementSelector>;
export declare type ContextCompoundSelector<isDefinition extends DefinitionAST | BlockAST> = CompoundSelector<isDefinition, ForeignAttributeSelector | AttributeSelector, PseudoClassSelector, never>;
export declare type ElementSelector = ScopeSelector | ClassSelector;
export declare type Selector<isDefinition extends DefinitionAST | BlockAST> = ElementSelector | KeyCompoundSelector<isDefinition> | ComplexSelector<isDefinition>;
export interface PseudoElementSelector {
    type: "PseudoElementSelector";
    /** The name of the psuedoelement without the `::` at the beginning. */
    name: string;
}
export interface PseudoClassSelector {
    type: "PseudoClassSelector";
    /** The name of the psuedoclass without the `:` at the beginning. */
    name: string;
}
export interface SelectorAndCombinator<isDefinition extends DefinitionAST | BlockAST> {
    selector: ContextCompoundSelector<isDefinition>;
    combinator: " " | ">" | "+" | "~";
}
export interface ComplexSelector<isDefinition extends DefinitionAST | BlockAST> {
    type: "ComplexSelector";
    /** There should be at least one context selector. */
    contextSelectors: Array<SelectorAndCombinator<isDefinition>>;
    keySelector: KeyCompoundSelector<isDefinition>;
}
export interface CompoundSelector<isDefinition extends DefinitionAST | BlockAST, AttributeSelectorType extends ForeignAttributeSelector | AttributeSelector, PseudoClassType extends PseudoClassSelector | never, PseudoElementType extends PseudoElementSelector | never> {
    type: "CompoundSelector";
    element: ElementSelector;
    attributes?: Array<AttributeSelectorType>;
    elementPseudoClasses?: isDefinition extends DefinitionAST ? undefined : (PseudoClassType extends never ? undefined : Array<PseudoClassType>);
    pseudoElement?: PseudoElementType;
    pseudoElementPseudoClasses?: isDefinition extends DefinitionAST ? undefined : (PseudoElementSelector extends never ? undefined : (PseudoClassType extends never ? undefined : Array<PseudoClassType>));
}
export interface ForeignAttributeSelector {
    type: "ForeignAttributeSelector";
    ns: string;
    attribute: string;
    matches?: {
        matcher: "=";
        value: string;
    };
}
export interface AttributeSelector {
    type: "AttributeSelector";
    ns?: undefined;
    attribute: string;
    matches?: {
        matcher: "=";
        value: string;
    };
}
export interface ScopeSelector {
    type: "ScopeSelector";
    value: ":scope";
}
export interface ClassSelector {
    type: "ClassSelector";
    /** The name of the class without the `.` at the beginning. */
    name: string;
}
export interface Declaration {
    type: "Declaration";
    property: string;
    value: string;
}
export interface Rule<isDefinition extends DefinitionAST | BlockAST> {
    type: "Rule";
    selectors: Array<Selector<isDefinition>>;
    declarations: Array<Declaration>;
}
export interface GlobalDeclaration {
    type: "GlobalDeclaration";
    selector: AttributeSelector;
}
export declare namespace typeguards {
    function isNode<isDefinition extends DefinitionAST | BlockAST>(node: unknown): node is Node<isDefinition>;
    function isRoot<isDefinition extends DefinitionAST | BlockAST>(node: unknown): node is Root<isDefinition>;
    function isBlockSyntaxVersion(node: unknown): node is BlockSyntaxVersion;
    function isBlockReference(node: unknown): node is BlockReference;
    function isBlockExport(node: unknown): node is BlockExport;
    function isLocalBlockExport(node: unknown): node is LocalBlockExport;
    function isPseudoElementSelector(node: unknown): node is PseudoElementSelector;
    function isPseudoClassSelector(node: unknown): node is PseudoClassSelector;
    function isComplexSelector<isDefinition extends DefinitionAST | BlockAST>(node: unknown): node is ComplexSelector<isDefinition>;
    function isCompoundSelector<isDefinition extends DefinitionAST | BlockAST>(node: unknown): node is KeyCompoundSelector<isDefinition> | ContextCompoundSelector<isDefinition>;
    function isAttributeSelector(node: unknown): node is AttributeSelector;
    function isForeignAttributeSelector(node: unknown): node is ForeignAttributeSelector;
    function isScopeSelector(node: unknown): node is ScopeSelector;
    function isClassSelector(node: unknown): node is ClassSelector;
    function isDeclaration(node: unknown): node is Declaration;
    function isRule<isDefinition extends DefinitionAST | BlockAST>(node: unknown): node is Rule<isDefinition>;
    function isGlobalDeclaration(node: unknown): node is GlobalDeclaration;
}
export declare namespace builders {
    function root<isDefinition extends DefinitionAST | BlockAST>(children?: Array<TopLevelNode<isDefinition>>): Root<isDefinition>;
    function blockSyntaxVersion(version: number): BlockSyntaxVersion;
    function blockReference(fromPath: string, defaultName: string | undefined, references: Array<Name | Rename> | undefined): BlockReference;
    function localBlockExport(exports: Array<Name | Rename>): LocalBlockExport;
    function blockExport(fromPath: string, exports: Array<Name | Rename>): BlockExport;
    function pseudoElementSelector(name: string): PseudoElementSelector;
    function pseudoClassSelector(name: string): PseudoClassSelector;
    function complexSelector<isDefinition extends DefinitionAST | BlockAST>(contextSelectors: Array<SelectorAndCombinator<isDefinition>>, keySelector: KeyCompoundSelector<isDefinition>): ComplexSelector<isDefinition>;
    function compoundSelector<isDefinition extends DefinitionAST | BlockAST>(element: ElementSelector, attributes?: Array<ForeignAttributeSelector | AttributeSelector>, elementPseudoClasses?: isDefinition extends DefinitionAST ? undefined : Array<PseudoClassSelector>, pseudoElement?: PseudoElementSelector, pseudoElementPseudoClasses?: isDefinition extends DefinitionAST ? undefined : Array<PseudoClassSelector>): CompoundSelector<isDefinition, AttributeSelector | ForeignAttributeSelector, PseudoClassSelector, PseudoElementSelector>;
    function keyCompoundSelector<isDefinition extends DefinitionAST | BlockAST>(element: ElementSelector, attributes?: Array<AttributeSelector>, elementPseudoClasses?: isDefinition extends DefinitionAST ? undefined : Array<PseudoClassSelector>, pseudoElement?: PseudoElementSelector, pseudoElementPseudoClasses?: isDefinition extends DefinitionAST ? undefined : Array<PseudoClassSelector>): KeyCompoundSelector<isDefinition>;
    function contextCompoundSelector<isDefinition extends DefinitionAST | BlockAST>(element: ElementSelector, attributes?: Array<ForeignAttributeSelector | AttributeSelector>, elementPseudoClasses?: isDefinition extends DefinitionAST ? undefined : Array<PseudoClassSelector>, pseudoElementPseudoClasses?: isDefinition extends DefinitionAST ? undefined : Array<PseudoClassSelector>): ContextCompoundSelector<isDefinition>;
    function attributeSelector(attribute: string, value?: string): AttributeSelector;
    function foreignAttributeSelector(ns: string, attribute: string, value?: string): ForeignAttributeSelector;
    function scopeSelector(): ScopeSelector;
    function classSelector(name: string): ClassSelector;
    function declaration(property: string, value: string): Declaration;
    function rule<isDefinition extends DefinitionAST | BlockAST>(selectors: Array<Selector<isDefinition>>, declarations: Array<Declaration>): Rule<isDefinition>;
    function globalDeclaration(selector: AttributeSelector): GlobalDeclaration;
}
export interface Visitor<isDefinition extends DefinitionAST | BlockAST> {
    Root?(root: Root<isDefinition>): void | boolean | undefined;
    BlockSyntaxVersion?(blockSyntaxVersion: BlockSyntaxVersion): void | boolean | undefined;
    BlockReference?(blockReference: BlockReference): void | boolean | undefined;
    LocalBlockExport?(localBlockExport: LocalBlockExport): void | boolean | undefined;
    BlockExport?(blockExport: BlockExport): void | boolean | undefined;
    PseudoElementSelector?(pseudoElementSelector: PseudoElementSelector): void | boolean | undefined;
    PseudoClassSelector?(pseudoClassSelector: PseudoClassSelector): void | boolean | undefined;
    ComplexSelector?(complexSelector: ComplexSelector<isDefinition>): void | boolean | undefined;
    CompoundSelector?(compoundSelector: KeyCompoundSelector<isDefinition> | ContextCompoundSelector<isDefinition>): void | boolean | undefined;
    AttributeSelector?(attributeSelector: AttributeSelector): void | boolean | undefined;
    ForeignAttributeSelector?(foreignAttributeSelector: ForeignAttributeSelector): void | boolean | undefined;
    ScopeSelector?(scopeSelector: ScopeSelector): void | boolean | undefined;
    ClassSelector?(classSelector: ClassSelector): void | boolean | undefined;
    Declaration?(declaration: Declaration): void | boolean | undefined;
    Rule?(rule: Rule<isDefinition>): void | boolean | undefined;
    GlobalDeclaration?(globalDeclaration: GlobalDeclaration): void | boolean | undefined;
}
export interface Mapper<isToDefinition extends DefinitionAST | BlockAST> {
    Root?(children: Array<TopLevelNode<isToDefinition>>): Root<isToDefinition>;
    BlockSyntaxVersion?(version: number): BlockSyntaxVersion;
    BlockReference?(fromPath: string, defaultName: string | undefined, references: Array<Name | Rename> | undefined): BlockReference;
    LocalBlockExport?(exports: Array<Name | Rename>): LocalBlockExport;
    BlockExport?(fromPath: string, exports: Array<Name | Rename>): BlockExport;
    PseudoElementSelector?(name: string): PseudoElementSelector;
    PseudoClassSelector?(name: string): PseudoClassSelector;
    ComplexSelector?(contextSelectors: Array<SelectorAndCombinator<isToDefinition>>, keySelector: KeyCompoundSelector<isToDefinition>): ComplexSelector<isToDefinition>;
    CompoundSelector?(element: ElementSelector, attributes?: Array<AttributeSelector | ForeignAttributeSelector>, elementPseudoClasses?: Array<PseudoClassSelector>, pseudoElement?: PseudoElementSelector, pseudoElementPseudoClasses?: Array<PseudoClassSelector>): KeyCompoundSelector<isToDefinition> | ContextCompoundSelector<isToDefinition>;
    AttributeSelector?(attribute: string, value?: string): AttributeSelector;
    ForeignAttributeSelector?(ns: string, attribute: string, value?: string): ForeignAttributeSelector;
    ScopeSelector?(): ScopeSelector;
    ClassSelector?(name: string): ClassSelector;
    Declaration?(property: string, value: string): Declaration;
    Rule?(selectors: Array<Selector<isToDefinition>>, declarations: Array<Declaration>): Rule<isToDefinition>;
    GlobalDeclaration?(selector: AttributeSelector): GlobalDeclaration;
}
export declare function map<isFromDefinition extends DefinitionAST | BlockAST, isToDefinition extends DefinitionAST | BlockAST, N extends Node<isFromDefinition>>(mapper: Mapper<isToDefinition>, node: N, fromType: isFromDefinition, toType: isToDefinition): N extends Root<isFromDefinition> ? Root<isToDefinition> : (N extends Rule<isFromDefinition> ? Rule<isToDefinition> : (N extends ComplexSelector<isFromDefinition> ? ComplexSelector<isToDefinition> : (N extends ContextCompoundSelector<isFromDefinition> ? ContextCompoundSelector<isToDefinition> : (N extends KeyCompoundSelector<isFromDefinition> ? KeyCompoundSelector<isToDefinition> : N))));
export declare function visit<isDefinition extends DefinitionAST | BlockAST>(visitor: Visitor<isDefinition>, node: Node<isDefinition>): void;
//# sourceMappingURL=ast.d.ts.map