@mathstack/viz 0.0.1-beta.0

package/lib/geographies/config/geographies-builder.d.ts

@@ -0,0 +1,80 @@
+import { ExtendedFeature, ExtendedFeatureCollection, ExtendedGeometryCollection, GeoGeometryObjects, GeoProjection } from 'd3';
+import { GeoJsonProperties, Geometry, MultiPolygon, Polygon } from 'geojson';
+import { GeographiesFeature } from '../geographies-feature';
+import { GeographiesConfig } from './geographies-config';
+import { GeographiesAttributeDataLayerBuilder } from './layers/attribute-data-layer/attribute-data-layer-builder';
+import { GeographiesGeojsonPropertiesLayerBuilder } from './layers/geojson-properties-layer/geojson-properties-layer-builder';
+import * as i0 from "@angular/core";
+/** Builds a configuration object for a GeographiesComponent.
+ *
+ * Must be added to a providers array in or above the component that consumes it if it is injected via the constructor. (e.g. `providers: [VicGeographiesBuilder]` in the component decorator)
+ *
+ * The first generic parameter, Datum, is the type of the attribute data that will be used to shade the map areas.
+ *
+ * The second generic parameter, TProperties, is the type of the properties object that is associated with the GeoJson.
+ *
+ * The optional third generic parameter, TGeometry, is the type of the geometry object that is associated with the GeoJson. It defaults to MultiPolygon | Polygon if not provided.
+ */
+export declare class VicGeographiesConfigBuilder<Datum, TProperties extends GeoJsonProperties, TGeometry extends Geometry = MultiPolygon | Polygon> {
+    private _boundary;
+    protected _class: (d: Datum) => string;
+    private _featureIndexAccessor;
+    private _mixBlendMode;
+    private _projection;
+    private attributeDataBuilder;
+    geojsonBuilders: GeographiesGeojsonPropertiesLayerBuilder<TProperties, TGeometry>[];
+    constructor();
+    /**
+     * REQUIRED. Sets a feature or geometry object or collection that defines the extents of the map to be drawn.
+     *
+     * Used for scaling the map.
+     */
+    boundary(boundary: ExtendedFeature | ExtendedFeatureCollection | GeoGeometryObjects | ExtendedGeometryCollection): this;
+    /**
+     * REQUIRED. Sets a function that derives an identifying string from the GeoJson feature.
+     */
+    featureIndexAccessor(accessor: (d: GeographiesFeature<TProperties, TGeometry>) => string): this;
+    /**
+     * OPTIONAL. Creates a configuration object for a layer that will be drawn and styled using solely the properties on a geojson feature.
+     *
+     * This might be used for to draw the outline of a country, for example. It could also shade the area of a country based on a property of the geojson feature.
+     *
+     * If events are enabled, the geojson properties will be used to populate the tooltip.
+     *
+     * This method can be called multiple times to create multiple layers. If this method is called with null, all layers will be removed. (Though subsequent calls can be made to add new layers.)
+     *
+     * The order in which layers are created will determine the order in which they are drawn.
+     *
+     * Multiple layers can be used to draw different parts of the map with different styles.
+     */
+    geojsonPropertiesLayer(geojson: null): this;
+    geojsonPropertiesLayer(geojson: (geojson: GeographiesGeojsonPropertiesLayerBuilder<TProperties, TGeometry>) => void): this;
+    /**
+     * OPTIONAL. Creates a configuration object for a layer that will be drawn from geojson and styled using attribute data.
+     *
+     * This object provides various methods for transforming data values into colors / color bins.
+     *
+     * This method can be called only once.
+     */
+    attributeDataLayer(attributeData: null): this;
+    attributeDataLayer(attributeData: (attributeData: GeographiesAttributeDataLayerBuilder<Datum, TProperties, TGeometry>) => void): this;
+    /**
+     * OPTIONAL. Sets the mix-blend-mode of the marks.
+     *
+     * @default 'normal'
+     */
+    mixBlendMode(mixBlendMode: string): this;
+    /**
+     * OPTIONAL. Sets a projection function that maps a point in the map's coordinate space to a point in the SVG's coordinate space.
+     *
+     * @default d3.geoAlbersUsa()
+     */
+    projection(projection: GeoProjection): this;
+    /**
+     * REQUIRED. Builds the GeographiesConfig object.
+     */
+    getConfig(): GeographiesConfig<Datum, TProperties, TGeometry>;
+    private validateBuilder;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VicGeographiesConfigBuilder<any, any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VicGeographiesConfigBuilder<any, any, any>>;
+}

package/lib/geographies/config/geographies-config.d.ts

