/**
 * External force source applied to a {@link FluidField} once per simulation step.
 *
 * Subclasses override {@link apply} to mutate the field's velocity (and, optionally,
 * scalar attributes). The simulator calls `apply(field, dt, world_to_grid)` for every
 * effector at the start of each step, before diffusion / projection / advection.
 *
 * Effectors are configured in WORLD coordinates. The `world_to_grid` matrix supplied
 * to {@link apply} converts a world-space point into the target field's grid space.
 * The same effector instance can therefore be applied to any number of fluid fields
 * across a single step — the system iterates fields and re-supplies the matching
 * matrix each time.
 *
 * Effectors should be idempotent given the same `dt`, field state, and
 * `world_to_grid` — they are pure functions of (their own configured state, field,
 * dt, matrix). They must not retain references to field buffers between calls (the
 * field's buffer references are stable, but caching them across resolution changes
 * would break).
 */
export class AbstractFluidEffector {
    /**
     * @param {FluidField} field
     * @param {number} dt seconds
     * @param {Float32Array|number[]} world_to_grid  Column-major 4×4 affine sending
     *                                               world-space points into the target
     *                                               field's grid space.
     */
    apply(field: FluidField, dt: number, world_to_grid: Float32Array | number[]): void;
    /**
     * Optional hook called by {@link FluidSystem} once per step on each effector whose
     * entity also has a `Transform` component. Default: no-op. Effectors that should
     * follow an entity override this to pull world-space position / orientation /
     * velocity off the transform.
     *
     * @param {Transform} transform
     */
    syncFromTransform(transform: Transform): void;
    /**
     * Strict value equality. The base implementation collapses to reference equality
     * — every concrete effector class overrides this to compare its own configured
     * state.
     * @param {AbstractFluidEffector} other
     * @return {boolean}
     */
    equals(other: AbstractFluidEffector): boolean;
    /**
     * Fast hash. The base implementation returns a constant — concrete effectors
     * override to hash their own state. Should stay cheap (a few `combine_hash` calls
     * over scalar fields).
     * @return {number}
     */
    hash(): number;
    /**
     * Write the effector's world-space axis-aligned bounding box into `out`. Used by
     * {@link FluidSystem} as a broad-phase culling primitive: if the effector's box
     * doesn't intersect a fluid field's box, the effector is skipped for that field
     * entirely.
     *
     * The base implementation writes infinite bounds — i.e. "could affect anything".
     * Safe (never produces false negatives) but defeats the broad-phase. Concrete
     * effectors override with tight bounds.
     *
     * @param {AABB3} out  destination, mutated in place
     */
    getBoundingBox(out: AABB3): void;
}
//# sourceMappingURL=AbstractFluidEffector.d.ts.map