import { SimpleExpressionNode, RootNode, TemplateChildNode, DirectiveNode, CompoundExpressionNode, ElementNode, AllNode, CompilerCompatOptions, CommentNode, TransformOptions as TransformOptions$1, CodegenOptions as CodegenOptions$1, BaseCodegenResult, SourceLocation, CodegenSourceMapGenerator, TemplateNode, CompilerOptions as CompilerOptions$1, CompilerError } from '@vue/compiler-dom';
export { parse } from '@vue/compiler-dom';
import * as packages_runtime_vapor_src from 'packages/runtime-vapor/src';
import * as packages_runtime_dom_src from 'packages/runtime-dom/src';
import { Prettify } from '@vue/shared';

export interface IRProp extends Omit<DirectiveTransformResult, 'value'> {
    values: SimpleExpressionNode[];
}
export declare enum IRDynamicPropsKind {
    EXPRESSION = 0,// v-bind="value"
    ATTRIBUTE = 1
}
export type IRPropsStatic = IRProp[];
export interface IRPropsDynamicExpression {
    kind: IRDynamicPropsKind.EXPRESSION;
    value: SimpleExpressionNode;
    handler?: boolean;
}
export interface IRPropsDynamicAttribute extends IRProp {
    kind: IRDynamicPropsKind.ATTRIBUTE;
}
export type IRProps = IRPropsStatic | IRPropsDynamicAttribute | IRPropsDynamicExpression;
export interface SlotBlockIRNode extends BlockIRNode {
    props?: SimpleExpressionNode;
}
export declare enum IRSlotType {
    STATIC = 0,
    DYNAMIC = 1,
    LOOP = 2,
    CONDITIONAL = 3,
    EXPRESSION = 4
}
export type IRSlotsStatic = {
    slotType: IRSlotType.STATIC;
    slots: Record<string, SlotBlockIRNode>;
};
export interface IRSlotDynamicBasic {
    slotType: IRSlotType.DYNAMIC;
    name: SimpleExpressionNode;
    fn: SlotBlockIRNode;
}
export interface IRSlotDynamicLoop {
    slotType: IRSlotType.LOOP;
    name: SimpleExpressionNode;
    fn: SlotBlockIRNode;
    loop: IRFor;
}
export interface IRSlotDynamicConditional {
    slotType: IRSlotType.CONDITIONAL;
    condition: SimpleExpressionNode;
    positive: IRSlotDynamicBasic;
    negative?: IRSlotDynamicBasic | IRSlotDynamicConditional;
}
export interface IRSlotsExpression {
    slotType: IRSlotType.EXPRESSION;
    slots: SimpleExpressionNode;
}
export type IRSlotDynamic = IRSlotDynamicBasic | IRSlotDynamicLoop | IRSlotDynamicConditional;
export type IRSlots = IRSlotsStatic | IRSlotDynamic | IRSlotsExpression;