@@ -0,0 +1,19 @@
+import { ExtendedFeature, ExtendedFeatureCollection, ExtendedGeometryCollection, GeoGeometryObjects, GeoProjection } from 'd3';
+import { GeoJsonProperties, GeometryObject as Geometry, MultiPolygon, Polygon } from 'geojson';
+import { MarksConfig } from '../../marks';
+import { GeographiesFeature } from '../geographies-feature';
+import { GeographiesOptions } from './geographies-options';
+import { GeographiesAttributeDataLayer } from './layers/attribute-data-layer/attribute-data-layer';
+import { GeographiesGeojsonPropertiesLayer } from './layers/geojson-properties-layer/geojson-properties-layer';
+export declare class GeographiesConfig<Datum, TProperties extends GeoJsonProperties, TGeometry extends Geometry = MultiPolygon | Polygon> extends MarksConfig implements GeographiesOptions<Datum, TProperties, TGeometry> {
+    readonly boundary: ExtendedFeature | ExtendedFeatureCollection | GeoGeometryObjects | ExtendedGeometryCollection;
+    readonly attributeDataLayer: GeographiesAttributeDataLayer<Datum, TProperties, TGeometry>;
+    featureIndexAccessor: (d: GeographiesFeature<TProperties, TGeometry>) => string;
+    layers: (GeographiesAttributeDataLayer<Datum, TProperties, TGeometry> | GeographiesGeojsonPropertiesLayer<TProperties, TGeometry>)[];
+    readonly geojsonPropertiesLayers: GeographiesGeojsonPropertiesLayer<TProperties, TGeometry>[];
+    readonly projection: GeoProjection;
+    constructor(options: GeographiesOptions<Datum, TProperties, TGeometry>);
+    protected initPropertiesFromData(): void;
+    private setLayers;
+    private setLayerFeatureIndexAccessors;
+}

package/lib/geographies/config/geographies-options.d.ts

@@ -0,0 +1,13 @@
+import { ExtendedFeature, ExtendedFeatureCollection, ExtendedGeometryCollection, GeoGeometryObjects, GeoProjection } from 'd3';
+import { GeoJsonProperties, Geometry, MultiPolygon, Polygon } from 'geojson';
+import { MarksOptions } from '../../marks/config/marks-options';
+import { GeographiesFeature } from '../geographies-feature';
+import { GeographiesAttributeDataLayer } from './layers/attribute-data-layer/attribute-data-layer';
+import { GeographiesGeojsonPropertiesLayer } from './layers/geojson-properties-layer/geojson-properties-layer';
+export interface GeographiesOptions<Datum, TProperties extends GeoJsonProperties, TGeometry extends Geometry = MultiPolygon | Polygon> extends MarksOptions {
+    boundary: ExtendedFeature | ExtendedFeatureCollection | GeoGeometryObjects | ExtendedGeometryCollection;
+    attributeDataLayer: GeographiesAttributeDataLayer<Datum, TProperties, TGeometry>;
+    featureIndexAccessor: (d: GeographiesFeature<TProperties, TGeometry>) => string;
+    geojsonPropertiesLayers: GeographiesGeojsonPropertiesLayer<TProperties, TGeometry>[];
+    projection: GeoProjection;
+}

package/lib/geographies/config/layers/attribute-data-layer/attribute-data-layer-builder.d.ts

