import { IUniform, RawShaderMaterial, WebGLRenderTarget, WebGLRenderer, Points, BufferGeometry, Float32BufferAttribute, Color, ColorRepresentation, Object3D, EventDispatcher, Camera, InstancedBufferGeometry, Matrix4, ShaderMaterial, ShaderMaterialParameters } from 'three';
import { GeoJsonProperties, Feature, Polygon, MultiPolygon, LineString } from 'geojson';
import proj4 from 'proj4';
import { S as SubsetGeometry, a as SubsetFeatureInfo } from './subset-DdV_1Izt.js';

type ComputeMaterialParameters = {
    computeShader?: string;
    uniforms?: {
        [key: string]: IUniform;
    };
};

declare class ComputeMaterial extends RawShaderMaterial {
    constructor({ computeShader, uniforms }: ComputeMaterialParameters);
}

declare class ComputeRenderTarget extends WebGLRenderTarget {
    private _outputCount;
    private _itemsPerPixel;
    private _format;
    constructor(outputCount: number, itemsPerPixel: 1 | 2 | 4);
    get outputCount(): number;
    readData(renderer: WebGLRenderer, start?: number, end?: number): Float32Array<ArrayBuffer>;
}

declare class ComputeProgram extends Points<BufferGeometry, RawShaderMaterial> {
    private _renderer;
    constructor(geometry: BufferGeometry, material: ComputeMaterial);
    private _onBeforeMaterialCompile;
    compute(renderTarget: ComputeRenderTarget, start?: number, end?: number): Promise<Float32Array<ArrayBufferLike>>;
    dispose(): void;
}

declare class FeatureGeometry extends SubsetGeometry<{
    id: Float32BufferAttribute;
    position: Float32BufferAttribute;
    color: Float32BufferAttribute;
}> {
    private _featureVertRanges;
    constructor(attributes: {
        id: Float32BufferAttribute;
        position: Float32BufferAttribute;
        color: Float32BufferAttribute;
    }, featureInfos: SubsetFeatureInfo[]);
    getFeatureColor(id: number): Color | undefined;
    setFeatureColor(id: number, colRep: ColorRepresentation): void;
}
type GeometryOptions = {
    defaultColor?: ColorRepresentation;
    projection?: proj4.Converter;
    translate?: [number, number];
};
declare class PolygonGeometry extends FeatureGeometry {
    constructor(polygons: Polygon["coordinates"][], { defaultColor, projection, translate, }?: GeometryOptions);
}
declare class PolygonEdgeGeometry extends FeatureGeometry {
    constructor(polygons: Polygon["coordinates"][], { defaultColor, projection, translate, }?: GeometryOptions);
}
declare class LineStringGeometry extends FeatureGeometry {
    constructor(lines: LineString["coordinates"][], { defaultColor, projection, translate, }?: GeometryOptions);
}
declare class MultiPolygonGeometry extends FeatureGeometry {
    constructor(multiPolys: MultiPolygon["coordinates"][], { defaultColor, projection, translate, }?: GeometryOptions);
}
declare class MultiPolygonEdgeGeometry extends FeatureGeometry {
    constructor(multiPolys: MultiPolygon["coordinates"][], { defaultColor, projection, translate, }?: GeometryOptions);
}
declare class GeoJSONFillGeometry<Properties extends GeoJsonProperties = object> extends FeatureGeometry {
    constructor(features: Feature<Polygon | MultiPolygon, Properties>[], { defaultColor, projection, translate, getBaseHeight, }?: GeometryOptions & {
        getBaseHeight?: (f: Feature<Polygon | MultiPolygon, Properties>, index: number, arr: Feature<Polygon | MultiPolygon, Properties>[]) => number;
    });
}
declare class GeoJSONEdgeGeometry<Properties extends GeoJsonProperties = object> extends FeatureGeometry {
    constructor(features: Feature<Polygon | MultiPolygon, Properties>[], { defaultColor, projection, translate, getBaseHeight, }?: GeometryOptions & {
        getBaseHeight?: (f: Feature<Polygon | MultiPolygon, Properties>, index: number, arr: Feature<Polygon | MultiPolygon, Properties>[]) => number;
    });
}
declare class GeoJSONFillExtrudeGeometry<Properties extends GeoJsonProperties = object> extends FeatureGeometry {
    constructor(features: Feature<Polygon | MultiPolygon, Properties>[], { defaultColor, projection, translate, getBaseHeight, getExtrudeHeight, }?: GeometryOptions & {
        getExtrudeHeight?: (f: Feature<Polygon | MultiPolygon, Properties>, index: number, arr: Feature<Polygon | MultiPolygon, Properties>[]) => number;
        getBaseHeight?: (f: Feature<Polygon | MultiPolygon, Properties>, index: number, arr: Feature<Polygon | MultiPolygon, Properties>[]) => number;
    });
}
declare class GeoJSONEdgeExtrudeGeometry<Properties extends GeoJsonProperties = object> extends FeatureGeometry {
    constructor(features: Feature<Polygon | MultiPolygon, Properties>[], { defaultColor, projection, translate, getBaseHeight, getExtrudeHeight, }?: GeometryOptions & {
        getExtrudeHeight?: (f: Feature<Polygon | MultiPolygon, Properties>, index: number, arr: Feature<Polygon | MultiPolygon, Properties>[]) => number;
        getBaseHeight?: (f: Feature<Polygon | MultiPolygon, Properties>, index: number, arr: Feature<Polygon | MultiPolygon, Properties>[]) => number;
    });
}

