stickyflow 0.0.0-stage → 0.2.0

package/dist/render-r1GYvjNm.d.cts

@@ -0,0 +1,970 @@
+interface ChartZone {
+    label: string;
+    color?: string;
+    offsetX?: number;
+    offsetY?: number;
+}
+interface ChartRule {
+    id: string;
+    at: number;
+    text?: string;
+    color?: string;
+    strokeWidth?: number;
+    dash?: number[];
+}
+
+interface ChartAxis {
+    min: number;
+    max: number;
+    step: number;
+    label?: string;
+    unit?: string;
+    thresholds?: number[];
+}
+
+interface ColorStop {
+    position: number;
+    color: string;
+}
+interface GradientColor {
+    type: 'gradient';
+    angle: number;
+    stops: ColorStop[];
+}
+interface MeshPoint {
+    id: string;
+    x: number;
+    y: number;
+    color: string;
+}
+interface MeshGradientColor {
+    type: 'mesh';
+    points: MeshPoint[];
+}
+
+interface ShadowStyle {
+    enabled: boolean;
+    color?: string;
+    opacity?: number;
+    blur?: number;
+    angle?: number;
+    distance?: number;
+}
+
+interface CategoryChartConfig {
+    categories?: string[];
+}
+
+interface BarChartConfig extends CategoryChartConfig {
+    barCornerRadius?: number;
+    barBorderColor?: string | GradientColor | MeshGradientColor;
+    barBorderWidth?: number;
+    barGroupGap?: number;
+    barGlow?: number;
+    barSegments?: number;
+    barSegmentGap?: number;
+    barSegmentSnap?: boolean;
+    barGlassBlur?: number;
+    barGlassSaturation?: number;
+    barGlassTint?: string;
+    barThickness?: number;
+    orientation?: 'horizontal' | 'vertical';
+    barTrack?: boolean;
+    barRoundedBottom?: boolean;
+    barLabelMaxOnly?: boolean;
+    barTrackColor?: string;
+    barTrackHatch?: boolean;
+    barTrackHatchColor?: string;
+    barTrackHatchAngle?: number;
+    barTrackHatchSpacing?: number;
+    barTrackHatchWidth?: number;
+    showBarLabels?: boolean;
+    barLabelPosition?: 'outside' | 'inside' | 'center' | 'axis';
+    barLabelFontSize?: number;
+    barLabelFontFamily?: string;
+    barLabelFontWeight?: 'normal' | 'bold';
+    barLabelColor?: string;
+    barLabelPill?: boolean;
+    barLabelPillColor?: string;
+    barLabelBorderColor?: string;
+    barLabelBorderWidth?: number;
+    barLabelFormat?: string;
+    barGap?: number;
+    stacked?: 'none' | 'true' | 'percent' | 'waterfall';
+}
+
+interface BoxplotChartConfig {
+    boxWidth?: number;
+    orientation?: 'horizontal' | 'vertical';
+    barCornerRadius?: number;
+    showBoxplotPoints?: boolean;
+    barBorderColor?: string | GradientColor | MeshGradientColor;
+    barBorderWidth?: number;
+}
+
+interface CustomChartConfig extends CategoryChartConfig {
+    zones?: ChartZone[];
+    orientation?: 'horizontal' | 'vertical';
+    connectPoints?: boolean;
+    reverseComparison?: boolean;
+}
+
+interface ChartRamp {
+    type: 'ramp';
+    stops: Array<{
+        position: number;
+        color: string;
+    }>;
+}
+
+interface FieldChartConfig {
+    scale?: ChartRamp;
+    interpolate?: 'idw';
+    idwPower?: number;
+    isolines?: number[];
+}
+
+interface HeatmapChartConfig extends CategoryChartConfig {
+    zones?: ChartZone[];
+    cellGap?: number;
+    showValues?: boolean;
+    squareCells?: boolean;
+    barCornerRadius?: number;
+}
+
+interface HexbinChartConfig {
+    hexRadius?: number;
+}
+
+interface LineChartConfig extends CategoryChartConfig {
+    areaOpacity?: number;
+    lineTension?: number;
+    lineWidth?: number;
+    lineGlow?: number;
+    pointSize?: number;
+    pointFill?: string;
+    pointStrokeWidth?: number;
+    highlightPoints?: number[];
+    highlightSize?: number;
+    highlightColor?: string;
+    highlightGuide?: boolean;
+    highlightLabels?: boolean;
+    highlightLabelColor?: string;
+    highlightLabelFormat?: string;
+}
+
+interface MekkoChartConfig extends CategoryChartConfig {
+    barCornerRadius?: number;
+    mekkoVaryHeight?: boolean;
+    tileGradient?: boolean;
+    showColumnBackdrop?: boolean;
+}
+
+interface PieChartConfig {
+    innerRadius?: number;
+    pieCornerRadius?: number;
+    pieSliceGap?: number;
+    pieStartAngle?: number;
+    pieSweep?: number;
+    pieExplode?: number;
+    pieGlow?: number;
+    pieStroke?: string;
+    pieStrokeWidth?: number;
+    pieLabelPosition?: 'auto' | 'inside' | 'outside';
+    pieLabelContent?: 'both' | 'percent' | 'name' | 'inline';
+    pieLabelColor?: string;
+    pieCenterText?: string;
+    pieCenterSize?: number;
+    pieCenterColor?: string;
+}
+
+interface RadarChartConfig extends CategoryChartConfig {
+    areaOpacity?: number;
+}
+
+interface RadialBarChartConfig {
+    ringThickness?: number;
+    ringGap?: number;
+}
+
+interface SankeyChartConfig {
+    zones?: ChartZone[];
+    barCornerRadius?: number;
+    labelPosition?: 'outside' | 'inside';
+    labelOrientation?: 'horizontal' | 'vertical';
+    labelColor?: string;
+    linkGradient?: boolean;
+}
+
+interface TreemapChartConfig {
+    zones?: ChartZone[];
+    cellGap?: number;
+    barCornerRadius?: number;
+    headerColor?: string;
+    tileGradient?: boolean;
+}
+
+interface ChartConfigCapabilities extends BarChartConfig, BoxplotChartConfig, CustomChartConfig, FieldChartConfig, HeatmapChartConfig, HexbinChartConfig, LineChartConfig, MekkoChartConfig, PieChartConfig, RadarChartConfig, RadialBarChartConfig, SankeyChartConfig, TreemapChartConfig {
+}
+
+interface PolarAreaChartConfig extends PieChartConfig {
+}
+
+interface RadialChartConfig extends RadarChartConfig {
+}
+
+interface ScatterChartConfig extends CategoryChartConfig {
+}
+
+interface ChartSeries {
+    id: string;
+    label: string;
+    color?: string | GradientColor | MeshGradientColor;
+    colors?: Array<string | GradientColor | MeshGradientColor | null>;
+    opacity?: number;
+    group?: string;
+    values: number[] | [number, number][] | [number, number, number][] | [number, number, number, number][];
+    error?: Array<number | [number, number] | null>;
+    source?: string;
+    target?: string;
+    size?: number;
+    symbol?: {
+        points: Array<[number, number]>;
+        normalized?: boolean;
+        tension?: number;
+    };
+    stroke?: string;
+    strokeWidth?: number;
+    offset?: number;
+    dash?: number[];
+    labelOffsetX?: number;
+    labelOffsetY?: number;
+}
+
+declare const CHART_TYPES: readonly ["bar", "line", "scatter", "radar", "radial", "field", "heatmap", "boxplot", "sankey", "treemap", "mekko", "hexbin", "pie", "radialBar", "polarArea", "custom"];
+type ChartType = (typeof CHART_TYPES)[number];
+
+interface ChartBase {
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    title?: string | null;
+    axisX: ChartAxis;
+    axisY: ChartAxis;
+    series: ChartSeries[];
+    rules?: ChartRule[];
+    strokeColor?: string;
+    strokeWidth?: number;
+    cornerRadius?: number;
+    fillColor?: string | GradientColor | MeshGradientColor;
+    fillImage?: {
+        url: string;
+        overlay?: string;
+    };
+    gridColor?: string;
+    gridWidth?: number;
+    gridShape?: 'rect' | 'circle';
+    gridLineStyle?: 'solid' | 'dashed' | 'dotted';
+    gridRoundedCorners?: boolean;
+    textColor?: string;
+    axisLabelColor?: string;
+    legendColor?: string;
+    axisLineWidth?: number;
+    axisLineColor?: string;
+    axisLineStyle?: 'solid' | 'dashed' | 'dotted';
+    tickLength?: number;
+    axisFontSize?: number;
+    axisFontFamily?: string;
+    showValueAxis?: boolean;
+    categoryAlign?: 'center' | 'left' | 'inside';
+    titleSize?: number;
+    titleWeight?: 'normal' | 'bold';
+    titleColor?: string;
+    gridAxes?: 'both' | 'x' | 'y';
+    fontFamily?: string;
+    fontSize?: number;
+    showGrid?: boolean;
+    showAxisLabels?: boolean;
+    showLegend?: boolean;
+    legendPosition?: 'top' | 'bottom' | 'bottomLeft' | 'bottomRight' | 'left' | 'right';
+    shadowStyle?: ShadowStyle;
+    order?: number;
+    sourceIndex?: number;
+    isVisible?: boolean;
+}
+interface TypedChart<TType extends ChartType = ChartType, TConfig extends object = ChartConfigCapabilities> extends ChartBase {
+    chartType: TType;
+    config?: TConfig;
+}
+interface BarChart extends TypedChart<'bar', BarChartConfig> {
+}
+interface LineChart extends TypedChart<'line', LineChartConfig> {
+}
+interface ScatterChart extends TypedChart<'scatter', ScatterChartConfig> {
+}
+interface BoxplotChart extends TypedChart<'boxplot', BoxplotChartConfig> {
+}
+interface FieldChart extends TypedChart<'field', FieldChartConfig> {
+}
+interface HeatmapChart extends TypedChart<'heatmap', HeatmapChartConfig> {
+}
+interface HexbinChart extends TypedChart<'hexbin', HexbinChartConfig> {
+}
+interface MekkoChart extends TypedChart<'mekko', MekkoChartConfig> {
+}
+interface PieChart extends TypedChart<'pie', PieChartConfig> {
+}
+interface PolarAreaChart extends TypedChart<'polarArea', PolarAreaChartConfig> {
+}
+interface RadarChart extends TypedChart<'radar', RadarChartConfig> {
+}
+interface RadialChart extends TypedChart<'radial', RadialChartConfig> {
+}
+interface RadialBarChart extends TypedChart<'radialBar', RadialBarChartConfig> {
+}
+interface SankeyChart extends TypedChart<'sankey', SankeyChartConfig> {
+}
+interface TreemapChart extends TypedChart<'treemap', TreemapChartConfig> {
+}
+interface CustomChart extends TypedChart<'custom', CustomChartConfig> {
+}
+type Chart = BarChart | BoxplotChart | CustomChart | FieldChart | HeatmapChart | HexbinChart | LineChart | MekkoChart | PieChart | PolarAreaChart | RadarChart | RadialBarChart | RadialChart | SankeyChart | ScatterChart | TreemapChart;
+
+interface Point {
+    x: number;
+    y: number;
+}
+interface Bounds {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+}
+type Side = 'top' | 'right' | 'bottom' | 'left';
+
+type IsometricFace = 'top' | 'bottom' | 'front' | 'back' | 'left' | 'right';
+interface IsometricObject {
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    depth: number;
+    rotation?: number;
+    order?: number;
+    sourceIndex?: number;
+    text?: string;
+    icon?: string;
+    fill?: string;
+    strokeColor?: string;
+    strokeWidth?: number;
+    cornerRadius?: number;
+    hasShadow?: boolean;
+    shadowStyle?: ShadowStyle;
+    labelOffsetX?: number;
+    labelOffsetY?: number;
+    labelBackground?: string;
+    parentFrameId?: string;
+}
+
+type StrokeStyle = 'solid' | 'dashed' | 'dotted';
+type PathType = 'straight' | 'curved' | 'orthogonal';
+type ArrowDirection = 'none' | 'forward' | 'backward' | 'bidirectional';
+type MarkerType = 'none' | 'arrow' | 'filled_arrow' | 'circle' | 'filled_circle' | 'diamond' | 'filled_diamond' | 'bar' | 'triangle' | 'one' | 'zero_one' | 'many' | 'one_many' | 'zero_many';
+interface LinkStyle {
+    color?: string | GradientColor;
+    strokeWidth?: number;
+    strokeStyle?: StrokeStyle;
+    pathType?: PathType;
+    arrowDirection?: ArrowDirection;
+    opacity?: number;
+    fontSize?: number;
+    fontFamily?: string;
+    shadow?: ShadowStyle;
+    startLabel?: string;
+    endLabel?: string;
+}
+type LinkEndpoint = {
+    kind: 'side';
+    side: 'top' | 'right' | 'bottom' | 'left';
+    offset?: number;
+} | {
+    kind: 'absolute';
+    x: number;
+    y: number;
+} | {
+    kind: 'port';
+    port: string;
+} | {
+    kind: 'face';
+    face: IsometricFace;
+};
+interface Link {
+    id: string;
+    name?: string;
+    fromId?: string;
+    toId?: string;
+    weight?: number;
+    showWeight?: boolean;
+    text?: string;
+    showText?: boolean;
+    style?: LinkStyle;
+    fromPoint?: LinkEndpoint;
+    toPoint?: LinkEndpoint;
+    segmentOffsets?: number[];
+    waypoints?: Array<{
+        x: number;
+        y: number;
+    }>;
+    startMarker?: MarkerType;
+    endMarker?: MarkerType;
+    layerGroup?: string;
+    orderKey?: string;
+    order?: number;
+    sourceIndex?: number;
+    isVisible?: boolean;
+    isLocked?: boolean;
+    parentFrameId?: string;
+    parentSwimlaneId?: string;
+    laneId?: string;
+}
+
+type PathPoint = Point;
+interface FreeformPath {
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    points: PathPoint[];
+    value?: number;
+    strokeColor?: string;
+    strokeWidth?: number;
+    dash?: number[];
+    opacity?: number;
+    tension?: number;
+    startMarker?: Extract<MarkerType, 'none' | 'arrow' | 'filled_arrow'>;
+    endMarker?: Extract<MarkerType, 'none' | 'arrow' | 'filled_arrow'>;
+    closed?: boolean;
+    fillColor?: string;
+    order?: number;
+    sourceIndex?: number;
+    isVisible?: boolean;
+}
+
+type ShaderParameter = string | number | boolean;
+interface Shader {
+    name: string;
+    program: string;
+    parameters: Record<string, ShaderParameter>;
+}
+
+type FontWeight = 'normal' | 'bold' | '100' | '200' | '300' | '400' | '500' | '600' | '700' | '800' | '900';
+type ShapeStrokeStyle = 'solid' | 'dashed' | 'dotted' | 'double';
+type ShapeType = 'rounded_rectangle' | 'rectangle' | 'diamond' | 'oval' | 'circle' | 'cylinder' | 'document' | 'pill' | 'person' | 'triangle' | 'hexagon' | 'parallelogram' | 'trapezoid' | 'note' | 'cloud' | 'predefined_process' | 'symbol';
+interface Shape {
+    id: string;
+    name?: string;
+    shapeType: ShapeType;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rotation?: number | null;
+    text?: string | null;
+    textColor?: string | null;
+    fontSize?: number;
+    fontWeight?: FontWeight;
+    letterSpacing?: number;
+    isText?: boolean;
+    fontFamily?: string;
+    textAlign?: 'left' | 'center' | 'right';
+    textVerticalAlign?: 'top' | 'middle' | 'bottom';
+    lineHeight?: number;
+    strokeColor?: string | GradientColor | null;
+    strokeWidth?: number;
+    fillColor?: string | GradientColor | MeshGradientColor | null;
+    cornerRadius?: number | null;
+    dash?: number[];
+    strokeStyle?: ShapeStrokeStyle;
+    opacity?: number;
+    hasShadow?: boolean;
+    shadowStyle?: ShadowStyle;
+    layerGroup?: string;
+    orderKey?: string;
+    sourceIndex?: number;
+    isVisible?: boolean;
+    isLocked?: boolean;
+    parentFrameId?: string | null;
+    parentSwimlaneId?: string | null;
+    laneId?: string | null;
+    symbol?: SymbolDef | null;
+    shader?: Shader;
+}
+interface SymbolDef {
+    name: string;
+    points: Array<[number, number]>;
+    tension?: number;
+    ports?: Array<{
+        name: string;
+        at: [number, number];
+    }>;
+}
+
+type WidgetType = 'rollingNumber' | 'tickScale' | 'ruler';
+interface RollingNumberWidgetStyle {
+    color?: string;
+    surface?: string;
+    divider?: string;
+    labelColor?: string;
+    fontFamily?: string;
+    variant?: 'flip' | 'plain';
+    motion?: 'roll' | 'fade';
+    fontWeight?: string;
+}
+interface RollingNumberWidget {
+    id: string;
+    type: 'rollingNumber';
+    value: string;
+    digits?: number;
+    duration?: number;
+    label?: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rotation?: number;
+    order?: number;
+    sourceIndex?: number;
+    parentFrameId?: string;
+    style: RollingNumberWidgetStyle;
+}
+interface TickScaleWidget {
+    id: string;
+    type: 'tickScale';
+    value: string;
+    max?: number;
+    label?: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rotation?: number;
+    order?: number;
+    sourceIndex?: number;
+    parentFrameId?: string;
+    parameters: Record<string, string | number>;
+    labels?: {
+        size?: number;
+        color?: string;
+        offset?: number;
+        weight?: string;
+        fontFamily?: string;
+    };
+}
+interface RulerWidget {
+    id: string;
+    type: 'ruler';
+    value: string;
+    min?: number;
+    max?: number;
+    label?: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rotation?: number;
+    order?: number;
+    sourceIndex?: number;
+    parentFrameId?: string;
+    parameters: Record<string, string | number>;
+    labels?: {
+        size?: number;
+        color?: string;
+        offset?: number;
+        weight?: string;
+        fontFamily?: string;
+    };
+}
+type Widget = RollingNumberWidget | TickScaleWidget | RulerWidget;
+
+interface Diagnostic {
+    severity: 'warning' | 'error';
+    code: string;
+    message: string;
+    ownerId?: string;
+}
+
+interface Frame {
+    id: string;
+    name?: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    title?: string | null;
+    strokeColor: string;
+    strokeWidth: number;
+    dash?: number[];
+    cornerRadius: number;
+    fillColor: string;
+    textColor: string;
+    fontSize: number;
+    fontWeight: 'normal' | 'bold';
+    fontFamily?: string;
+    showLabel: boolean;
+    labelPosition?: 'top' | 'bottom' | 'left' | 'right';
+    shadow?: boolean;
+    layerGroup?: string;
+    orderKey?: string;
+    order?: number;
+    sourceIndex?: number;
+    isVisible?: boolean;
+    isLocked?: boolean;
+}
+
+interface Lane {
+    id: string;
+    label: string;
+    size: number;
+    color?: string | null;
+}
+interface Swimlane {
+    id: string;
+    name?: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    title?: string | null;
+    orientation: 'horizontal' | 'vertical';
+    lanes: Lane[];
+    strokeColor: string;
+    strokeWidth: number;
+    dash?: number[];
+    cornerRadius: number;
+    fillColor: string;
+    shadowStyle?: ShadowStyle;
+    textColor: string;
+    fontSize: number;
+    fontWeight: 'normal' | 'bold';
+    fontFamily?: string;
+    showLaneLabels: boolean;
+    layerGroup?: string;
+    orderKey?: string;
+    order?: number;
+    sourceIndex?: number;
+    isVisible?: boolean;
+    isLocked?: boolean;
+}
+
+interface RenderInputLink {
+    link: Link;
+    from: Point;
+    to: Point;
+    kind?: string;
+}
+interface RenderInput {
+    shapes: Shape[];
+    frames: Frame[];
+    swimlanes: Swimlane[];
+    isometricObjects?: IsometricObject[];
+    paths?: FreeformPath[];
+    charts?: Chart[];
+    widgets?: Widget[];
+    links: RenderInputLink[];
+    diagnostics?: Diagnostic[];
+}
+
+type RenderDiagnostic = Diagnostic;
+
+type ScenePaint = {
+    kind: 'none';
+} | {
+    kind: 'solid';
+    color: string;
+} | {
+    kind: 'linear-gradient';
+    angle: number;
+    stops: Array<{
+        offset: number;
+        color: string;
+    }>;
+} | {
+    kind: 'mesh-gradient';
+    points: Array<{
+        x: number;
+        y: number;
+        color: string;
+    }>;
+};
+interface SceneStyle {
+    fill?: ScenePaint;
+    stroke?: ScenePaint;
+    strokeWidth?: number;
+    dash?: number[];
+    lineCap?: 'butt' | 'round' | 'square';
+    lineJoin?: 'miter' | 'round' | 'bevel';
+    opacity?: number;
+    pointerEvents?: 'none' | 'all' | 'stroke';
+    shadow?: {
+        color: string;
+        opacity: number;
+        blur: number;
+        dx: number;
+        dy: number;
+    };
+    innerShadow?: {
+        color: string;
+        opacity: number;
+        blur: number;
+        dx: number;
+        dy: number;
+    };
+    blur?: number;
+    saturate?: number;
+    clip?: {
+        type: 'rect';
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        rx: number;
+    } | {
+        type: 'path';
+        d: string;
+    };
+}
+type SceneRole = 'shape' | 'link' | 'frame' | 'swimlane' | 'path' | 'chart' | 'widget' | 'isometric';
+interface SceneIdentity {
+    role: SceneRole;
+    id: string;
+    kind?: string;
+    primary?: boolean;
+    label?: string;
+    parentFrameId?: string;
+}
+interface SceneLinkSegment {
+    ax: number;
+    ay: number;
+    bx: number;
+    by: number;
+    ox: number;
+    oy: number;
+    movable: boolean;
+}
+type SceneDetail = {
+    of: 'link';
+    fromId?: string;
+    toId?: string;
+    route?: PathType;
+    fromSide?: Side;
+    toSide?: Side;
+    fromFace?: IsometricFace;
+    toFace?: IsometricFace;
+    labelGap?: boolean;
+    segments?: SceneLinkSegment[];
+} | {
+    of: 'chartValue';
+    series: string;
+    valueIndex: number;
+    mark?: 'bar' | 'pie-slice' | 'radar-vertex' | 'radial-bar-ring' | 'polar-area-wedge';
+    radius?: number;
+    colorProp?: string;
+    hasColorOverride?: boolean;
+    pieStart?: number;
+    pieEnd?: number;
+    pieValue?: number;
+} | {
+    of: 'chartScale';
+    valueScale: string;
+} | {
+    of: 'pieGeometry';
+    pieGeometry: string;
+} | {
+    of: 'radarGeometry';
+    radarGeometry: string;
+} | {
+    of: 'chartSeries';
+    series: string;
+    lineTension?: number;
+    mark?: string;
+    pulled?: boolean;
+    midAngle?: number;
+    wedgeRadius?: number;
+} | {
+    of: 'frameBoundary';
+    cornerRadius: number;
+    squareCorner: 'topLeft' | 'topRight' | 'bottomRight' | 'bottomLeft';
+} | {
+    of: 'symbolGeometry';
+    points: Array<[number, number]>;
+    tension: number;
+    declaredBounds: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+} | {
+    of: 'declaredBounds';
+    bounds: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+} | {
+    of: 'pathGeometry';
+    points: Array<[number, number]>;
+    tension: number;
+    closed: boolean;
+} | {
+    of: 'isometricGeometry';
+    width: number;
+    height: number;
+    depth: number;
+    cornerRadius: number;
+    bounds: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    labelOffsetX: number;
+    labelOffsetY: number;
+};
+interface SceneBase {
+    id: string;
+    order: number;
+    rank?: number;
+    sequence?: number;
+    bounds: Bounds;
+    identity?: SceneIdentity;
+    detail?: SceneDetail;
+    prop?: string;
+    propKind?: 'value' | 'color';
+    propSolidOnly?: boolean;
+    zoneGradient?: {
+        axis: 'x' | 'y';
+        min: number;
+        max: number;
+    };
+    mark?: string;
+}
+interface SceneRect extends SceneBase {
+    type: 'rect';
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rx?: number;
+    rotation?: number;
+    style: SceneStyle;
+}
+interface SceneEllipse extends SceneBase {
+    type: 'ellipse';
+    cx: number;
+    cy: number;
+    rx: number;
+    ry: number;
+    rotation?: number;
+    style: SceneStyle;
+}
+interface ScenePath extends SceneBase {
+    type: 'path';
+    d: string;
+    rotation?: number;
+    rotationCenter?: Point;
+    style: SceneStyle;
+    markerStart?: MarkerType;
+    markerEnd?: MarkerType;
+}
+interface SceneText extends SceneBase {
+    type: 'text';
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    lines: string[];
+    fontFamily: string;
+    fontSize: number;
+    fontWeight: 'normal' | 'bold' | '100' | '200' | '300' | '400' | '500' | '600' | '700' | '800' | '900';
+    letterSpacing?: number;
+    color: string;
+    align: 'left' | 'center' | 'right';
+    verticalAlign: 'top' | 'middle' | 'bottom';
+    lineHeight: number;
+    rotation?: number;
+    rotationCenter?: Point;
+    richLines?: Array<Array<{
+        text: string;
+        bold: boolean;
+    }>>;
+}
+interface SceneShaderSurface extends SceneBase {
+    type: 'shader-surface';
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rotation?: number;
+    shader: Shader;
+    mask: 'ellipse' | 'rect';
+    fillColor?: string;
+}
+interface SceneRollingNumber extends SceneBase {
+    type: 'rolling-number';
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rotation?: number;
+    value: string;
+    digits?: number;
+    duration: number;
+    label?: string;
+    widgetStyle: Required<RollingNumberWidgetStyle>;
+}
+interface SceneImage extends SceneBase {
+    type: 'image';
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    href: string;
+    style: SceneStyle;
+}
+type RenderNode = SceneRect | SceneEllipse | ScenePath | SceneText | SceneShaderSurface | SceneRollingNumber | SceneImage;
+interface RenderScene {
+    nodes: RenderNode[];
+    bounds: Bounds;
+    diagnostics: RenderDiagnostic[];
+}
+
+interface TextMetrics {
+    measure: (text: string, bold: boolean) => number;
+    spaceWidth: number;
+}
+type MeasureTextFactory = (fontFamily: string, fontSize: number) => TextMetrics;
+
+interface RenderResult {
+    svg: string;
+    width: number;
+    height: number;
+    diagnostics: RenderDiagnostic[];
+    scene: RenderScene;
+}
+interface RenderOptions {
+    padding?: number;
+    includeXmlDeclaration?: boolean;
+    idPrefix?: string;
+    measureText?: MeasureTextFactory;
+    linkHitAreas?: boolean;
+}
+declare function renderCanvas(input: RenderInput, options?: RenderOptions): RenderResult;
+declare function render(source: string, options?: RenderOptions): RenderResult;
+
+export { renderCanvas as A, type Bounds as B, type Chart as C, type Diagnostic as D, type Side as E, type Frame as F, type IsometricFace as I, type LinkStyle as L, type MeasureTextFactory as M, type PathPoint as P, type RenderInput as R, type Shader as S, type TextMetrics as T, type Widget as W, type ShadowStyle as a, type Shape as b, type Link as c, type Swimlane as d, type IsometricObject as e, type FreeformPath as f, type RenderOptions as g, type RenderResult as h, CHART_TYPES as i, type ChartAxis as j, type ChartRamp as k, type ChartSeries as l, type ChartType as m, type Point as n, type RenderDiagnostic as o, type RenderNode as p, type RenderScene as q, type RollingNumberWidget as r, type RollingNumberWidgetStyle as s, type RulerWidget as t, type SceneRole as u, type ShaderParameter as v, type ShapeType as w, type TickScaleWidget as x, type WidgetType as y, render as z };