@@ -0,0 +1,63 @@
+import { Geometry, MultiPolygon, Polygon } from 'geojson';
+import { FillDefinition } from '../../../../fill-definitions/fill-definitions';
+import { GeographiesLayerBuilder } from '../geographies-layer/geographies-layer-builder';
+import { GeographiesAttributeDataLayer } from './attribute-data-layer';
+import { CategoricalBinsBuilder } from './dimensions/categorical-bins/categorical-bins-builder';
+import { CustomBreaksBinsAttributeDataDimensionBuilder } from './dimensions/custom-breaks/custom-breaks-bins-builder';
+import { EqualFrequenciesAttributeDataDimensionBuilder } from './dimensions/equal-frequencies-bins/equal-frequencies-bins-builder';
+import { EqualValueRangesBinsBuilder } from './dimensions/equal-value-ranges-bins/equal-value-ranges-bins-builder';
+import { NoBinsAttributeDataDimensionBuilder } from './dimensions/no-bins/no-bins-builder';
+export declare class GeographiesAttributeDataLayerBuilder<Datum, TProperties, TGeometry extends Geometry = MultiPolygon | Polygon> extends GeographiesLayerBuilder<TProperties, TGeometry> {
+    private _customFills;
+    private _data;
+    private _geographyIndexAccessor;
+    private binsBuilder;
+    private categoricalBinsBuilder;
+    private customBreaksBinsBuilder;
+    private equalFrequenciesBinsBuilder;
+    private equalValueRangesBinsBuilder;
+    private noBinsBuilder;
+    constructor();
+    /**
+     * OPTIONAL. Creates a configuration object that maps data to colors by categorical values.
+     *
+     * For example, if the data for a set of U.S. states had a string property, 'region', this could be used to color the states by region.
+     */
+    categoricalBins(bins: null): this;
+    categoricalBins(bins: (bins: CategoricalBinsBuilder<Datum>) => void): this;
+    /**
+     * OPTIONAL. Creates a configuration object that maps data to colors by custom breaks values for bins.
+     */
+    customBreaksBins(bins: null): this;
+    customBreaksBins(bins: (bins: CustomBreaksBinsAttributeDataDimensionBuilder<Datum>) => void): this;
+    /**
+     * REQUIRED. The data that will be used to color the geographies.
+     */
+    data(data: Datum[]): this;
+    /**
+     * OPTIONAL. Creates a configuration object that for creating a map without binning values.
+     */
+    noBins(bins: null): this;
+    noBins(bins: (bins: NoBinsAttributeDataDimensionBuilder<Datum>) => void): this;
+    /**
+     * OPTIONAL. Creates a configuration object that maps data to bins that each have the same size range.
+     *
+     * For example, bins may be, 0-10, 10-20, 20-30, etc.
+     */
+    equalValueRangesBins(bins: null): this;
+    equalValueRangesBins(bins: (bins: EqualValueRangesBinsBuilder<Datum>) => void): this;
+    /**
+     * OPTIONAL. Creates a configuration object that maps data to bins that contain an equal number of data observations.
+     *
+     * This is useful for creating quartiles, deciles, etc.
+     */
+    equalFrequenciesBins(bins: null): this;
+    equalFrequenciesBins(bins: (bins: EqualFrequenciesAttributeDataDimensionBuilder<Datum>) => void): this;
+    customFills(customFills: FillDefinition<Datum>[]): this;
+    /**
+     * REQUIRED. The accessor function that returns a value from a Datum that must match the value returned by featureIndexAccessor.
+     */
+    geographyIndexAccessor(accessor: (d: Datum) => string): this;
+    _build(): GeographiesAttributeDataLayer<Datum, TProperties, TGeometry>;
+    private validateBuilder;
+}

package/lib/geographies/config/layers/attribute-data-layer/attribute-data-layer-options.d.ts

@@ -0,0 +1,16 @@
+import { Geometry, MultiPolygon, Polygon } from 'geojson';
+import { FillDefinition } from '../../../../fill-definitions/fill-definitions';
+import { GeographiesLayerOptions } from '../geographies-layer/geographies-layer-options';
+import { CategoricalBinsAttributeDataDimension } from './dimensions/categorical-bins/categorical-bins';
+import { CustomBreaksBinsAttributeDataDimension } from './dimensions/custom-breaks/custom-breaks-bins';
+import { EqualFrequenciesAttributeDataDimension } from './dimensions/equal-frequencies-bins/equal-frequencies-bins';
+import { EqualValueRangesAttributeDataDimension } from './dimensions/equal-value-ranges-bins/equal-value-ranges-bins';
+import { NoBinsAttributeDataDimension } from './dimensions/no-bins/no-bins';
+export interface GeographiesAttributeDataLayerOptions<Datum, TProperties, TGeometry extends Geometry = MultiPolygon | Polygon> extends GeographiesLayerOptions<TProperties, TGeometry> {
+    attributeDimension: CategoricalBinsAttributeDataDimension<Datum> | NoBinsAttributeDataDimension<Datum> | EqualValueRangesAttributeDataDimension<Datum> | EqualFrequenciesAttributeDataDimension<Datum> | CustomBreaksBinsAttributeDataDimension<Datum>;
+    customFills: FillDefinition<Datum>[];
+    data: Datum[];
+    geographyIndexAccessor: (d: Datum) => string;
+    marksClass: string;
+    mixBlendMode: string;
+}

package/lib/geographies/config/layers/attribute-data-layer/attribute-data-layer.d.ts

