/**
 * Sentinel for {@link Interpolated#key} before assignment. The
 * {@link InterpolationSystem} replaces it with the entity id at link time.
 * @type {number}
 */
export const INTERPOLATION_KEY_UNSET: number;
/**
 * Default {@link Interpolated#sourceId}: the local fixed-step timeline (the
 * {@link InterpolationSystem}'s own log, blended on `fixedStepTick`). Every
 * physics-driven body uses this. Other source ids are registered with the
 * system (e.g. a network playout) and assigned to remote entities.
 * @type {number}
 */
export const INTERPOLATION_SOURCE_LOCAL: number;
/**
 * Marker component opting an entity into render-time interpolation, and the
 * cooperation point producers (physics, network) and the consumer
 * ({@link InterpolationSystem}) share.
 *
 * Carries:
 *  - `key`: the integer identity this entity's snapshots are filed under in the
 *    interpolation log. Defaults to {@link INTERPOLATION_KEY_UNSET}; the
 *    {@link InterpolationSystem} assigns it the entity id at link time when
 *    unset — the common case needs no manual setup. The network layer can set it
 *    to the `network_id` instead, so a replicated entity keeps one identity
 *    across peers.
 *  - `interpolands`: the {@link Interpoland} kinds to blend for this entity (one
 *    pose interpoland in the common case; more for entities that smooth several
 *    quantities).
 *  - `snap`: when true, the next consume shows the latest snapshot exactly (no
 *    blend) and the flag clears — used to avoid sliding across a teleport.
 *
 * Transient render configuration: NOT serialized or replicated.
 *
 * @author Alex Goldring
 * @copyright Company Named Limited (c) 2026
 */
export class Interpolated {
    /**
     * Log key. {@link INTERPOLATION_KEY_UNSET} until the system assigns the
     * entity id (or a producer assigns a network_id).
     * @type {number}
     */
    key: number;
    /**
     * When true, the next consume snaps to the latest snapshot (no blend) and
     * the flag clears. Set on teleport so the render doesn't slide across the jump.
     * @type {boolean}
     */
    snap: boolean;
    /**
     * The interpoland kinds to blend for this entity.
     * @type {Interpoland[]}
     */
    interpolands: Interpoland[];
    /**
     * Which interpolation timeline this entity is blended on — a plain id, NOT a
     * resource or behavior (those live on the {@link InterpolationSystem}, keyed
     * by this id). {@link INTERPOLATION_SOURCE_LOCAL} (the default) is the local
     * fixed-step clock + the system's own log; a remote/networked entity carries
     * the id of a source the network registered with the system (its
     * render-delayed playout + log), so one render pass blends local and remote
     * entities coherently.
     * @type {number}
     */
    sourceId: number;
    /**
     * Value equality over the configurable state: the timeline ({@link sourceId})
     * and the interpoland kinds (compared by their stable `type_id`). The
     * system-assigned log {@link key} and the transient {@link snap} flag are
     * excluded.
     *
     * @param {Interpolated} other
     * @returns {boolean}
     */
    equals(other: Interpolated): boolean;
    /**
     * Hash over the same configurable state as {@link equals}. Equal components
     * hash equal.
     * @returns {number}
     */
    hash(): number;
    /**
     * Copy `other`'s state into this component. The interpoland list is
     * duplicated as a new array sharing the (stateless, shared) interpoland
     * descriptors; `key`, `snap`, and `sourceId` are copied verbatim.
     *
     * @param {Interpolated} other
     * @returns {Interpolated} this
     */
    copy(other: Interpolated): Interpolated;
    /**
     * @readonly
     * @type {boolean}
     */
    readonly isInterpolated: boolean;
}
export namespace Interpolated {
    let typeName: string;
}
//# sourceMappingURL=Interpolated.d.ts.map