/**
 * Domain Manifest
 *
 * Centralizes domain-level routing preferences and evidence checklist mappings.
 * This reduces hard-coded branching in orchestrator and provides one place
 * to evolve domain behavior for new scenarios.
 */
export type StrategyExecutionPolicy = 'prefer_strategy' | 'prefer_hypothesis';
export type AnalysisPlanModeLike = 'strategy' | 'hypothesis' | 'clarify' | 'compare' | 'extend' | 'drill_down';
export type SceneTypeGroup = 'startup' | 'scroll' | 'interaction' | 'navigation' | 'app_switch' | 'idle' | 'device_state' | 'jank_region' | 'anr' | 'all';
export type SceneRouteProfile = 'legacy' | 'smart';
export interface SceneReconstructionRouteRule {
    id: string;
    routeProfile: SceneRouteProfile;
    sceneTypes?: string[];
    sceneTypeGroups?: SceneTypeGroup[];
    excludeSceneTypes?: string[];
    agentId: string;
    domain: string;
    directSkillId: string;
    descriptionTemplate: string;
    paramMapping: Record<string, string>;
    skillParams?: Record<string, any>;
    priority?: number;
}
/**
 * Scene Deep-Dive Route — maps user-clicked scene events to drill-down skills.
 *
 * Intentionally kept separate from SceneReconstructionRouteRule: Stage2 batch
 * routes match by scene category (coarse), deep-dive routes match by individual
 * event type (fine). The two concepts deliberately do not share a data model.
 */
export interface SceneDeepDiveRoute {
    /** Stable identifier for logs and debugging */
    id: string;
    /** Event types this route matches (e.g. cold_start/warm_start/hot_start) */
    eventTypes: string[];
    /** Skill to execute when user clicks an event of these types */
    skillId: string;
    /** User-facing description (Chinese) */
    description: string;
    /** How to map DisplayedScene fields into skill params */
    paramMapping: Record<string, string>;
    /** Fallback route used when no eventTypes match */
    fallback?: boolean;
}
export interface DomainManifest {
    strategyExecutionPolicies: Record<string, StrategyExecutionPolicy>;
    aspectEvidenceMap: Record<string, string[]>;
    modeEvidenceMap: Partial<Record<AnalysisPlanModeLike, string[]>>;
    sceneReconstructionRoutes: SceneReconstructionRouteRule[];
    sceneDeepDiveRoutes: SceneDeepDiveRoute[];
    baselineEvidence: string;
    fallbackEvidence: string[];
}
export interface StrategyLoopDecisionInput {
    strategyId: string;
    forceStrategy?: boolean;
    preferredLoopMode?: string | null;
}
export declare const DEFAULT_DOMAIN_MANIFEST: DomainManifest;
export declare function getSceneReconstructionRoutes(profileOrManifest?: SceneRouteProfile | DomainManifest, maybeManifest?: DomainManifest): SceneReconstructionRouteRule[];
/**
 * Get all scene deep-dive routes from manifest, with fallback to defaults.
 */
export declare function getSceneDeepDiveRoutes(manifest?: DomainManifest): SceneDeepDiveRoute[];
/**
 * Look up a deep-dive route by scene/event type.
 * Returns the first route whose eventTypes includes the given type,
 * or the first fallback route if no match, or null.
 */
export declare function getSceneDeepDiveRoute(eventType: string, manifest?: DomainManifest): SceneDeepDiveRoute | null;
export declare function matchesSceneReconstructionRoute(sceneType: string, route: SceneReconstructionRouteRule): boolean;
export declare function resolveSceneReconstructionRoute(sceneType: string, manifest?: DomainManifest, routeProfile?: SceneRouteProfile): SceneReconstructionRouteRule | null;
export declare function getStrategyExecutionPolicy(strategyId: string, manifest?: DomainManifest): StrategyExecutionPolicy;
export declare function shouldPreferHypothesisLoop(input: StrategyLoopDecisionInput, manifest?: DomainManifest): boolean;
export declare function getAspectEvidenceChecklist(aspects: string[], manifest?: DomainManifest): string[];
export declare function getModeSpecificEvidenceChecklist(mode: AnalysisPlanModeLike, manifest?: DomainManifest): string[];
//# sourceMappingURL=domainManifest.d.ts.map