import type { GLTF as ThreeGltf } from 'three/examples/jsm/loaders/GLTFLoader.js';
import { type Pose, Geometry as ViamGeometry } from '@viamrobotics/sdk';
import { type Entity } from 'koota';
import { Matrix4, BufferGeometry as ThreeBufferGeometry } from 'three';
export declare const Name: import("koota").Trait<() => string>;
export declare const UUID: import("koota").Trait<() => string>;
/**
 * Set on an entity whose desired parent (by name) doesn't yet exist in the
 * world. Replaced with `relations.ChildOf(parentEntity)` once a frame with
 * the matching `Name` is added. Managed by the hierarchy module — call sites
 * should use `hierarchy.setParent` / `hierarchy.parentTraits` rather than
 * adding this trait directly.
 */
export declare const Orphan: import("koota").Trait<() => string>;
/**
 * Static positional offset (e.g. center of a geometry). Stored as a Pose
 * for the rare cases that need OV+theta semantics (currently unused).
 * Never composed through the parent chain — the `WorldMatrix` system
 * doesn't read it.
 */
export declare const Center: import("koota").Trait<{
    x: number;
    y: number;
    z: number;
    oX: number;
    oY: number;
    oZ: number;
    theta: number;
}>;
/**
 * Local-to-parent transform. Stored AoS — one `Matrix4` instance per entity —
 * not as 16 SoA fields. Every consumer reads all 16 elements of one entity at
 * a time (`Object3D.matrix.copy`, batched-mesh per-instance writes, the
 * world-matrix walk). SoA would allocate a fresh 16-field object on every
 * `entity.get(Matrix)`; AoS returns the `Matrix4` reference, zero allocation
 * per read, and plugs straight into Three.js. The trade-off — losing
 * column-iteration locality — is fine because no system iterates a single
 * matrix element across entities.
 *
 * Update pattern: read the `Matrix4` and mutate in place, then call
 * `entity.changed(Matrix)` so `onChange` listeners (the `WorldMatrix` system,
 * etc.) fire. Allocate a fresh `Matrix4` only on add.
 */
export declare const Matrix: import("koota").Trait<() => Matrix4>;
/** User-staged local transform during a `FrameEditSession`. */
export declare const EditedMatrix: import("koota").Trait<() => Matrix4>;
/**
 * Live local transform from the robot's kinematics. Composed with `Matrix`
 * (network baseline) and `EditedMatrix` to produce the rendered transform.
 */
export declare const LiveMatrix: import("koota").Trait<() => Matrix4>;
/**
 * Cumulative world-space transform — `parent.WorldMatrix × local rendered`.
 * Maintained by `provideWorldMatrix`. Read by hover label placement,
 * batched-mesh population, and any other consumer that needs world-space.
 */
export declare const WorldMatrix: import("koota").Trait<() => Matrix4>;
/**
 * World-space transform of a hovered instance inside a points/arrows batch,
 * paired with the instance index in the parent batched mesh.
 */
export declare const InstancedMatrix: import("koota").Trait<() => {
    matrix: Matrix4;
    index: number;
}>;
export declare const Hovered: import("koota").Trait<() => boolean>;
export declare const Invisible: import("koota").Trait<() => boolean>;
/**
 * Suppresses the default frame-style world/local pose and parent-frame blocks
 * in the details panel. Entities that render their own pose UI via the
 * `details-extensions` portal target (e.g. gizmo plugin entities) opt in by
 * adding this trait.
 */
export declare const CustomDetails: import("koota").TagTrait;
/**
 * True when the entity itself, or any of its parents up the `ChildOf`
 * chain, has `Invisible`. Maintained by `provideInheritedInvisible`;
 * don't add or remove it by hand — toggle `Invisible` and the cascade
 * follows.
 */
export declare const InheritedInvisible: import("koota").Trait<() => boolean>;
/**
 * Represents that an entity is composed of many instances, so that the treeview and
 * details panel may display all instances
 */
export declare const InstanceId: import("koota").Trait<() => number>;
export declare const Instance: import("koota").Trait<{
    meshID: number;
    instanceID: number;
}>;
export declare const Instances: import("koota").Trait<{
    count: number;
}>;
export declare const RenderOrder: import("koota").Trait<() => number>;
export declare const Opacity: import("koota").Trait<() => number>;
/**
 * The color of an object
 * @default { r: 1, g: 0, b: 0 }
 */
export declare const Color: import("koota").Trait<{
    r: number;
    g: number;
    b: number;
}>;
/**
 * Material properties
 */
export declare const Material: import("koota").Trait<{
    depthTest: boolean;
    depthWrite: boolean;
}>;
export declare const DepthTest: import("koota").Trait<() => boolean>;
export declare const Arrow: import("koota").Trait<() => boolean>;
export declare const Positions: import("koota").Trait<() => Float32Array<ArrayBufferLike>>;
/** Per-vertex RGB colors packed as [r, g, b, ...], stride of 3, values 0-255. */
export declare const Colors: import("koota").Trait<() => Uint8Array<ArrayBufferLike>>;
/**
 * Per-vertex opacity values packed as uint8 (0-255).
 */
