MathBox 2 Typescript type declaration file

mathbox.d.ts

/** MathBox type declarations (autogenerated) */

/** Matrix width */
declare interface MBArea {
    /** Use (fast) integer lookups */
    aligned?: boolean;
    /** Axis pair */
    axes?: number[];
    /** Matrix buffer height */
    bufferHeight?: number;
    /** Matrix buffer width */
    bufferWidth?: number;
    /** Centered instead of corner sampling */
    centeredX?: boolean;
    /** Centered instead of corner sampling */
    centeredY?: boolean;
    /** Number of channels */
    channels?: number;
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Data array */
    data?: object;
    /** Data emitter expression, e.g. `function (emit, x, y, i, j, time, delta) { ... }` */
    expr?: (emit: (...args: any[]) => void, ...args: number[]) => void;
    /** Frames-per-second update rate, e.g. `60` */
    fps?: number;
    /** Matrix height */
    height?: number;
    /** Matrix history */
    history?: number;
    /** Maximum frames to hurry per frame */
    hurry?: number;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Number of items */
    items?: number;
    /** Maximum frames to track */
    limit?: number;
    /** Update continuously */
    live?: boolean;
    /** Texture magnification filtering */
    magFilter?: any;
    /** Texture minification filtering */
    minFilter?: any;
    /** Pass clock time to data */
    observe?: boolean;
    /** Number of samples padding */
    paddingX?: number;
    /** Number of samples padding */
    paddingY?: number;
    /** Range on axis */
    rangeX?: [number, number];
    /** Range on axis */
    rangeY?: [number, number];
    /** Run on real time, not clock time */
    realtime?: boolean;
    /** Texture data type */
    type?: string;
    /** Matrix width */
    width?: number;

}
/** Array width */
declare interface MBArray {
    /** Use (fast) integer lookups */
    aligned?: boolean;
    /** Array buffer width */
    bufferWidth?: number;
    /** Number of channels */
    channels?: number;
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Data array */
    data?: object;
    /** Data emitter expression, e.g. `function (emit, i, time, delta) { ... }` */
    expr?: (emit: (...args: any[]) => void, ...args: number[]) => void;
    /** Frames-per-second update rate, e.g. `60` */
    fps?: number;
    /** Array history */
    history?: number;
    /** Maximum frames to hurry per frame */
    hurry?: number;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Number of items */
    items?: number;
    /** Maximum frames to track */
    limit?: number;
    /** Update continuously */
    live?: boolean;
    /** Texture magnification filtering */
    magFilter?: any;
    /** Texture minification filtering */
    minFilter?: any;
    /** Pass clock time to data */
    observe?: boolean;
    /** Run on real time, not clock time */
    realtime?: boolean;
    /** Texture data type */
    type?: string;
    /** Array width */
    width?: number;

}
/** Write Z buffer */
declare interface MBAxis {
    /** Axis */
    axis?: number;
    /** Blending mode ('no, normal, add, subtract, multiply) */
    blending?: string;
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Close line */
    closed?: boolean;
    /** Color */
    color?: string;
    /** UVWO map on matching axis */
    crossed?: boolean;
    /** Depth scaling */
    depth?: number;
    /** Geometric detail */
    detail?: number;
    /** Draw end arrow */
    end?: boolean;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Opacity */
    opacity?: number;
    /** 4D Origin */
    origin?: [number, number, number, number];
    /** Proximity threshold, e.g. `10` */
    proximity?: number;
    /** Range on axis */
    range?: [number, number];
    /** Arrow size */
    size?: number;
    /** Draw start arrow */
    start?: boolean;
    /** Line stroke (solid, dotted, dashed) */
    stroke?: string;
    /** Visibility for rendering */
    visible?: boolean;
    /** Z-Bias (3D stacking) */
    zBias?: number;
    /** Z-Index (2D stacking) */
    zIndex?: number;
    /** Z-Order (drawing order), e.g. `2` */
    zOrder?: number;
    /** Test Z buffer */
    zTest?: boolean;
    /** Write Z buffer */
    zWrite?: boolean;
    width?: number;
}
/** 3D Up, e.g. `[0, 1, 0]` */
declare interface MBCamera {
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** 3D Euler order */
    eulerOrder?: number[];
    /** Field-of-view (degrees), e.g. `60` */
    fov?: number;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** 3D Look at, e.g. `[2, 3, 4]` */
    lookAt?: [number, number, number];
    /** 3D Position, e.g. `[1, 2, 3]` */
    position?: [number, number, number];
    /** Re-use existing camera */
    proxy?: boolean;
    /** 3D Quaternion, e.g. `[0.707, 0, 0, 0.707]` */
    quaternion?: [number, number, number, number];
    /** 3D Euler rotation, e.g. `[π/2, 0, 0]` */
    rotation?: [number, number, number];
    /** 3D Up, e.g. `[0, 1, 0]` */
    up?: [number, number, number];
    width?: number;
}
/** Visibility for rendering */
declare interface MBCartesian {
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Euler order */
    eulerOrder?: number[];
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Vertex pass (data, view, world, eye) */
    pass?: any;
    /** 3D Position */
    position?: [number, number, number];
    /** 3D Quaternion */
    quaternion?: [number, number, number, number];
    /** 4D range in view */
    range?: [number, number][];
    /** 3D Euler rotation */
    rotation?: [number, number, number];
    /** 3D Scale */
    scale?: [number, number, number];
    /** Visibility for rendering */
    visible?: boolean;
    width?: number;
}
/** Visibility for rendering */
declare interface MBCartesian4 {
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Vertex pass (data, view, world, eye) */
    pass?: any;
    /** 4D Position */
    position?: [number, number, number, number];
    /** 4D range in view */
    range?: [number, number][];
    /** 4D Scale */
    scale?: [number, number, number, number];
    /** Visibility for rendering */
    visible?: boolean;
    width?: number;
}
/** Input source */
declare interface MBClamp {
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Input source */
    source?: string;
    width?: number;
}
/** Play until */
declare interface MBClock {
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Play delay */
    delay?: number;
    /** Play from */
    from?: number;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Loop */
    loop?: boolean;
    /** Play pace */
    pace?: number;
    /** Run on real time, not clock time */
    realtime?: boolean;
    /** Seek to time, e.g. `4` */
    seek?: number;
    /** Play speed */
    speed?: number;
    /** Play until */
    to?: number;
    width?: number;
}
/** Write Z buffer */
declare interface MBCompose {
    /** Compose with alpha transparency */
    alpha?: boolean;
    /** Blending mode ('no, normal, add, subtract, multiply) */
    blending?: string;
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Color */
    color?: string;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Opacity */
    opacity?: number;
    /** Input source */
    source?: string;
    /** Visibility for rendering */
    visible?: boolean;
    /** Z-Bias (3D stacking) */
    zBias?: number;
    /** Z-Index (2D stacking) */
    zIndex?: number;
    /** Z-Order (drawing order), e.g. `2` */
    zOrder?: number;
    /** Test Z buffer */
    zTest?: boolean;
    /** Write Z buffer */
    zWrite?: boolean;
    width?: number;
}
/** HTML zoom */
declare interface MBDom {
    /** HTML attributes, e.g. `{"style": {"color": "red"}}` */
    attributes?: object;
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Color */
    color?: string;
    /** Depth scaling */
    depth?: number;
    /** HTML data source */
    html?: string;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** 2D offset */
    offset?: [number, number];
    /** Opacity */
    opacity?: number;
    /** Outline size */
    outline?: number;
    /** Allow pointer events */
    pointerEvents?: boolean;
    /** Points data source */
    points?: string;
    /** Text size */
    size?: number;
    /** Snap to pixel */
    snap?: boolean;
    /** Visibility for rendering */
    visible?: boolean;
    /** Z-Index (2D stacking) */
    zIndex?: number;
    /** HTML zoom */
    zoom?: number;
    width?: number;
}
/** Write Z buffer */
declare interface MBFace {
    /** Blending mode ('no, normal, add, subtract, multiply) */
    blending?: string;
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Close line */
    closed?: boolean;
    /** Color */
    color?: string;
    /** Colors data source, e.g. `"#colors"` */
    colors?: string;
    /** Depth scaling */
    depth?: number;
    /** Fill mesh */
    fill?: boolean;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Draw line */
    line?: boolean;
    /** Z-Bias for lines on fill */
    lineBias?: number;
    /** Texture map source, e.g. `"#map"` */
    map?: string;
    /** Opacity */
    opacity?: number;
    /** Points data source */
    points?: string;
    /** Proximity threshold, e.g. `10` */
    proximity?: number;
    /** Shade mesh */
    shaded?: boolean;
    /** Line width */
    size?: number;
    /** Line stroke (solid, dotted, dashed) */
    stroke?: string;
    /** Visibility for rendering */
    visible?: boolean;
    /** Z-Bias (3D stacking) */
    zBias?: number;
    /** Z-Index (2D stacking) */
    zIndex?: number;
    /** Z-Order (drawing order), e.g. `2` */
    zOrder?: number;
    /** Test Z buffer */
    zTest?: boolean;
    /** Write Z buffer */
    zWrite?: boolean;
    width?: number;
}
/** Font weight, e.g. `"bold"` */
declare interface MBFormat {
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Array of labels, e.g. `["Grumpy", "Sleepy", "Sneezy"]` */
    data?: number[];
    /** Font detail */
    detail?: number;
    /** Digits of precision, e.g. `2` */
    digits?: number;
    /** Label formatter expression, e.g. `function (x, y, z, w, i, j, k, l, time, delta) { ... }` */
    expr?: (...args: any[]) => void;
    /** Font family */
    font?: string;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Update continuously */
    live?: boolean;
    /** Texture magnification filtering */
    magFilter?: any;
    /** Texture minification filtering */
    minFilter?: any;
    /** Signed distance field range */
    sdf?: number;
    /** Input source */
    source?: string;
    /** Font style, e.g. `"italic"` */
    style?: string;
    /** Texture data type */
    type?: string;
    /** Font variant, e.g. `"small-caps"` */
    variant?: string;
    /** Font weight, e.g. `"bold"` */
    weight?: string;
    width?: number;
}
/** Shader to use */
declare interface MBFragment {
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Pass RGBA values in sRGB instead of linear RGB */
    gamma?: boolean;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Fragment pass (color, light, rgba) */
    pass?: string;
    /** Shader to use */
    shader?: string;
    width?: number;
}
/** Include zero */
declare interface MBGrid {
    /** Axis pair */
    axes?: number[];
    /** Power base for sub/super units */
    baseX?: number;
    /** Power base for sub/super units */
    baseY?: number;
    /** Blending mode ('no, normal, add, subtract, multiply) */
    blending?: string;
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Close line */
    closed?: boolean;
    /** Close X lines */
    closedX?: boolean;
    /** Close Y lines */
    closedY?: boolean;
    /** Color */
    color?: string;
    /** UVWO map on matching axes */
    crossed?: boolean;
    /** UVWO map on matching axis */
    crossedX?: boolean;
    /** UVWO map on matching axis */
    crossedY?: boolean;
    /** Depth scaling */
    depth?: number;
    /** Geometric detail */
    detailX?: number;
    /** Geometric detail */
    detailY?: number;
    /** Number of divisions */
    divideX?: number;
    /** Number of divisions */
    divideY?: number;
    /** Include end */
    endX?: boolean;
    /** Include end */
    endY?: boolean;
    /** Scale factor */
    factorX?: number;
    /** Scale factor */
    factorY?: number;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Draw X lines */
    lineX?: boolean;
    /** Draw Y lines */
    lineY?: boolean;
    /** Scale type */
    modeX?: string;
    /** Scale type */
    modeY?: string;
    /** Snap to nice numbers */
    niceX?: boolean;
    /** Snap to nice numbers */
    niceY?: boolean;
    /** Opacity */
    opacity?: number;
    /** 4D Origin */
    origin?: [number, number, number, number];
    /** Proximity threshold, e.g. `10` */
    proximity?: number;
    /** Range on axis */
    rangeX?: [number, number];
    /** Range on axis */
    rangeY?: [number, number];
    /** Line width */
    size?: number;
    /** Include start */
    startX?: boolean;
    /** Include start */
    startY?: boolean;
    /** Line stroke (solid, dotted, dashed) */
    stroke?: string;
    /** Reference unit */
    unitX?: number;
    /** Reference unit */
    unitY?: number;
    /** Visibility for rendering */
    visible?: boolean;
    /** Z-Bias (3D stacking) */
    zBias?: number;
    /** Z-Index (2D stacking) */
    zIndex?: number;
    /** Z-Order (drawing order), e.g. `2` */
    zOrder?: number;
    /** Test Z buffer */
    zTest?: boolean;
    /** Write Z buffer */
    zWrite?: boolean;
    /** Include zero */
    zeroX?: boolean;
    /** Include zero */
    zeroY?: boolean;
    width?: number;
}
/** Visibility for rendering */
declare interface MBGroup {
    /** Updates continuously */
    active?: boolean;
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Visibility for rendering */
    visible?: boolean;
    width?: number;
}
/** Width alignment */
declare interface MBGrow {
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Depth alignment */
    depth?: string;
    /** Height alignment */
    height?: string;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Items alignment */
    items?: string;
    /** Scale factor */
    scale?: number;
    /** Input source */
    source?: string;
    /** Width alignment */
    width?: string;

}
/** Voxel width */
declare interface MBHtml {
    /** Use (fast) integer lookups */
    aligned?: boolean;
    /** Voxel buffer depth */
    bufferDepth?: number;
    /** Voxel buffer height */
    bufferHeight?: number;
    /** Voxel buffer width */
    bufferWidth?: number;
    /** Number of channels */
    channels?: number;
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Data array */
    data?: object;
    /** Voxel depth */
    depth?: number;
    /** Data emitter expression */
    expr?: (emit: (...args: any[]) => void, ...args: number[]) => void;
    /** Frames-per-second update rate, e.g. `60` */
    fps?: number;
    /** Voxel height */
    height?: number;
    /** Maximum frames to hurry per frame */
    hurry?: number;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Number of items */
    items?: number;
    /** Maximum frames to track */
    limit?: number;
    /** Update continuously */
    live?: boolean;
    /** Pass clock time to data */
    observe?: boolean;
    /** Run on real time, not clock time */
    realtime?: boolean;
    /** Voxel width */
    width?: number;

}
/** Unique ID, e.g. `"sampler"` */
declare interface MBInherit {
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    width?: number;
}
/** Array width */
declare interface MBInterval {
    /** Use (fast) integer lookups */
    aligned?: boolean;
    /** Axis */
    axis?: number;
    /** Array buffer width */
    bufferWidth?: number;
    /** Centered instead of corner sampling */
    centered?: boolean;
    /** Number of channels */
    channels?: number;
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Data array */
    data?: object;
    /** Data emitter expression, e.g. `function (emit, x, i, time, delta) { ... }` */
    expr?: (emit: (...args: any[]) => void, ...args: number[]) => void;
    /** Frames-per-second update rate, e.g. `60` */
    fps?: number;
    /** Array history */
    history?: number;
    /** Maximum frames to hurry per frame */
    hurry?: number;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Number of items */
    items?: number;
    /** Maximum frames to track */
    limit?: number;
    /** Update continuously */
    live?: boolean;
    /** Texture magnification filtering */
    magFilter?: any;
    /** Texture minification filtering */
    minFilter?: any;
    /** Pass clock time to data */
    observe?: boolean;
    /** Number of samples padding */
    padding?: number;
    /** Range on axis */
    range?: [number, number];
    /** Run on real time, not clock time */
    realtime?: boolean;
    /** Texture data type */
    type?: string;
    /** Array width */
    width?: number;

}
/** Input source */
declare interface MBJoin {
    /** Axis to join, e.g. `x` */
    axis?: number;
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Axis order */
    order?: number[];
    /** Tuple overlap */
    overlap?: number;
    /** Input source */
    source?: string;
    width?: number;
}
/** Write Z buffer */
declare interface MBLabel {
    /** Outline background */
    background?: string;
    /** Blending mode ('no, normal, add, subtract, multiply) */
    blending?: string;
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Color */
    color?: string;
    /** Colors data source, e.g. `"#colors"` */
    colors?: string;
    /** Depth scaling */
    depth?: number;
    /** Expand glyphs */
    expand?: number;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** 2D offset */
    offset?: [number, number];
    /** Opacity */
    opacity?: number;
    /** Outline size */
    outline?: number;
    /** Points data source */
    points?: string;
    /** Text size */
    size?: number;
    /** Snap to pixel */
    snap?: boolean;
    /** Text source */
    text?: string;
    /** Visibility for rendering */
    visible?: boolean;
    /** Z-Bias (3D stacking) */
    zBias?: number;
    /** Z-Index (2D stacking) */
    zIndex?: number;
    /** Z-Order (drawing order), e.g. `2` */
    zOrder?: number;
    /** Test Z buffer */
    zTest?: boolean;
    /** Write Z buffer */
    zWrite?: boolean;
    width?: number;
}
/** Vertex pass (data, view, world, eye) */
declare interface MBLayer {
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** 3D Depth */
    depth?: number;
    /** Fit to (contain, cover, x, y) */
    fit?: string;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Vertex pass (data, view, world, eye) */
    pass?: any;
    width?: number;
}
/** Lerp to width, e.g. `5` */
declare interface MBLerp {
    /** Centered instead of corner sampling */
    centeredW?: boolean;
    /** Centered instead of corner sampling */
    centeredX?: boolean;
    /** Centered instead of corner sampling */
    centeredY?: boolean;
    /** Centered instead of corner sampling */
    centeredZ?: boolean;
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Lerp to depth, e.g. `5` */
    depth?: number;
    /** Lerp to height, e.g. `5` */
    height?: number;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Lerp to items, e.g. `5` */
    items?: number;
    /** Number of samples padding */
    paddingW?: number;
    /** Number of samples padding */
    paddingX?: number;
    /** Number of samples padding */
    paddingY?: number;
    /** Number of samples padding */
    paddingZ?: number;
    /** Scaling mode (relative, absolute) */
    size?: string;
    /** Input source */
    source?: string;
    /** Lerp to width, e.g. `5` */
    width?: number;

}
/** Write Z buffer */
declare interface MBLine {
    /** Blending mode ('no, normal, add, subtract, multiply) */
    blending?: string;
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Close line */
    closed?: boolean;
    /** Color */
    color?: string;
    /** Colors data source, e.g. `"#colors"` */
    colors?: string;
    /** Depth scaling */
    depth?: number;
    /** Draw end arrow */
    end?: boolean;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Opacity */
    opacity?: number;
    /** Points data source */
    points?: string;
    /** Proximity threshold, e.g. `10` */
    proximity?: number;
    /** Arrow size */
    size?: number;
    /** Draw start arrow */
    start?: boolean;
    /** Line stroke (solid, dotted, dashed) */
    stroke?: string;
    /** Visibility for rendering */
    visible?: boolean;
    /** Z-Bias (3D stacking) */
    zBias?: number;
    /** Z-Index (2D stacking) */
    zIndex?: number;
    /** Z-Order (drawing order), e.g. `2` */
    zOrder?: number;
    /** Test Z buffer */
    zTest?: boolean;
    /** Write Z buffer */
    zWrite?: boolean;
    width?: number;
}
/** Shader to use */
declare interface MBMask {
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Shader to use */
    shader?: string;
    width?: number;
}
/** Matrix width */
declare interface MBMatrix {
    /** Use (fast) integer lookups */
    aligned?: boolean;
    /** Matrix buffer height */
    bufferHeight?: number;
    /** Matrix buffer width */
    bufferWidth?: number;
    /** Number of channels */
    channels?: number;
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Data array */
    data?: object;
    /** Data emitter expression, e.g. `function (emit, i, j, time, delta) { ... }` */
    expr?: (emit: (...args: any[]) => void, ...args: number[]) => void;
    /** Frames-per-second update rate, e.g. `60` */
    fps?: number;
    /** Matrix height */
    height?: number;
    /** Matrix history */
    history?: number;
    /** Maximum frames to hurry per frame */
    hurry?: number;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Number of items */
    items?: number;
    /** Maximum frames to track */
    limit?: number;
    /** Update continuously */
    live?: boolean;
    /** Texture magnification filtering */
    magFilter?: any;
    /** Texture minification filtering */
    minFilter?: any;
    /** Pass clock time to data */
    observe?: boolean;
    /** Run on real time, not clock time */
    realtime?: boolean;
    /** Texture data type */
    type?: string;
    /** Matrix width */
    width?: number;

}
/** Texture data type */
declare interface MBMemo {
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Texture magnification filtering */
    magFilter?: any;
    /** Texture minification filtering */
    minFilter?: any;
    /** Input source */
    source?: string;
    /** Texture data type */
    type?: string;
    width?: number;
}
/** Exit to */
declare interface MBMove {
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Transition delay */
    delay?: number;
    /** Transition enter delay, e.g. `0.3` */
    delayEnter?: number;
    /** Transition exit delay, e.g. `0.3` */
    delayExit?: number;
    /** Transition duration */
    duration?: number;
    /** Transition enter duration */
    durationEnter?: number;
    /** Transition exit duration */
    durationExit?: number;
    /** Enter state, e.g. `0.5` */
    enter?: number;
    /** Exit state, e.g. `0.5` */
    exit?: number;
    /** Enter from */
    from?: [number, number, number, number];
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Vertex pass (data, view, world, eye) */
    pass?: any;
    /** Stagger dimensions, e.g. `[2, 1, 0, 0]` */
    stagger?: [number, number, number, number];
    /** Exit to */
    to?: [number, number, number, number];
    width?: number;
}
/** Time speed */
declare interface MBNow {
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Current moment, e.g. `1444094929.619` */
    now?: number;
    /** Time pace */
    pace?: number;
    /** Seek to time */
    seek?: number;
    /** Time speed */
    speed?: number;
    width?: number;
}
/** Trigger on step */
declare interface MBPlay {
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Play delay */
    delay?: number;
    /** Animation ease (linear, cosine, binary, hold) */
    ease?: string;
    /** Play from */
    from?: number;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Loop */
    loop?: boolean;
    /** Play pace */
    pace?: number;
    /** Run on real time, not clock time */
    realtime?: boolean;
    /** Animation script, e.g. `{ "0": { props: { color: "red" }, expr: { size: function (t) { return Math.sin(t) + 1; }}}, "1": ...}` */
    script?: object;
    /** Play speed */
    speed?: number;
    /** Animation target */
    target?: string;
    /** Play until */
    to?: number;
    /** Trigger on step */
    trigger?: number;
    width?: number;
}
/** Write Z buffer */
declare interface MBPoint {
    /** Blending mode ('no, normal, add, subtract, multiply) */
    blending?: string;
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Color */
    color?: string;
    /** Colors data source, e.g. `"#colors"` */
    colors?: string;
    /** Depth scaling */
    depth?: number;
    /** Fill shape */
    fill?: boolean;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Opacity */
    opacity?: number;
    /** Optical or exact sizing */
    optical?: boolean;
    /** Points data source */
    points?: string;
    /** Point shape (circle, square, diamond, up, down, left, right) */
    shape?: string;
    /** Point size */
    size?: number;
    /** Point sizes data source, e.g. `"#sizes"` */
    sizes?: string;
    /** Visibility for rendering */
    visible?: boolean;
    /** Z-Bias (3D stacking) */
    zBias?: number;
    /** Z-Index (2D stacking) */
    zIndex?: number;
    /** Z-Order (drawing order), e.g. `2` */
    zOrder?: number;
    /** Test Z buffer */
    zTest?: boolean;
    /** Write Z buffer */
    zWrite?: boolean;
    width?: number;
}
/** Visibility for rendering */
declare interface MBPolar {
    /** Amount of polar bend */
    bend?: number;
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Euler order */
    eulerOrder?: number[];
    /** Expand into helix */
    helix?: number;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Vertex pass (data, view, world, eye) */
    pass?: any;
    /** 3D Position */
    position?: [number, number, number];
    /** 3D Quaternion */
    quaternion?: [number, number, number, number];
    /** 4D range in view */
    range?: [number, number][];
    /** 3D Euler rotation */
    rotation?: [number, number, number];
    /** 3D Scale */
    scale?: [number, number, number];
    /** Visibility for rendering */
    visible?: boolean;
    width?: number;
}
/** Presentation length (computed) */
declare interface MBPresent {
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Apply directional transitions */
    directed?: boolean;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Present slide number */
    index?: number;
    /** Presentation length (computed) */
    length?: number;
    width?: number;
}
/** Readback width (read only) */
declare interface MBReadback {
    /** Updates continuously */
    active?: boolean;
    /** Readback channels (read only) */
    channels?: number;
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Readback data buffer (read only) */
    data?: any;
    /** Readback depth (read only) */
    depth?: number;
    /** Readback consume expression, e.g. `function (x, y, z, w, i, j, k, l) { ... }` */
    expr?: (...args: any[]) => void;
    /** Readback height (read only) */
    height?: number;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Readback items (read only) */
    items?: number;
    /** Input source */
    source?: string;
    /** Readback data type (float, unsignedByte) */
    type?: number;
    /** Readback width (read only) */
    width?: number;

}
/** Repeat width */
declare interface MBRepeat {
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Repeat depth */
    depth?: number;
    /** Repeat height */
    height?: number;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Repeat items */
    items?: number;
    /** Input source */
    source?: string;
    /** Repeat width */
    width?: number;

}
/** Resample factor width, e.g. `10` */
declare interface MBResample {
    /** Centered instead of corner sampling */
    centeredW?: boolean;
    /** Centered instead of corner sampling */
    centeredX?: boolean;
    /** Centered instead of corner sampling */
    centeredY?: boolean;
    /** Centered instead of corner sampling */
    centeredZ?: boolean;
    /** Resample channels */
    channels?: number;
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Resample factor depth, e.g. `10` */
    depth?: number;
    /** Resample factor height, e.g. `10` */
    height?: number;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Resample indices */
    indices?: number;
    /** Resample factor items, e.g. `10` */
    items?: number;
    /** Number of samples padding */
    paddingW?: number;
    /** Number of samples padding */
    paddingX?: number;
    /** Number of samples padding */
    paddingY?: number;
    /** Number of samples padding */
    paddingZ?: number;
    /** Source sampling (relative, absolute) */
    sample?: string;
    /** Shader to use */
    shader?: string;
    /** Scaling mode (relative, absolute) */
    size?: string;
    /** Input source */
    source?: string;
    /** Resample factor width, e.g. `10` */
    width?: number;

}
/** Resample factor width, e.g. `10` */
declare interface MBRetext {
    /** Centered instead of corner sampling */
    centeredW?: boolean;
    /** Centered instead of corner sampling */
    centeredX?: boolean;
    /** Centered instead of corner sampling */
    centeredY?: boolean;
    /** Centered instead of corner sampling */
    centeredZ?: boolean;
    /** Resample channels */
    channels?: number;
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Resample factor depth, e.g. `10` */
    depth?: number;
    /** Resample factor height, e.g. `10` */
    height?: number;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Resample indices */
    indices?: number;
    /** Resample factor items, e.g. `10` */
    items?: number;
    /** Number of samples padding */
    paddingW?: number;
    /** Number of samples padding */
    paddingX?: number;
    /** Number of samples padding */
    paddingY?: number;
    /** Number of samples padding */
    paddingZ?: number;
    /** Source sampling (relative, absolute) */
    sample?: string;
    /** Shader to use */
    shader?: string;
    /** Scaling mode (relative, absolute) */
    size?: string;
    /** Input source */
    source?: string;
    /** Resample factor width, e.g. `10` */
    width?: number;

}
/** Stagger dimensions, e.g. `[2, 1, 0, 0]` */
declare interface MBReveal {
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Transition delay */
    delay?: number;
    /** Transition enter delay, e.g. `0.3` */
    delayEnter?: number;
    /** Transition exit delay, e.g. `0.3` */
    delayExit?: number;
    /** Transition duration */
    duration?: number;
    /** Transition enter duration */
    durationEnter?: number;
    /** Transition exit duration */
    durationExit?: number;
    /** Enter state, e.g. `0.5` */
    enter?: number;
    /** Exit state, e.g. `0.5` */
    exit?: number;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Stagger dimensions, e.g. `[2, 1, 0, 0]` */
    stagger?: [number, number, number, number];
    width?: number;
}
/** Global speed */
declare interface MBRoot {
    /** Active camera */
    camera?: string;
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Camera focus distance in world units */
    focus?: number;
    /** (Vertical) Field-of-view to calibrate units for (degrees), e.g. `60` */
    fov?: number;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Vertex pass (data, view, world, eye) */
    pass?: any;
    /** (Vertical) Reference scale of viewport in pixels, e.g. `720` */
    scale?: number;
    /** Global speed */
    speed?: number;
    width?: number;
}
/** RTT width, e.g. `640` */
declare interface MBRtt {
    /** Active camera */
    camera?: string;
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** RTT height, e.g. `360` */
    height?: number;
    /** RTT history */
    history?: number;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Texture magnification filtering */
    magFilter?: any;
    /** Texture minification filtering */
    minFilter?: any;
    /** Vertex pass (data, view, world, eye) */
    pass?: any;
    /** Global speed */
    speed?: number;
    /** Texture data type */
    type?: string;
    /** RTT width, e.g. `640` */
    width?: number;

}
/** Include zero */
declare interface MBScale {
    /** Axis */
    axis?: number;
    /** Power base for sub/super units */
    base?: number;
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Number of divisions */
    divide?: number;
    /** Include end */
    end?: boolean;
    /** Scale factor */
    factor?: number;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Scale type */
    mode?: string;
    /** Snap to nice numbers */
    nice?: boolean;
    /** 4D Origin */
    origin?: [number, number, number, number];
    /** Range on axis */
    range?: [number, number];
    /** Include start */
    start?: boolean;
    /** Reference unit */
    unit?: number;
    /** Include zero */
    zero?: boolean;
    width?: number;
}
/** Shader uniform objects (three.js style), e.g. `{ time: { type: 'f', value: 3 }}` */
declare interface MBShader {
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Shader code */
    code?: string;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Shader language */
    language?: string;
    /** Sampler sources, e.g. `["#pressure", "#divergence"]` */
    sources?: string;
    /** Shader uniform objects (three.js style), e.g. `{ time: { type: 'f', value: 3 }}` */
    uniforms?: object;
    width?: number;
}
/** Slice from, to width (excluding to), e.g. `[2, 4]` */
declare interface MBSlice {
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Slice from, to depth (excluding to), e.g. `[2, 4]` */
    depth?: [number, number];
    /** Slice from, to height (excluding to), e.g. `[2, 4]` */
    height?: [number, number];
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Slice from, to items (excluding to), e.g. `[2, 4]` */
    items?: [number, number];
    /** Input source */
    source?: string;
    /** Slice from, to width (excluding to), e.g. `[2, 4]` */
    width?: [number, number];

}
/** Disappear on step, e.g. `4` */
declare interface MBSlide {
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Appear early steps */
    early?: number;
    /** Appear from step, e.g. `2` */
    from?: number;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Stay late steps */
    late?: number;
    /** Slide order */
    order?: number;
    /** Slide steps */
    steps?: number;
    /** Disappear on step, e.g. `4` */
    to?: number;
    width?: number;
}
/** Visibility for rendering */
declare interface MBSpherical {
    /** Amount of spherical bend */
    bend?: number;
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Euler order */
    eulerOrder?: number[];
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Vertex pass (data, view, world, eye) */
    pass?: any;
    /** 3D Position */
    position?: [number, number, number];
    /** 3D Quaternion */
    quaternion?: [number, number, number, number];
    /** 4D range in view */
    range?: [number, number][];
    /** 3D Euler rotation */
    rotation?: [number, number, number];
    /** 3D Scale */
    scale?: [number, number, number];
    /** Visibility for rendering */
    visible?: boolean;
    width?: number;
}
/** Input source */
declare interface MBSplit {
    /** Axis to split, e.g. `x` */
    axis?: number;
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Tuple length */
    length?: number;
    /** Axis order */
    order?: number[];
    /** Tuple overlap */
    overlap?: number;
    /** Input source */
    source?: string;
    width?: number;
}
/** Width offset, e.g. `[1.5, 0, 0, 0]` */
declare interface MBSpread {
    /** Depth alignment */
    alignDepth?: string;
    /** Height alignment */
    alignHeight?: string;
    /** Items alignment */
    alignItems?: string;
    /** Width alignment */
    alignWidth?: string;
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Depth offset, e.g. `[1.5, 0, 0, 0]` */
    depth?: [number, number, number, number];
    /** Height offset, e.g. `[1.5, 0, 0, 0]` */
    height?: [number, number, number, number];
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Items offset, e.g. `[1.5, 0, 0, 0]` */
    items?: [number, number, number, number];
    /** Input source */
    source?: string;
    /** Spread per item (absolute) or array (relative) */
    unit?: string;
    /** Width offset, e.g. `[1.5, 0, 0, 0]` */
    width?: [number, number, number, number];

}
/** Trigger on step */
declare interface MBStep {
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Step delay */
    delay?: number;
    /** Step duration */
    duration?: number;
    /** Animation ease (linear, cosine, binary, hold) */
    ease?: string;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Step pace */
    pace?: number;
    /** Playhead ease (linear, cosine, binary, hold) */
    playback?: string;
    /** Run on real time, not clock time */
    realtime?: boolean;
    /** Step rewind factor */
    rewind?: number;
    /** Animation script, e.g. `{ "0": { props: { color: "red" }, expr: { size: function (t) { return Math.sin(t) + 1; }}}, "1": ...}` */
    script?: object;
    /** Speed up through skips */
    skip?: boolean;
    /** Step speed */
    speed?: number;
    /** Playhead stops, e.g. `[0, 1, 3, 5]` */
    stops?: number;
    /** Animation target */
    target?: string;
    /** Trigger on step */
    trigger?: number;
    width?: number;
}
/** Visibility for rendering */
declare interface MBStereographic {
    /** Amount of stereographic bend */
    bend?: number;
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Euler order */
    eulerOrder?: number[];
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Vertex pass (data, view, world, eye) */
    pass?: any;
    /** 3D Position */
    position?: [number, number, number];
    /** 3D Quaternion */
    quaternion?: [number, number, number, number];
    /** 4D range in view */
    range?: [number, number][];
    /** 3D Euler rotation */
    rotation?: [number, number, number];
    /** 3D Scale */
    scale?: [number, number, number];
    /** Visibility for rendering */
    visible?: boolean;
    width?: number;
}
/** Visibility for rendering */
declare interface MBStereographic4 {
    /** Amount of stereographic bend */
    bend?: number;
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Vertex pass (data, view, world, eye) */
    pass?: any;
    /** 4D Position */
    position?: [number, number, number, number];
    /** 4D range in view */
    range?: [number, number][];
    /** 4D Scale */
    scale?: [number, number, number, number];
    /** Visibility for rendering */
    visible?: boolean;
    width?: number;
}
/** Write Z buffer */
declare interface MBStrip {
    /** Blending mode ('no, normal, add, subtract, multiply) */
    blending?: string;
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Close line */
    closed?: boolean;
    /** Color */
    color?: string;
    /** Colors data source, e.g. `"#colors"` */
    colors?: string;
    /** Depth scaling */
    depth?: number;
    /** Fill mesh */
    fill?: boolean;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Draw line */
    line?: boolean;
    /** Z-Bias for lines on fill */
    lineBias?: number;
    /** Texture map source, e.g. `"#map"` */
    map?: string;
    /** Opacity */
    opacity?: number;
    /** Points data source */
    points?: string;
    /** Proximity threshold, e.g. `10` */
    proximity?: number;
    /** Shade mesh */
    shaded?: boolean;
    /** Line width */
    size?: number;
    /** Line stroke (solid, dotted, dashed) */
    stroke?: string;
    /** Visibility for rendering */
    visible?: boolean;
    /** Z-Bias (3D stacking) */
    zBias?: number;
    /** Z-Index (2D stacking) */
    zIndex?: number;
    /** Z-Order (drawing order), e.g. `2` */
    zOrder?: number;
    /** Test Z buffer */
    zTest?: boolean;
    /** Write Z buffer */
    zWrite?: boolean;
    width?: number;
}
/** Divisions of width, e.g. `5` */
declare interface MBSubdivide {
    /** Fraction to end outward from vertices */
    bevel?: number;
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Divisions of depth, e.g. `5` */
    depth?: number;
    /** Divisions of height, e.g. `5` */
    height?: number;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Divisions of items, e.g. `5` */
    items?: number;
    /** Interpolate values with computed indices */
    lerp?: boolean;
    /** Input source */
    source?: string;
    /** Divisions of width, e.g. `5` */
    width?: number;

}
/** Write Z buffer */
declare interface MBSurface {
    /** Blending mode ('no, normal, add, subtract, multiply) */
    blending?: string;
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Close line */
    closed?: boolean;
    /** Close X lines */
    closedX?: boolean;
    /** Close Y lines */
    closedY?: boolean;
    /** Color */
    color?: string;
    /** Colors data source, e.g. `"#colors"` */
    colors?: string;
    /** UVWO map on matching axes */
    crossed?: boolean;
    /** Depth scaling */
    depth?: number;
    /** Fill mesh */
    fill?: boolean;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Z-Bias for lines on fill */
    lineBias?: number;
    /** Draw X lines */
    lineX?: boolean;
    /** Draw Y lines */
    lineY?: boolean;
    /** Texture map source, e.g. `"#map"` */
    map?: string;
    /** Opacity */
    opacity?: number;
    /** Points data source */
    points?: string;
    /** Proximity threshold, e.g. `10` */
    proximity?: number;
    /** Shade mesh */
    shaded?: boolean;
    /** Line width */
    size?: number;
    /** Line stroke (solid, dotted, dashed) */
    stroke?: string;
    /** Visibility for rendering */
    visible?: boolean;
    /** Z-Bias (3D stacking) */
    zBias?: number;
    /** Z-Index (2D stacking) */
    zIndex?: number;
    /** Z-Order (drawing order), e.g. `2` */
    zOrder?: number;
    /** Test Z buffer */
    zTest?: boolean;
    /** Write Z buffer */
    zWrite?: boolean;
    width?: number;
}
/** Input source */
declare interface MBSwizzle {
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Swizzle order */
    order?: number[];
    /** Input source */
    source?: string;
    width?: number;
}
/** Voxel width */
declare interface MBText {
    /** Use (fast) integer lookups */
    aligned?: boolean;
    /** Voxel buffer depth */
    bufferDepth?: number;
    /** Voxel buffer height */
    bufferHeight?: number;
    /** Voxel buffer width */
    bufferWidth?: number;
    /** Number of channels */
    channels?: number;
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Data array */
    data?: object;
    /** Voxel depth */
    depth?: number;
    /** Font detail */
    detail?: number;
    /** Data emitter expression */
    expr?: (emit: (...args: any[]) => void, ...args: number[]) => void;
    /** Font family */
    font?: string;
    /** Frames-per-second update rate, e.g. `60` */
    fps?: number;
    /** Voxel height */
    height?: number;
    /** Maximum frames to hurry per frame */
    hurry?: number;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Number of items */
    items?: number;
    /** Maximum frames to track */
    limit?: number;
    /** Update continuously */
    live?: boolean;
    /** Texture magnification filtering */
    magFilter?: any;
    /** Texture minification filtering */
    minFilter?: any;
    /** Pass clock time to data */
    observe?: boolean;
    /** Run on real time, not clock time */
    realtime?: boolean;
    /** Signed distance field range */
    sdf?: number;
    /** Font style, e.g. `"italic"` */
    style?: string;
    /** Texture data type */
    type?: string;
    /** Font variant, e.g. `"small-caps"` */
    variant?: string;
    /** Font weight, e.g. `"bold"` */
    weight?: string;
    /** Voxel width */
    width?: number;

}
/** Write Z buffer */
declare interface MBTicks {
    /** Blending mode ('no, normal, add, subtract, multiply) */
    blending?: string;
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Close line */
    closed?: boolean;
    /** Color */
    color?: string;
    /** Colors data source, e.g. `"#colors"` */
    colors?: string;
    /** Depth scaling */
    depth?: number;
    /** Tick epsilon */
    epsilon?: number;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Normal for reference plane */
    normal?: boolean;
    /** Opacity */
    opacity?: number;
    /** Points data source */
    points?: string;
    /** Proximity threshold, e.g. `10` */
    proximity?: number;
    /** Tick size */
    size?: number;
    /** Line stroke (solid, dotted, dashed) */
    stroke?: string;
    /** Visibility for rendering */
    visible?: boolean;
    /** Z-Bias (3D stacking) */
    zBias?: number;
    /** Z-Index (2D stacking) */
    zIndex?: number;
    /** Z-Order (drawing order), e.g. `2` */
    zOrder?: number;
    /** Test Z buffer */
    zTest?: boolean;
    /** Write Z buffer */
    zWrite?: boolean;
    width?: number;
}
/** 3D Scale */
declare interface MBTransform {
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** 3D Euler order */
    eulerOrder?: number[];
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** 3D Projective Matrix */
    matrix?: number[];
    /** Vertex pass (data, view, world, eye) */
    pass?: any;
    /** 3D Position */
    position?: [number, number, number];
    /** 3D Quaternion */
    quaternion?: [number, number, number, number];
    /** 3D Euler rotation */
    rotation?: [number, number, number];
    /** 3D Scale */
    scale?: [number, number, number];
    width?: number;
}
/** 4D Scale */
declare interface MBTransform4 {
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** 4D Affine Matrix */
    matrix?: number[];
    /** Vertex pass (data, view, world, eye) */
    pass?: any;
    /** 4D Position */
    position?: [number, number, number, number];
    /** 4D Scale */
    scale?: [number, number, number, number];
    width?: number;
}
/** Input source */
declare interface MBTranspose {
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Transpose order */
    order?: number[];
    /** Input source */
    source?: string;
    width?: number;
}
/** (Vertical) Reference scale of viewport in pixels, e.g. `720` */
declare interface MBUnit {
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Camera focus distance in world units */
    focus?: number;
    /** (Vertical) Field-of-view to calibrate units for (degrees), e.g. `60` */
    fov?: number;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** (Vertical) Reference scale of viewport in pixels, e.g. `720` */
    scale?: number;
    width?: number;
}
/** Write Z buffer */
declare interface MBVector {
    /** Blending mode ('no, normal, add, subtract, multiply) */
    blending?: string;
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Close line */
    closed?: boolean;
    /** Color */
    color?: string;
    /** Colors data source, e.g. `"#colors"` */
    colors?: string;
    /** Depth scaling */
    depth?: number;
    /** Draw end arrow */
    end?: boolean;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Opacity */
    opacity?: number;
    /** Points data source */
    points?: string;
    /** Proximity threshold, e.g. `10` */
    proximity?: number;
    /** Arrow size */
    size?: number;
    /** Draw start arrow */
    start?: boolean;
    /** Line stroke (solid, dotted, dashed) */
    stroke?: string;
    /** Visibility for rendering */
    visible?: boolean;
    /** Z-Bias (3D stacking) */
    zBias?: number;
    /** Z-Index (2D stacking) */
    zIndex?: number;
    /** Z-Order (drawing order), e.g. `2` */
    zOrder?: number;
    /** Test Z buffer */
    zTest?: boolean;
    /** Write Z buffer */
    zWrite?: boolean;
    width?: number;
}
/** Shader to use */
declare interface MBVertex {
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Vertex pass (data, view, world, eye) */
    pass?: any;
    /** Shader to use */
    shader?: string;
    width?: number;
}
/** Visibility for rendering */
declare interface MBView {
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Vertex pass (data, view, world, eye) */
    pass?: any;
    /** 4D range in view */
    range?: [number, number][];
    /** Visibility for rendering */
    visible?: boolean;
    width?: number;
}
/** Voxel width */
declare interface MBVolume {
    /** Use (fast) integer lookups */
    aligned?: boolean;
    /** Axis triplet */
    axes?: number[];
    /** Voxel buffer depth */
    bufferDepth?: number;
    /** Voxel buffer height */
    bufferHeight?: number;
    /** Voxel buffer width */
    bufferWidth?: number;
    /** Centered instead of corner sampling */
    centeredX?: boolean;
    /** Centered instead of corner sampling */
    centeredY?: boolean;
    /** Centered instead of corner sampling */
    centeredZ?: boolean;
    /** Number of channels */
    channels?: number;
    /** Custom classes, e.g. `["big"]` */
    classes?: string[];
    /** Data array */
    data?: object;
    /** Voxel depth */
    depth?: number;
    /** Data emitter expression, e.g. `function (emit, x, y, z, i, j, k, time, delta) { ... }` */
    expr?: (emit: (...args: any[]) => void, ...args: number[]) => void;
    /** Frames-per-second update rate, e.g. `60` */
    fps?: number;
    /** Voxel height */
    height?: number;
    /** Maximum frames to hurry per frame */
    hurry?: number;
    /** Unique ID, e.g. `"sampler"` */
    id?: string;
    /** Number of items */
    items?: number;
    /** Maximum frames to track */
    limit?: number;
    /** Update continuously */
    live?: boolean;
    /** Texture magnification filtering */
    magFilter?: any;
    /** Texture minification filtering */
    minFilter?: any;
    /** Pass clock time to data */
    observe?: boolean;
    /** Number of samples padding */
    paddingX?: number;
    /** Number of samples padding */
    paddingY?: number;
    /** Number of samples padding */
    paddingZ?: number;
    /** Range on axis */
    rangeX?: [number, number];
    /** Range on axis */
    rangeY?: [number, number];
    /** Range on axis */
    rangeZ?: [number, number];
    /** Run on real time, not clock time */
    realtime?: boolean;
    /** Texture data type */
    type?: string;
    /** Voxel width */
    width?: number;

}

