import { select } from "d3-selection";
import type { DataPoint } from "@d3plus/data";
declare const Viz_base: any;
/**
    Creates an x/y plot based on an array of data. See [this example](https://d3plus.org/examples/d3plus-treemap/getting-started/) for help getting started using the treemap generator.
*/
export default class Viz extends Viz_base {
    [key: string]: any;
    /**
        Invoked when creating a new class instance, and sets any default parameters.
        @private
    */
    constructor();
    /**
     Called by draw before anything is drawn. Formats the data and performs preparations for draw.
     @private
     */
    _preDraw(): void;
    /**
        Called by render once all checks are passed.
        @private
    */
    _draw(): void;
    /**
     * Applies the threshold algorithm according to the type of chart used.
     * @param {Array} data The data to process.
     * @private
     */
    _thresholdFunction(data: DataPoint[], _tree?: unknown): DataPoint[];
    /**
     * Detects width and height and sets SVG properties
     * @private
     */
    _setSVGSize(width?: number, height?: number): void;
    /**
        Draws the visualization given the specified configuration.
      @param callback Optional callback invoked after rendering completes.
    */
    render(callback?: () => void): this;
    /**
        Tears down the visualization: disconnects the ResizeObserver and removes DOM event listeners. Call this when unmounting to avoid memory leaks.
    */
    destroy(): this;
    /**
        The active callback function for highlighting shapes.
  */
    active(_?: ((d: DataPoint, i: number) => boolean) | false): this | ((d: DataPoint, i: number) => boolean) | false;
    /**
        Custom aggregation methods for each data key.
  */
    aggs(_?: Record<string, unknown>): this | Record<string, unknown>;
    /**
        The "aria-hidden" attribute of the containing SVG element. The default value is "false", but if you need to hide the SVG from screen readers set this property to "true".
  */
    ariaHidden(_?: boolean): this | boolean;
    /**
        Sets text to be shown positioned absolute on top of the visualization in the bottom-right corner. This is most often used in Geomaps to display the copyright of map tiles. The text is rendered as HTML, so any valid HTML string will render as expected (eg. anchor links work).
  */
    attribution(_?: string | boolean): this | string | boolean;
    /**
        Configuration object for the attribution style.
  */
    attributionStyle(_?: Record<string, unknown>): this | Record<string, unknown>;
    /**
        Configuration object for the back button.
  */
    backConfig(_?: Record<string, unknown>): this | Record<string, unknown>;
    /**
        Enables a lru cache that stores up to 5 previously loaded files/URLs. Helpful when constantly writing over the data array with a URL in the render function of a react component.
  */
    cache(_?: boolean): this | boolean;
    /**
        Defines the main color to be used for each data point in a visualization. Can be either an accessor function or a string key to reference in each data point. If a color value is returned, it will be used as is. If a string is returned, a unique color will be assigned based on the string.
  */
    color(_?: string | ((d: DataPoint, i: number) => DataPoint[keyof DataPoint]) | false): this | string | ((d: DataPoint, i: number) => DataPoint[keyof DataPoint]) | false;
    /**
        Defines the value to be used for a color scale. Can be either an accessor function or a string key to reference in each data point.
  */
    colorScale(_?: string | ((d: DataPoint, i: number) => DataPoint[keyof DataPoint]) | false): this | string | ((d: DataPoint, i: number) => DataPoint[keyof DataPoint]) | false;
    /**
        A pass-through to the config method of ColorScale.
  */
    colorScaleConfig(_?: Record<string, unknown>): this | Record<string, unknown>;
    /**
        Tells the colorScale whether or not to use the internal padding defined by the visualization in it's positioning. For example, d3plus-plot will add padding on the left so that the colorScale appears centered above the x-axis. By default, this padding is only applied on screens larger than 600 pixels wide.
  */
    colorScalePadding(_?: boolean | (() => boolean)): this | boolean | (() => boolean);
    /**
        Defines which side of the visualization to anchor the color scale. Acceptable values are `"top"`, `"bottom"`, `"left"`, `"right"`, and `false`. A `false` value will cause the color scale to not be displayed, but will still color shapes based on the scale.
  */
    colorScalePosition(_?: string | boolean | (() => string | boolean)): this | string | boolean | (() => string | boolean);
    /**
        The maximum pixel size for drawing the color scale: width for horizontal scales and height for vertical scales.
  */
    colorScaleMaxSize(_?: number): this | number;
    /**
        The primary data array used to draw the visualization. The value passed should be an *Array* of objects or a *String* representing a filepath or URL to be loaded. The following filetypes are supported: `csv`, `tsv`, `txt`, and `json`.
  
  If your data URL needs specific headers to be set, an Object with "url" and "headers" keys may also be passed.
  
  Additionally, a custom formatting function can be passed as a second argument to this method. This custom function will be passed the data that has been loaded, as long as there are no errors. This function should return the final array of obejcts to be used as the primary data array. For example, some JSON APIs return the headers split from the data values to save bandwidth. These would need be joined using a custom formatter.
  
  If you would like to specify certain configuration options based on the yet-to-be-loaded data, you can also return a full `config` object from the data formatter (including the new `data` array as a key in the object).
  
  Defaults to an empty array (`[]`).
      @param f The data array or a URL string to load data from.
    */
    data(_?: DataPoint[] | string | {
        url: string;
        headers: Record<string, string>;
    }, f?: (data: DataPoint[]) => DataPoint[] | Record<string, unknown>): this | DataPoint[];
    /**
        If the number of visible data points exceeds this number, the default hover behavior will be disabled (helpful for very large visualizations bogging down the DOM with opacity updates).
  */
    dataCutoff(_?: number): this | number;
    /**
        The current depth of the visualization. The value should correspond with an index in the [groupBy](#groupBy) array.
  */
    depth(_?: number): this | number;
    /**
        If the width and/or height of a Viz is not user-defined, it is determined by the size of it's parent element. When this method is set to `true`, the Viz will listen for the `window.onresize` event and adjust it's dimensions accordingly.
  */
    detectResize(_?: boolean): this | boolean;
    /**
        When resizing the browser window, this is the millisecond delay to trigger the resize event.
  */
    detectResizeDelay(_?: number): this | number;
    /**
        Toggles whether or not the Viz should try to detect if it visible in the current viewport. When this method is set to `true`, the Viz will only be rendered when it has entered the viewport either through scrolling or if it's display or visibility is changed.
  */
    detectVisible(_?: boolean): this | boolean;
    /**
        The interval, in milliseconds, for checking if the visualization is visible on the page.
  */
    detectVisibleInterval(_?: number): this | number;
    /**
        If *value* is specified, sets the discrete accessor to the specified method name (usually an axis) and returns the current class instance.
  */
    discrete(_?: string): this | string;
    /**
        Shows a button that allows for downloading the current visualization.
  */
    downloadButton(_?: boolean): this | boolean;
    /**
        Sets specific options of the saveElement function used when downloading the visualization.
  */
    downloadConfig(_?: Record<string, unknown>): this | Record<string, unknown>;
    /**
        Defines which control group to add the download button into.
  */
    downloadPosition(_?: string): this | string;
    /**
        The animation duration in milliseconds.
  */
    duration(_?: number): this | number;
    /**
        A filter function applied to the data before drawing.
  */
    filter(_?: ((d: DataPoint, i: number) => boolean) | false): this | ((d: DataPoint, i: number) => boolean) | false;
    /**
        The font family used throughout the visualization.
  */
    fontFamily(_?: string | string[]): this | string | string[];
    /**
        Defines the mapping between data and shape. The value can be a String matching a key in each data point (default is "id"), or an accessor Function that returns a unique value for each data point. Additionally, an Array of these values may be provided if the visualization supports nested hierarchies.
  */
    groupBy(_?: string | ((d: DataPoint, i: number) => DataPoint[keyof DataPoint]) | (string | ((d: DataPoint, i: number) => DataPoint[keyof DataPoint]))[]): this | ((d: DataPoint, i: number) => DataPoint[keyof DataPoint])[];
    /**
        The overall height of the visualization in pixels.
  */
    height(_?: number): this | number;
    /**
        Defines the color used for legend shapes when the corresponding grouping is hidden from display (by clicking on the legend).
  */
    hiddenColor(_?: string | ((d: DataPoint, i: number) => string)): this | string | ((d: DataPoint, i: number) => string);
    /**
        Defines the opacity used for legend labels when the corresponding grouping is hidden from display (by clicking on the legend).
  */
    hiddenOpacity(_?: number | ((d: DataPoint, i: number) => number)): this | number | ((d: DataPoint, i: number) => number);
    /**
        The hover callback function for highlighting shapes on mouseover.
  */
    hover(_?: ((d: DataPoint, i: number) => boolean) | false): this;
    /**
        Accessor function or string key for the label of each data point.
  */
    label(_?: string | ((d: DataPoint, i: number) => string)): this | string | ((d: DataPoint, i: number) => string);
    /**
        Whether to display the legend.
  */
    legend(_?: boolean | ((config: Record<string, unknown>, arr: DataPoint[]) => boolean)): this | boolean | ((config: Record<string, unknown>, arr: DataPoint[]) => boolean);
    /**
        Configuration object passed to the legend's config method.
  */
    legendConfig(_?: Record<string, unknown>): this | Record<string, unknown>;
    /**
        Defines the click functionality of categorical legend squares. When set to false, clicking will hide that category and shift+clicking will solo that category. When set to true, clicking with solo that category and shift+clicking will hide that category.
  */
    legendFilterInvert(_?: boolean | (() => boolean)): this | boolean | (() => boolean);
    /**
        Tells the legend whether or not to use the internal padding defined by the visualization in it's positioning. For example, d3plus-plot will add padding on the left so that the legend appears centered underneath the x-axis. By default, this padding is only applied on screens larger than 600 pixels wide.
  */
    legendPadding(_?: boolean | (() => boolean)): this | boolean | (() => boolean);
    /**
        Defines which side of the visualization to anchor the legend. Expected values are `"top"`, `"bottom"`, `"left"`, and `"right"`.
  */
    legendPosition(_?: string | (() => string)): this | string | (() => string);
    /**
        A JavaScript [sort comparator function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) used to sort the legend.
  */
    legendSort(_?: (a: DataPoint, b: DataPoint) => number): this | ((a: DataPoint, b: DataPoint) => number);
    /**
        Configuration object for the legend tooltip.
  */
    legendTooltip(_?: Record<string, unknown>): this | Record<string, unknown>;
    /**
        The inner HTML of the status message displayed when loading AJAX requests and displaying errors. Must be a valid HTML string or a function that, when passed this Viz instance, returns a valid HTML string.
  */
    loadingHTML(_?: string | ((viz: Viz) => string)): this | string | ((viz: Viz) => string);
    /**
        Toggles the visibility of the status message that is displayed when loading AJAX requests and displaying errors.
  */
    loadingMessage(_?: boolean): this | boolean;
    /**
        The color of the mask displayed underneath the status message when loading AJAX requests and displaying errors. Set to `false` to turn off the mask completely.
  */
    messageMask(_?: string | boolean): this | string | boolean;
    /**
        Defines the CSS style properties for the status message that is displayed when loading AJAX requests and displaying errors.
  */
    messageStyle(_?: Record<string, unknown>): this | Record<string, unknown>;
    /**
        The inner HTML of the status message displayed when no data is supplied to the visualization. Must be a valid HTML string or a function that, when passed this Viz instance, returns a valid HTML string.
  */
    noDataHTML(_?: string | ((viz: Viz) => string)): this | string | ((viz: Viz) => string);
    /**
       Toggles the visibility of the status message that is displayed when no data is supplied to the visualization.
  */
    noDataMessage(_?: boolean): this | boolean;
    /**
        If using scroll or visibility detection, this method allow a custom override of the element to which the scroll detection function gets attached.
  */
    scrollContainer(_?: string | HTMLElement | Window): this | string | HTMLElement | Window;
    /**
        The SVG container element as a d3 selector or DOM element. Defaults to `undefined`.
  */
    select(_?: string | HTMLElement): this | ReturnType<typeof select>;
    /**
        Changes the primary shape used to represent each data point in a visualization. Not all visualizations support changing shapes, this method can be provided the String name of a D3plus shape class (for example, "Rect" or "Circle"), or an accessor Function that returns the String class name to be used for each individual data point.
  */
    shape(_?: string | ((d: DataPoint, i: number) => string)): this | string | ((d: DataPoint, i: number) => string);
    /**
        Configuration object with key/value pairs applied as method calls on each shape.
  */
    shapeConfig(_?: Record<string, unknown>): this | Record<string, unknown>;
    /**
        Accessor function or string for the visualization's subtitle.
  */
    subtitle(_?: string | ((data: DataPoint[]) => string)): this | string | ((data: DataPoint[]) => string);
    /**
        Configuration object for the subtitle.
  */
    subtitleConfig(_?: Record<string, unknown>): this | Record<string, unknown>;
    /**
        Tells the subtitle whether or not to use the internal padding defined by the visualization in it's positioning. For example, d3plus-plot will add padding on the left so that the subtitle appears centered above the x-axis. By default, this padding is only applied on screens larger than 600 pixels wide.
  */
    subtitlePadding(_?: boolean | (() => boolean)): this | boolean | (() => boolean);
    /**
        The description text for the SVG `<desc>` element, used for accessibility.
  */
    svgDesc(_?: string): this | string;
    /**
        The title text for the SVG `<title>` element, used for accessibility.
  */
    svgTitle(_?: string): this | string;
    /**
        The threshold value for bucketing small data points together.
  */
    threshold(_?: number | ((data: DataPoint[]) => number)): this | number | ((data: DataPoint[]) => number);
    /**
        Accessor for the value used in the threshold algorithm.
      @param key The data key used to group values for thresholding.
  */
    thresholdKey(key?: string | ((d: DataPoint, i: number) => DataPoint[keyof DataPoint])): this | string | ((d: DataPoint, i: number) => DataPoint[keyof DataPoint]);
    /**
        The label displayed for bucketed threshold items.
  */
    thresholdName(_?: string | ((d: DataPoint, i: number) => string)): this | string | ((d: DataPoint, i: number) => string);
    /**
        Accessor function or string key for the time dimension of each data point.
  */
    time(_?: string | ((d: DataPoint, i: number) => DataPoint[keyof DataPoint]) | false): this | string | ((d: DataPoint, i: number) => DataPoint[keyof DataPoint]) | false;
    /**
        A filter function that limits which time periods are shown.
  */
    timeFilter(_?: ((d: DataPoint, i: number) => boolean) | false): this | ((d: DataPoint, i: number) => boolean) | false;
    /**
        Whether to display the timeline.
  */
    timeline(_?: boolean): this | boolean;
    /**
        Configuration object for the timeline.
  */
    timelineConfig(_?: Record<string, unknown>): this | Record<string, unknown>;
    /**
        The starting time or range for the timeline. Can be a single Date/String, or an Array of 2 values representing the min and max.
  */
    timelineDefault(_?: Date | string | (Date | string)[]): this | Date[];
    /**
        Tells the timeline whether or not to use the internal padding defined by the visualization in it's positioning. For example, d3plus-plot will add padding on the left so that the timeline appears centered underneath the x-axis. By default, this padding is only applied on screens larger than 600 pixels wide.
  */
    timelinePadding(_?: boolean | (() => boolean)): this | boolean | (() => boolean);
    /**
        Accessor function or string for the visualization's title.
  */
    title(_?: string | ((data: DataPoint[]) => string)): this | string | ((data: DataPoint[]) => string);
    /**
        Configuration object for the title.
  */
    titleConfig(_?: Record<string, unknown>): this | Record<string, unknown>;
    /**
        Tells the title whether or not to use the internal padding defined by the visualization in it's positioning. For example, d3plus-plot will add padding on the left so that the title appears centered above the x-axis. By default, this padding is only applied on screens larger than 600 pixels wide.
  */
    titlePadding(_?: boolean | (() => boolean)): this | boolean | (() => boolean);
    /**
        Whether to display tooltips on hover.
  */
    tooltip(_?: boolean | ((d: DataPoint, i: number) => boolean)): this | boolean | ((d: DataPoint, i: number) => boolean);
    /**
        Configuration object for the tooltip.
  */
    tooltipConfig(_?: Record<string, unknown>): this | Record<string, unknown>;
    /**
        Accessor function or string key for the total value displayed in the visualization.
  */
    total(_?: boolean | string | ((d: DataPoint, i: number) => number)): this | boolean | string | ((d: DataPoint, i: number) => number);
    /**
        Configuration object for the total bar.
  */
    totalConfig(_?: Record<string, unknown>): this | Record<string, unknown>;
    /**
        Formatter function for the value in the total bar.
  */
    totalFormat(_?: (d: number) => string): this | ((d: number) => string);
    /**
        Tells the total whether or not to use the internal padding defined by the visualization in it's positioning. For example, d3plus-plot will add padding on the left so that the total appears centered above the x-axis. By default, this padding is only applied on screens larger than 600 pixels wide.
  */
    totalPadding(_?: boolean | (() => boolean)): this | boolean | (() => boolean);
    /**
        The overall width of the visualization in pixels.
  */
    width(_?: number): this | number;
    /**
        Toggles the ability to zoom/pan the visualization. Certain parameters for zooming are required to be hooked up on a visualization by visualization basis.
  */
    zoom(_?: boolean): this | boolean;
    /**
        The pixel stroke-width of the zoom brush area.
  */
    zoomBrushHandleSize(_?: number): this | number;
    /**
        An object containing CSS key/value pairs that is used to style the outer handle area of the zoom brush. Passing `false` will remove all default styling.
  */
    zoomBrushHandleStyle(_?: Record<string, unknown> | false): this | Record<string, unknown> | false;
    /**
        An object containing CSS key/value pairs that is used to style the inner selection area of the zoom brush. Passing `false` will remove all default styling.
  */
    zoomBrushSelectionStyle(_?: Record<string, unknown> | false): this | Record<string, unknown> | false;
    /**
        An object containing CSS key/value pairs that is used to style each zoom control button (`.zoom-in`, `.zoom-out`, `.zoom-reset`, and `.zoom-brush`). Passing `false` will remove all default styling.
  */
    zoomControlStyle(_?: Record<string, unknown> | false): this | Record<string, unknown> | false;
    /**
        An object containing CSS key/value pairs that is used to style each zoom control button when active (`.zoom-in`, `.zoom-out`, `.zoom-reset`, and `.zoom-brush`). Passing `false` will remove all default styling.
  */
    zoomControlStyleActive(_?: Record<string, unknown> | false): this | Record<string, unknown> | false;
    /**
        An object containing CSS key/value pairs that is used to style each zoom control button on hover (`.zoom-in`, `.zoom-out`, `.zoom-reset`, and `.zoom-brush`). Passing `false` will remove all default styling.
  */
    zoomControlStyleHover(_?: Record<string, unknown> | false): this | Record<string, unknown> | false;
    /**
        The multiplier that is used in with the control buttons when zooming in and out.
  */
    zoomFactor(_?: number): this | number;
    /**
        The max zoom scale.
  */
    zoomMax(_?: number): this | number;
    /**
        Toggles panning.
  */
    zoomPan(_?: boolean): this | boolean;
    /**
        A pixel value to be used to pad all sides of a zoomed area.
  */
    zoomPadding(_?: number): this | number;
    /**
        Toggles scroll zooming.
  */
    zoomScroll(_?: boolean): this | boolean;
}
export {};