export declare enum IRNodeTypes {
    ROOT = 0,
    BLOCK = 1,
    SET_PROP = 2,
    SET_DYNAMIC_PROPS = 3,
    SET_TEXT = 4,
    SET_EVENT = 5,
    SET_DYNAMIC_EVENTS = 6,
    SET_HTML = 7,
    SET_TEMPLATE_REF = 8,
    INSERT_NODE = 9,
    PREPEND_NODE = 10,
    CREATE_TEXT_NODE = 11,
    CREATE_COMPONENT_NODE = 12,
    SLOT_OUTLET_NODE = 13,
    DIRECTIVE = 14,
    DECLARE_OLD_REF = 15,// consider make it more general
    IF = 16,
    FOR = 17
}
export interface BaseIRNode {
    type: IRNodeTypes;
}
export type CoreHelper = keyof typeof packages_runtime_dom_src;
export type VaporHelper = keyof typeof packages_runtime_vapor_src;
export interface BlockIRNode extends BaseIRNode {
    type: IRNodeTypes.BLOCK;
    node: RootNode | TemplateChildNode;
    dynamic: IRDynamicInfo;
    effect: IREffect[];
    operation: OperationNode[];
    expressions: SimpleExpressionNode[];
    returns: number[];
}
export interface RootIRNode {
    type: IRNodeTypes.ROOT;
    node: RootNode;
    source: string;
    template: string[];
    rootTemplateIndex?: number;
    component: Set<string>;
    directive: Set<string>;
    block: BlockIRNode;
    hasTemplateRef: boolean;
}
export interface IfIRNode extends BaseIRNode {
    type: IRNodeTypes.IF;
    id: number;
    condition: SimpleExpressionNode;
    positive: BlockIRNode;
    negative?: BlockIRNode | IfIRNode;
    once?: boolean;
}
export interface IRFor {
    source: SimpleExpressionNode;
    value?: SimpleExpressionNode;
    key?: SimpleExpressionNode;
    index?: SimpleExpressionNode;
}
export interface ForIRNode extends BaseIRNode, IRFor {
    type: IRNodeTypes.FOR;
    id: number;
    keyProp?: SimpleExpressionNode;
    render: BlockIRNode;
    once: boolean;
    component: boolean;
}
export interface SetPropIRNode extends BaseIRNode {
    type: IRNodeTypes.SET_PROP;
    element: number;
    prop: IRProp;
    root: boolean;
    tag: string;
}
export interface SetDynamicPropsIRNode extends BaseIRNode {
    type: IRNodeTypes.SET_DYNAMIC_PROPS;
    element: number;
    props: IRProps[];
    root: boolean;
}
export interface SetDynamicEventsIRNode extends BaseIRNode {
    type: IRNodeTypes.SET_DYNAMIC_EVENTS;
    element: number;
    event: SimpleExpressionNode;
}
export interface SetTextIRNode extends BaseIRNode {
    type: IRNodeTypes.SET_TEXT;
    element: number;
    values: SimpleExpressionNode[];
}
export type KeyOverride = [find: string, replacement: string];
export interface SetEventIRNode extends BaseIRNode {
    type: IRNodeTypes.SET_EVENT;
    element: number;
    key: SimpleExpressionNode;
    value?: SimpleExpressionNode;
    modifiers: {
        options: string[];
        keys: string[];
        nonKeys: string[];
    };
    keyOverride?: KeyOverride;
    delegate: boolean;
    /** Whether it's in effect */
    effect: boolean;
}
export interface SetHtmlIRNode extends BaseIRNode {
    type: IRNodeTypes.SET_HTML;
    element: number;
    value: SimpleExpressionNode;
}
export interface SetTemplateRefIRNode extends BaseIRNode {
    type: IRNodeTypes.SET_TEMPLATE_REF;
    element: number;
    value: SimpleExpressionNode;
    refFor: boolean;
    effect: boolean;
}
export interface CreateTextNodeIRNode extends BaseIRNode {
    type: IRNodeTypes.CREATE_TEXT_NODE;
    id: number;
    values: SimpleExpressionNode[];
    effect: boolean;
}
export interface InsertNodeIRNode extends BaseIRNode {
    type: IRNodeTypes.INSERT_NODE;
    elements: number[];
    parent: number;
    anchor?: number;
}
export interface PrependNodeIRNode extends BaseIRNode {
    type: IRNodeTypes.PREPEND_NODE;
    elements: number[];
    parent: number;
}
export interface DirectiveIRNode extends BaseIRNode {
    type: IRNodeTypes.DIRECTIVE;
    element: number;
    dir: VaporDirectiveNode;
    name: string;
    builtin?: boolean;
    asset?: boolean;
    modelType?: 'text' | 'dynamic' | 'radio' | 'checkbox' | 'select';
}
export interface CreateComponentIRNode extends BaseIRNode {
    type: IRNodeTypes.CREATE_COMPONENT_NODE;
    id: number;
    tag: string;
    props: IRProps[];
    slots: IRSlots[];
    asset: boolean;
    root: boolean;
    once: boolean;
    dynamic?: SimpleExpressionNode;
}
export interface DeclareOldRefIRNode extends BaseIRNode {
    type: IRNodeTypes.DECLARE_OLD_REF;
    id: number;
}
export interface SlotOutletIRNode extends BaseIRNode {
    type: IRNodeTypes.SLOT_OUTLET_NODE;
    id: number;
    name: SimpleExpressionNode;
    props: IRProps[];
    fallback?: BlockIRNode;
}
export type IRNode = OperationNode | RootIRNode;
export type OperationNode = SetPropIRNode | SetDynamicPropsIRNode | SetTextIRNode | SetEventIRNode | SetDynamicEventsIRNode | SetHtmlIRNode | SetTemplateRefIRNode | CreateTextNodeIRNode | InsertNodeIRNode | PrependNodeIRNode | DirectiveIRNode | IfIRNode | ForIRNode | CreateComponentIRNode | DeclareOldRefIRNode | SlotOutletIRNode;
export declare enum DynamicFlag {
    NONE = 0,
    /**
     * This node is referenced and needs to be saved as a variable.
     */
    REFERENCED = 1,
    /**
     * This node is not generated from template, but is generated dynamically.
     */
    NON_TEMPLATE = 2,
    /**
     * This node needs to be inserted back into the template.
     */
    INSERT = 4
}
export interface IRDynamicInfo {
    id?: number;
    flags: DynamicFlag;
    anchor?: number;
    children: IRDynamicInfo[];
    template?: number;
}
export interface IREffect {
    expressions: SimpleExpressionNode[];
    operations: OperationNode[];
}
type Overwrite<T, U> = Pick<T, Exclude<keyof T, keyof U>> & Pick<U, Extract<keyof U, keyof T>>;
export type HackOptions<T> = Prettify<Overwrite<T, {
    nodeTransforms?: NodeTransform[];
    directiveTransforms?: Record<string, DirectiveTransform | undefined>;
}>>;
export type VaporDirectiveNode = Overwrite<DirectiveNode, {
    exp: Exclude<DirectiveNode['exp'], CompoundExpressionNode>;
    arg: Exclude<DirectiveNode['arg'], CompoundExpressionNode>;
}>;

