import { type SceneNativeAttachmentContract, type SceneRuntimeServiceContract } from "@skenora/contracts";
import { type CapabilityDescription } from "@skenora/contracts";
import { type FlowNodeRegistryView } from "@skenora/flow";
import { SCENE_PLAN_DEFAULTS_PROFILE, type SceneBlueprintInput } from "../model/types.js";
import type { ScenePlanDiagnostic } from "../diagnostics/diagnostics.js";
export declare const SCENE_INFORMATION_VERSION: 1;
export interface SceneInformationOptions {
    readonly domains?: readonly string[];
    readonly capabilityIds?: readonly string[];
    readonly flowRegistry?: FlowNodeRegistryView;
    readonly nativeAttachmentContracts?: readonly SceneNativeAttachmentContract[];
    readonly runtimeServiceContracts?: readonly SceneRuntimeServiceContract[];
    readonly capabilityDescriptions?: readonly CapabilityDescription[];
}
/** Detached data; safe to serialize without importing Babylon or starting a host. */
export declare function describeSceneCapabilities(options?: SceneInformationOptions): readonly CapabilityDescription[];
type Schema = Record<string, unknown>;
/** Syntax contract only. Reference, hierarchy, resource, device and host checks remain mandatory. */
export declare function getSceneBlueprintJsonSchema(options?: {
    normalized?: boolean;
}): Schema;
/** Redacts arbitrary plugin messages/details. IDs/paths originate in authoring input. */
export declare function toPublicScenePlanDiagnostics(diagnostics: readonly ScenePlanDiagnostic[]): {
    code: string | (string & {});
    severity: import("@skenora/contracts").SkenoraDiagnosticSeverity;
    stage: import("..").ScenePlanDiagnosticStage;
    path: (string | number)[];
    repair: string;
}[];
export declare function getScenePlanInformation(options?: SceneInformationOptions): {
    informationVersion: 1;
    protocol: {
        schema: "skenora.scene.blueprint";
        version: 1;
        defaultsProfile: "scene-v1";
    };
    capabilities: readonly CapabilityDescription[];
    fragments: {
        readonly schema: "skenora.scene.fragment";
        readonly version: 1;
        readonly supportedVersions: readonly [1, 2];
        readonly coordinateSpace: "source-parent-local";
        readonly owner: "@skenora/scene-plan";
        readonly functions: readonly ["extractSceneFragment", "validateSceneFragment", "planSceneFragmentInsertion", "getSceneFragmentExamples", "expandSceneFragmentTemplate", "planSceneFragmentReexpansion", "convertSceneFragmentVersion", "planSceneFragmentInstanceInsertion", "planSceneFragmentInstanceUpgrade", "planSceneFragmentInstanceAdoption", "planSceneFragmentInstanceDetach", "planSceneFragmentRepetition"];
        readonly editorEntry: "@skenora/sdk/editor: SkenoraEditor.insertFragment";
        readonly budgets: {
            readonly maxBytes: number;
            readonly maxDepth: 64;
            readonly maxSourceBytes: number;
            readonly entities: 1000;
            readonly resources: 256;
            readonly materials: 256;
            readonly materialBindings: 2000;
            readonly textureAnimations: 256;
            readonly cameraPaths: 64;
            readonly flows: 64;
            readonly flowNodes: 2000;
            readonly flowEdges: 4000;
            readonly variablesAndEvents: 512;
            readonly operations: 5000;
            readonly animationTracks: 1024;
            readonly animationClips: 128;
        };
        readonly rules: readonly ["Native scene records are authoritative; this container is not a second scene schema. validateSceneFragment enforces the bounded closed subset.", "SceneFragment V1 cannot carry scene animationTracks or animationClips. Extraction rejects relevant entity/material targets, clip camera paths and Flow references, and counts unrelated excluded domains; insertion preserves existing target animations.", "V2 is explicit: it carries supported scene tracks, complete synchronized clips, camera paths, static Flow references and typed extensions. Ordered animation arrays merge atomically. Conversion to V1 rejects data loss.", "Managed V2 instances persist source mappings, a bounded baseline and local overrides. Explicit upgrades use baseline/current/template comparison, advance baseline and overrides in one Patch, and reject unresolved conflicts. Ordinary Editor edits refresh overrides in the same history entry.", "Template content hashes use FNV-1a for deterministic change detection, not cryptographic authentication. Instance content remains ordinary scene records; no template runtime or automatic update service is required.", "Adoption requires an exact reproducible old baseline and ID map. Detach preserves content. Added objects outside a managed baseline remain independent and cannot be silently deleted by an upgrade.", "Select complete authored subtrees with one source parent. Flow IDs are explicit; no implicit external-reference expansion.", "Use an explicit namespace for every copy. Variables and namespaces must be dot-free when variables are present.", "Map every logical resource ID to an existing compatible target asset. Resource locators never belong in fragment resources.", "Copy material definitions by default. Explicit equality-checked reuse may affect existing bound entities.", "Reference metadata belongs to the actual Flow node definition. Dynamic identity inputs and opaque custom nodes are rejected.", "Camera behavior requires preserve-world opt-in; world camera paths do not move with the inserted group.", "The pure result is one revision/hash-guarded ordinary ScenePatch, typed mappings and warnings. It does not acquire resources or mutate an editor.", "SDK insertion checks preview twice, preflights actual candidate assets, rechecks definitions and revision, and commits through one history entry.", "Fragment templates V1 preserve bounded single-axis position/scaling parameters. V2 additionally accepts bindings on a numeric parameter: 1–16 transform/programNumber targets, 256 bindings total, each with optional finite multiplier and offset. No arbitrary paths or executable expressions. Both versions permit 64 parameters, 32 color/visibility variants and 256 variant overrides.", "Each V2 programNumber binding names an owned materialId and its declared numeric parameter. Transform bindings name entityId, property position/scaling and axis x/y/z. Mapped endpoints must satisfy the destination range; duplicate destinations reject. Expansion writes ordinary fragment records, and re-expansion preserves revision and shared-material conflict checks.", "Explicit re-expansion returns before/after previews and a revision-bound Patch. Managed-field conflicts and materials shared outside the insertion reject; no automatic updates or executable expressions.", "Execution permits only signal, modelLoadPolicy, label and explicit allowVariables. Planned mappings do not prove a commit; committed does not prove ready projection."];
        readonly excluded: readonly ["nested or automatically synchronized template instances", "automatic live variant propagation", "automatic asset import", "behavior startup", "rendered verification"];
        readonly diagnosticRepairs: {
            readonly "fragment-animation-tracks-unsupported": "Explicitly choose V2 with complete animation closure or use a native scene document. V1 cannot carry these tracks; do not strip them to retry automatically.";
            readonly "fragment-invalid": "Use supported native records and complete finite JSON values.";
            readonly "fragment-budget-exceeded": "Reduce input bytes, depth, selected records or operations; host budgets may only tighten defaults.";
            readonly "fragment-root-space-mismatch": "Select roots with a common source parent or extract separate fragments.";
            readonly "fragment-external-reference": "Include the referenced owner in the selection or remove the behavior.";
            readonly "fragment-dynamic-reference": "Disconnect identity value inputs and provide static config targets.";
            readonly "fragment-opaque-data": "Remove unsupported fields or register precise reference metadata on the owning node definition.";
            readonly "fragment-slot-identity-unsupported": "Use a supported generated selector or the model's asset-local source selector.";
            readonly "fragment-id-conflict": "Choose another explicit namespace; keep the original Patch for an idempotent retry.";
            readonly "fragment-resource-binding-invalid": "Supply every existing compatible target asset ID, including declared integrity and media type.";
            readonly "fragment-material-reuse-conflict": "Copy the material or select a normalized equal definition without competing texture tracks.";
            readonly "fragment-shared-material": "Inspect sharedMaterialImpacts before deliberately sharing behavior with existing entities.";
            readonly "fragment-variable-default-missing": "Include defaults for every selected variable reference.";
            readonly "fragment-preview-active": "Stop manual preview before insertion; do not restart it during resource waiting.";
            readonly "flow-registry-changed": "Capture the current registry and revision and plan again.";
        };
    };
    nativeAttachments: {
        schema: Record<string, unknown>;
        contracts: readonly SceneNativeAttachmentContract[];
        limits: Readonly<{
            records: 256;
            resourcesPerRecord: 16;
            configBytes: 16384;
            bytes: number;
            depth: 32;
        }>;
        runtimePlugin: string;
        states: string[];
        policy: string;
    };
    runtimeServices: {
        schema: Record<string, unknown>;
        extensionSchema: Record<string, unknown>;
        contracts: readonly SceneRuntimeServiceContract[];
        limits: Readonly<{
            records: 64;
            referencesPerSlot: 64;
            slots: 32;
            configBytes: 32768;
            bytes: number;
            depth: 32;
        }>;
        policy: string;
    };
    inspection: {
        version: number;
        objectKinds: string[];
        inspect: {
            method: string;
            target: string;
            referencePageLimit: number;
            impactLimit: number;
            cursor: string;
            observation: string;
        };
        preview: {
            method: string;
            option: string;
            maxChanges: number;
            maxCharacters: number;
            binding: string;
            privateFields: string;
        };
        replacement: {
            method: string;
            policy: string;
        };
        mutations: {
            functions: string[];
            policy: string;
            patchOperations: string[];
            replacement: string;
        };
        limitations: string[];
    };
    annotations: {
        readonly APIs: readonly ["createSceneDimension", "createSceneBoundsDimensions", "createSceneCallout", "formatSceneLength", "layoutSceneAnnotations"];
        readonly units: readonly ["mm", "cm", "m", "in", "ft"];
        readonly limits: {
            readonly layoutLabels: 256;
            readonly reservedRectangles: 32;
            readonly textCharacters: 512;
        };
        readonly semantics: readonly ["Ordinary group/shape/primitive/annotation records; no new persistent schema", "Explicit endpoints are parent-local; observed dimensions are fixed world-axis AABB snapshots", "Labels use explicit scene scale and deterministic decimal formatting", "Hosts measure text and present layout rectangles in CSS pixels; projections arrive in render pixels", "Layout priority packing hides crowded labels; it does not infer font metrics or route leader crossings", "Occlusion is opt-in native ray picking, not geometric visibility or a depth-buffer proof"];
    };
    spatial: {
        APIs: string[];
        patterns: string[];
        limits: {
            entities: number;
            inputPathPoints: number;
            staticTriangles: number;
        };
        semantics: string[];
    };
    motionPaths: {
        APIs: string[];
        coordinateSpace: string;
        interpolation: string;
        limits: {
            inputPoints: number;
            keyframesPerTrack: number;
        };
        reduction: string;
    };
    importedAnimations: {
        APIs: string[];
        playbackSchema: Readonly<Record<string, unknown>>;
        persistentFlow: string;
        limits: {
            targetTracks: number;
            page: number;
            targetDetailsPerGroup: number;
        };
        semantics: string[];
    };
    repetition: {
        API: string;
        representation: string;
        limits: {
            count: number;
            operations: number;
        };
        materials: string;
        optimization: string;
    };
    semantics: {
        namespace: string;
        capability: string;
        version: number;
        schema: Record<string, unknown>;
        limits: {
            records: 1024;
            labels: 16;
            anchors: 16;
            text: 256;
        };
        APIs: string[];
        semantics: string[];
    };
    schemas: {
        blueprintInput: Schema;
        normalizedBlueprint: Schema;
        sceneAnimationTrack: Record<string, unknown>;
        sceneAnimationClip: Record<string, unknown>;
        authoredMaterial: Record<string, unknown>;
        proceduralGeometryProgram: Record<string, unknown>;
        materialProgram: Record<string, unknown>;
        textureProgram: Record<string, unknown>;
        renderGraph: Record<string, unknown>;
        simulationProgram: Readonly<Record<string, unknown>>;
        textureReference: Record<string, unknown>;
        hostQualityPolicy: {
            $schema: string;
            $id: string;
        };
        hostMaterialPolicy: {
            $schema: string;
            $id: string;
        };
    };
    nativeDefaults: import("@skenora/contracts").SceneDocumentData;
    flowNodes: {
        fragment?: import("@skenora/flow").FlowFragmentDescription;
        semantics?: import("@skenora/flow").FlowNodeSemantics;
        inputFallback: {
            port: string;
            configField: string;
            required: boolean;
            precedence: string;
        }[];
        configSchema?: {
            properties: {
                [x: string]: unknown;
            };
        };
        description?: string;
        type: string;
        category: "value" | "control" | "trigger" | "action";
        inputs: readonly import("@skenora/flow").FlowPortDefinition[];
        outputs: readonly import("@skenora/flow").FlowPortDefinition[];
    }[];
    diagnostics: {
        [x: string]: string;
    };
    examples: readonly SceneBlueprintExample[];
    repairExamples: ({
        id: string;
        input: {
            materials: ({
                shaderSource: string;
                id: import("@skenora/contracts").MaterialId;
                creation: import("@skenora/contracts").MaterialCreation;
                effects?: import("@skenora/contracts").MaterialSurfaceEffects;
                animations?: readonly import("@skenora/contracts").MaterialParameterAnimation[];
                program?: import("@skenora/contracts").MaterialProgram;
                generatedTextures?: Partial<Record<import("@skenora/contracts").MaterialTextureSlot, import("@skenora/contracts").TextureProgram>>;
                renderGraph?: import("@skenora/contracts").RenderGraphProgram;
                targetEntityId?: import("@skenora/contracts").EntityId;
                targetName?: string;
                workflow?: "metallic-roughness" | "specular-glossiness";
                baseColor?: import("@skenora/contracts").Color3Value;
                reflectivityColor?: import("@skenora/contracts").Color3Value;
                ambientColor?: import("@skenora/contracts").Color3Value;
                metallic?: number | null;
                roughness?: number | null;
                microSurface?: number;
                metallicF0Factor?: number;
                alpha?: number;
                emissiveColor?: import("@skenora/contracts").Color3Value;
                emissiveIntensity?: number;
                indexOfRefraction?: number;
                transparencyMode?: number;
                alphaCutOff?: number;
                useAlphaFromBaseColorTexture?: boolean;
                useLightmapAsShadowmap?: boolean;
                useAmbientInGrayScale?: boolean;
                useMicroSurfaceFromReflectivityMapAlpha?: boolean;
                useAutoMicroSurfaceFromReflectivityMap?: boolean;
                unlit?: boolean;
                doubleSided?: boolean;
                clearCoat?: {
                    enabled: boolean;
                    intensity: number;
                    roughness: number;
                    indexOfRefraction: number;
                    remapF0OnInterfaceChange?: boolean;
                    tintEnabled?: boolean;
                    tintColor?: import("@skenora/contracts").Color3Value;
                    tintThickness?: number;
                    tintColorAtDistance?: number;
                };
                sheen?: {
                    enabled: boolean;
                    intensity: number;
                    roughness: number;
                    color: import("@skenora/contracts").Color3Value;
                    linkWithBaseColor?: boolean;
                    useRoughnessFromMainTexture?: boolean;
                };
                anisotropy?: {
                    enabled: boolean;
                    intensity: number;
                    direction: import("@skenora/contracts").Vector2Value;
                };
                subSurface?: {
                    enabled?: boolean;
                    refractionEnabled: boolean;
                    translucencyEnabled: boolean;
                    indexOfRefraction: number;
                    volumeIndexOfRefraction: number;
                    minimumThickness: number;
                    maximumThickness: number;
                    tintColor: import("@skenora/contracts").Color3Value;
                    tintColorAtDistance: number;
                    refractionIntensity?: number;
                    translucencyIntensity?: number;
                    diffusionDistance?: import("@skenora/contracts").Color3Value;
                    linkRefractionWithTransparency?: boolean;
                    useAlbedoToTintRefraction?: boolean;
                    useAlbedoToTintTranslucency?: boolean;
                };
                textures?: Partial<Record<import("@skenora/contracts").MaterialTextureSlot, import("@skenora/contracts").TextureReference>>;
                extras?: Record<string, unknown>;
            } | {
                shaderSource: string;
                id: string;
            })[];
            version: import("..").ScenePlanVersion;
            schema: import("..").SceneBlueprintSchema;
            scene: Readonly<{
                id: string;
                name: string;
            }>;
            animationClips?: readonly import("@skenora/contracts").SceneAnimationClipV1[];
            entities?: readonly import("..").SceneBlueprintEntity[];
            materialBindings?: readonly import("..").SceneBlueprintMaterialBinding[];
            animationTracks?: readonly import("@skenora/contracts").SceneAnimationTrackV1[];
            textureAnimations?: readonly import("..").SceneBlueprintTextureAnimation[];
            camera?: Partial<import("@skenora/contracts").ViewportCameraConfig>;
            cameraPaths?: readonly import("..").SceneBlueprintCameraPath[];
            environment?: import("..").SceneBlueprintEnvironment;
            ground?: Partial<import("@skenora/contracts").GroundConfig>;
            fog?: Partial<import("@skenora/contracts").FogConfig>;
            weather?: import("..").SceneBlueprintWeather;
            lights?: readonly import("@skenora/contracts").LightConfig[];
            postProcess?: import("..").SceneBlueprintPostProcess;
            flows?: readonly import("..").SceneBlueprintFlow[];
            extensions?: readonly import("..").SceneBlueprintExtension[];
            resources?: readonly import("..").SceneBlueprintResource[];
            defaultsProfile?: typeof SCENE_PLAN_DEFAULTS_PROFILE;
            requires?: readonly import("..").SceneCapabilityRequirement[];
            initialVariables?: import("@skenora/contracts").JsonObject;
        };
        expected: {
            stage: string;
            code: string;
            path: (string | number)[];
        };
        repair: string;
    } | {
        id: string;
        input: SceneBlueprintInput;
        expected: {
            stage: string;
            code: string;
            path: (string | number)[];
        };
        repair: string;
    } | {
        id: string;
        input: {
            materialBindings: {
                target: {
                    nodeId: string;
                    slot: number;
                };
                id: string;
                materialId: string;
                entityId: string;
                targetName?: string;
            }[];
            version: import("..").ScenePlanVersion;
            schema: import("..").SceneBlueprintSchema;
            scene: Readonly<{
                id: string;
                name: string;
            }>;
            animationClips?: readonly import("@skenora/contracts").SceneAnimationClipV1[];
            entities?: readonly import("..").SceneBlueprintEntity[];
            materials?: readonly import("..").SceneBlueprintMaterial[];
            animationTracks?: readonly import("@skenora/contracts").SceneAnimationTrackV1[];
            textureAnimations?: readonly import("..").SceneBlueprintTextureAnimation[];
            camera?: Partial<import("@skenora/contracts").ViewportCameraConfig>;
            cameraPaths?: readonly import("..").SceneBlueprintCameraPath[];
            environment?: import("..").SceneBlueprintEnvironment;
            ground?: Partial<import("@skenora/contracts").GroundConfig>;
            fog?: Partial<import("@skenora/contracts").FogConfig>;
            weather?: import("..").SceneBlueprintWeather;
            lights?: readonly import("@skenora/contracts").LightConfig[];
            postProcess?: import("..").SceneBlueprintPostProcess;
            flows?: readonly import("..").SceneBlueprintFlow[];
            extensions?: readonly import("..").SceneBlueprintExtension[];
            resources?: readonly import("..").SceneBlueprintResource[];
            defaultsProfile?: typeof SCENE_PLAN_DEFAULTS_PROFILE;
            requires?: readonly import("..").SceneCapabilityRequirement[];
            initialVariables?: import("@skenora/contracts").JsonObject;
        };
        expected: {
            stage: string;
            code: string;
            path?: never;
        };
        repair: string;
    })[];
    recipes: {
        rules: string[];
        id: string;
        version: number;
        purpose: string;
    }[];
    sceneStyles: {
        id: import("./styles.js").SceneStyleId;
        title: "Soft gallery / 柔和展陈" | "Warm daylight / 暖色日光" | "Clear technical / 清晰设备";
        usage: "Single subjects, products and sculptural compositions; explicit scene meters." | "Open spatial compositions with host-authored floors and walls; not an enclosed-room lighting solver." | "Assemblies, parts and explanatory views; accent separates the active component.";
        surfaces: string[];
        persistence: string;
    }[];
    sceneExplosions: {
        readonly authoring: "Ordinary position tracks and two finite synchronized clips; one guarded Editor transaction";
        readonly limits: {
            readonly parts: 64;
            readonly durationMs: readonly [1, 60000];
        };
        readonly placement: readonly ["explicit parent-local offsets", "observed world radial", "observed world-axis layers"];
        readonly playback: readonly ["expand", "collapse", "progress", "pause", "resume", "reset"];
        readonly requires: readonly ["explicit document entity IDs", "ready observed geometry for automatic planning", "animation clip playback; explicit Editor preview"];
        readonly limitations: readonly ["No automatic decomposition of a monolithic imported mesh", "No collision or mechanical constraints", "Do not select both an ancestor and its descendant"];
    };
    particleEffects: {
        readonly presets: readonly [{
            readonly id: "aura-v1";
            readonly name: "Cool luminous halo";
            readonly mode: "continuous";
            readonly textures: readonly ["soft-dot-v1"];
        }, {
            readonly id: "embers-v1";
            readonly name: "Warm rising embers";
            readonly mode: "continuous";
            readonly textures: readonly ["soft-dot-v1", "rain-streak-v1"];
        }, {
            readonly id: "spark-burst-v1";
            readonly name: "Short golden spark burst";
            readonly mode: "explicit-trigger";
            readonly textures: readonly ["soft-dot-v1", "rain-streak-v1"];
        }];
        readonly layers: 2;
        readonly limits: {
            readonly size: readonly [0.01, 1000];
            readonly intensity: readonly [0.1, 3];
            readonly maxCapacity: 1800;
        };
        readonly fields: "Ordinary group and particle entities with explicit replaceable textures; no new entity kind";
        readonly playback: "Renderer playback or explicit Editor preview; spark burst does not auto-start";
        readonly limitations: readonly ["Visual sprites, not volumetric fire or collision simulation", "Host must install its explicit texture provider", "Glow is additive sprite blending; bloom is an optional separate presentation setting"];
    };
    particleClouds: {
        id: string;
        version: string;
        domain: string;
        description: string;
        inputSchema: Record<string, unknown>;
        targets: string[];
        semantics: string[];
        requirements: string[];
        diagnostics: {
            code: string;
            repair: string;
        }[];
        limits: Readonly<{
            points: 8192;
            shapes: 4;
            fields: 4;
            trailSamples: 4;
            sceneVertices: 65536;
        }>;
    };
    sceneSequences: {
        id: string;
        version: string;
        underlyingCapability: string;
        limits: {
            chapters: number;
            participants: number;
        };
        semantics: string[];
    };
    materialEffectParameters: {
        property: "gradientColorStart" | "gradientColorEnd" | "gradientStrength" | "rimColor" | "rimIntensity" | "rimPower" | "dissolveProgress" | "dissolveEdgeColor" | "dissolveEdgeIntensity" | "clipOffset" | "clipEdgeWidth" | "clipEdgeColor" | "clipEdgeIntensity" | "neonColor" | "neonIntensity" | "neonScale" | "neonWidth" | "neonPhase" | "neonPulseStrength" | "gradientStart" | "gradientEnd" | "dissolveScale" | "dissolveEdgeWidth" | "clipPlaneNormal";
        capabilityId: "skenora.material.effect.gradient" | "skenora.material.effect.rim" | "skenora.material.effect.dissolve" | "skenora.material.effect.clip" | "skenora.material.effect.neon";
        inputSchema: Record<string, unknown>;
        update: "parameter";
    }[];
    resourceMetadata: string[];
    boundaries: string[];
};
/** Complete ordinary inputs, shipped in dist as data returned by a public function. */
export interface SceneBlueprintExample {
    id: string;
    blueprint: SceneBlueprintInput;
    note: string;
}
export declare function getSceneBlueprintExamples(): readonly SceneBlueprintExample[];
export declare function getSceneBlueprintRepairExamples(): ({
    id: string;
    input: {
        materials: ({
            shaderSource: string;
            id: import("@skenora/contracts").MaterialId;
            creation: import("@skenora/contracts").MaterialCreation;
            effects?: import("@skenora/contracts").MaterialSurfaceEffects;
            animations?: readonly import("@skenora/contracts").MaterialParameterAnimation[];
            program?: import("@skenora/contracts").MaterialProgram;
            generatedTextures?: Partial<Record<import("@skenora/contracts").MaterialTextureSlot, import("@skenora/contracts").TextureProgram>>;
            renderGraph?: import("@skenora/contracts").RenderGraphProgram;
            targetEntityId?: import("@skenora/contracts").EntityId;
            targetName?: string;
            workflow?: "metallic-roughness" | "specular-glossiness";
            baseColor?: import("@skenora/contracts").Color3Value;
            reflectivityColor?: import("@skenora/contracts").Color3Value;
            ambientColor?: import("@skenora/contracts").Color3Value;
            metallic?: number | null;
            roughness?: number | null;
            microSurface?: number;
            metallicF0Factor?: number;
            alpha?: number;
            emissiveColor?: import("@skenora/contracts").Color3Value;
            emissiveIntensity?: number;
            indexOfRefraction?: number;
            transparencyMode?: number;
            alphaCutOff?: number;
            useAlphaFromBaseColorTexture?: boolean;
            useLightmapAsShadowmap?: boolean;
            useAmbientInGrayScale?: boolean;
            useMicroSurfaceFromReflectivityMapAlpha?: boolean;
            useAutoMicroSurfaceFromReflectivityMap?: boolean;
            unlit?: boolean;
            doubleSided?: boolean;
            clearCoat?: {
                enabled: boolean;
                intensity: number;
                roughness: number;
                indexOfRefraction: number;
                remapF0OnInterfaceChange?: boolean;
                tintEnabled?: boolean;
                tintColor?: import("@skenora/contracts").Color3Value;
                tintThickness?: number;
                tintColorAtDistance?: number;
            };
            sheen?: {
                enabled: boolean;
                intensity: number;
                roughness: number;
                color: import("@skenora/contracts").Color3Value;
                linkWithBaseColor?: boolean;
                useRoughnessFromMainTexture?: boolean;
            };
            anisotropy?: {
                enabled: boolean;
                intensity: number;
                direction: import("@skenora/contracts").Vector2Value;
            };
            subSurface?: {
                enabled?: boolean;
                refractionEnabled: boolean;
                translucencyEnabled: boolean;
                indexOfRefraction: number;
                volumeIndexOfRefraction: number;
                minimumThickness: number;
                maximumThickness: number;
                tintColor: import("@skenora/contracts").Color3Value;
                tintColorAtDistance: number;
                refractionIntensity?: number;
                translucencyIntensity?: number;
                diffusionDistance?: import("@skenora/contracts").Color3Value;
                linkRefractionWithTransparency?: boolean;
                useAlbedoToTintRefraction?: boolean;
                useAlbedoToTintTranslucency?: boolean;
            };
            textures?: Partial<Record<import("@skenora/contracts").MaterialTextureSlot, import("@skenora/contracts").TextureReference>>;
            extras?: Record<string, unknown>;
        } | {
            shaderSource: string;
            id: string;
        })[];
        version: import("..").ScenePlanVersion;
        schema: import("..").SceneBlueprintSchema;
        scene: Readonly<{
            id: string;
            name: string;
        }>;
        animationClips?: readonly import("@skenora/contracts").SceneAnimationClipV1[];
        entities?: readonly import("..").SceneBlueprintEntity[];
        materialBindings?: readonly import("..").SceneBlueprintMaterialBinding[];
        animationTracks?: readonly import("@skenora/contracts").SceneAnimationTrackV1[];
        textureAnimations?: readonly import("..").SceneBlueprintTextureAnimation[];
        camera?: Partial<import("@skenora/contracts").ViewportCameraConfig>;
        cameraPaths?: readonly import("..").SceneBlueprintCameraPath[];
        environment?: import("..").SceneBlueprintEnvironment;
        ground?: Partial<import("@skenora/contracts").GroundConfig>;
        fog?: Partial<import("@skenora/contracts").FogConfig>;
        weather?: import("..").SceneBlueprintWeather;
        lights?: readonly import("@skenora/contracts").LightConfig[];
        postProcess?: import("..").SceneBlueprintPostProcess;
        flows?: readonly import("..").SceneBlueprintFlow[];
        extensions?: readonly import("..").SceneBlueprintExtension[];
        resources?: readonly import("..").SceneBlueprintResource[];
        defaultsProfile?: typeof SCENE_PLAN_DEFAULTS_PROFILE;
        requires?: readonly import("..").SceneCapabilityRequirement[];
        initialVariables?: import("@skenora/contracts").JsonObject;
    };
    expected: {
        stage: string;
        code: string;
        path: (string | number)[];
    };
    repair: string;
} | {
    id: string;
    input: SceneBlueprintInput;
    expected: {
        stage: string;
        code: string;
        path: (string | number)[];
    };
    repair: string;
} | {
    id: string;
    input: {
        materialBindings: {
            target: {
                nodeId: string;
                slot: number;
            };
            id: string;
            materialId: string;
            entityId: string;
            targetName?: string;
        }[];
        version: import("..").ScenePlanVersion;
        schema: import("..").SceneBlueprintSchema;
        scene: Readonly<{
            id: string;
            name: string;
        }>;
        animationClips?: readonly import("@skenora/contracts").SceneAnimationClipV1[];
        entities?: readonly import("..").SceneBlueprintEntity[];
        materials?: readonly import("..").SceneBlueprintMaterial[];
        animationTracks?: readonly import("@skenora/contracts").SceneAnimationTrackV1[];
        textureAnimations?: readonly import("..").SceneBlueprintTextureAnimation[];
        camera?: Partial<import("@skenora/contracts").ViewportCameraConfig>;
        cameraPaths?: readonly import("..").SceneBlueprintCameraPath[];
        environment?: import("..").SceneBlueprintEnvironment;
        ground?: Partial<import("@skenora/contracts").GroundConfig>;
        fog?: Partial<import("@skenora/contracts").FogConfig>;
        weather?: import("..").SceneBlueprintWeather;
        lights?: readonly import("@skenora/contracts").LightConfig[];
        postProcess?: import("..").SceneBlueprintPostProcess;
        flows?: readonly import("..").SceneBlueprintFlow[];
        extensions?: readonly import("..").SceneBlueprintExtension[];
        resources?: readonly import("..").SceneBlueprintResource[];
        defaultsProfile?: typeof SCENE_PLAN_DEFAULTS_PROFILE;
        requires?: readonly import("..").SceneCapabilityRequirement[];
        initialVariables?: import("@skenora/contracts").JsonObject;
    };
    expected: {
        stage: string;
        code: string;
        path?: never;
    };
    repair: string;
})[];
export {};
//# sourceMappingURL=information.d.ts.map