import type { EcoPagesAppConfig } from '../../../types/internal-types.js';
import type { EcoComponent, EcoPageComponent, EcoPageFile, HtmlTemplateProps, IntegrationRendererRenderOptions, PageBrowserGraphContribution, PageBrowserGraphContributionContext, PageBrowserGraphResult, PageMetadataProps, RouteRendererBody, RouteRendererOptions, RouteRenderResult, EcoPageLayoutEntry } from '../../../types/public-types.js';
import type { AssetProcessingService, ProcessedAsset } from '../../../services/assets/asset-processing-service/index.js';
import type { HtmlDocumentContribution } from '../../../services/html/html-transformer.service.js';
import { OwnershipValidationService } from '../ownership-graph/ownership-validation.service.js';
import { PageBrowserGraphService } from '../page-browser-graph/page-browser-graph.service.js';
import type { GroupedGraphBuildPlan } from '../page-browser-graph/grouped-graph-build-plan.js';
import type { ResolvedPageDependencies } from '../../page-loading/resolved-page-dependencies.js';
export type RouteRenderOrchestratorResolvedInputs = {
    Page: EcoPageFile['default'] | EcoPageComponent<any>;
    pageModule: EcoPageFile;
    HtmlTemplate: EcoComponent<HtmlTemplateProps>;
    Layouts: EcoComponent[];
    Layout?: EcoComponent;
    layoutEntries?: EcoPageLayoutEntry[];
    props: Record<string, unknown>;
    metadata: PageMetadataProps;
    integrationSpecificProps: Record<string, unknown>;
};
export type RouteRenderOrchestratorResolvedDependencies = {
    resolvedDependencies: ProcessedAsset[];
};
/**
 * Structural HTML work applied after the route body has been fully resolved.
 *
 * The shared route flow only needs to know whether a post-render HTML step
 * exists. When `finalizeHtml` is absent, the captured body can be reused as-is.
 */
export type RouteHtmlFinalization = {
    finalizeHtml?(html: string): string;
    htmlContributions?: HtmlDocumentContribution[];
};
export interface RouteRenderOrchestratorAdapter<C> {
    /**
     * Name of the owning Integration for the current route render.
     */
    readonly name: string;
    /**
     * Loads the Integration-owned route inputs needed for one Page render.
     */
    resolveRouteRenderInputs(routeOptions: RouteRendererOptions): Promise<RouteRenderOrchestratorResolvedInputs>;
    /**
     * Resolves route-owned dependencies needed before Integration rendering starts.
     */
    resolveRouteDependencies(input: {
        components: (EcoComponent | Partial<EcoComponent>)[];
    }): Promise<RouteRenderOrchestratorResolvedDependencies>;
    /**
     * Collects declarative Page Browser Graph requirements for one route instance.
     */
    collectPageBrowserGraphContribution(context: PageBrowserGraphContributionContext): Promise<PageBrowserGraphContribution | undefined>;
    resolvePageDependencies(context: PageBrowserGraphContributionContext): Promise<ResolvedPageDependencies | undefined>;
    /**
     * Builds the graph contribution context for one route file and optional params.
     */
    buildPageBrowserGraphContributionContext(routeFile: string, routeOptions?: Pick<RouteRendererOptions, 'params' | 'query'>): Promise<PageBrowserGraphContributionContext>;
    /**
     * Executes the Integration-specific route render.
     */
    renderRouteBody(renderOptions: IntegrationRendererRenderOptions<C>): Promise<RouteRendererBody>;
    /**
     * Returns the structural Html finalization plan for one prepared route render.
     */
    getRouteHtmlFinalization(renderOptions: IntegrationRendererRenderOptions<C>): RouteHtmlFinalization;
    /**
     * Runs SSR-policy response transformation and returns the body value exposed to callers.
     */
    transformRouteResponse(response: Response, htmlContributions?: HtmlDocumentContribution[], pagePackage?: IntegrationRendererRenderOptions<C>['pagePackage']): Promise<RouteRendererBody>;
}
/**
 * Captured route-render output in both replayable body and string HTML forms.
 */
export interface CapturedHtmlRenderResult {
    body: RouteRendererBody;
    html: string;
}
/**
 * Optional app-scoped collaborators used by the route render orchestrator.
 */
export interface RouteRenderOrchestratorDependencies {
    ownershipValidationService?: OwnershipValidationService;
    pageBrowserGraphService?: PageBrowserGraphService;
}
/**
 * Owns one route render from normalized module loading through final HTML output.
 *
 * This orchestrator keeps route rendering as one app-scoped unit while still
 * delegating integration-specific behavior through the adapter seam. It owns
 * route-root validation, dependency aggregation, page package creation, and the
 * final HTML/body handling that happens after the integration render returns.
 */
export declare class RouteRenderOrchestrator {
    private readonly appConfig;
    private readonly assetProcessingService;
    private readonly ownershipValidationService;
    private readonly pageBrowserGraphService;
    constructor(appConfig: EcoPagesAppConfig, assetProcessingService: AssetProcessingService, dependencies?: RouteRenderOrchestratorDependencies);
    /**
     * Builds normalized route render options before the integration render runs.
     *
     * This preparation step validates route-root ownership, resolves page data,
     * collects processed assets, and produces the page package consumed by downstream
     * HTML transformation.
     */
    prepareRenderOptions<C = unknown>(routeOptions: RouteRendererOptions, adapter: RouteRenderOrchestratorAdapter<C>): Promise<IntegrationRendererRenderOptions<C>>;
    resolveDeclaredPageBrowserGraph(input: {
        routeFile: string;
        dependencyInstanceKey?: string;
        integrationName: string;
        collectContribution: () => Promise<PageBrowserGraphContribution | undefined>;
        groupedBuildPlan?: GroupedGraphBuildPlan;
    }): Promise<PageBrowserGraphResult | undefined>;
    /**
     * Captures one route render body as HTML while preserving a replayable body value.
     */
    captureHtmlRender(render: () => Promise<RouteRendererBody>): Promise<CapturedHtmlRenderResult>;
    /**
     * Executes the full route-render flow and returns the final body plus cache strategy.
     */
    execute<C = unknown>(options: RouteRendererOptions, adapter: RouteRenderOrchestratorAdapter<C>): Promise<RouteRenderResult>;
    /**
     * Executes the route-render finalization path for already prepared render options.
     */
    executePrepared<C = unknown>(renderOptions: IntegrationRendererRenderOptions<C>, adapter: RouteRenderOrchestratorAdapter<C>): Promise<RouteRenderResult>;
    private captureRenderedBody;
}