export type NodeTransform = (node: RootNode | TemplateChildNode, context: TransformContext<RootNode | TemplateChildNode>) => void | (() => void) | (() => void)[];
export type DirectiveTransform = (dir: VaporDirectiveNode, node: ElementNode, context: TransformContext<ElementNode>) => DirectiveTransformResult | void;
interface DirectiveTransformResult {
    key: SimpleExpressionNode;
    value: SimpleExpressionNode;
    modifier?: '.' | '^';
    runtimeCamelize?: boolean;
    handler?: boolean;
    handlerModifiers?: string[];
    model?: boolean;
    modelModifiers?: string[];
}
export type StructuralDirectiveTransform = (node: ElementNode, dir: VaporDirectiveNode, context: TransformContext<ElementNode>) => void | (() => void);
type TransformOptions = HackOptions<TransformOptions$1>;
export declare class TransformContext<T extends AllNode = AllNode> {
    ir: RootIRNode;
    node: T;
    parent: TransformContext<RootNode | ElementNode> | null;
    root: TransformContext<RootNode>;
    index: number;
    block: BlockIRNode;
    options: Required<Omit<TransformOptions, 'filename' | keyof CompilerCompatOptions>>;
    template: string;
    childrenTemplate: (string | null)[];
    dynamic: IRDynamicInfo;
    inVOnce: boolean;
    inVFor: number;
    comment: CommentNode[];
    component: Set<string>;
    directive: Set<string>;
    slots: IRSlots[];
    private globalId;
    constructor(ir: RootIRNode, node: T, options?: TransformOptions);
    enterBlock(ir: BlockIRNode, isVFor?: boolean): () => void;
    increaseId: () => number;
    reference(): number;
    pushTemplate(content: string): number;
    registerTemplate(): number;
    registerEffect(expressions: SimpleExpressionNode[], ...operations: OperationNode[]): void;
    registerOperation(...node: OperationNode[]): void;
    create<T extends TemplateChildNode>(node: T, index: number): TransformContext<T>;
}
export declare function transform(node: RootNode, options?: TransformOptions): RootIRNode;
export declare function createStructuralDirectiveTransform(name: string | string[], fn: StructuralDirectiveTransform): NodeTransform;