declare type Selector<T> = {
    /** Set a prop to the value provided. */
    set<A extends keyof T>(attr: A, v: T[A]);

    /** Set multiple props to the values provided. */
    set(elts: {[A in keyof T]: T[A]});

    /** Invoke the function every frame and set the prop to its return value. */
    bind<A extends keyof T>(attr: A, cb: (time: number, delta: number) => T[A]);

    /** Get the current value of a prop. */
    get<A extends keyof T>(attr: A): T[A];

    /** Get the current values of all props. */
    get(): T;

    /** A function on mathbox that returns a selection of all the nodes matching the selector.
    Like CSS, the selector may be the name of a primitive (e.g. "camera"), an id (e.g. "#colors"),
    or a class (e.g. ".points"). */
    select(selector: string): Selector<any>;

    /** Print (in the console) the DOM nodes in this selection. Called automatically on first load. */
    inspect(): void;

    /** Display a visual representation of all shader snippets, how they are wired, with the GLSL available on mouseover. */
    debug(): void;

    /** Iterate over a selection's nodes in document order and discard the return values. */
    each(cb: (node: Selector<any>) => void): void;

    /** Iterate over a selection's nodes in document order and return the resulting values as an array. */
    map(cb: (node: Selector<any>) => any): any[];

    /** Select the i'th node where i is a 0-indexed number of the node in question. */
    eq(i: number): Selector<any>;

    
    /** Matrix width */
    area: (opts?: MBArea) => Selector<MBArea>;
    /** Array width */
    array: (opts?: MBArray) => Selector<MBArray>;
    /** Write Z buffer */
    axis: (opts?: MBAxis) => Selector<MBAxis>;
    /** 3D Up, e.g. `[0, 1, 0]` */
    camera: (opts?: MBCamera) => Selector<MBCamera>;
    /** Visibility for rendering */
    cartesian: (opts?: MBCartesian) => Selector<MBCartesian>;
    /** Visibility for rendering */
    cartesian4: (opts?: MBCartesian4) => Selector<MBCartesian4>;
    /** Input source */
    clamp: (opts?: MBClamp) => Selector<MBClamp>;
    /** Play until */
    clock: (opts?: MBClock) => Selector<MBClock>;
    /** Write Z buffer */
    compose: (opts?: MBCompose) => Selector<MBCompose>;
    /** HTML zoom */
    dom: (opts?: MBDom) => Selector<MBDom>;
    /** Write Z buffer */
    face: (opts?: MBFace) => Selector<MBFace>;
    /** Font weight, e.g. `"bold"` */
    format: (opts?: MBFormat) => Selector<MBFormat>;
    /** Shader to use */
    fragment: (opts?: MBFragment) => Selector<MBFragment>;
    /** Include zero */
    grid: (opts?: MBGrid) => Selector<MBGrid>;
    /** Visibility for rendering */
    group: (opts?: MBGroup) => Selector<MBGroup>;
    /** Width alignment */
    grow: (opts?: MBGrow) => Selector<MBGrow>;
    /** Voxel width */
    html: (opts?: MBHtml) => Selector<MBHtml>;
    /** Unique ID, e.g. `"sampler"` */
    inherit: (opts?: MBInherit) => Selector<MBInherit>;
    /** Array width */
    interval: (opts?: MBInterval) => Selector<MBInterval>;
    /** Input source */
    join: (opts?: MBJoin) => Selector<MBJoin>;
    /** Write Z buffer */
    label: (opts?: MBLabel) => Selector<MBLabel>;
    /** Vertex pass (data, view, world, eye) */
    layer: (opts?: MBLayer) => Selector<MBLayer>;
    /** Lerp to width, e.g. `5` */
    lerp: (opts?: MBLerp) => Selector<MBLerp>;
    /** Write Z buffer */
    line: (opts?: MBLine) => Selector<MBLine>;
    /** Shader to use */
    mask: (opts?: MBMask) => Selector<MBMask>;
    /** Matrix width */
    matrix: (opts?: MBMatrix) => Selector<MBMatrix>;
    /** Texture data type */
    memo: (opts?: MBMemo) => Selector<MBMemo>;
    /** Exit to */
    move: (opts?: MBMove) => Selector<MBMove>;
    /** Time speed */
    now: (opts?: MBNow) => Selector<MBNow>;
    /** Trigger on step */
    play: (opts?: MBPlay) => Selector<MBPlay>;
    /** Write Z buffer */
    point: (opts?: MBPoint) => Selector<MBPoint>;
    /** Visibility for rendering */
    polar: (opts?: MBPolar) => Selector<MBPolar>;
    /** Presentation length (computed) */
    present: (opts?: MBPresent) => Selector<MBPresent>;
    /** Readback width (read only) */
    readback: (opts?: MBReadback) => Selector<MBReadback>;
    /** Repeat width */
    repeat: (opts?: MBRepeat) => Selector<MBRepeat>;
    /** Resample factor width, e.g. `10` */
    resample: (opts?: MBResample) => Selector<MBResample>;
    /** Resample factor width, e.g. `10` */
    retext: (opts?: MBRetext) => Selector<MBRetext>;
    /** Stagger dimensions, e.g. `[2, 1, 0, 0]` */
    reveal: (opts?: MBReveal) => Selector<MBReveal>;
    /** Global speed */
    root: (opts?: MBRoot) => Selector<MBRoot>;
    /** RTT width, e.g. `640` */
    rtt: (opts?: MBRtt) => Selector<MBRtt>;
    /** Include zero */
    scale: (opts?: MBScale) => Selector<MBScale>;
    /** Shader uniform objects (three.js style), e.g. `{ time: { type: 'f', value: 3 }}` */
    shader: (opts?: MBShader) => Selector<MBShader>;
    /** Slice from, to width (excluding to), e.g. `[2, 4]` */
    slice: (opts?: MBSlice) => Selector<MBSlice>;
    /** Disappear on step, e.g. `4` */
    slide: (opts?: MBSlide) => Selector<MBSlide>;
    /** Visibility for rendering */
    spherical: (opts?: MBSpherical) => Selector<MBSpherical>;
    /** Input source */
    split: (opts?: MBSplit) => Selector<MBSplit>;
    /** Width offset, e.g. `[1.5, 0, 0, 0]` */
    spread: (opts?: MBSpread) => Selector<MBSpread>;
    /** Trigger on step */
    step: (opts?: MBStep) => Selector<MBStep>;
    /** Visibility for rendering */
    stereographic: (opts?: MBStereographic) => Selector<MBStereographic>;
    /** Visibility for rendering */
    stereographic4: (opts?: MBStereographic4) => Selector<MBStereographic4>;
    /** Write Z buffer */
    strip: (opts?: MBStrip) => Selector<MBStrip>;
    /** Divisions of width, e.g. `5` */
    subdivide: (opts?: MBSubdivide) => Selector<MBSubdivide>;
    /** Write Z buffer */
    surface: (opts?: MBSurface) => Selector<MBSurface>;
    /** Input source */
    swizzle: (opts?: MBSwizzle) => Selector<MBSwizzle>;
    /** Voxel width */
    text: (opts?: MBText) => Selector<MBText>;
    /** Write Z buffer */
    ticks: (opts?: MBTicks) => Selector<MBTicks>;
    /** 3D Scale */
    transform: (opts?: MBTransform) => Selector<MBTransform>;
    /** 4D Scale */
    transform4: (opts?: MBTransform4) => Selector<MBTransform4>;
    /** Input source */
    transpose: (opts?: MBTranspose) => Selector<MBTranspose>;
    /** (Vertical) Reference scale of viewport in pixels, e.g. `720` */
    unit: (opts?: MBUnit) => Selector<MBUnit>;
    /** Write Z buffer */
    vector: (opts?: MBVector) => Selector<MBVector>;
    /** Shader to use */
    vertex: (opts?: MBVertex) => Selector<MBVertex>;
    /** Visibility for rendering */
    view: (opts?: MBView) => Selector<MBView>;
    /** Voxel width */
    volume: (opts?: MBVolume) => Selector<MBVolume>;
}

