import { EventDispatcher, type Box3, type BufferAttribute, type Vector3 } from 'three';
import type Disposable from '../core/Disposable';
import type CoordinateSystem from '../core/geographic/CoordinateSystem';
import type MemoryUsage from '../core/MemoryUsage';
import type { GetMemoryUsageContext } from '../core/MemoryUsage';
import type Progress from '../core/Progress';
export interface PointCloudAttribute {
    /**
     * The name of the attribute.
     */
    name: string;
    /**
     * Dimension of the attribute. Scalar attributes have dimension 1, e.g intensity, return number,
     * classification. Dimension 3 is for 3-component vectors such as position (XYZ), and color (RGB).
     */
    dimension: 1 | 3;
    /**
     * Dictates how the attribute will be interpreted. Color means the attribute (which
     * is expected to be a 3-component vector) will be interpreted as a RGB triplet. Classification
     * will map discrete colors to the values. Unknown is the default and will use a colormap to map
     * the values to colors.
     */
    interpretation: 'color' | 'classification' | 'unknown';
    /**
     * The data type of this attribute.
     */
    type: 'signed' | 'unsigned' | 'float';
    /**
     * The size, in bytes, of each element in the attribute. For scalars, this is effectively the
     * size in bytes of the whole attribute, per-point. For vectors, this is the size of each component
     * of the vector.
     */
    size: 1 | 2 | 4;
    /**
     * The minimum value of this attribute, if any. Can be used as a hint to specify color map bounds.
     */
    min?: number;
    /**
     * The maximum value of this attribute, if any. Can be used as a hint to specify color map bounds.
     */
    max?: number;
}
/**
 * Contains lightweight metadata about the source, such as point count.
 */
export interface PointCloudMetadata {
    /**
     * The volume of the point cloud.
     *
     * Note: if the source cannot provide a volume (for example, because it is not present in the
     * headers, or because the source is split into many files), this is `undefined`. In this case,
     * clients should use the volume of the root node in the hierarchy.
     */
    volume?: Box3;
    /**
     * The total number of points in this source.
     *
     * Note: if the source cannot provide a total point count (for example, because it is not
     * present in the headers, or because the source is split into many files), this is `undefined`.
     */
    pointCount?: number;
    /**
     * The supported attributes in this source.
     */
    attributes: PointCloudAttribute[];
    /**
     * The coordinate system of this source, if any.
     */
    crs?: CoordinateSystem;
}
/**
 * A point cloud hierarchy node.
 */
export interface PointCloudNode {
    /**
     * The ID of the node in the source.
     * Note: this ID is **not unique** across sources.
     */
    id: string;
    /**
     * The ID of the {@link PointCloudSource} that owns this node.
     */
    sourceId: string;
    /**
     * The depth of the node in the hierarchy. A depth of zero indicates a root node.
     */
    depth: number;
    /**
     * True if the node has point cloud data, or if it is empty.
     */
    hasData: boolean;
    /**
     * The geometric error of this node. Used to determine if the node should be displayed from
     * a given camera position. Generally it can be the same as the point spacing.
     */
    geometricError: number;
    /**
     * The node volume in world space coordinates.
     */
    volume: Box3;
    /**
     * The center of the volume, in world space coordinates.
     */
    center: Vector3;
    /**
     * The number of points in this node, if known.
     */
    pointCount?: number;
    /**
     * The parent of this node. If `undefined`, this node is a root node.
     */
    parent?: PointCloudNode;
    /**
     * The children of this node. If undefined, this node is a leaf node. The array can contain
     * undefined items though (for example an octree that does not have 8 defined children).
     */
    children?: Array<PointCloudNode | undefined>;
}
/**
 * Performs a depth-first traversal of the node hierarchy, applying the callback to each traversed node.
 * If the callback returns `false` for a given node, the children of this node are not traversed.
 */
export declare function traverseNode(root: PointCloudNode | undefined | null, callback: (node: PointCloudNode) => boolean): void;
/**
 * Contains data for a single {@link PointCloudNode}.
 */