export type CodegenOptions = Omit<CodegenOptions$1, 'optimizeImports'>;
export declare class CodegenContext {
    ir: RootIRNode;
    options: Required<CodegenOptions>;
    helpers: Set<string>;
    helper: (name: CoreHelper | VaporHelper) => string;
    delegates: Set<string>;
    identifiers: Record<string, (string | SimpleExpressionNode)[]>;
    seenInlineHandlerNames: Record<string, number>;
    block: BlockIRNode;
    withId<T>(fn: () => T, map: Record<string, string | SimpleExpressionNode | null>): T;
    enterBlock(block: BlockIRNode): () => BlockIRNode;
    scopeLevel: number;
    enterScope(): [level: number, exit: () => number];
    constructor(ir: RootIRNode, options: CodegenOptions);
}
export interface VaporCodegenResult extends BaseCodegenResult {
    ast: RootIRNode;
    helpers: Set<string>;
}
export declare function generate(ir: RootIRNode, options?: CodegenOptions): VaporCodegenResult;

declare const NEWLINE: unique symbol;
/** increase offset but don't push actual code */
declare const LF: unique symbol;
declare const INDENT_START: unique symbol;
declare const INDENT_END: unique symbol;
type FalsyValue = false | null | undefined;
export type CodeFragment = typeof NEWLINE | typeof LF | typeof INDENT_START | typeof INDENT_END | string | [code: string, newlineIndex?: number, loc?: SourceLocation, name?: string] | FalsyValue;
type CodeFragments = Exclude<CodeFragment, any[]> | CodeFragment[];
export declare function buildCodeFragment(...frag: CodeFragment[]): [
    CodeFragment[],
    (...items: CodeFragment[]) => number,
    (...items: CodeFragment[]) => number
];
type CodeFragmentDelimiters = [
    left: CodeFragments,
    right: CodeFragments,
    delimiter: CodeFragments,
    placeholder?: CodeFragments
];
export declare function genMulti([left, right, seg, placeholder]: CodeFragmentDelimiters, ...frags: CodeFragments[]): CodeFragment[];
export declare function genCall(name: string | [name: string, placeholder?: CodeFragments], ...frags: CodeFragments[]): CodeFragment[];
export declare function codeFragmentToString(code: CodeFragment[], context: CodegenContext): [code: string, map: CodegenSourceMapGenerator | undefined];

export declare function wrapTemplate(node: ElementNode, dirs: string[]): TemplateNode;

export declare function compile(source: string | RootNode, options?: CompilerOptions): VaporCodegenResult;
export type CompilerOptions = HackOptions<CompilerOptions$1>;
export type TransformPreset = [
    NodeTransform[],
    Record<string, DirectiveTransform>
];

export interface VaporCompilerError extends CompilerError {
    code: VaporErrorCodes;
}
export declare function createVaporCompilerError(code: VaporErrorCodes, loc?: SourceLocation): VaporCompilerError;
export declare enum VaporErrorCodes {
    X_V_PLACEHOLDER = 100,
    __EXTEND_POINT__ = 101
}
export declare const VaporErrorMessages: Record<VaporErrorCodes, string>;

export declare const transformElement: NodeTransform;

export declare const transformChildren: NodeTransform;

export declare const transformTemplateRef: NodeTransform;

export declare const transformText: NodeTransform;

export declare const transformVBind: DirectiveTransform;

export declare const transformVHtml: DirectiveTransform;

export declare const transformVOn: DirectiveTransform;

export declare const transformVOnce: NodeTransform;

export declare const transformVShow: DirectiveTransform;

export declare const transformVText: DirectiveTransform;

export declare const transformVIf: NodeTransform;

export declare const transformVFor: NodeTransform;

export declare const transformVModel: DirectiveTransform;

export declare const transformComment: NodeTransform;

export declare const transformSlotOutlet: NodeTransform;

export declare const transformVSlot: NodeTransform;