import { CompoundSelector, postcssSelectorParser as selectorParser } from "opticss";
import { AttrToken } from "../BlockSyntax";
import { AttrValue, Block, BlockClass } from "../BlockTree";
export declare enum BlockType {
    root = 0,
    attribute = 1,
    class = 2,
    classAttribute = 3
}
export declare type RootAttributeNode = {
    blockName?: string;
    blockType: BlockType.attribute;
    node: selectorParser.Attribute;
};
export declare type ClassAttributeNode = {
    blockName?: string;
    blockType: BlockType.classAttribute;
    node: selectorParser.Attribute;
};
export declare type AttributeNode = RootAttributeNode | ClassAttributeNode;
export declare type RootClassNode = {
    blockName?: string;
    blockType: BlockType.root;
    node: selectorParser.Pseudo;
};
export declare type BlockClassNode = {
    blockName?: string;
    blockType: BlockType.class;
    node: selectorParser.ClassName;
};
export declare type ClassNode = RootClassNode | BlockClassNode;
export declare type NodeAndType = AttributeNode | ClassNode;
/** Extract an Attribute's name from an attribute selector */
export declare function toAttrToken(attr: selectorParser.Attribute): AttrToken;
/**
 * Internal method used to generate human readable error messages when parsing.
 * @param t The block type we're generating a human readable name for.
 * @param options Options for output, currently just to specify plurality.
 * @return A human readable descriptor for the given `BlockType`.
 */
export declare function blockTypeName(t: BlockType, options?: {
    plural: boolean;
}): string;
/**
 * Test if the provided node representation is an external block.
 * @param object The NodeAndType's descriptor object.
 */
export declare function isExternalBlock(object: NodeAndType): object is RootAttributeNode | RootClassNode;
/**
 * Test if the provided node representation is a root level object, aka: operating
 * on the root element.
 * @param object The NodeAndType's descriptor object.
 */
export declare function isRootLevelObject(object: NodeAndType): object is RootAttributeNode | RootClassNode;
/**
 * Test if the provided node representation is a class level object, aka: operating
 * on an element contained by the root, not the root itself.
 * @param object The CompoundSelector's descriptor object.
 */
export declare function isClassLevelObject(object: NodeAndType): object is ClassAttributeNode | BlockClassNode;
/**
 * Check if given selector node is targeting the root block node
 */
export declare function isRootNode(node: unknown): node is selectorParser.Pseudo;
export declare const isClassNode: typeof selectorParser.isClassName;
/**
 * Check if given selector node is an attribute selector
 * @param  node The selector to test.
 * @return True if attribute selector, false if not.
 */
export declare function isAttributeNode(node: selectorParser.Node): node is selectorParser.Attribute;
/**
 * Describes all possible terminating styles in a CSS Blocks selector.
 */
export interface StyleTargets {
    blockAttrs: AttrValue[];
    blockClasses: BlockClass[];
}
/**
 * Given a Block and ParsedSelector, return all terminating Style objects.
 * These may be either a single `BlockClass` or 1 to many `AttrValue`s.
 * @param block The Block to query against.
 * @param sel The ParsedSelector
 * @returns The array of discovered Style objects.
 */
export declare function getStyleTargets(block: Block, sel: CompoundSelector): StyleTargets;
//# sourceMappingURL=block-intermediates.d.ts.map