/**
 * The `d3` global exposed to widget script blocks (spec: "Available globals" —
 * "D3 (bundled, tree-shaken to core + scale + array)"). Bundled directly
 * (unlike Vega) since d3-scale is already a hard dependency of the accessor
 * expression language (scale()).
 */
import * as d3Scale from "d3-scale";
import * as d3Array from "d3-array";
export declare const d3: {
    min(iterable: Iterable<string>): string | undefined;
    min<T extends d3Array.Numeric>(iterable: Iterable<T>): T | undefined;
    min<T>(iterable: Iterable<T>, accessor: (datum: T, index: number, array: Iterable<T>) => string | undefined | null): string | undefined;
    min<T, U extends d3Array.Numeric>(iterable: Iterable<T>, accessor: (datum: T, index: number, array: Iterable<T>) => U | undefined | null): U | undefined;
    minIndex(iterable: Iterable<unknown>): number;
    minIndex<TDatum>(iterable: Iterable<TDatum>, accessor: (datum: TDatum, index: number, array: Iterable<TDatum>) => unknown): number;
    minIndex(iterable: Iterable<unknown>): number;
    max(iterable: Iterable<string>): string | undefined;
    max<T extends d3Array.Numeric>(iterable: Iterable<T>): T | undefined;
    max<T>(iterable: Iterable<T>, accessor: (datum: T, index: number, array: Iterable<T>) => string | undefined | null): string | undefined;
    max<T, U extends d3Array.Numeric>(iterable: Iterable<T>, accessor: (datum: T, index: number, array: Iterable<T>) => U | undefined | null): U | undefined;
    maxIndex(iterable: Iterable<unknown>): number;
    maxIndex<TDatum>(iterable: Iterable<TDatum>, accessor: (datum: TDatum, index: number, array: Iterable<TDatum>) => unknown): number;
    extent(iterable: Iterable<string>): [string, string] | [undefined, undefined];
    extent<T extends d3Array.Numeric>(iterable: Iterable<T>): [T, T] | [undefined, undefined];
    extent<T>(iterable: Iterable<T>, accessor: (datum: T, index: number, array: Iterable<T>) => string | undefined | null): [string, string] | [undefined, undefined];
    extent<T, U extends d3Array.Numeric>(iterable: Iterable<T>, accessor: (datum: T, index: number, array: Iterable<T>) => U | undefined | null): [U, U] | [undefined, undefined];
    mode(iterable: Iterable<d3Array.Numeric | undefined | null>): number;
    mode<T>(iterable: Iterable<T>, accessor: (datum: T, index: number, array: Iterable<T>) => number | undefined | null): number;
    sum(iterable: Iterable<d3Array.Numeric | undefined | null>): number;
    sum<T>(iterable: Iterable<T>, accessor: (datum: T, index: number, array: Iterable<T>) => number | undefined | null): number;
    mean(iterable: Iterable<d3Array.Numeric | undefined | null>): number | undefined;
    mean<T>(iterable: Iterable<T>, accessor: (datum: T, index: number, array: Iterable<T>) => number | undefined | null): number | undefined;
    median(iterable: Iterable<d3Array.Numeric | undefined | null>): number | undefined;
    median<T>(iterable: Iterable<T>, accessor: (element: T, i: number, array: Iterable<T>) => number | undefined | null): number | undefined;
    medianIndex(iterable: Iterable<d3Array.Numeric | undefined | null>): number;
    medianIndex<T>(iterable: Iterable<T>, accessor: (element: T, i: number, array: Iterable<T>) => number | undefined | null): number;
    cumsum(iterable: Iterable<d3Array.Numeric | undefined | null>): Float64Array;
    cumsum<T>(iterable: Iterable<T>, accessor: (element: T, i: number, array: Iterable<T>) => number | undefined | null): Float64Array;
    quantile(iterable: Iterable<d3Array.Numeric | undefined | null>, p: number): number | undefined;
    quantile<T>(iterable: Iterable<T>, p: number, accessor: (element: T, i: number, array: Iterable<T>) => number | undefined | null): number | undefined;
    quantileIndex(iterable: Iterable<d3Array.Numeric | undefined | null>, p: number): number;
    quantileIndex<T>(iterable: Iterable<T>, p: number, accessor: (element: T, i: number, array: Iterable<T>) => number | undefined | null): number;
    quantileSorted(array: Array<d3Array.Numeric | undefined | null>, p: number): number | undefined;
    quantileSorted<T>(array: T[], p: number, accessor: (element: T, i: number, array: T[]) => number | undefined | null): number | undefined;
    rank(iterable: Iterable<d3Array.Numeric | undefined | null>): Float64Array;
    rank<T>(iterable: Iterable<T>, accessorOrComparator: ((datum: T, index: number, array: Iterable<T>) => number | undefined | null) | ((a: T, b: T) => number | undefined | null)): Float64Array;
    variance(iterable: Iterable<d3Array.Numeric | undefined | null>): number | undefined;
    variance<T>(iterable: Iterable<T>, accessor: (datum: T, index: number, array: Iterable<T>) => number | undefined | null): number | undefined;
    deviation(iterable: Iterable<d3Array.Numeric | undefined | null>): number | undefined;
    deviation<T>(iterable: Iterable<T>, accessor: (datum: T, index: number, array: Iterable<T>) => number | undefined | null): number | undefined;
    fsum(values: Iterable<d3Array.Numeric | undefined | null>): number;
    fsum<T>(values: Iterable<T>, accessor: (datum: T, index: number, array: Iterable<T>) => number | undefined | null): number;
    fcumsum(values: Iterable<d3Array.Numeric | undefined | null>): Float64Array;
    fcumsum<T>(values: Iterable<T>, accessor: (datum: T, index: number, array: Iterable<T>) => number | undefined | null): Float64Array;
    least<T>(iterable: Iterable<T>, comparator?: (a: T, b: T) => number): T | undefined;
    least<T>(iterable: Iterable<T>, accessor: (a: T) => unknown): T | undefined;
    leastIndex(iterable: Iterable<unknown>): number | undefined;
    leastIndex<T>(iterable: Iterable<T>, comparator: (a: T, b: T) => number): number | undefined;
    leastIndex<T>(iterable: Iterable<T>, accessor: (a: T) => unknown): number | undefined;
    greatest<T>(iterable: Iterable<T>, comparator?: (a: T, b: T) => number): T | undefined;
    greatest<T>(iterable: Iterable<T>, accessor: (a: T) => unknown): T | undefined;
    greatestIndex(iterable: Iterable<unknown>): number | undefined;
    greatestIndex<T>(iterable: Iterable<T>, comparator: (a: T, b: T) => number): number | undefined;
    greatestIndex<T>(iterable: Iterable<T>, accessor: (a: T) => unknown): number | undefined;
    bisectLeft(array: ArrayLike<number>, x: number, lo?: number, hi?: number): number;
    bisectLeft(array: ArrayLike<string>, x: string, lo?: number, hi?: number): number;
    bisectLeft(array: ArrayLike<Date>, x: Date, lo?: number, hi?: number): number;
    bisectRight(array: ArrayLike<number>, x: number, lo?: number, hi?: number): number;
    bisectRight(array: ArrayLike<string>, x: string, lo?: number, hi?: number): number;
    bisectRight(array: ArrayLike<Date>, x: Date, lo?: number, hi?: number): number;
    bisectCenter(array: ArrayLike<number>, x: number, lo?: number, hi?: number): number;
    bisectCenter(array: ArrayLike<string>, x: string, lo?: number, hi?: number): number;
    bisectCenter(array: ArrayLike<Date>, x: Date, lo?: number, hi?: number): number;
    bisector<T, U>(comparator: (a: T, b: U) => number): d3Array.Bisector<T, U>;
    bisector<T, U>(accessor: (x: T) => U): d3Array.Bisector<T, U>;
    quickselect<T>(array: ArrayLike<T>, k: number, left?: number, right?: number, compare?: (a: d3Array.Primitive | undefined, b: d3Array.Primitive | undefined) => number): T[];
    ascending(a: d3Array.Primitive | undefined, b: d3Array.Primitive | undefined): number;
    descending(a: d3Array.Primitive | undefined, b: d3Array.Primitive | undefined): number;
    group<TObject, TKeys extends unknown[]>(iterable: Iterable<TObject>, ...keys: { [Index in keyof TKeys]: (value: TObject, index: number, values: TObject[]) => TKeys[Index]; }): d3Array.NestedInternMap<TObject, TObject[], TKeys>;
    groups<TObject, TKeys extends unknown[]>(iterable: Iterable<TObject>, ...keys: { [Index in keyof TKeys]: (value: TObject, index: number, values: TObject[]) => TKeys[Index]; }): d3Array.NestedArray<TObject, TObject[], TKeys>;
    flatGroup<TObject, TKeys extends unknown[]>(iterable: Iterable<TObject>, ...keys: { [Index in keyof TKeys]: (value: TObject, index: number, values: TObject[]) => TKeys[Index]; }): Array<[...TKeys, TObject[]]>;
    index<TObject, TKeys extends unknown[]>(iterable: Iterable<TObject>, ...keys: { [Index in keyof TKeys]: (value: TObject, index: number, values: TObject[]) => TKeys[Index]; }): d3Array.NestedInternMap<TObject, TObject, TKeys>;
    indexes<TObject, TKeys extends unknown[]>(iterable: Iterable<TObject>, ...keys: { [Index in keyof TKeys]: (value: TObject, index: number, values: TObject[]) => TKeys[Index]; }): d3Array.NestedArray<TObject, TObject, TKeys>;
    rollup<TObject, TReduce, TKeys extends unknown[]>(iterable: Iterable<TObject>, reduce: (values: TObject[]) => TReduce, ...keys: { [Index in keyof TKeys]: (value: TObject, index: number, values: TObject[]) => TKeys[Index]; }): d3Array.NestedInternMap<TObject, TReduce, TKeys>;
    rollups<TObject, TReduce, TKeys extends unknown[]>(iterable: Iterable<TObject>, reduce: (values: TObject[]) => TReduce, ...keys: { [Index in keyof TKeys]: (value: TObject, index: number, values: TObject[]) => TKeys[Index]; }): d3Array.NestedArray<TObject, TReduce, TKeys>;
    flatRollup<TObject, TReduce, TKeys extends unknown[]>(iterable: Iterable<TObject>, reduce: (values: TObject[]) => TReduce, ...keys: { [Index in keyof TKeys]: (value: TObject, index: number, values: TObject[]) => TKeys[Index]; }): Array<[...TKeys, TReduce]>;
    groupSort<TObject, TKey>(iterable: Iterable<TObject>, comparator: (a: TObject[], b: TObject[]) => number, key: (value: TObject) => TKey): TKey[];
    groupSort<TObject, TKey>(iterable: Iterable<TObject>, accessor: (value: TObject[]) => unknown, key: (value: TObject) => TKey): TKey[];
    count(iterable: Iterable<unknown>): number;
    count<TObject>(iterable: Iterable<TObject>, accessor: (a: TObject, b: TObject) => number | null | undefined): number;
    cross<T extends unknown[]>(...iterables: { [K in keyof T]: Iterable<T[K]>; }): T[];
    cross<T extends unknown[], U>(...args: [...iterables: { [K in keyof T]: Iterable<T[K]>; }, reducer: (...values: T) => U]): U[];
    merge<T>(iterables: Iterable<Iterable<T>>): T[];
    pairs<T>(iterable: Iterable<T>): Array<[T, T]>;
    pairs<T, U>(iterable: Iterable<T>, reducer: (a: T, b: T) => U): U[];
    permute<T>(source: {
        [key: number]: T;
    }, keys: Iterable<number>): T[];
    permute<T, K extends keyof T>(source: T, keys: Iterable<K>): Array<T[K]>;
    shuffle<T>(array: T[], lo?: number, hi?: number): T[];
    shuffle(array: Int8Array, lo?: number, hi?: number): Int8Array;
    shuffle(array: Uint8Array, lo?: number, hi?: number): Uint8Array;
    shuffle(array: Uint8ClampedArray, lo?: number, hi?: number): Uint8ClampedArray;
    shuffle(array: Int16Array, lo?: number, hi?: number): Int16Array;
    shuffle(array: Uint16Array, lo?: number, hi?: number): Uint16Array;
    shuffle(array: Int32Array, lo?: number, hi?: number): Int32Array;
    shuffle(array: Uint32Array, lo?: number, hi?: number): Uint32Array;
    shuffle(array: Float32Array, lo?: number, hi?: number): Float32Array;
    shuffle(array: Float64Array, lo?: number, hi?: number): Float64Array;
    shuffler(random: () => number): typeof d3Array.shuffle;
    ticks(start: number, stop: number, count: number): number[];
    tickIncrement(start: number, stop: number, count: number): number;
    tickStep(start: number, stop: number, count: number): number;
    nice(start: number, stop: number, count: number): [number, number];
    range(stop: number): number[];
    range(start: number, stop: number, step?: number): number[];
    transpose<T>(matrix: ArrayLike<ArrayLike<T>>): T[][];
    zip<T>(...arrays: Array<ArrayLike<T>>): T[][];
    blur(data: ArrayLike<number>, radius: number): ArrayLike<number>;
    blur2(data: d3Array.Matrix, rx: number, ry?: number): d3Array.Matrix;
    blurImage(imageData: ImageData, rx: number, ry?: number): ImageData;
    every<T>(iterable: Iterable<T>, test: (value: T, index: number, iterable: Iterable<T>) => unknown): boolean;
    some<T>(iterable: Iterable<T>, test: (value: T, index: number, iterable: Iterable<T>) => unknown): boolean;
    filter<T>(iterable: Iterable<T>, test: (value: T, index: number, iterable: Iterable<T>) => unknown): T[];
    map<T, U>(iterable: Iterable<T>, mapper: (value: T, index: number, iterable: Iterable<T>) => U): U[];
    reduce<T>(iterable: Iterable<T>, reducer: (previousValue: T, currentValue: T, currentIndex: number, iterable: Iterable<T>) => T, initialValue?: T): T;
    reduce<T, U>(iterable: Iterable<T>, reducer: (previousValue: U, currentValue: T, currentIndex: number, iterable: Iterable<T>) => U, initialValue: U): U;
    reverse<T>(iterable: Iterable<T>): T[];
    sort<T>(iterable: Iterable<T>, comparator?: (a: T, b: T) => number): T[];
    sort<T>(iterable: Iterable<T>, ...accessors: Array<(a: T) => unknown>): T[];
    difference<T>(iterable: Iterable<T>, ...others: Array<Iterable<T>>): d3Array.InternSet<T>;
    union<T>(...iterables: Array<Iterable<T>>): d3Array.InternSet<T>;
    intersection<T>(...iterables: Array<Iterable<T>>): d3Array.InternSet<T>;
    superset<T>(a: Iterable<T>, b: Iterable<T>): boolean;
    subset<T>(a: Iterable<T>, b: Iterable<T>): boolean;
    disjoint<T>(a: Iterable<T>, b: Iterable<T>): boolean;
    histogram(): d3Array.HistogramGeneratorNumber<number, number>;
    histogram<Datum, Value extends number | undefined>(): d3Array.HistogramGeneratorNumber<Datum, Value>;
    histogram<Datum, Value extends Date | undefined>(): d3Array.HistogramGeneratorDate<Datum, Value>;
    bin(): d3Array.HistogramGeneratorNumber<number, number>;
    bin<Datum, Value extends number | undefined>(): d3Array.HistogramGeneratorNumber<Datum, Value>;
    bin<Datum, Value extends Date | undefined>(): d3Array.HistogramGeneratorDate<Datum, Value>;
    thresholdFreedmanDiaconis(values: ArrayLike<number | undefined>, min: number, max: number): number;
    thresholdScott(values: ArrayLike<number | undefined>, min: number, max: number): number;
    thresholdSturges(values: ArrayLike<number | undefined>): number;
    Adder: typeof d3Array.Adder;
    bisect: typeof d3Array.bisectRight;
    InternMap: typeof d3Array.InternMap;
    InternSet: typeof d3Array.InternSet;
    tickFormat(start: number, stop: number, count: number, specifier?: string): (d: d3Scale.NumberValue) => string;
    scaleLinear<Range = number, Output = Range, Unknown = never>(range?: Iterable<Range>): d3Scale.ScaleLinear<Range, Output, Unknown>;
    scaleLinear<Range, Output = Range, Unknown = never>(domain: Iterable<d3Scale.NumberValue>, range: Iterable<Range>): d3Scale.ScaleLinear<Range, Output, Unknown>;
    scalePow<Range = number, Output = Range, Unknown = never>(range?: Iterable<Range>): d3Scale.ScalePower<Range, Output, Unknown>;
    scalePow<Range, Output = Range, Unknown = never>(domain: Iterable<d3Scale.NumberValue>, range: Iterable<Range>): d3Scale.ScalePower<Range, Output, Unknown>;
    scaleSqrt<Range = number, Output = Range, Unknown = never>(range?: Iterable<Range>): d3Scale.ScalePower<Range, Output, Unknown>;
    scaleSqrt<Range, Output = Range, Unknown = never>(domain: Iterable<d3Scale.NumberValue>, range: Iterable<Range>): d3Scale.ScalePower<Range, Output, Unknown>;
    scaleLog<Range = number, Output = Range, Unknown = never>(range?: Iterable<Range>): d3Scale.ScaleLogarithmic<Range, Output, Unknown>;
    scaleLog<Range, Output = Range, Unknown = never>(domain: Iterable<d3Scale.NumberValue>, range: Iterable<Range>): d3Scale.ScaleLogarithmic<Range, Output, Unknown>;
    scaleSymlog<Range = number, Output = Range, Unknown = never>(range?: Iterable<Range>): d3Scale.ScaleSymLog<Range, Output, Unknown>;
    scaleSymlog<Range, Output = Range, Unknown = never>(domain: Iterable<d3Scale.NumberValue>, range: Iterable<Range>): d3Scale.ScaleSymLog<Range, Output, Unknown>;
    scaleIdentity<Unknown = never>(range?: Iterable<d3Scale.NumberValue>): d3Scale.ScaleIdentity<Unknown>;
    scaleRadial<Range = number, Unknown = never>(range?: Iterable<Range>): d3Scale.ScaleRadial<Range, Range, Unknown>;
    scaleRadial<Range, Unknown = never>(domain: Iterable<d3Scale.NumberValue>, range: Iterable<Range>): d3Scale.ScaleRadial<Range, Range, Unknown>;
    scaleTime<Range = number, Output = Range, Unknown = never>(range?: Iterable<Range>): d3Scale.ScaleTime<Range, Output, Unknown>;
    scaleTime<Range, Output = Range, Unknown = never>(domain: Iterable<Date | d3Scale.NumberValue>, range: Iterable<Range>): d3Scale.ScaleTime<Range, Output, Unknown>;
    scaleUtc<Range = number, Output = Range, Unknown = never>(range?: Iterable<Range>): d3Scale.ScaleTime<Range, Output, Unknown>;
    scaleUtc<Range, Output = Range, Unknown = never>(domain: Iterable<d3Scale.NumberValue>, range: Iterable<Range>): d3Scale.ScaleTime<Range, Output, Unknown>;
    scaleSequential<Output = number, Unknown = never>(interpolator?: ((t: number) => Output) | Iterable<Output>): d3Scale.ScaleSequential<Output, Unknown>;
    scaleSequential<Output, Unknown = never>(domain: Iterable<d3Scale.NumberValue>, interpolator: ((t: number) => Output) | Iterable<Output>): d3Scale.ScaleSequential<Output, Unknown>;
    scaleSequentialLog<Output = number, Unknown = never>(interpolator?: (t: number) => Output): d3Scale.ScaleSequential<Output, Unknown>;
    scaleSequentialLog<Output, Unknown = never>(domain: Iterable<d3Scale.NumberValue>, interpolator: (t: number) => Output): d3Scale.ScaleSequential<Output, Unknown>;
    scaleSequentialPow<Output = number, Unknown = never>(interpolator?: (t: number) => Output): d3Scale.ScaleSequential<Output, Unknown>;
    scaleSequentialPow<Output, Unknown = never>(domain: Iterable<d3Scale.NumberValue>, interpolator: (t: number) => Output): d3Scale.ScaleSequential<Output, Unknown>;
    scaleSequentialSqrt<Output = number, Unknown = never>(interpolator?: (t: number) => Output): d3Scale.ScaleSequential<Output, Unknown>;
    scaleSequentialSqrt<Output, Unknown = never>(domain: Iterable<d3Scale.NumberValue>, interpolator: (t: number) => Output): d3Scale.ScaleSequential<Output, Unknown>;
    scaleSequentialSymlog<Output = number, Unknown = never>(interpolator?: (t: number) => Output): d3Scale.ScaleSequential<Output, Unknown>;
    scaleSequentialSymlog<Output, Unknown = never>(domain: Iterable<d3Scale.NumberValue>, interpolator: (t: number) => Output): d3Scale.ScaleSequential<Output, Unknown>;
    scaleSequentialQuantile<Output = number, Unknown = never>(interpolator?: (t: number) => Output): d3Scale.ScaleSequentialQuantile<Output, Unknown>;
    scaleSequentialQuantile<Output, Unknown = never>(domain: Iterable<d3Scale.NumberValue>, interpolator: (t: number) => Output): d3Scale.ScaleSequentialQuantile<Output, Unknown>;
    scaleDiverging<Output = number, Unknown = never>(interpolator?: ((t: number) => Output) | Iterable<Output>): d3Scale.ScaleDiverging<Output, Unknown>;
    scaleDiverging<Output, Unknown = never>(domain: Iterable<d3Scale.NumberValue>, interpolator: ((t: number) => Output) | Iterable<Output>): d3Scale.ScaleDiverging<Output, Unknown>;
    scaleDivergingLog<Output = number, Unknown = never>(interpolator?: (t: number) => Output): d3Scale.ScaleDiverging<Output, Unknown>;
    scaleDivergingLog<Output, Unknown = never>(domain: Iterable<d3Scale.NumberValue>, interpolator: (t: number) => Output): d3Scale.ScaleDiverging<Output, Unknown>;
    scaleDivergingPow<Output = number, Unknown = never>(interpolator?: (t: number) => Output): d3Scale.ScaleDiverging<Output, Unknown>;
    scaleDivergingPow<Output, Unknown = never>(domain: Iterable<d3Scale.NumberValue>, interpolator: (t: number) => Output): d3Scale.ScaleDiverging<Output, Unknown>;
    scaleDivergingSqrt<Output = number, Unknown = never>(interpolator?: (t: number) => Output): d3Scale.ScaleDiverging<Output, Unknown>;
    scaleDivergingSqrt<Output, Unknown = never>(domain: Iterable<d3Scale.NumberValue>, interpolator: (t: number) => Output): d3Scale.ScaleDiverging<Output, Unknown>;
    scaleDivergingSymlog<Output = number, Unknown = never>(interpolator?: (t: number) => Output): d3Scale.ScaleDiverging<Output, Unknown>;
    scaleDivergingSymlog<Output, Unknown = never>(domain: Iterable<d3Scale.NumberValue>, interpolator: (t: number) => Output): d3Scale.ScaleDiverging<Output, Unknown>;
    scaleQuantize<Range = number, Unknown = never>(range?: Iterable<Range>): d3Scale.ScaleQuantize<Range, Unknown>;
    scaleQuantize<Range, Unknown = never>(domain: Iterable<d3Scale.NumberValue>, range: Iterable<Range>): d3Scale.ScaleQuantize<Range, Unknown>;
    scaleQuantile<Range = number, Unknown = never>(range?: Iterable<Range>): d3Scale.ScaleQuantile<Range, Unknown>;
    scaleQuantile<Range, Unknown = never>(domain: Iterable<d3Scale.NumberValue | null | undefined>, range: Iterable<Range>): d3Scale.ScaleQuantile<Range, Unknown>;
    scaleThreshold<Domain extends number | string | Date = number, Range = number, Unknown = never>(range?: Iterable<Range>): d3Scale.ScaleThreshold<Domain, Range, Unknown>;
    scaleThreshold<Domain extends number | string | Date, Range, Unknown = never>(domain: Iterable<Domain>, range: Iterable<Range>): d3Scale.ScaleThreshold<Domain, Range, Unknown>;
    scaleOrdinal<Range>(range?: Iterable<Range>): d3Scale.ScaleOrdinal<string, Range>;
    scaleOrdinal<Domain extends {
        toString(): string;
    }, Range, Unknown = never>(range?: Iterable<Range>): d3Scale.ScaleOrdinal<Domain, Range, Unknown>;
    scaleOrdinal<Domain extends {
        toString(): string;
    }, Range, Unknown = never>(domain: Iterable<Domain>, range: Iterable<Range>): d3Scale.ScaleOrdinal<Domain, Range, Unknown>;
    scaleBand<Domain extends {
        toString(): string;
    } = string>(range?: Iterable<d3Scale.NumberValue>): d3Scale.ScaleBand<Domain>;
    scaleBand<Domain extends {
        toString(): string;
    }>(domain: Iterable<Domain>, range: Iterable<d3Scale.NumberValue>): d3Scale.ScaleBand<Domain>;
    scalePoint<Domain extends {
        toString(): string;
    } = string>(range?: Iterable<d3Scale.NumberValue>): d3Scale.ScalePoint<Domain>;
    scalePoint<Domain extends {
        toString(): string;
    }>(domain: Iterable<Domain>, range: Iterable<d3Scale.NumberValue>): d3Scale.ScalePoint<Domain>;
    scaleImplicit: {
        name: "implicit";
    };
};