declare interface MathBox extends Selector<MBRoot> {
  fallback: any;
  three: any;
}

declare var mathBox: (opts?: {
    init?: boolean,
    element?: any,
    plugins?: string[],
    aliases?: any
}) => MathBox;

declare var THREE: any;

z_api.py

import re
import sys

if len(sys.argv) == 1:
    print("please pass the path to mapbox/docs/primitives.md")

PRIMITIVES_MD = sys.argv[1]

data = open(PRIMITIVES_MD).readlines()

prim = None
doc = None


ifaces = ''
members = ''


def optsname(prim):
    return 'MB' + prim[0].upper() + prim[1:]


def output(prim, doc, funs):
    global ifaces, members
    ifaces += f'\n/** {doc} */\ndeclare interface {optsname(prim)} {{\n{funs}\n}}'
    members += f'\n    /** {doc} */\n    {prim}: (opts?: {optsname(prim)}) => Selector<{optsname(prim)}>;'


def proctype(ty):
    try:
        if ty == 'bool':
            return 'boolean'
        if ty in {'type', 'color', 'stroke', 'select', 'blending',
                  'font', 'anchor', 'ease', 'shape', 'mapping', 'fit', 'scale',
                  'fragmentPass'}:
            return 'string'
        if ty in ['function']:
            return '(...args: any[]) => void'
        if ty == 'emitter':
            return '(emit: (...args: any[]) => void, ...args: number[]) => void'
        if ty in ['int', 'positive', 'timestamp', 'float', 'axis']:
            return 'number'
        if ty in ['vec2']:
            return '[number, number]'
        if ty in ['vec3']:
            return '[number, number, number]'
        if ty in ['vec4', 'quat']:
            return '[number, number, number, number]'
        if ty in ['swizzle', 'array', 'transpose', 'swizzle(2) axis', 'swizzle(3) axis', 'mat4']:
            return 'number[]'
        if ty in ['filter', 'vertexPass', 'data']:
            return 'any'
        if ty.startswith('nullable'):
            return proctype(ty.split(' ')[1])
        if ty.endswith('array'):
            return proctype(ty.split(' ')[0]) + '[]'
        if ty.startswith('array'):
            return proctype(ty.split(' ')[1]) + '[]'
        if ty.startswith('positive'):
            return proctype(ty.split(' ')[1])
    except:
        print('bad:', ty, file=sys.stderr)

    return ty


