import { IntervalMark, RectMark, AreaMark, PointMark, CellMark, VectorMark, LinkMark, PolygonMark, ImageMark, TextMark, BoxMark, LineMark, LineXMark, LineYMark, RangeMark, RangeXMark, RangeYMark, ConnectorMark, SankeyMark, BoxPlotMark, DensityMark, HeatmapMark, PathMark, ShapeMark, TreemapMark, ForceGraphMark, PackMark, TreeMark, WordCloudMark, HOMMarkMark, GaugeMark } from '../../spec';
import { NodePropertyDescriptor } from '../props';
import { Concrete } from '../types';
import { MarkNode } from './base';
import { API } from './types';
export interface Interval extends API<Concrete<IntervalMark>, Interval> {
    type: 'interval';
}
export interface Rect extends API<Concrete<RectMark>, Rect> {
    type: 'rect';
}
export interface Point extends API<Concrete<PointMark>, Point> {
    type: 'point';
}
export interface Area extends API<Concrete<AreaMark>, Area> {
    type: 'area';
}
export interface Line extends API<Concrete<LinkMark>, Line> {
    type: 'line';
}
export interface Cell extends API<Concrete<CellMark>, Cell> {
    type: 'cell';
}
export interface Vector extends API<Concrete<VectorMark>, Vector> {
    type: 'cell';
}
export interface Link extends API<Concrete<LinkMark>, Link> {
    type: 'link';
}
export interface Polygon extends API<Concrete<PolygonMark>, Polygon> {
    type: 'polygon';
}
export interface Image extends API<Concrete<ImageMark>, Image> {
    type: 'image';
}
export interface Text extends API<Concrete<TextMark>, Text> {
    type: 'text';
}
export interface Box extends API<Concrete<BoxMark>, Box> {
    type: 'box';
}
export interface LineX extends API<Concrete<LineXMark>, LineX> {
    type: 'annotation.lineX';
}
export interface LineY extends API<Concrete<LineYMark>, LineY> {
    type: 'annotation.lineY';
}
export interface Range extends API<Concrete<RangeMark>, Range> {
    type: 'annotation.range';
}
export interface RangeX extends API<Concrete<RangeXMark>, RangeX> {
    type: 'annotation.rangeX';
}
export interface RangeY extends API<Concrete<RangeYMark>, RangeY> {
    type: 'annotation.rangeY';
}
export interface Connector extends API<Concrete<ConnectorMark>, Connector> {
    type: 'connector';
}
export interface Sankey extends API<Concrete<SankeyMark>, Sankey> {
    type: 'sankey';
}
export interface Boxplot extends API<Concrete<BoxPlotMark>, Boxplot> {
    type: 'boxplot';
}
export interface Density extends API<Concrete<DensityMark>, Density> {
    type: 'density';
}
export interface Heatmap extends API<Concrete<HeatmapMark>, Heatmap> {
    type: 'heatmap';
}
export interface Path extends API<Concrete<PathMark>, Path> {
    type: 'path';
}
export interface Shape extends API<Concrete<ShapeMark>, Shape> {
    type: 'shape';
}
export interface Treemap extends API<Concrete<TreemapMark>, Treemap> {
    type: 'treemap';
}
export interface Pack extends API<Concrete<PackMark>, Pack> {
    type: 'pack';
}
export interface ForceGraph extends API<Concrete<ForceGraphMark>, ForceGraph> {
    type: 'forceGraph';
}
export interface Tree extends API<Concrete<TreeMark>, Tree> {
    type: 'tree';
}
export interface WordCloud extends API<Concrete<WordCloudMark>, WordCloud> {
    type: 'wordCloud';
}
export interface Gauge extends API<Concrete<GaugeMark>, Gauge> {
    type: 'gauge';
}
export interface HOMMark extends API<Concrete<HOMMarkMark>, HOMMark> {
    type: 'interval';
}
export declare const props: NodePropertyDescriptor[];
export declare class HOMMark extends MarkNode<HOMMark> {
    constructor();
}
export declare class Interval extends MarkNode<IntervalMark> {
    constructor();
}
export declare class Rect extends MarkNode<RectMark> {
    constructor();
}
export declare class Point extends MarkNode<PointMark> {
    constructor();
}
export declare class Area extends MarkNode<AreaMark> {
    constructor();
}
export declare class Line extends MarkNode<LineMark> {
    constructor();
}
export declare class Cell extends MarkNode<CellMark> {
    constructor();
}
export declare class Vector extends MarkNode<VectorMark> {
    constructor();
}
export declare class Link extends MarkNode<LinkMark> {
    constructor();
}
export declare class Polygon extends MarkNode<PolygonMark> {
    constructor();
}
export declare class Image extends MarkNode<ImageMark> {
    constructor();
}
export declare class Text extends MarkNode<TextMark> {
    constructor();
}
export declare class Box extends MarkNode<BoxMark> {
    constructor();
}
export declare class LineX extends MarkNode<LineXMark> {
    constructor();
}
export declare class LineY extends MarkNode<LineYMark> {
    constructor();
}
export declare class Range extends MarkNode<RangeMark> {
    constructor();
}
export declare class RangeX extends MarkNode<RangeXMark> {
    constructor();
}
export declare class RangeY extends MarkNode<RangeYMark> {
    constructor();
}
export declare class Connector extends MarkNode<ConnectorMark> {
    constructor();
}
export declare class Shape extends MarkNode<ShapeMark> {
    constructor();
}
export declare class Sankey extends MarkNode<SankeyMark> {
    constructor();
}
export declare class Treemap extends MarkNode<TreemapMark> {
    constructor();
}
export declare class Boxplot extends MarkNode<BoxPlotMark> {
    constructor();
}
export declare class Density extends MarkNode<DensityMark> {
    constructor();
}
export declare class Heatmap extends MarkNode<HeatmapMark> {
    constructor();
}
export declare class Path extends MarkNode<PathMark> {
    constructor();
}
export declare class Pack extends MarkNode<PackMark> {
    constructor();
}
export declare class ForceGraph extends MarkNode<ForceGraphMark> {
    constructor();
}
export declare class Tree extends MarkNode<TreeMark> {
    constructor();
}
export declare class WordCloud extends MarkNode<WordCloudMark> {
    constructor();
}
export declare class Gauge extends MarkNode<GaugeMark> {
    constructor();
}