import * as THREE from 'three/webgpu';
import type { TSLFloatNode, TSLMat4Node, TSLTextureNode, TSLUniformNode, TSLVec2Node, TSLVec3Node, TSLVec4Node } from '../types/tsl.cjs';
import type { OceanWaves } from '../TSL/OceanWaves.cjs';
import type { WaterCaustics } from './WaterCaustics.cjs';
type WaterFloatUniform = TSLUniformNode<'float', number>;
type WaterColorUniform = TSLUniformNode<'color', THREE.Color>;
type WaterVec2Uniform = TSLUniformNode<'vec2', THREE.Vector2>;
type WaterVec3Uniform = TSLUniformNode<'vec3', THREE.Vector3>;
export interface WaterUniforms {
    absorption: WaterVec3Uniform;
    scatterColor: WaterColorUniform;
    scatterTint: WaterColorUniform;
    scatterDepth: WaterFloatUniform;
    phaseG: WaterFloatUniform;
    horizonOcclusionStrength: WaterFloatUniform;
    refractionStrength: WaterFloatUniform;
    refractionBlur: WaterFloatUniform;
    dispersionStrength: WaterFloatUniform;
    fresnelF0: WaterFloatUniform;
    horizonColor: WaterColorUniform;
    zenithColor: WaterColorUniform;
    environmentIntensity: WaterFloatUniform;
    reflectionFloor: WaterColorUniform;
    baseRoughness: WaterFloatUniform;
    thicknessRoughness: WaterFloatUniform;
    sunDirection: WaterVec3Uniform;
    sunColor: WaterColorUniform;
    sunPower: WaterFloatUniform;
    sunStrength: WaterFloatUniform;
    scatterShadow: WaterFloatUniform;
    glitterStrength: WaterFloatUniform;
    cameraUnderwater: WaterFloatUniform;
    foamColor: WaterColorUniform;
    foamThreshold: WaterFloatUniform;
    foamFeather: WaterFloatUniform;
    foamOpacity: WaterFloatUniform;
    foamAlbedoMax: WaterFloatUniform;
    foamRoughness: WaterFloatUniform;
    foamFlowScale: WaterFloatUniform;
    foamNoiseScale: WaterFloatUniform;
    foamNormalStrength: WaterFloatUniform;
    foamEdgeCutoff: WaterFloatUniform;
    contactFoamWidth: WaterFloatUniform;
    edgeFade: WaterFloatUniform;
    domainFade: WaterFloatUniform;
    domainNormalFade: WaterFloatUniform;
    domainWallReflection: WaterFloatUniform;
    domainWallColor: WaterColorUniform;
    domainWallFill: WaterFloatUniform;
    thicknessBoost: WaterFloatUniform;
    thicknessMax: WaterFloatUniform;
    sssStrength: WaterFloatUniform;
    sssThickness: WaterFloatUniform;
    sssWrap: WaterFloatUniform;
    sssCurvature: WaterVec2Uniform;
    whitewaterDensity: WaterFloatUniform;
    whitewaterMaxBrightness: WaterFloatUniform;
    whitewaterEdgeCutoff: WaterFloatUniform;
    whitewaterEdgePower: WaterFloatUniform;
}
export type WaterUniformOverrideValue = number | THREE.Color | THREE.Vector2 | THREE.Vector3;
export type WaterUniformOverrides = Readonly<Record<string, WaterUniformOverrideValue | undefined>>;
export interface WaterSurfaceCompositeUniforms {
    near: TSLFloatNode;
    far: TSLFloatNode;
    projectionMatrix: TSLMat4Node;
    projectionMatrixInverse: TSLMat4Node;
    viewMatrix: TSLMat4Node;
    viewMatrixInverse: TSLMat4Node;
    thicknessTexelSize: TSLVec2Node;
    fullTexelSize: TSLVec2Node;
    fullResolution: TSLVec2Node;
}
export interface WaterCompositeSurface {
    uniforms: WaterSurfaceCompositeUniforms;
    depthNode: TSLTextureNode;
    normalNode: TSLTextureNode;
    thicknessNode: TSLTextureNode;
    whitewaterNode: TSLTextureNode;
    /** Optional ray data: rg scatter integrals, signed-b horizon/wave hit, a normal variance. */
    auxNode?: TSLTextureNode | undefined;
    setSceneNodes?: (options: {
        depthNode: TSLTextureNode;
    }) => unknown;
}
export type WaterEnvironmentSampleNode = TSLVec3Node | TSLVec4Node;
export type WaterEnvironmentSampler = (reflectedWorld: TSLVec3Node, roughness: TSLFloatNode) => WaterEnvironmentSampleNode;
export type WaterEnvironmentNode = THREE.Texture | WaterEnvironmentSampleNode | WaterEnvironmentSampler;
export type WaterSunShadowSampler = (worldPosition: TSLVec3Node) => TSLFloatNode;
export interface WaterDetailNormalsOptions {
    waves?: OceanWaves | null | undefined;
    surfaceField?: THREE.Texture | null | undefined;
    micro?: number | undefined;
}
export interface WaterSSROptions {
    steps?: number | undefined;
    refine?: number | undefined;
    maxDistance?: number | undefined;
    thickness?: number | undefined;
}
export interface WaterCompositeOptions {
    sceneColorNode?: TSLTextureNode | undefined;
    sceneDepthNode?: TSLTextureNode | undefined;
    surfaceField?: THREE.Texture | null | undefined;
    surfaceFoam?: boolean | undefined;
    worldToVolume?: TSLMat4Node | null | undefined;
    envNode?: WaterEnvironmentNode | null | undefined;
    uvNode?: TSLVec2Node | null | undefined;
    compositeWhitewater?: boolean | undefined;
    physicalRefraction?: boolean | undefined;
    ssr?: WaterSSROptions | boolean | undefined;
    caustics?: WaterCaustics | null | undefined;
    sunShadowNode?: WaterSunShadowSampler | null | undefined;
    detailNormals?: WaterDetailNormalsOptions | null | undefined;
    contactFoam?: number | undefined;
    dispersion?: number | undefined;
    glitter?: number | undefined;
    reducedMotion?: boolean | undefined;
    underwater?: boolean | undefined;
    uniforms?: WaterUniformOverrides | undefined;
}
export interface WaterCompositeDiagnostics {
    foamMaskNode: TSLFloatNode;
    contactFoamMaskNode: TSLFloatNode;
    detailNormalNode: TSLVec3Node;
    refractionDeltaNode: TSLVec2Node;
    ssrNode: TSLVec4Node;
    whitewaterAccumulationNode: TSLTextureNode;
}
export interface WaterCompositeResult {
    node: TSLVec4Node;
    uniforms: WaterUniforms;
    diagnostics: WaterCompositeDiagnostics;
}
/**
 * Full-resolution SSF water composite. Foam is treated as a rough, porous
 * material rather than white paint; thickness is bounded before absorption;
 * reflections can sample a PMREM environment; and thin backlit crests receive
 * a wrapped subsurface term. The renderer's density buffer is composited once,
 * so overlapping whitewater sprites brighten sub-linearly.
 *
 * @short Production SSF water composite: bounded absorption, PMREM reflection, porous foam, crest SSS.
 * @category Materials
 * @tags WebGPU, TSL, Water, SSF
 *
 * @param {WaterSurfaceRenderer} surface SSF pass owner.
 * @param {Object} options
 * @param {Node} options.sceneColorNode Scene color texture node.
 * @param {Node} options.sceneDepthNode Scene depth texture node.
 * @param {?THREE.Texture} [options.surfaceField=null] SurfaceField texture (`g`: foam, `ba`: XZ velocity).
 * @param {?Node} [options.worldToVolume=null] Domain matrix uniform required with `surfaceField`.
 * @param {?THREE.Texture|Node|Function} [options.envNode=null] Environment source. A texture is sampled
 *  through PMREM, a callback receives `(reflectedWorld, roughness)`, and an already-built node is used directly.
 * @param {?Node} [options.uvNode=null] Sample coordinate; defaults to `uv()`.
 * @param {boolean} [options.compositeWhitewater=true] Resolve the separately accumulated whitewater target.
 * @param {Object} [options.uniforms] Initial shading-uniform values.
 * @returns {{node: Node, uniforms: Object, diagnostics: Object}} Composite output, uniforms, and raw diagnostic nodes.
 */
export declare function createWaterComposite(surface: WaterCompositeSurface, { sceneColorNode, sceneDepthNode, surfaceField, surfaceFoam, worldToVolume, envNode, uvNode, compositeWhitewater, physicalRefraction: physicalRefractionEnabled, ssr, caustics, sunShadowNode, detailNormals, contactFoam, dispersion, glitter, reducedMotion, underwater: underwaterEnabled, uniforms: uniformOverrides, }?: WaterCompositeOptions): WaterCompositeResult;
/** Fullscreen-quad wrapper around {@link createWaterComposite}. */
export declare class WaterNodeMaterial extends THREE.NodeMaterial {
    waterUniforms: WaterUniforms;
    waterDiagnostics: WaterCompositeDiagnostics;
    static get type(): string;
    constructor(surface: WaterCompositeSurface, options?: WaterCompositeOptions);
}
export {};