export declare const Opacities: import("koota").Trait<() => Uint8Array<ArrayBuffer>>;
export declare const Arrows: import("koota").Trait<{
    headAtPose: boolean;
}>;
/**
 * Render entity as points
 */
export declare const Points: import("koota").Trait<() => boolean>;
/**
 * A box, in mm
 */
export declare const Box: import("koota").Trait<{
    x: number;
    y: number;
    z: number;
}>;
/**
 * A capsule, in mm
 */
export declare const Capsule: import("koota").Trait<{
    l: number;
    r: number;
}>;
/**
 * A sphere, in mm
 */
export declare const Sphere: import("koota").Trait<{
    r: number;
}>;
export declare const BufferGeometry: import("koota").Trait<() => ThreeBufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>>;
export declare const GLTF: import("koota").Trait<() => {
    source: {
        url: string;
    } | {
        gltf: ThreeGltf;
    } | {
        glb: Uint8Array;
    };
    animationName: string;
}>;
export declare const FramesAPI: import("koota").Trait<() => boolean>;
export declare const GeometriesAPI: import("koota").Trait<() => boolean>;
export declare const DrawAPI: import("koota").Trait<() => boolean>;
export declare const DrawServiceAPI: import("koota").Trait<() => boolean>;
export declare const WorldStateStoreAPI: import("koota").Trait<() => boolean>;
export declare const SnapshotAPI: import("koota").Trait<() => boolean>;
/**
 * Marker trait for entities created from user-dropped files (PLY, PCD, etc.)
 */
export declare const DroppedFile: import("koota").Trait<() => boolean>;
/**
 * Marker trait for entities the dashboard's TransformControls may attach to —
 * editable frames and ad-hoc custom geometries. Other entity kinds (lines,
 * points, batched arrows, etc.) are deliberately excluded.
 */
export declare const Transformable: import("koota").Trait<() => boolean>;
export declare const ShowAxesHelper: import("koota").Trait<() => boolean>;
/**
 * Marker trait for entities that should be rendered in screen space (CSS pixels)
 */
export declare const ScreenSpace: import("koota").Trait<() => boolean>;
/**
 * Point size, in mm
 */
export declare const PointSize: import("koota").Trait<() => number>;
/**
 * Line positions, format [x, y, z, ...]
 */
export declare const LinePositions: import("koota").Trait<() => Float32Array<ArrayBufferLike>>;
/**
 * Line width, in mm when in world units, or CSS pixels when in screen space
 */
export declare const LineWidth: import("koota").Trait<() => number>;
/**
 * Dot colors for line vertices, format [r, g, b, a, ...]
 */
export declare const DotColors: import("koota").Trait<() => Uint8Array<ArrayBufferLike>>;
/**
 * Dot size for line vertices, in mm when in world units, or CSS pixels when in screen space
 */
export declare const DotSize: import("koota").Trait<() => number>;
export declare const ReferenceFrame: import("koota").Trait<() => boolean>;
/**
 * Tracks chunk loading progress for progressively-loaded entities.
 * `loaded` is the number of elements received so far; `total` is the target.
 */
export declare const ChunkProgress: import("koota").Trait<{
    loaded: number;
    total: number;
}>;
/**
 * Interaction layers for entities
 */
export type InteractionLayerValue = 'selectTool';
export declare const SelectToolInteractionLayer: import("koota").Trait<() => boolean>;
/**
 * This entity is selected by the user
 */
export declare const Selected: import("koota").TagTrait;
/**
 * This entity can be safely removed from the scene by the user
 */
export declare const Removable: import("koota").Trait<() => boolean>;
export declare const Geometry: (geometry: ViamGeometry) => import("koota").Trait<() => boolean> | [import("koota").Trait<{
    x: number;
    y: number;
    z: number;
}>, Partial<{
    x: number;
    y: number;
    z: number;
}>] | [import("koota").Trait<{
    l: number;
    r: number;
}>, Partial<{
    l: number;
    r: number;
}>] | [import("koota").Trait<{
    r: number;
}>, Partial<{
    r: number;
}>] | [import("koota").Trait<() => ThreeBufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>>, ThreeBufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>];
export declare const updateGeometryTrait: (entity: Entity, geometry?: ViamGeometry) => void;
/**
 * Patches an entity's `Matrix` trait in-place via the `Pose` round-trip
 * (`matrixToPose` → merge → `poseToMatrix`), then signals `entity.changed(Matrix)`.
 * No-ops silently if the entity has no `Matrix` trait.
 */
export declare const writeMatrix: (entity: Entity, patch: Partial<Pose>) => void;