@@ -0,0 +1,30 @@
+import { InternMap } from 'd3';
+import { Geometry, MultiPolygon, Polygon } from 'geojson';
+import { FillDefinition } from '../../../../fill-definitions/fill-definitions';
+import { GeographiesFeature } from '../../../geographies-feature';
+import { GeographiesLayer, GeographiesTooltipDatum } from '../geographies-layer/geographies-layer';
+import { GeographiesAttributeDataLayerOptions } from './attribute-data-layer-options';
+import { CategoricalBinsAttributeDataDimension } from './dimensions/categorical-bins/categorical-bins';
+import { CustomBreaksBinsAttributeDataDimension } from './dimensions/custom-breaks/custom-breaks-bins';
+import { EqualFrequenciesAttributeDataDimension } from './dimensions/equal-frequencies-bins/equal-frequencies-bins';
+import { EqualValueRangesAttributeDataDimension } from './dimensions/equal-value-ranges-bins/equal-value-ranges-bins';
+import { NoBinsAttributeDataDimension } from './dimensions/no-bins/no-bins';
+export declare class GeographiesAttributeDataLayer<Datum, TProperties, TGeometry extends Geometry = MultiPolygon | Polygon> extends GeographiesLayer<Datum, TProperties, TGeometry> implements GeographiesAttributeDataLayerOptions<Datum, TProperties, TGeometry> {
+    readonly attributeDimension: CategoricalBinsAttributeDataDimension<Datum> | NoBinsAttributeDataDimension<Datum> | EqualValueRangesAttributeDataDimension<Datum> | EqualFrequenciesAttributeDataDimension<Datum> | CustomBreaksBinsAttributeDataDimension<Datum>;
+    attributeScale: any;
+    attributeValuesByGeographyIndex: InternMap<string, string | number>;
+    readonly customFills: FillDefinition<Datum>[];
+    readonly data: Datum[];
+    datumsByGeographyIndex: InternMap<string, Datum>;
+    geographyIndexAccessor: (d: Datum) => string;
+    readonly marksClass: string;
+    readonly mixBlendMode: string;
+    constructor(options: GeographiesAttributeDataLayerOptions<Datum, TProperties, TGeometry>);
+    initPropertiesFromData(): void;
+    private getUniqueDatumsByGeoAccessor;
+    private setAttributeDataMaps;
+    getFill(feature: GeographiesFeature<TProperties, TGeometry>): string;
+    getPatternFill(geographyIndex: string): string;
+    getAttributeFill(geographyIndex: string): string;
+    getTooltipData(path: SVGPathElement): GeographiesTooltipDatum<Datum>;
+}

package/lib/geographies/config/layers/attribute-data-layer/dimensions/attribute-data/attribute-data-dimension-builder.d.ts

@@ -0,0 +1,40 @@
+import { DataValue } from '../../../../../../core/types/values';
+import { DataDimensionBuilder } from '../../../../../../data-dimensions/dimension-builder';
+export declare abstract class AttributeDataDimensionBuilder<Datum, AttributeValue extends DataValue, RangeValue extends string | number = string> extends DataDimensionBuilder<Datum, AttributeValue> {
+    protected _interpolator: (...args: any) => any;
+    protected _nullColor: string;
+    protected _range: RangeValue[];
+    protected _scale: (...args: any) => string;
+    /**
+     * OPTIONAL. For binned dimensions, a function that will be used to create the a new range for the attribute data scale if the user's specified numBins is greater than the values in the user's specified range.
+     *
+     * For the No Bins dimension, this will be used to interpolate between the two colors in the range.
+     *
+     * @default interpolateLab
+     */
+    interpolator(interpolator: (...args: any) => any): this;
+    /**
+     * A color that will be used if there are any geojson features provided in this dimension's geographies that do not have attribute data.
+     *
+     * @default 'whitesmoke'
+     */
+    nullColor(nullColor: string): this;
+    /**
+     * OPTIONAL. An array of values that will be used as the range in the attribute data scale.
+     *
+     * @default ['white', 'slategray'] for Categorical Bins
+     * @default ['white', 'blue'] for Equal Frequencies Bins
+     * @default ['white', 'pink', 'red'] for Equal Value Ranges Bins
+     */
+    range(range: RangeValue[]): this;
+    /**
+     * A function that will be used to create the scale for the attribute data.
+     *
+     * @default scaleOrdinal for Categorical Bins
+     * @default scaleThreshold for Custom Breaks Bins (cannot be overridden)
+     * @default scaleQuantile for Equal Frequencies Bins
+     * @default scaleQuantize for Equal Value Ranges Bins
+     * @default scaleLinear for No Bins
+     */
+    scale(scale: (...args: any) => string): this;
+}

package/lib/geographies/config/layers/attribute-data-layer/dimensions/attribute-data/attribute-data-dimension-options.d.ts

@@ -0,0 +1,8 @@
+import { DataValue } from '../../../../../../core/types/values';
+import { DataDimensionOptions } from '../../../../../../data-dimensions/dimension-options';
+export interface AttributeDataDimensionOptions<Datum, AttributeValue extends DataValue, RangeValue extends string | number = string> extends DataDimensionOptions<Datum, AttributeValue> {
+    interpolator: (...args: any) => any;
+    nullColor: string;
+    range: RangeValue[];
+    scale: (...args: any) => string;
+}

package/lib/geographies/config/layers/attribute-data-layer/dimensions/attribute-data/attribute-data-dimension.d.ts