type PickerEvent<TargetType> = {
    id: number;
    object: TargetType | null;
};
type PickerEventMap<TargetType> = {
    mouseover: PickerEvent<TargetType>;
    mouseenter: PickerEvent<TargetType>;
    mouseleave: PickerEvent<TargetType>;
    click: PickerEvent<TargetType>;
    dblclick: PickerEvent<TargetType>;
    added: object;
    removed: object;
};
declare const ShaderIdOutVarName: string;
declare class IdPicker<TargetType extends Object3D> extends EventDispatcher<PickerEventMap<TargetType>> {
    private _domElement;
    private _scene;
    private _objects;
    private _objectMap;
    private _renderTarget;
    private _readBuffer;
    private _mousePosition;
    private _hasClicked;
    private _hasDblClicked;
    private _disposed;
    private _currentId;
    private _currentObject;
    private _availableIds;
    constructor();
    setDomElement(elem: HTMLElement | null): void;
    triggerEvent(type: "mouseover" | "click" | "dblclick", e: MouseEvent): void;
    add(target: TargetType, { uniforms, vertexSource, idAttrName, withObject, }?: {
        idAttrName?: string;
        vertexSource?: string;
        uniforms?: Record<string, IUniform<any>>;
        withObject?: boolean;
    }): void;
    remove(target: TargetType): void;
    update(renderer: WebGLRenderer, camera: Camera): void;
    private _onMouseMove;
    private _onClick;
    private _onDblClick;
    private _modifyCamera;
    private _updateId;
    private _processEvents;
    dispose(): void;
}

declare class InstancedGeometry extends InstancedBufferGeometry {
    constructor(baseGeometry: BufferGeometry, instanceCount: number);
    setInstanceMatrix(i: number, mat: Matrix4): void;
}
declare class StandardInstancedMaterial extends ShaderMaterial {
    constructor(params?: Exclude<ShaderMaterialParameters, "vertexShader" | "fragmentShader">);
}

type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array;
declare function mergeIndexArrays(arrays: Uint32Array[], offsets: number[]): Uint32Array<ArrayBuffer>;
declare function mergeTypedArrays(arrays: Float32Array[]): Float32Array;
declare function mergeTypedArrays(arrays: Float64Array[]): Float64Array;
declare function mergeTypedArrays(arrays: Int8Array[]): Int8Array;
declare function mergeTypedArrays(arrays: Int16Array[]): Int16Array;
declare function mergeTypedArrays(arrays: Int32Array[]): Int32Array;
declare function mergeTypedArrays(arrays: Uint8Array[]): Uint8Array;
declare function mergeTypedArrays(arrays: Uint8ClampedArray[]): Uint8ClampedArray;
declare function mergeTypedArrays(arrays: Uint16Array[]): Uint16Array;
declare function mergeTypedArrays(arrays: Uint32Array[]): Uint32Array;

export { ComputeProgram, ComputeRenderTarget, FeatureGeometry, GeoJSONEdgeExtrudeGeometry, GeoJSONEdgeGeometry, GeoJSONFillExtrudeGeometry, GeoJSONFillGeometry, IdPicker, InstancedGeometry, LineStringGeometry, MultiPolygonEdgeGeometry, MultiPolygonGeometry, type PickerEvent, PolygonEdgeGeometry, PolygonGeometry, ShaderIdOutVarName, StandardInstancedMaterial, SubsetFeatureInfo, SubsetGeometry, type TypedArray, mergeIndexArrays, mergeTypedArrays };
