/**
 * Vue SFC parser implementation
 *
 * This parser handles Vue Single File Components (.vue files).
 * It extracts the <template> block and parses it using Vue's template compiler
 * to produce an AST that can be used for data-ds attribute injection.
 *
 * The key challenge is that Vue template AST positions are relative to the
 * template block content, not the full SFC. This parser calculates absolute
 * positions for correct injection.
 *
 * @module @domscribe/transform/parsers/vue/vue-sfc-parser
 */
import { ParserInterface } from '../parser.interface.js';
import { ParseParams, SourceLocation } from '../types.js';
import { VueElementNode, VueSFCParseResult } from './types.js';
/**
 * VueSFCParser implementation for Vue Single File Components
 *
 * Uses vue/compiler-sfc for SFC structure parsing and template AST generation.
 * The parse function in Vue 3.3+ returns the template AST directly.
 */
export declare class VueSFCParser implements ParserInterface<VueSFCParseResult, VueElementNode> {
    /**
     * Lazily loaded Vue compiler-sfc module
     * Vue is an optional peer dependency, so we load it dynamically
     */
    private compilerSfc;
    /**
     * Cached template content offset from the last parse
     * Used by getInsertPosition to calculate absolute SFC positions
     */
    private lastTemplateContentOffset;
    /**
     * Load Vue compiler-sfc module dynamically
     * Logs a warning if Vue is not installed
     */
    private loadCompiler;
    /**
     * Synchronously ensure compiler is loaded
     * Call loadCompiler() before using this parser
     */
    private ensureCompiler;
    /**
     * Initialize the parser by loading Vue compiler
     * Should be called before first use
     */
    initialize(): Promise<void>;
    /**
     * Parse a Vue SFC and extract the template AST with position information
     *
     * @param source - The full SFC source code
     * @param params - Parse parameters including source file path
     * @returns Parsed result containing template AST and offset information
     */
    parse(source: string, params?: ParseParams): VueSFCParseResult;
    /**
     * Find all element nodes in the template AST
     *
     * Skips:
     * - <template> wrapper elements (tagType === ElementTypes.TEMPLATE)
     * - Comment and text nodes
     *
     * @param parseResult - The parsed SFC result from parse()
     * @returns Array of element nodes that should receive data-ds attributes
     */
    findJSXOpeningElements(parseResult: VueSFCParseResult): VueElementNode[];
    /**
     * Check if an element already has a data-ds attribute
     *
     * @param node - Vue element node to check
     * @returns true if data-ds attribute exists
     */
    hasDataDsAttribute(node: VueElementNode): boolean;
    /**
     * Get the source location of an element in the original SFC
     *
     * Note: Line/column are returned as-is (template-relative) for manifest entries
     * since they represent the logical position within the template.
     * The offset is converted to absolute SFC position for correct injection.
     *
     * @param node - Vue element node
     * @returns Source location with absolute offset positions
     */
    getLocation(node: VueElementNode): SourceLocation | undefined;
    /**
     * Get the tag name of an element
     *
     * @param node - Vue element node
     * @returns Tag name (e.g., "div", "UserCard", "my-component")
     */
    getTagName(node: VueElementNode): string;
    /**
     * Calculate the position for inserting the data-ds attribute
     *
     * Returns an absolute position in the SFC source, accounting
     * for the template content offset.
     *
     * @param node - Vue element node
     * @returns Absolute byte offset in the SFC for attribute insertion
     */
    getInsertPosition(node: VueElementNode): number;
}
/**
 * Create a VueSFCParser instance
 *
 * Factory function for consistency with other parsers.
 */
export declare function createVueSFCParser(): VueSFCParser;
//# sourceMappingURL=vue-sfc.parser.d.ts.map