@@ -0,0 +1,18 @@
+import { DataValue } from '../../../../../../core/types/values';
+import { DataDimension } from '../../../../../../data-dimensions/dimension';
+import { BinStrategy } from '../attribute-data-bin-enums';
+import { AttributeDataDimensionOptions } from './attribute-data-dimension-options';
+/**
+ * Configuration object for attribute data that will be used to shade the map.
+ *
+ * The first generic parameter is the type of the attribute data.
+ */
+export declare abstract class AttributeDataDimension<Datum, AttributeValue extends DataValue, RangeValue extends string | number = string> extends DataDimension<Datum, AttributeValue> implements AttributeDataDimensionOptions<Datum, AttributeValue, RangeValue> {
+    binType: BinStrategy;
+    interpolator: (...args: any) => any;
+    nullColor: string;
+    range: RangeValue[];
+    scale: (...args: any) => any;
+    abstract getScale(): any;
+    constructor(dimensionType: 'number' | 'ordinal' | 'date');
+}

package/lib/geographies/config/layers/attribute-data-layer/dimensions/attribute-data-bin-enums.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Enum that defines the types of binning that can be used to map quantitative attribute data to colors.
+ */
+export declare enum BinStrategy {
+    none = "none",
+    categorical = "categorical",
+    equalValueRanges = "equalValueRanges",
+    equalFrequencies = "equalFrequencies",
+    customBreaks = "customBreaks"
+}

package/lib/geographies/config/layers/attribute-data-layer/dimensions/attribute-data-bin-types.d.ts

@@ -0,0 +1,8 @@
+import { BinStrategy } from './attribute-data-bin-enums';
+import { CategoricalBinsAttributeDataDimension } from './categorical-bins/categorical-bins';
+import { CustomBreaksBinsAttributeDataDimension } from './custom-breaks/custom-breaks-bins';
+import { EqualFrequenciesAttributeDataDimension } from './equal-frequencies-bins/equal-frequencies-bins';
+import { EqualValueRangesAttributeDataDimension } from './equal-value-ranges-bins/equal-value-ranges-bins';
+import { NoBinsAttributeDataDimension } from './no-bins/no-bins';
+export type VicNumberValuesBin = Omit<BinStrategy, BinStrategy.categorical>;
+export type VicAttributeDataDimensionConfig<Datum> = CategoricalBinsAttributeDataDimension<Datum> | NoBinsAttributeDataDimension<Datum> | EqualValueRangesAttributeDataDimension<Datum> | EqualFrequenciesAttributeDataDimension<Datum> | CustomBreaksBinsAttributeDataDimension<Datum>;

package/lib/geographies/config/layers/attribute-data-layer/dimensions/calculated-bins/calculated-bins-builder.d.ts

@@ -0,0 +1,10 @@
+import { AttributeDataDimensionBuilder } from '../attribute-data/attribute-data-dimension-builder';
+export declare abstract class CalculatedBinsAttributeDataDimensionBuilder<Datum, RangeValue extends string | number = string> extends AttributeDataDimensionBuilder<Datum, number, RangeValue> {
+    protected _formatSpecifier: string;
+    /**
+     * OPTIONAL. Sets a format specifier that will be applied to the value of this dimension using D3 format for display purposes.
+     *
+     * For example, this will format data values shown in a tooltip
+     */
+    formatSpecifier(formatSpecifier: string): this;
+}

package/lib/geographies/config/layers/attribute-data-layer/dimensions/calculated-bins/calculated-bins-options.d.ts

@@ -0,0 +1,4 @@
+import { AttributeDataDimensionOptions } from '../attribute-data/attribute-data-dimension-options';
+export interface CalculatedBinsAttributeDataDimensionOptions<Datum, RangeValue extends string | number = string> extends AttributeDataDimensionOptions<Datum, number, RangeValue> {
+    formatSpecifier: string;
+}

package/lib/geographies/config/layers/attribute-data-layer/dimensions/calculated-bins/calculated-bins.d.ts

@@ -0,0 +1,8 @@
+import { AttributeDataDimension } from '../attribute-data/attribute-data-dimension';
+export declare abstract class CalculatedBinsAttributeDataDimension<Datum, RangeValue extends string | number = string> extends AttributeDataDimension<Datum, number, RangeValue> {
+    protected calculatedNumBins: number;
+    readonly formatSpecifier: string;
+    protected setRange(): void;
+    private shouldCalculateBinColors;
+    private getColorGenerator;
+}

package/lib/geographies/config/layers/attribute-data-layer/dimensions/categorical-bins/categorical-bins-builder.d.ts

@@ -0,0 +1,14 @@
+import { AttributeDataDimensionBuilder } from '../attribute-data/attribute-data-dimension-builder';
+import { CategoricalBinsAttributeDataDimension } from './categorical-bins';
+export declare class CategoricalBinsBuilder<Datum, RangeValue extends string | number = string> extends AttributeDataDimensionBuilder<Datum, RangeValue> {
+    private _domain;
+    constructor();
+    /**
+     * OPTIONAL. Sets the domain of the scale. If not set, the domain will be inferred from the data.
+     */
+    domain(domain: string[]): this;
+    /**
+     * @internal This method is not intended to be used by consumers of this library.
+     */
+    _build(): CategoricalBinsAttributeDataDimension<Datum, RangeValue>;
+}

