export declare enum NodeType {
    Row = "row",
    Delimited = "delimited",
    Accent = "accent",
    Macro = "macro",
    Table = "table",
    SubSup = "subsup",
    Limits = "limits",
    Frac = "frac",
    Root = "root"
}
export type Row<A, C> = C & {
    readonly type: NodeType.Row;
    readonly children: readonly Node<A, C>[];
};
export type Delimited<A, C> = C & {
    readonly type: NodeType.Delimited;
    readonly children: readonly [Row<A, C>];
    readonly leftDelim: Atom<A, C>;
    readonly rightDelim: Atom<A, C>;
};
export declare enum AccentType {
    Hat = "hat",
    Bar = "bar",
    Vec = "vec",
    Dot = "dot",
    DDot = "ddot",
    Tilde = "tilde",
    Acute = "acute",
    Grave = "grave"
}
export declare const isAccentType: (accent: string) => accent is AccentType;
export type Accent<A, C> = C & {
    readonly type: NodeType.Accent;
    readonly accent: AccentType;
    readonly wide: boolean;
    readonly children: readonly [Row<A, C>];
};
export type Macro<A, C> = C & {
    readonly type: NodeType.Macro;
    readonly children: readonly [Row<A, C>];
};
export type RowStyle = {
    readonly border?: 'top' | 'bottom';
    readonly alignment?: 'top' | 'middle' | 'bottom';
};
type ColStyle = {
    readonly border?: 'left' | 'right';
    readonly alignment?: 'left' | 'center' | 'right';
};
export type Table<A, C> = C & {
    readonly type: NodeType.Table;
    readonly children: readonly (Row<A, C> | null)[];
    readonly rowCount: number;
    readonly colCount: number;
    readonly delimiters?: {
        readonly left: Atom<A, C>;
        readonly right: Atom<A, C>;
    };
    readonly rowStyles?: readonly (RowStyle | null)[];
    readonly colStyles?: readonly (ColStyle | null)[];
};
export type SubSup<A, C> = C & {
    readonly type: NodeType.SubSup;
    readonly children: readonly [Row<A, C> | null, Row<A, C> | null];
};
export type Limits<A, C> = C & {
    readonly type: NodeType.Limits;
    readonly inner: Node<A, C>;
    readonly children: readonly [Row<A, C>, Row<A, C> | null];
};
export type Frac<A, C> = C & {
    readonly type: NodeType.Frac;
    readonly children: readonly [Row<A, C>, Row<A, C>];
};
export type Root<A, C> = C & {
    readonly type: NodeType.Root;
    readonly children: readonly [Row<A, C> | null, Row<A, C>];
};
export type Atom<A, C> = C & A;
export type Node<A, C> = Row<A, C> | Delimited<A, C> | Accent<A, C> | Macro<A, C> | Table<A, C> | SubSup<A, C> | Limits<A, C> | Frac<A, C> | Root<A, C> | Atom<A, C>;
export {};