export declare const DEFAULT_MATERIAL_PACK_SLUG = "helix-materials";
export type HelixMaterialKind = 'texture' | 'glass' | 'procedural_water';
export type HelixMaterialMapPaths = {
    albedo: string;
    normal: string;
    orm: string;
};
/** One texture-resolution variant a material declares (catalog schemaVersion 2+). */
export type HelixMaterialResolutionVariant = {
    pixels?: number;
    maps: HelixMaterialMapPaths;
};
/** A resolution tier the pack declares catalog-wide (catalog schemaVersion 2+). */
export type HelixMaterialResolutionTier = {
    key: string;
    pixels?: number;
    default?: boolean;
};
/** One resolvable resolution of one material, normalized across schema versions. */
export type HelixMaterialResolutionOption = {
    key: string;
    pixels: number | null;
    maps: HelixMaterialMapPaths;
};
export type HelixMaterialDefinition = {
    id: string;
    name: string;
    category: string;
    kind: HelixMaterialKind;
    tags: string[];
    repeatPerMeter: number;
    roughness: number;
    metalness: number;
    swatch: string;
    normalScale: number;
    /** The default resolution's maps. Unchanged across schema versions. */
    maps?: HelixMaterialMapPaths;
    /** Names which `resolutions` key `maps` mirrors. */
    defaultResolution?: string;
    /** Every texture resolution this material carries. */
    resolutions?: Record<string, HelixMaterialResolutionVariant>;
    source?: {
        provider?: string;
        assetId?: string;
        license?: string;
        url?: string;
        sourceResolution?: string;
        [key: string]: unknown;
    };
    glass?: {
        color: number;
        opacity: number;
        transmission: number;
    };
    water?: {
        color: number;
        opacity: number;
        transmission: number;
        roughness: number;
        waveScale?: number;
        waveSpeed?: number;
    };
    tiling?: {
        technique?: string;
        wrap?: number;
        accepted?: boolean;
        measuredAt?: string;
        wrapBefore?: number;
        wrapAfter?: number;
        bandAfter?: number;
        [key: string]: unknown;
    };
    [key: string]: unknown;
};
export type HelixMaterialCatalog = {
    /** Verbatim from the pack: 1, "1", 2, "2" are all valid spellings. */
    schemaVersion: number | string;
    pack: {
        slug: string;
        version: string;
    };
    resolutions?: HelixMaterialResolutionTier[];
    materials: HelixMaterialDefinition[];
};
export type ResolvedHelixMaterial = HelixMaterialDefinition & {
    /** Absolute URLs for the resolved resolution. */
    maps?: HelixMaterialMapPaths;
    /** Absolute URLs per declared variant, so a caller can switch tiers in place. */
    resolutions?: Record<string, HelixMaterialResolutionVariant>;
    resolution?: {
        key: string;
        pixels: number | null;
        available: string[];
    };
};
export type HelixMaterialQuery = {
    query?: string;
    category?: string;
    kind?: HelixMaterialKind;
    /** Palette budget for one world/scene. The global catalog remains unbounded. */
    limit?: number;
};
export type HelixMaterialLibrary = {
    readonly assetBaseUrl: string;
    readonly catalog: HelixMaterialCatalog;
    /** Tiers the pack declares catalog-wide; `[]` for a schemaVersion 1 pack. */
    readonly catalogResolutions: HelixMaterialResolutionTier[];
    list(query?: HelixMaterialQuery): HelixMaterialDefinition[];
    get(id: string): HelixMaterialDefinition | null;
    /** Every resolution one material offers, with maps absolutized like `resolve`. */
    resolutions(id: string): HelixMaterialResolutionOption[];
    /** Throws when `options.resolution` names a key the material does not declare. */
    resolve(id: string, options?: {
        resolution?: string;
    }): ResolvedHelixMaterial | null;
};
export declare function createMaterialLibrary(assetBaseUrl: string, catalog: HelixMaterialCatalog): HelixMaterialLibrary;
export declare function createMaterialsNamespace(fetchCatalog?: typeof fetch): {
    load(assetBaseUrl: string): Promise<HelixMaterialLibrary>;
    fromCatalog(assetBaseUrl: string, catalog: HelixMaterialCatalog): HelixMaterialLibrary;
    clearCache(): void;
};