import * as THREE from "three";
import { SCENE_ACTORS_SCHEMA, type AssetRepresentationDescriptor, type AssetReviewDocument3D, type AssetStreamDescriptor, type Bounds3D, type NavigationSequence, type ReviewAsset3D, type SceneReviewActor, type SpatialReviewIndex, type SpatialReviewProfile, type SpatialReviewSourceStatusMessage, type Transform3D } from "@alterno-dev/spatial-review-protocol";
import { type SceneAssemblyRegistration } from "./assemblies.js";
export type SceneAssetRegistration = {
    actorId: string;
    assetId: string;
    name: string;
    sourceRef: string;
    category: string;
    roots: THREE.Object3D[];
    tags?: string[];
    order?: number;
    parentAssemblyId?: string;
    visible?: boolean;
};
export type SceneAssetRepresentationProgress = {
    phase: "generating" | "serializing";
    completed?: number;
    total?: number;
};
export type SceneAssetRepresentationContext = {
    assetId: string;
    profile: SpatialReviewProfile;
    representation: AssetRepresentationDescriptor;
    maxBytes: number;
    priority: "interactive" | "visible" | "background";
    signal: AbortSignal;
    reportProgress: (progress: SceneAssetRepresentationProgress) => void;
};
export type DeferredSceneAssetRegistration = {
    actorId: string;
    assetId: string;
    name: string;
    sourceRef: string;
    category: string;
    transform: Transform3D;
    bounds: Bounds3D;
    stream: AssetStreamDescriptor;
    produceRepresentation: (context: SceneAssetRepresentationContext) => ReviewAsset3D | THREE.Object3D | THREE.Object3D[] | Promise<ReviewAsset3D | THREE.Object3D | THREE.Object3D[]>;
    tags?: string[];
    order?: number;
    parentAssemblyId?: string;
    visible?: boolean;
};
export type NavigationSequenceRegistration = NavigationSequence & {
    order?: number;
};
export declare class SceneAssetRegistry {
    readonly buildId: string;
    private registrations;
    private deferredRegistrations;
    private navigationRegistrations;
    private assemblyRegistrations;
    private assets;
    private orderedEntries;
    private assetCache;
    private actorCache;
    private graph;
    private textureResources;
    private textureResourceOwners;
    private textureResourceOwnerAssets;
    private deferredRepresentationCache;
    private deferredRepresentationCacheBytes;
    private deferredTextureResourceOwners;
    private deferredTextureResourceBytes;
    private deferredTextureResourceTrimTimer;
    private unavailableDeferredRepresentations;
    private liveReviewSessions;
    private catalogVersion;
    private sourceStatus;
    private sourceStatusListeners;
    constructor(buildId?: string);
    get catalogRevision(): string;
    getSourceStatus(): SpatialReviewSourceStatusMessage;
    onSourceStatus(listener: (status: SpatialReviewSourceStatusMessage) => void): () => boolean;
    setSourceStatus(status: Omit<SpatialReviewSourceStatusMessage, "type" | "buildId" | "catalogRevision">): {
        phase: "booting" | "catalog-ready" | "streaming" | "complete" | "error";
        expectedActors?: number;
        readyActors?: number;
        activeRequests?: number;
        message?: string;
        type: "alterno:spatial-review:source-status";
        buildId: string;
        catalogRevision: string;
    };
    register(registration: Omit<SceneAssetRegistration, "roots"> & {
        root?: THREE.Object3D;
        roots?: THREE.Object3D[];
    }): THREE.Object3D<THREE.Object3DEventMap>;
    /** Register catalog metadata immediately and defer geometry creation until a
     * negotiated representation request supplies an AbortSignal and byte budget. */
    registerDeferred(registration: DeferredSceneAssetRegistration): DeferredSceneAssetRegistration;
    unregister(actorId: string): boolean;
    /** Register a transform-only owner. A root supplies a pose, never geometry. */
    registerAssembly(registration: SceneAssemblyRegistration): SceneAssemblyRegistration;
    unregisterAssembly(assemblyId: string): boolean;
    get assemblySize(): number;
    /** Transform/hierarchy edits and attribute.needsUpdate are detected automatically.
     * Explicitly invalidate after changing raw geometry buffers without a version bump. */
    invalidate(actorId?: string): void;
    private resetCatalog;
    registerNavigationSequence(registration: NavigationSequenceRegistration): NavigationSequenceRegistration;
    get size(): number;
    get navigationSize(): number;
    get cacheMetrics(): {
        worldMatrices: number;
        bounds: number;
        geometries: number;
        assets: number;
    };
    get deferredCacheMetrics(): {
        entries: number;
        bytes: number;
        maxEntries: number;
        maxBytes: number;
        textureOwners: number;
        textureBytes: number;
        maxTextureOwners: number;
        maxTextureBytes: number;
        textureGraceMs: number;
    };
    /** @internal Keeps generated resources alive while at least one bridge can
     * receive late texture requests, then releases all session-only snapshots. */
    retainLiveReviewSession(): () => void;
    private forgetDeferredTextureResourceOwner;
    private scheduleDeferredTextureResourceTrim;
    private trimDeferredTextureResources;
    private retainDeferredTextureResourceOwner;
    private touchDeferredTextureResourceOwners;
    private deleteDeferredRepresentation;
    private rememberDeferredRepresentation;
    private useDeferredRepresentation;
    private ordered;
    private canonicalEntries;
    private revision;
    private releaseTextureResourceOwner;
    private replaceTextureResources;
    private clearTextureResources;
    private estimateBytes;
    private streamDescriptor;
    private asset;
    private document;
    toAssetDocument(profile?: SpatialReviewProfile): AssetReviewDocument3D;
    /** Serializes only the requested family. The byte budget is checked before allocating arrays. */
    toAsset(assetId: string, profile?: SpatialReviewProfile, compact?: boolean, maxBytes?: number): ReviewAsset3D | undefined;
    getAssetStreamDescriptor(assetId: string, profile?: SpatialReviewProfile): AssetStreamDescriptor | undefined;
    private deferredRepresentationKey;
    private ownsAssetTextureResources;
    canReuseAssetRepresentation(assetId: string, profile: SpatialReviewProfile, representationId: string, revision: string): boolean;
    produceAssetRepresentation(assetId: string, profile: SpatialReviewProfile, representationId: string, maxBytes: number, priority: SceneAssetRepresentationContext["priority"], signal: AbortSignal, reportProgress?: SceneAssetRepresentationContext["reportProgress"]): Promise<{
        asset: ReviewAsset3D;
        representation: AssetRepresentationDescriptor;
        transfer: ArrayBuffer[];
        bytes: number;
    } | undefined>;
    private actors;
    /** Legacy actor-only callers have no assembly context, so return world-space fallback records. */
    toActors(): SceneReviewActor[];
    toScene(hierarchical?: boolean, includeDeferred?: boolean): {
        schema: typeof SCENE_ACTORS_SCHEMA;
        actors: SceneReviewActor[];
        assemblies?: import("@alterno-dev/spatial-review-protocol").SceneReviewAssembly[];
        ownership?: import("@alterno-dev/spatial-review-protocol").SceneOwnership;
        navigationSequences: NavigationSequence[];
    };
    toNavigationSequences(): NavigationSequence[];
    toReviewIndex(profile?: SpatialReviewProfile, legacy?: boolean, metadata?: boolean, hierarchical?: boolean, stream?: boolean): SpatialReviewIndex;
    hasTextureResource(resourceId: string): boolean;
    readTextureResource(resourceId: string, maxBytes: number): Promise<import("./resource.js").TextureResource | undefined>;
}
//# sourceMappingURL=registry.d.ts.map