export interface PointCloudNodeData {
    /**
     * The number of points in the buffers.
     * Might be undefined if position buffer was not required by the caller.
     */
    pointCount?: number;
    /**
     * The origin of the position buffer.
     */
    origin: Vector3;
    /**
     * The optional scale to apply to the resulting mesh.
     */
    scale?: Vector3;
    /**
     * The position buffer.
     * Might be undefined if position buffer was not required by the caller.
     */
    position?: BufferAttribute;
    /**
     * The local bounding box of this node's point cloud. If undefined, the volume of the node will
     * be used instead.
     * Might be undefined if position buffer was not required by the caller.
     */
    localBoundingBox?: Box3;
    /**
     * The optionally requested attribute buffers (color, classification, etc).
     */
    attributes: Array<BufferAttribute | undefined>;
}
/**
 * Default event map.
 */
export interface PointCloudSourceEventMap {
    /** Raised when the progress of this source changes. */
    progress: unknown;
    /** Raised when the source is initialized. */
    initialized: unknown;
    /** Raised when the source's content has been updated. */
    updated: unknown;
}
export interface GetNodeDataOptions {
    /**
     * To node to process.
     */
    node: PointCloudNode;
    /**
     * Load the point position attribute.
     */
    position: boolean;
    /**
     * The optional attributes to load.
     */
    attributes?: PointCloudAttribute[];
    /**
     * Optional abort signal for early cancellation of asynchronous requests.
     */
    signal?: AbortSignal;
}
/**
 * Provides point cloud data.
 */
export interface PointCloudSource<TEventMap extends PointCloudSourceEventMap = PointCloudSourceEventMap> extends Progress, Disposable, MemoryUsage, EventDispatcher<TEventMap> {
    readonly id: string;
    /**
     * A flag that indicates that the source is ready to use. This flag should be true when
     * {@link initialize} has finished.
     */
    ready: boolean;
    /**
     * The name of the source implementation.
     */
    type: string;
    /**
     * Initialize this source.
     * As long as this source is not initialized, it cannot be used.
     */
    initialize(): Promise<this>;
    /**
     * Gets the hierarchy of this point cloud.
     *
     * Note: this does not provide point cloud data itself.
     */
    getHierarchy(): Promise<PointCloudNode>;
    /**
     * Gets the metadata of this source.
     */
    getMetadata(): Promise<PointCloudMetadata>;
    /**
     * Loads buffer data for the specific {@link PointCloudNode}.
     * @param params - Options.
     */
    getNodeData(params: GetNodeDataOptions): Promise<PointCloudNodeData>;
}
/**
 * Base class for sources that provide point cloud data.
 */
export declare abstract class PointCloudSourceBase<TEventMap extends PointCloudSourceEventMap = PointCloudSourceEventMap> extends EventDispatcher<TEventMap & PointCloudSourceEventMap> implements PointCloudSource, Progress, Disposable, MemoryUsage {
    abstract type: string;
    readonly isMemoryUsage: true;
    /** Read-only flag to indicate that this object is a PointCloudSource. */
    readonly isPointCloudSource: true;
    /** An auto-generated UUID used internally to create unique keys for various purposes. */
    readonly id: string;
    private _initializePromise;
    private _ready;
    get ready(): boolean;
    /**
     * Initialize this source.
     * As long as this source is not initialized, it cannot be used.
     */
    initialize(): Promise<this>;
    /**
     * Raises an event to reload the source.
     */
    update(): void;
    /**
     * Implement by subclasses to initialize the source. This is automatically called by {@link initialize}.
     */
    protected abstract initializeOnce(): Promise<this>;
    /**
     * Gets the hierarchy of this point cloud.
     *
     * Note: this does not provide point cloud data itself.
     */
    abstract getHierarchy(): Promise<PointCloudNode>;
    /**
     * Gets the metadata of this source.
     */
    abstract getMetadata(): Promise<PointCloudMetadata>;
    /**
     * Loads buffer data for the specific {@link PointCloudNode}.
     * @param params - Options.
     */
    abstract getNodeData(params: GetNodeDataOptions): Promise<PointCloudNodeData>;
    abstract get progress(): number;
    abstract get loading(): boolean;
    abstract dispose(): void;
    abstract getMemoryUsage(context: GetMemoryUsageContext): void;
}
//# sourceMappingURL=PointCloudSource.d.ts.map