package/lib/geographies/config/layers/attribute-data-layer/dimensions/categorical-bins/categorical-bins-options.d.ts

@@ -0,0 +1,4 @@
+import { AttributeDataDimensionOptions } from '../attribute-data/attribute-data-dimension-options';
+export interface CategoricalBinsOptions<Datum, RangeValue extends string | number = string> extends AttributeDataDimensionOptions<Datum, RangeValue> {
+    domain: string[];
+}

package/lib/geographies/config/layers/attribute-data-layer/dimensions/categorical-bins/categorical-bins.d.ts

@@ -0,0 +1,20 @@
+import { BinStrategy } from '../attribute-data-bin-enums';
+import { AttributeDataDimension } from '../attribute-data/attribute-data-dimension';
+import { CategoricalBinsOptions } from './categorical-bins-options';
+/**
+ * Configuration object for attribute data that is categorical.
+ *
+ * The generic parameter is the type of the attribute data.
+ */
+export declare class CategoricalBinsAttributeDataDimension<Datum, RangeValue extends string | number = string> extends AttributeDataDimension<Datum, string> implements CategoricalBinsOptions<Datum, string> {
+    readonly binType: BinStrategy.categorical;
+    calculatedDomain: string[];
+    readonly domain: string[];
+    interpolator: never;
+    constructor(options: CategoricalBinsOptions<Datum, RangeValue>);
+    getDomain(): string[];
+    setPropertiesFromData(data: Datum[]): void;
+    protected setDomain(values: string[]): void;
+    protected setRange(): void;
+    getScale(): any;
+}

package/lib/geographies/config/layers/attribute-data-layer/dimensions/custom-breaks/custom-breaks-bins-builder.d.ts

@@ -0,0 +1,29 @@
+import { AttributeDataDimensionBuilder } from '../attribute-data/attribute-data-dimension-builder';
+import { CustomBreaksBinsAttributeDataDimension } from './custom-breaks-bins';
+export declare class CustomBreaksBinsAttributeDataDimensionBuilder<Datum, RangeValue extends string | number = string> extends AttributeDataDimensionBuilder<Datum, number, RangeValue> {
+    private _breakValues;
+    private _formatSpecifier;
+    constructor();
+    /**
+     * REQUIRED. An array of values to specify bin ranges. This array should include both the lowest and highest values and must have at least two values.
+     *
+     * An array of [0, 2, 5, 10, 50] will create bins [0, 2], [2, 5], [5, 10], [10, 50].
+     *
+     * Values should be in ascending order.
+     *
+     * Values below the first value will be colored with the color for the first bin. Values above the last value will be colored with the color for the last bin.
+     *
+     * In this sense, the first and last values are primarily used for
+     in a legend, should one be displayed.
+     *
+     *In order for the legend to be accurate, users should ensure that the first and last values are the minimum and maximum values in the data.
+     */
+    breakValues(breakValues: number[]): this;
+    /**
+     * OPTIONAL. Sets a format specifier that will be applied to the value of this dimension using D3 format for display purposes.
+     *
+     * For example, this will format data values shown in a tooltip
+     */
+    formatSpecifier(formatSpecifier: string): this;
+    _build(): CustomBreaksBinsAttributeDataDimension<Datum, RangeValue>;
+}

package/lib/geographies/config/layers/attribute-data-layer/dimensions/custom-breaks/custom-breaks-bins-options.d.ts

@@ -0,0 +1,5 @@
+import { CalculatedBinsAttributeDataDimensionOptions } from '../calculated-bins/calculated-bins-options';
+export interface CustomBreaksBinsAttributeDataDimensionOptions<Datum, RangeValue extends string | number = string> extends CalculatedBinsAttributeDataDimensionOptions<Datum, RangeValue> {
+    breakValues: number[];
+    formatSpecifier: string;
+}

package/lib/geographies/config/layers/attribute-data-layer/dimensions/custom-breaks/custom-breaks-bins.d.ts

