import * as THREE from 'three/webgpu';
export type SplatRenderAlphaMode = 'straight' | 'premultiplied';
export interface SplatRenderCompositorOptions {
    scale?: number | undefined;
    alphaMode?: SplatRenderAlphaMode | undefined;
    format?: THREE.PixelFormat | 'rgba16float' | undefined;
    type?: THREE.TextureDataType | undefined;
    depthBuffer?: boolean | undefined;
}
/** Context passed while the compositor-owned scaled target is active. */
export interface SplatScaledRenderContext {
    readonly renderer: THREE.Renderer;
    readonly target: THREE.RenderTarget<THREE.Texture>;
    readonly width: number;
    readonly height: number;
    readonly alphaMode: SplatRenderAlphaMode;
}
/** Context passed after the renderer's previous target has been restored. */
export interface SplatCompositeContext extends SplatScaledRenderContext {
    readonly texture: THREE.Texture;
    readonly premultipliedAlpha: true;
}
export type SplatScaledRenderCallback = (context: SplatScaledRenderContext) => void;
export type SplatCompositeCallback = (context: SplatCompositeContext) => void;
/**
 * Optional application-managed scaled render target for Gaussian splat reconstruction pipelines.
 *
 * This helper deliberately does not resize the renderer or assume how an application composites
 * splats with opaque geometry. It creates a premultiplied-alpha-compatible HDR target and wraps
 * scaled rendering plus an application-provided reconstruction/composite callback.
 *
 * @class SplatRenderCompositor
 * @short Optional scaled HDR target wrapper for Gaussian splat reconstruction.
 * @category GaussianSplatting
 */
export declare class SplatRenderCompositor {
    renderer: THREE.Renderer;
    scale: number;
    alphaMode: SplatRenderAlphaMode;
    requestedFormat: THREE.PixelFormat | 'rgba16float';
    format: THREE.PixelFormat;
    type: THREE.TextureDataType;
    target: THREE.RenderTarget<THREE.Texture>;
    _compositeMaterial: THREE.NodeMaterial;
    _quad: THREE.QuadMesh;
    width: number;
    height: number;
    _disposed: boolean;
    constructor(renderer: THREE.Renderer, options?: SplatRenderCompositorOptions);
    resize(): this;
    setScale(scale: number): this;
    /**
     * Render into the scaled target, then invoke application reconstruction/compositing.
     *
     * @param {Function} renderScaled Called with `{ renderer, target, width, height }` while target is active.
     * @param {Function} [composite] Optional custom reconstruction callback. Defaults to bilinear premultiplied-alpha compositing.
     */
    render(renderScaled: SplatScaledRenderCallback, composite?: SplatCompositeCallback): void;
    /** Composite the scaled HDR texture with bilinear premultiplied-alpha blending. */
    composite(): void;
    dispose(): void;
}