import { ScatterplotLayer } from '@deck.gl/layers';
import { IconLayer } from '@deck.gl/layers';
import Layer, { LayerBaseConfig, LayerColorConfig, LayerColumn, LayerSizeConfig, LayerStrokeColorConfig } from '../base-layer';
import PointLayerIcon from './point-layer-icon';
import { Merge, RGBColor } from '../../reducers';
import { VisConfigBoolean, VisConfigColorRange, VisConfigColorSelect, VisConfigNumber, VisConfigRange } from '../layer-factory';
import { ColorRange } from '../../constants/color-ranges';
import { KeplerTable } from '../../utils';
export type PointLayerVisConfigSettings = {
    radius: VisConfigNumber;
    fixedRadius: VisConfigBoolean;
    opacity: VisConfigNumber;
    outline: VisConfigBoolean;
    thickness: VisConfigNumber;
    strokeColor: VisConfigColorSelect;
    colorRange: VisConfigColorRange;
    strokeColorRange: VisConfigColorRange;
    radiusRange: VisConfigRange;
    filled: VisConfigBoolean;
};
export type PointLayerColumnsConfig = {
    lat: LayerColumn;
    lng: LayerColumn;
    altitude: LayerColumn;
};
export type PointLayerVisConfig = {
    radius: number;
    fixedRadius: boolean;
    opacity: number;
    outline: boolean;
    thickness: number;
    strokeColor: RGBColor;
    colorRange: ColorRange;
    strokeColorRange: ColorRange;
    radiusRange: [number, number];
    filled: boolean;
};
export type PointLayerVisualChannelConfig = LayerColorConfig & LayerSizeConfig & LayerStrokeColorConfig;
export type PointLayerConfig = Merge<LayerBaseConfig, {
    columns: PointLayerColumnsConfig;
    visConfig: PointLayerVisConfig;
}> & PointLayerVisualChannelConfig;
export type PointLayerData = {
    position: number[];
    index: number;
};
export declare const pointPosAccessor: ({ lat, lng, altitude }: PointLayerColumnsConfig) => (dc: any) => (d: any) => any[];
export declare const pointRequiredColumns: ['lat', 'lng'];
export declare const pointOptionalColumns: ['altitude'];
export declare const pointVisConfigs: {
    radius: 'radius';
    fixedRadius: 'fixedRadius';
    opacity: 'opacity';
    outline: 'outline';
    thickness: 'thickness';
    strokeColor: 'strokeColor';
    colorRange: 'colorRange';
    strokeColorRange: 'strokeColorRange';
    radiusRange: 'radiusRange';
    filled: VisConfigBoolean;
};
export default class PointLayer extends Layer {
    config: PointLayerConfig;
    visConfigSettings: PointLayerVisConfigSettings;
    constructor(props: any);
    get type(): 'point';
    get isAggregated(): false;
    get layerIcon(): typeof PointLayerIcon;
    get requiredLayerColumns(): ["lat", "lng"];
    get optionalColumns(): ["altitude"];
    get columnPairs(): import("../base-layer").ColumnPairs;
    get noneLayerDataAffectingProps(): string[];
    get visualChannels(): {
        color: {
            accessor: string;
            condition: (config: any) => any;
            defaultValue: (config: any) => any;
            property: string;
            field: string;
            scale: string;
            domain: string;
            range: string;
            key: string;
            channelScaleType: string;
            nullValue?: any;
            defaultMeasure?: any;
            getAttributeValue?: (config: any) => (d: any) => any;
            fixed?: any;
            supportedFieldTypes?: ("string" | "boolean" | "point" | "geojson" | "date" | "integer" | "real" | "timestamp")[];
            aggregation?: import("../base-layer").VisualChannelAggregation;
        };
        strokeColor: {
            property: string;
            key: string;
            field: string;
            scale: string;
            domain: string;
            range: string;
            channelScaleType: "color";
            accessor: string;
            condition: (config: any) => any;
            defaultValue: (config: any) => any;
        };
        size: {
            property: string;
            range: string;
            channelScaleType: string;
            accessor: string;
            defaultValue: number;
            field: string;
            scale: string;
            domain: string;
            key: string;
            nullValue?: any;
            defaultMeasure?: any;
            condition?: (config: any) => boolean;
            getAttributeValue?: (config: any) => (d: any) => any;
            fixed?: any;
            supportedFieldTypes?: ("string" | "boolean" | "point" | "geojson" | "date" | "integer" | "real" | "timestamp")[];
            aggregation?: import("../base-layer").VisualChannelAggregation;
        };
        customMarkers: {
            property: string;
            key: string;
            field: string;
            scale: string;
            domain: string;
            range: string;
            fixed: string;
            channelScaleType: "customMarker";
            accessor: string;
            supportedFieldTypes: string[];
            defaultValue: (config: any) => any;
            condition: (config: any) => any;
        };
        rotation: {
            property: string;
            key: string;
            field: string;
            channelScaleType: "identity";
            accessor: string;
            supportedFieldTypes: string[];
            defaultValue: () => number;
            nullValue: number;
            condition: (config: any) => any;
        };
    };
    setInitialLayerConfig(dataset: any): this;
    static findDefaultLayerProps({ fieldPairs }: KeplerTable): {
        props: {
            label: string;
            color?: RGBColor;
            isVisible?: boolean;
            columns?: PointLayerColumnsConfig;
        }[];
    };
    getDefaultLayerConfig(props?: {}): {
        strokeColorField: any;
        strokeColorDomain: number[];
        strokeColorScale: string;
        customMarkersField: any;
        customMarkersScale: string;
        dataId: string;
        label: string;
        color: RGBColor;
        columns: import("../base-layer").LayerColumns;
        isVisible: boolean;
        isConfigActive: boolean;
        highlightColor: import("../../reducers").RGBAColor | RGBColor;
        hidden: boolean;
        visConfig: import("../layer-factory").LayerVisConfig;
        textLabel: import("../layer-factory").LayerTextLabel[];
        colorUI: {
            color: import("../layer-factory").ColorUI;
            colorRange: import("../layer-factory").ColorUI;
        };
        animation: {
            enabled: boolean;
            domain?: null;
        };
        colorField?: import("../../utils/table-utils/kepler-table").Field;
        colorDomain?: import("../base-layer").VisualChannelDomain;
        colorScale?: "point" | "log" | "ordinal" | "quantile" | "quantize" | "linear" | "sqrt" | "custom" | "logarithmic" | "identity";
        sizeDomain?: import("../base-layer").VisualChannelDomain;
        sizeScale?: "point" | "log" | "ordinal" | "quantile" | "quantize" | "linear" | "sqrt" | "custom" | "logarithmic" | "identity";
        sizeField?: import("../../utils/table-utils/kepler-table").Field;
    };
    calculateDataAttribute({ filteredIndex }: KeplerTable, getPosition: any): PointLayerData[];
    formatLayerData(datasets: any, oldLayerData: any): {};
    updateLayerMeta(dataContainer: any): void;
    isLayerHovered(objectInfo: any): boolean;
    renderLayer(opts: any): (import("@deck.gl/carto").PointLabelLayer<any, {}> | IconLayer<any, {
        id: `${string}-icon`;
        data: any;
        getColor: any;
        getFilterValue: any;
        updateTriggers: {
            getFilterValue: any;
            getColor: any;
            getIcon: any;
            getSize: any;
            getAngle: any;
        };
        getIcon: (d: any) => {
            id: string;
            url: any;
            width: number;
            height: number;
            mask: boolean;
        };
        getPosition: any;
        getSize: any;
        getAngle: number | ((d: any, i: any) => number);
        sizeScale: any;
        sizeUnits: string;
        loadOptions: {
            image: {
                type: string;
            };
            imagebitmap: {
                resizeWidth: number;
                resizeHeight: number;
                resizeQuality: string;
            };
        };
        parameters: {
            depthTest: boolean;
        };
        idx: number;
        coordinateSystem: 1;
        pickable: boolean;
        wrapLongitude: boolean;
        hidden: boolean;
        visibilityByZoom: any;
        opacity: any;
        highlightColor: import("../../reducers").RGBAColor | RGBColor;
        extensions: (import("@deck.gl/extensions").MaskExtension | import("@deck.gl/extensions").DataFilterExtension)[];
        filterRange: number[][];
        visible: boolean;
        maskId: string;
    }> | IconLayer<any, {
        id: `${string}-icon-hovered`;
        data: any[];
        getColor: import("../../reducers").RGBAColor | RGBColor;
        visible: boolean;
        pickable: boolean;
        wrapLongitude: boolean;
        coordinateSystem: 1;
        getIcon: (d: any) => {
            id: string;
            url: any;
            width: number;
            height: number;
            mask: boolean;
        };
        getPosition: any;
        getSize: any;
        getAngle: number | ((d: any, i: any) => number);
        sizeScale: any;
        sizeUnits: string;
        loadOptions: {
            image: {
                type: string;
            };
            imagebitmap: {
                resizeWidth: number;
                resizeHeight: number;
                resizeQuality: string;
            };
        };
    }>)[] | (import("@deck.gl/carto").PointLabelLayer<any, {}> | ScatterplotLayer<any, {}>)[];
}