@@ -0,0 +1,23 @@
+import { BinStrategy } from '../attribute-data-bin-enums';
+import { AttributeDataDimension } from '../attribute-data/attribute-data-dimension';
+import { CustomBreaksBinsAttributeDataDimensionOptions } from './custom-breaks-bins-options';
+/**
+ * Configuration object for attribute data that is quantitative and will be binned into custom breaks.
+ *
+ * For example, if the data is [0, 1, 2, 4, 60, 100] and breakValues is [0, 2, 5, 10, 50], the bin ranges will be [0, 2], [2, 5], [5, 10], [10, 50], [50, 100].
+ *
+ * The generic parameter is the type of the attribute data.
+ */
+export declare class CustomBreaksBinsAttributeDataDimension<Datum, RangeValue extends string | number = string> extends AttributeDataDimension<Datum, number, RangeValue> implements CustomBreaksBinsAttributeDataDimensionOptions<Datum, RangeValue> {
+    readonly binType: BinStrategy.customBreaks;
+    readonly breakValues: number[];
+    private calculatedNumBins;
+    private calculatedDomain;
+    readonly formatSpecifier: string;
+    constructor(options: CustomBreaksBinsAttributeDataDimensionOptions<Datum, RangeValue>);
+    setPropertiesFromData(): void;
+    protected setDomain(): void;
+    private setNumBins;
+    protected setRange(): void;
+    getScale(): any;
+}

package/lib/geographies/config/layers/attribute-data-layer/dimensions/equal-frequencies-bins/equal-frequencies-bins-builder.d.ts

@@ -0,0 +1,16 @@
+import { CalculatedBinsAttributeDataDimensionBuilder } from '../calculated-bins/calculated-bins-builder';
+import { EqualFrequenciesAttributeDataDimension } from './equal-frequencies-bins';
+export declare class EqualFrequenciesAttributeDataDimensionBuilder<Datum, RangeValue extends string | number = string> extends CalculatedBinsAttributeDataDimensionBuilder<Datum, RangeValue> {
+    private _numBins;
+    constructor();
+    /**
+     * OPTIONAL. The number of bins to create.
+     *
+     * @default 4
+     */
+    numBins(numBins: number): this;
+    /**
+     * @internal This method is not intended to be used by consumers of this library.
+     */
+    _build(): EqualFrequenciesAttributeDataDimension<Datum, RangeValue>;
+}

package/lib/geographies/config/layers/attribute-data-layer/dimensions/equal-frequencies-bins/equal-frequencies-bins-options.d.ts

@@ -0,0 +1,4 @@
+import { CalculatedBinsAttributeDataDimensionOptions } from '../calculated-bins/calculated-bins-options';
+export interface EqualFrequenciesAttributeDataDimensionOptions<Datum, RangeValue extends string | number = string> extends CalculatedBinsAttributeDataDimensionOptions<Datum, RangeValue> {
+    numBins: number;
+}

package/lib/geographies/config/layers/attribute-data-layer/dimensions/equal-frequencies-bins/equal-frequencies-bins.d.ts

@@ -0,0 +1,18 @@
+import { BinStrategy } from '../attribute-data-bin-enums';
+import { CalculatedBinsAttributeDataDimension } from '../calculated-bins/calculated-bins';
+import { EqualFrequenciesAttributeDataDimensionOptions } from './equal-frequencies-bins-options';
+/**
+ * Configuration object for attribute data that is quantitative and will be binned into equal number of observations. For example, if the data is [0, 1, 2, 4, 60, 100] and numBins is 2, the bin ranges will be [0, 2] and [4, 100].
+ *
+ * The generic parameter is the type of the attribute data.
+ */
+export declare class EqualFrequenciesAttributeDataDimension<Datum, RangeValue extends string | number = string> extends CalculatedBinsAttributeDataDimension<Datum, RangeValue> implements EqualFrequenciesAttributeDataDimensionOptions<Datum, RangeValue> {
+    readonly binType: BinStrategy.equalFrequencies;
+    private calculatedDomain;
+    readonly numBins: number;
+    constructor(options: EqualFrequenciesAttributeDataDimensionOptions<Datum, RangeValue>);
+    setPropertiesFromData(data: Datum[]): void;
+    protected setDomain(values: number[]): void;
+    private setNumBins;
+    getScale(): any;
+}

package/lib/geographies/config/layers/attribute-data-layer/dimensions/equal-value-ranges-bins/equal-value-ranges-bins-builder.d.ts

@@ -0,0 +1,21 @@
+import { CalculatedBinsAttributeDataDimensionBuilder } from '../calculated-bins/calculated-bins-builder';
+import { EqualValueRangesAttributeDataDimension } from './equal-value-ranges-bins';
+export declare class EqualValueRangesBinsBuilder<Datum, RangeValue extends string | number = string> extends CalculatedBinsAttributeDataDimensionBuilder<Datum, RangeValue> {
+    private _domain;
+    private _numBins;
+    constructor();
+    /**
+     * OPTIONAL. The domain of the scale. If not set, the domain will be inferred from the data.
+     */
+    domain(domain: [number, number]): this;
+    /**
+     * OPTIONAL. The number of bins to create.
+     *
+     * @default 3
+     */
+    numBins(numBins: number): this;
+    /**
+     * @internal This method is not intended to be used by consumers of this library.
+     */
+    _build(): EqualValueRangesAttributeDataDimension<Datum, RangeValue>;
+}