i = 0

while not data[i].startswith('### Reference'):
    i += 1

i += 1

funs = ''

while True:
    if i >= len(data):
        break

    line = data[i]
    if line.strip() == '':
        i += 1
        continue

    if line.startswith('####'):
        if prim:
            if 'width?:' not in funs:
                funs += '    width?: number;'
            output(prim, doc, funs)
        doc = ''
        funs = ''
        prim = re.search('`\w+/(\w+)`', line).group(1)

    if line.startswith('*'):
        doc = line

    if line.startswith(' *'):
        q = re.match(' \* \*(\w+)\* = `.*` \((.*)\) - (.*)', line)
        if q is None:
            print('failure:', line)
            1/0
        name = q.group(1)
        ty = q.group(2)
        doc = q.group(3)
        fun = f'    /** {doc} */\n    {name}?: {proctype(ty)};\n'

        funs += fun

    i += 1

print(f'''/** MathBox type declarations (autogenerated) */
{ifaces}

declare type Selector<T> = {{
    /** Set a prop to the value provided. */
    set<A extends keyof T>(attr: A, v: T[A]);

    /** Set multiple props to the values provided. */
    set(elts: {{[A in keyof T]: T[A]}});

    /** Invoke the function every frame and set the prop to its return value. */
    bind<A extends keyof T>(attr: A, cb: (time: number, delta: number) => T[A]);

    /** Get the current value of a prop. */
    get<A extends keyof T>(attr: A): T[A];

    /** Get the current values of all props. */
    get(): T;

    /** A function on mathbox that returns a selection of all the nodes matching the selector.
    Like CSS, the selector may be the name of a primitive (e.g. "camera"), an id (e.g. "#colors"),
    or a class (e.g. ".points"). */
    select(selector: string): Selector<any>;

    /** Print (in the console) the DOM nodes in this selection. Called automatically on first load. */
    inspect(): void;

    /** Display a visual representation of all shader snippets, how they are wired, with the GLSL available on mouseover. */
    debug(): void;

    /** Iterate over a selection's nodes in document order and discard the return values. */
    each(cb: (node: Selector<any>) => void): void;

    /** Iterate over a selection's nodes in document order and return the resulting values as an array. */
    map(cb: (node: Selector<any>) => any): any[];

    /** Select the i'th node where i is a 0-indexed number of the node in question. */
    eq(i: number): Selector<any>;

    {members}
}}

declare interface MathBox extends Selector<MBRoot> {{
  fallback: any;
  three: any;
}}

declare var mathBox: (opts?: {{
    init?: boolean,
    element?: any,
    plugins?: string[],
    aliases?: any
}}) => MathBox;

declare var THREE: any;

''')