/**
 * Engine-agnostic access to durable HELIX Vault assets.
 *
 * Persist `VaultAssetHandle` (assetId + immutable integer version), never an
 * artifact URL. URLs are resolution results and may change when the serving
 * host changes.
 */
export declare const VAULT_ASSET_KINDS: readonly ["prop", "character", "animation", "audio", "texture", "material", "environment", "terrain", "vfx", "decal", "sky", "gaussian_splat", "scene", "unreal_package"];
export type VaultAssetKind = (typeof VAULT_ASSET_KINDS)[number];
export type VaultRuntime = 'web' | 'unreal';
export type VaultSplatScope = 'object' | 'environment';
export type VaultPerformanceTier = 'mobile' | 'desktop' | 'cinematic' | 'unknown';
export type VaultRankMode = 'relevance' | 'performance' | 'reuse';
export type VaultAssetHandle = {
    assetId: string;
    /** Immutable, one-based Vault version. */
    version: number;
};
export type VaultImmutableArtifactReference = VaultAssetHandle & {
    checksumSha256: string;
};
export type VaultArtifactMetadata = {
    format: string;
    mimeType: string;
    sourceBytes: number;
};
export type VaultPerformanceMetadata = {
    costScore: number | null;
    tier: VaultPerformanceTier;
    downloadBytes: number;
    qualityScore: number | null;
    rankingSignals: string[];
    triangles?: number;
    drawCalls?: number;
    maxTextureEdge?: number;
    memoryBytes?: number | null;
};
type VaultMetadataBase = {
    schemaVersion: '1' | string;
    subtype: string;
    artifact: VaultArtifactMetadata;
    performance: VaultPerformanceMetadata;
    [key: string]: unknown;
};
export type VaultPropMetadata = VaultMetadataBase & {
    prop: {
        static: true;
        coordinateSystem: string;
        units: 'meters' | string;
        dimensionsMeters: [number, number, number];
        triangleCount: number;
        materialCount: number;
        maxTextureEdge: number;
        fileSizeBytes: number;
        lods: Array<{
            level: number;
            triangles: number;
            format: string;
        }>;
        limits: {
            maxFileBytes: number;
            maxTextureEdge: number;
            generated: boolean;
            [key: string]: unknown;
        };
        [key: string]: unknown;
    };
};
export type VaultCharacterMetadata = VaultMetadataBase & {
    character: {
        skinned: boolean;
        meshCount: number;
        triangleCount: number | null;
        boneCount: number;
    };
};
export type VaultAnimationMetadata = VaultMetadataBase & {
    animation: {
        clipCount: number;
        clips: string[];
        durationSeconds: number | null;
        frameCount: number | null;
        framesPerSecond: number | null;
        rig: string;
        loop: boolean;
        rootMotion: boolean;
    };
};
/** Which ElevenLabs-backed mode produced this audio asset. */
export type VaultAudioGenerationMode = 'sound_effect' | 'music' | 'text_to_speech';
export type VaultAudioMetadata = VaultMetadataBase & {
    audio: {
        format: string;
        durationSeconds: number | null;
        loop: boolean;
        /** Present on generated (ElevenLabs) assets; absent on uploads. */
        mode?: VaultAudioGenerationMode;
        model?: string;
        outputFormat?: string;
        /** Text-to-speech only. */
        voiceId?: string;
        /** Measured vendor usage/cost this specific generation was billed for. */
        measuredUsage?: {
            creditsCharged: number;
            measured: boolean;
            providerCostUsd: number;
        };
        [key: string]: unknown;
    };
};
export type VaultTextureMetadata = VaultMetadataBase & {
    texture: {
        semantic: 'albedo' | 'normal' | 'roughness' | 'metallic' | 'ambient-occlusion' | 'emissive' | 'height' | 'mask' | 'unspecified';
        colorSpace: 'srgb' | 'linear' | 'unspecified';
    };
};
export type VaultMaterialMetadata = VaultMetadataBase & {
    material: {
        schemaVersion: string;
        materialId: string;
        materialType: 'pbr' | 'procedural_glass' | 'procedural_water';
        mapSemantics: string[];
    };
};
export type VaultEnvironmentMetadata = VaultMetadataBase & {
    environment: {
        representation: 'mesh' | 'gaussian-splat';
        scope?: 'environment';
        meshCount?: number;
        triangleCount?: number;
        dimensionsMeters?: [number, number, number] | null;
        materialCount?: number;
    };
    gaussianSplat?: VaultGaussianSplatMetadata['gaussianSplat'];
};
export type VaultTerrainMetadata = VaultMetadataBase & {
    terrain: {
        representation: 'heightmap' | 'mesh';
        sourceFormat?: 'png16' | 'raw16' | 'exr' | 'glb';
        dimensionsMeters: [number, number, number] | null;
        triangleCount?: number | null;
        schemaVersion?: string;
    };
};
export type VaultVfxMetadata = VaultMetadataBase & {
    vfx: {
        schemaVersion: string;
        deviceTier: 'mobile' | 'desktop' | 'cinematic';
        effectType: 'particle' | 'beam' | 'trail' | 'flipbook';
        boundsMeters: [number, number, number];
        portability: 'renderer-neutral-contract-draft';
        runtimeCompatibility: VaultRuntime[];
        loop: boolean;
        maxParticles: number;
        drawCalls: number;
        decodedTextureMemoryBytes: number;
        limits: {
            maxParticles: number;
            spawnRatePerSecond: number;
            lifetimeSeconds: number;
            speedMetersPerSecond: number;
            sizeMeters: number;
            boundsMeters: number;
            beamLengthMeters: number;
            beamSegments: number;
            trailPoints: number;
        };
        textures: Array<{
            role: 'sprite' | 'flipbook' | 'beam' | 'trail' | 'distortion';
            artifact: VaultImmutableArtifactReference;
            resolvedKind: 'texture' | 'decal';
            colorSpace: 'srgb' | 'linear';
            frames: {
                columns: number;
                rows: number;
                frameCount: number;
                framesPerSecond: number;
            } | null;
        }>;
        particle: {
            textureRole: string;
            shape: 'point' | 'sphere' | 'box' | 'cone';
            spawnRatePerSecond: number;
            lifetimeSeconds: [number, number];
            speedMetersPerSecond: [number, number];
            sizeMeters: [number, number];
            blendMode: 'alpha' | 'additive' | 'multiply';
            billboard: 'camera' | 'velocity' | 'world';
        } | null;
        beam: {
            textureRole: string;
            widthMeters: [number, number];
            lengthMeters: [number, number];
            maxSegments: number;
            noiseAmplitudeMeters: number;
            blendMode: 'alpha' | 'additive' | 'multiply';
        } | null;
        trail: {
            textureRole: string;
            lifetimeSeconds: number;
            widthMeters: [number, number];
            maxPoints: number;
            minVertexDistanceMeters: number;
            blendMode: 'alpha' | 'additive' | 'multiply';
        } | null;
        flipbook: {
            textureRole: string;
            sizeMeters: [number, number];
            blendMode: 'alpha' | 'additive' | 'multiply';
        } | null;
    };
};
export type VaultDecalMetadata = VaultMetadataBase & {
    decal: {
        projection: 'planar' | 'box';
        widthMeters: number;
        heightMeters: number;
        blendMode: 'normal' | 'multiply' | 'additive';
    };
};
export type VaultSkyMetadata = VaultMetadataBase & {
    sky: {
        schemaVersion: string;
        sourceFormat: 'hdr' | 'exr';
        projection: 'equirectangular' | 'cubemap';
        colorSpace: 'linear-srgb' | 'acescg';
        dynamicRangeStops: number;
        exposureEv: number;
        resolution: {
            width: number;
            height: number;
        };
        backdropRenditions: unknown[];
        lightingRenditions: unknown[];
        channelsSeparated: true;
    };
};
export type VaultGaussianSplatMetadata = VaultMetadataBase & {
    gaussianSplat: {
        format: 'spz';
        scope: VaultSplatScope;
        pointCount: number | null;
        boundsMeters: [number, number, number] | null;
        pointDensityPerCubicMeter: number | null;
        sphericalHarmonicsDegree: number | null;
        quality: 'mobile' | 'balanced' | 'high' | 'cinematic' | 'unverified';
        lodCount: number;
        compression: {
            format: 'spz';
            level: unknown;
        };
        capture: {
            provider: unknown;
            source: unknown;
            metersPerUnit: number;
            upAxis: 'x' | 'y' | 'z';
        };
        performance: {
            downloadBytes: number;
            memoryBytes: number | null;
        };
    };
};
export type VaultSceneMetadata = VaultMetadataBase & {
    scene: {
        schemaVersion: string;
        nodeCount: number;
        references: Array<VaultImmutableArtifactReference & {
            kind: 'prop' | 'character' | 'environment' | 'scene' | 'terrain' | 'vfx';
        }>;
        runtimeBundles: Array<{
            runtime: VaultRuntime;
            format: string;
            artifact: VaultImmutableArtifactReference;
        }>;
        budget: {
            deviceTier: 'mobile' | 'desktop' | 'cinematic';
            derivedTotals: {
                uniqueMaterials: number;
                drawCalls: number;
                decodedTextureMemoryBytes: number;
                triangles: number;
                particles: number;
            };
            basis: 'server-resolved-immutable-artifacts';
            limits: {
                uniqueMaterials: number;
                drawCalls: number;
                decodedTextureMemoryBytes: number;
                triangles: number;
                particles: number;
            };
            costScore: number;
            withinBudget: true;
        };
    };
};
export type VaultUnrealPackageMetadata = VaultMetadataBase;
export type VaultMetadataByKind = {
    prop: VaultPropMetadata;
    character: VaultCharacterMetadata;
    animation: VaultAnimationMetadata;
    audio: VaultAudioMetadata;
    texture: VaultTextureMetadata;
    material: VaultMaterialMetadata;
    environment: VaultEnvironmentMetadata;
    terrain: VaultTerrainMetadata;
    vfx: VaultVfxMetadata;
    decal: VaultDecalMetadata;
    sky: VaultSkyMetadata;
    gaussian_splat: VaultGaussianSplatMetadata;
    scene: VaultSceneMetadata;
    unreal_package: VaultUnrealPackageMetadata;
};
export type VaultCompatibility = {
    skeleton?: string;
    skeletonVerification?: 'verified' | 'declared' | string;
    skeletonBonesMatched?: number;
    system?: string;
    engines?: VaultRuntime[];
};
export type VaultCanonicalThumbnail = {
    provenance?: string;
    rendererVersion?: string;
    artifactChecksumSha256?: string;
    [key: string]: unknown;
};
export type VaultSelectionExplanation = {
    rankMode: VaultRankMode;
    lexical: {
        matchedTerms: string[];
        matchedFields: string[];
    };
    hardFilters: Record<string, unknown>;
    performance: {
        tier: VaultPerformanceTier | null;
        costScore: number | null;
        qualityScore: number | null;
    };
    reuse: {
        worldUsageCount: number;
        usageCount: number;
        lastUsedAt: string | null;
    };
    availability: {
        performanceMeasured: boolean;
        qualityMeasured: boolean;
        reuseObserved: boolean;
    };
};
export type VaultAssetSummary<K extends VaultAssetKind = VaultAssetKind> = {
    assetId: string;
    slug: string;
    title: string;
    description: string | null;
    kind: K;
    license: 'helix_standard' | 'cc0' | 'cc_by' | 'all_rights_reserved';
    compatibility: VaultCompatibility;
    metadata: VaultMetadataByKind[K];
    tags: string[];
    source: 'manual' | 'dreamer' | 'world_generation' | 'import';
    origin: 'generated' | 'uploaded';
    visibility: 'public' | 'private' | 'held';
    currentVersion: number;
    thumbnailUrl: string | null;
    thumbnailGenerator: string | null;
    canonicalThumbnail: VaultCanonicalThumbnail | null;
    artifactUrl: string | null;
    artifactMimeType: string | null;
    artifactSizeBytes: number | null;
    contentRating: string;
    contentRatingStatus: string | null;
    worldUsageCount: number;
    usageCount: number;
    lastUsedAt: string | null;
    creatorId: string;
    createdAt: string;
    updatedAt: string;
    selectionExplanation?: VaultSelectionExplanation | null;
};
export type VaultRelatedArtifact = {
    role: string;
    url: string | null;
    mimeType: string;
    sizeBytes: number;
    checksumSha256: string | null;
};
export type VaultResolvedArtifact = {
    assetId: string;
    version: number;
    url: string | null;
    urlKind: 'cdn' | 'unavailable';
    mimeType: string;
    sizeBytes: number;
    checksumSha256: string | null;
    relatedArtifacts: VaultRelatedArtifact[];
};
export type VaultAssetDetail<K extends VaultAssetKind = VaultAssetKind> = VaultAssetSummary<K> & {
    artifact: VaultResolvedArtifact;
    usedInWorlds: Array<{
        worldId: string;
        slug: string;
        title: string;
    }>;
};
export type VaultAssetVersion = {
    handle: VaultAssetHandle;
    url: string | null;
    mimeType: string;
    sizeBytes: number;
    checksumSha256: string | null;
    notes: string | null;
    createdAt: string;
};
export type VaultSearchQuery = {
    q?: string;
    kind?: VaultAssetKind | VaultAssetKind[];
    subtype?: string;
    scope?: VaultSplatScope;
    format?: string;
    performanceTier?: VaultPerformanceTier;
    skeleton?: 'humanoid' | 'quadruped';
    engine?: VaultRuntime;
    license?: VaultAssetSummary['license'];
    source?: VaultAssetSummary['source'];
    origin?: VaultAssetSummary['origin'];
    creatorId?: string;
    rank?: VaultRankMode;
    page?: number;
    limit?: number;
};
export type VaultSearchResult = {
    items: VaultAssetSummary[];
    totalItems: number;
};
export type VaultResolvedAsset<K extends VaultAssetKind = VaultAssetKind> = {
    handle: VaultAssetHandle;
    asset: VaultAssetDetail<K>;
    artifact: VaultResolvedArtifact;
    /**
     * False only for a historical version: the backend currently exposes related
     * artifacts on current-version detail, not version-history rows.
     */
    relatedArtifactsComplete: boolean;
};
export type VaultArtifactReference = {
    role: 'primary' | string;
    url: string | null;
    mimeType: string;
    sizeBytes: number;
    checksumSha256: string | null;
};
export type VaultLoadPlan = {
    loader: 'gltf';
    purpose: 'prop' | 'character' | 'animation' | 'environment' | 'terrain';
    handle: VaultAssetHandle;
    primary: VaultArtifactReference;
    related: VaultArtifactReference[];
} | {
    loader: 'image';
    purpose: 'texture' | 'decal';
    handle: VaultAssetHandle;
    primary: VaultArtifactReference;
    related: VaultArtifactReference[];
} | {
    loader: 'audio';
    purpose: 'audio';
    handle: VaultAssetHandle;
    primary: VaultArtifactReference;
    related: VaultArtifactReference[];
} | {
    loader: 'hdr-environment';
    purpose: 'sky';
    format: 'hdr' | 'exr';
    handle: VaultAssetHandle;
    primary: VaultArtifactReference;
    related: VaultArtifactReference[];
} | {
    loader: 'gaussian-splat';
    purpose: 'gaussian_splat' | 'environment';
    format: 'spz';
    scope: VaultSplatScope;
    handle: VaultAssetHandle;
    primary: VaultArtifactReference;
    related: VaultArtifactReference[];
} | {
    loader: 'helix-descriptor';
    purpose: 'material' | 'scene' | 'terrain' | 'vfx' | 'sky';
    schema: 'helix-material@1' | 'helix-scene@1' | 'helix-terrain@1' | 'helix-vfx@1' | 'helix-sky@1';
    handle: VaultAssetHandle;
    primary: VaultArtifactReference;
    related: VaultArtifactReference[];
};
export type VaultDownloadedArtifact = {
    reference: VaultArtifactReference;
    bytes: ArrayBuffer;
    checksumVerified: boolean;
};
export type VaultInstallResult = {
    asset: VaultResolvedAsset;
    plan: VaultLoadPlan;
    primary: VaultDownloadedArtifact;
    related: VaultDownloadedArtifact[];
};
export type VaultClientOptions = {
    /**
     * HELIX API origin (the client appends `/api/v1/vault`) or a full Vault API
     * base ending in `/api/v1/vault`.
     */
    apiBaseUrl: string;
    fetch?: typeof fetch;
    accessToken?: string | null | (() => string | null | Promise<string | null>);
    /** Optional portable SHA-256 implementation; output must be lowercase hex. */
    sha256?: (bytes: ArrayBuffer) => Promise<string>;
};
export type VaultInstallOptions = {
    /** Related rendition roles to fetch. Omit to fetch no related artifacts. */
    relatedRoles?: string[];
    /** Defaults to true whenever the server supplied a checksum. */
    verifyChecksum?: boolean;
};
export declare class VaultApiError extends Error {
    readonly status: number;
    readonly url: string;
    readonly responseBody: string;
    constructor(status: number, url: string, responseBody: string);
}
export declare class VaultArtifactUnavailableError extends Error {
    readonly handle: VaultAssetHandle;
    constructor(handle: VaultAssetHandle);
}
export declare class VaultChecksumMismatchError extends Error {
    readonly expected: string;
    readonly actual: string;
    constructor(expected: string, actual: string);
}
export declare class VaultUnsupportedRuntimeError extends Error {
    readonly kind: VaultAssetKind;
    readonly mimeType: string;
    constructor(kind: VaultAssetKind, mimeType: string, reason: string);
}
export declare class VaultCapabilityUnavailableError extends Error {
    readonly capability: 'fetch' | 'sha256';
    constructor(capability: 'fetch' | 'sha256');
}
/**
 * Convert a resolved Vault artifact into a renderer-neutral loader handoff.
 * The SDK never imports or guesses a rendering engine.
 */
export declare function createVaultLoadPlan(resolved: VaultResolvedAsset): VaultLoadPlan;
export type VaultClient = {
    search(query?: VaultSearchQuery): Promise<VaultSearchResult>;
    get<K extends VaultAssetKind = VaultAssetKind>(assetId: string): Promise<VaultAssetDetail<K>>;
    versions(assetId: string): Promise<VaultAssetVersion[]>;
    resolve<K extends VaultAssetKind = VaultAssetKind>(handleOrAssetId: VaultAssetHandle | string): Promise<VaultResolvedAsset<K>>;
    createLoadPlan(resolved: VaultResolvedAsset): VaultLoadPlan;
    download(handleOrAssetId: VaultAssetHandle | string, options?: Pick<VaultInstallOptions, 'verifyChecksum'>): Promise<VaultDownloadedArtifact>;
    downloadArtifact(reference: VaultArtifactReference, options?: Pick<VaultInstallOptions, 'verifyChecksum'>): Promise<VaultDownloadedArtifact>;
    install(handleOrAssetId: VaultAssetHandle | string, options?: VaultInstallOptions): Promise<VaultInstallResult>;
};
export declare function createVaultClient(options: VaultClientOptions): VaultClient;
export {};