package/lib/geographies/config/layers/attribute-data-layer/dimensions/equal-value-ranges-bins/equal-value-ranges-bins-options.d.ts

@@ -0,0 +1,5 @@
+import { CalculatedBinsAttributeDataDimensionOptions } from '../calculated-bins/calculated-bins-options';
+export interface EqualValueRangesAttributeDataDimensionOptions<Datum, RangeValue extends string | number = string> extends CalculatedBinsAttributeDataDimensionOptions<Datum, RangeValue> {
+    domain: [number, number];
+    numBins: number;
+}

package/lib/geographies/config/layers/attribute-data-layer/dimensions/equal-value-ranges-bins/equal-value-ranges-bins.d.ts

@@ -0,0 +1,24 @@
+import { BinStrategy } from '../attribute-data-bin-enums';
+import { CalculatedBinsAttributeDataDimension } from '../calculated-bins/calculated-bins';
+import { EqualValueRangesAttributeDataDimensionOptions } from './equal-value-ranges-bins-options';
+/**
+ * Configuration object for attribute data that is quantitative and will be binned into equal value ranges. For example, if the data is [0, 1, 2, 4, 60, 100] and numBins is 2, the bin ranges will be [0, 49] and [50, 100].
+ *
+ * The generic parameter is the type of the attribute data.
+ */
+export declare class EqualValueRangesAttributeDataDimension<Datum, RangeValue extends string | number = string> extends CalculatedBinsAttributeDataDimension<Datum, RangeValue> implements EqualValueRangesAttributeDataDimensionOptions<Datum, RangeValue> {
+    readonly binType: BinStrategy.equalValueRanges;
+    private calculatedDomain;
+    readonly domain: [number, number];
+    readonly numBins: number;
+    constructor(options: EqualValueRangesAttributeDataDimensionOptions<Datum, RangeValue>);
+    setPropertiesFromData(data: Datum[]): void;
+    protected setDomain(values: number[]): void;
+    private setValidatedDomainAndNumBins;
+    protected valueFormatIsInteger(): boolean;
+    protected getValidatedNumBinsAndDomainForIntegerValues(numBins: number, domain: [number, number]): {
+        numBins: number;
+        domain: [number, number];
+    };
+    getScale(): any;
+}

package/lib/geographies/config/layers/attribute-data-layer/dimensions/no-bins/no-bins-builder.d.ts

@@ -0,0 +1,26 @@
+import { AttributeDataDimensionBuilder } from '../attribute-data/attribute-data-dimension-builder';
+import { NoBinsAttributeDataDimension } from './no-bins';
+/**
+ * Configuration object for attribute data that is quantitative and does not have bins.
+ *
+ * The generic parameter is the type of the attribute data.
+ */
+export declare class NoBinsAttributeDataDimensionBuilder<Datum> extends AttributeDataDimensionBuilder<Datum, number> {
+    private _domain;
+    private _formatSpecifier;
+    constructor();
+    /**
+     * OPTIONAL. The domain of the scale. If not set, the domain will be inferred from the data.
+     */
+    domain(domain: [number, number]): this;
+    /**
+     * OPTIONAL. Sets a format specifier that will be applied to the value of this dimension using D3 format for display purposes.
+     *
+     * For example, this will format data values shown in a tooltip
+     */
+    formatSpecifier(formatSpecifier: string): this;
+    /**
+     * @internal This method is not intended to be used by consumers of this library.
+     */
+    _build(): NoBinsAttributeDataDimension<Datum>;
+}

package/lib/geographies/config/layers/attribute-data-layer/dimensions/no-bins/no-bins-options.d.ts

@@ -0,0 +1,5 @@
+import { AttributeDataDimensionOptions } from '../attribute-data/attribute-data-dimension-options';
+export interface NoBinsAttributeDataDimensionOptions<Datum> extends AttributeDataDimensionOptions<Datum, number> {
+    domain: [number, number];
+    formatSpecifier: string;
+}

package/lib/geographies/config/layers/attribute-data-layer/dimensions/no-bins/no-bins.d.ts

@@ -0,0 +1,12 @@
+import { BinStrategy } from '../attribute-data-bin-enums';
+import { AttributeDataDimension } from '../attribute-data/attribute-data-dimension';
+import { NoBinsAttributeDataDimensionOptions } from './no-bins-options';
+export declare class NoBinsAttributeDataDimension<Datum> extends AttributeDataDimension<Datum, number> {
+    readonly binType: BinStrategy.none;
+    domain: [number, number];
+    formatSpecifier: string;
+    constructor(options: NoBinsAttributeDataDimensionOptions<Datum>);
+    setPropertiesFromData(data: Datum[]): void;
+    protected setDomain(values: number[]): void;
+    getScale(): any;
+}