import type { ProcessedAsset } from '../../../services/assets/asset-processing-service/index.js';
import type { BaseIntegrationContext, ComponentRenderInput, ComponentRenderResult, EcoComponent, ForeignSubtreeRenderPayload } from '../../../types/public-types.js';
import { type ForeignChildRuntime } from './component-render-context.js';
export type QueuedForeignChildDecisionInput = {
    currentIntegration: string;
    targetIntegration?: string;
    component: EcoComponent;
    props: Record<string, unknown>;
};
export type QueuedForeignSubtreeResolution = {
    token: string;
    component: EcoComponent;
    props: Record<string, unknown>;
    componentInstanceId: string;
};
/**
 * Shared mutable state for one renderer-owned queued foreign-subtree runtime.
 */
export type QueuedForeignSubtreeResolutionContext = {
    rendererCache: Map<string, unknown>;
    componentInstanceScope?: string;
    nextForeignSubtreeId: number;
    queuedResolutions: QueuedForeignSubtreeResolution[];
};
type QueuedForeignSubtreeIntegrationContext = BaseIntegrationContext & Record<string, unknown>;
type QueuedForeignSubtreeChildRenderResult = {
    assets: ProcessedAsset[];
    html?: string;
    children?: unknown;
};
export interface ForeignSubtreeExecutionOwningRenderer {
    readonly name: string;
    renderComponentWithForeignChildren(input: ComponentRenderInput): Promise<ComponentRenderResult>;
}
export interface ForeignSubtreeExecutionDecisionInput {
    currentIntegration: string;
    targetIntegration?: string;
}
export interface ForeignSubtreeExecutionRenderOptions {
    currentIntegrationName: string;
    input: ComponentRenderInput;
    renderComponent(input: ComponentRenderInput): Promise<ComponentRenderResult>;
    normalizeComponentRenderOutput(result: ComponentRenderResult): ComponentRenderResult;
    hasForeignChildDescendants(component: EcoComponent): boolean;
    createForeignChildRuntime(options: {
        renderInput: ComponentRenderInput;
        rendererCache: Map<string, ForeignSubtreeExecutionOwningRenderer>;
    }): ForeignChildRuntime;
    getOwningRenderer(integrationName: string, rendererCache: Map<string, ForeignSubtreeExecutionOwningRenderer>): Promise<ForeignSubtreeExecutionOwningRenderer>;
}
export interface ForeignSubtreeQueuedRuntimeOptions<TContext extends QueuedForeignSubtreeResolutionContext> {
    renderInput: ComponentRenderInput;
    rendererCache: Map<string, ForeignSubtreeExecutionOwningRenderer>;
    runtimeContextKey: string;
    tokenPrefix: string;
    createRuntimeContext?: (integrationContext: BaseIntegrationContext & Record<string, unknown>, rendererCache: Map<string, unknown>) => TContext;
}
export interface ForeignSubtreeStringQueuedHtmlOptions {
    currentIntegrationName: string;
    renderInput: ComponentRenderInput;
    html: string;
    runtimeContextKey: string;
    queueLabel: string;
    getOwningRenderer(integrationName: string, rendererCache: Map<string, ForeignSubtreeExecutionOwningRenderer>): Promise<ForeignSubtreeExecutionOwningRenderer>;
    applyAttributesToFirstElement(html: string, attributes: Record<string, string>): string;
    dedupeProcessedAssets(assets: ProcessedAsset[]): ProcessedAsset[];
}
export interface ForeignSubtreeQueuedHtmlOptions<TContext extends QueuedForeignSubtreeResolutionContext> {
    currentIntegrationName: string;
    html: string;
    runtimeContext?: TContext;
    queueLabel: string;
    renderQueuedChildren(children: unknown, runtimeContext: TContext, queuedResolutionsByToken: Map<string, QueuedForeignSubtreeResolution>, resolveToken: (token: string) => Promise<string>): Promise<{
        assets: ProcessedAsset[];
        children?: unknown;
        html?: string;
    }>;
    getOwningRenderer(integrationName: string, rendererCache: Map<string, ForeignSubtreeExecutionOwningRenderer>): Promise<ForeignSubtreeExecutionOwningRenderer>;
    applyAttributesToFirstElement(html: string, attributes: Record<string, string>): string;
    dedupeProcessedAssets(assets: ProcessedAsset[]): ProcessedAsset[];
}
export interface ResolveQueuedForeignSubtreeTokensOptions<TContext extends QueuedForeignSubtreeResolutionContext> {
    html: string;
    runtimeContext?: TContext;
    queueLabel: string;
    renderQueuedChildren: (children: unknown, runtimeContext: TContext, queuedResolutionsByToken: Map<string, QueuedForeignSubtreeResolution>, resolveToken: (token: string) => Promise<string>) => Promise<QueuedForeignSubtreeChildRenderResult>;
    resolveForeignSubtree: (input: ComponentRenderInput, rendererCache: Map<string, unknown>) => Promise<ForeignSubtreeRenderPayload | undefined>;
    applyAttributesToFirstElement: (html: string, attributes: Record<string, string>) => string;
    dedupeProcessedAssets: (assets: ProcessedAsset[]) => ProcessedAsset[];
}
/**
 * Maps one component render result into the foreign-subtree payload shape used by
 * queue resolution and integration tests.
 */
export declare function toForeignSubtreeRenderPayload(result: ComponentRenderResult): ForeignSubtreeRenderPayload;
/**
 * Executes one component render tree under Foreign Child support.
 *
 * This service owns mixed-integration execution policy and the queued token
 * mechanics renderers use when foreign children cannot resolve inline.
 */
export declare class ForeignSubtreeExecutionService {
    private requiresForeignChildRuntime;
    shouldDelegateForeignChild(input: ForeignSubtreeExecutionDecisionInput): boolean;
    createFailFastRuntime(rendererName: string): ForeignChildRuntime;
    getQueuedRuntimeContext<TContext extends QueuedForeignSubtreeResolutionContext>(input: ComponentRenderInput, runtimeContextKey: string): TContext | undefined;
    createQueuedRuntime<TContext extends QueuedForeignSubtreeResolutionContext>(options: ForeignSubtreeQueuedRuntimeOptions<TContext>): ForeignChildRuntime;
    createQueueRuntime<TContext extends QueuedForeignSubtreeResolutionContext>(options: {
        renderInput: ComponentRenderInput;
        rendererCache: Map<string, unknown>;
        runtimeContextKey: string;
        tokenPrefix: string;
        shouldQueueForeignChild: (input: QueuedForeignChildDecisionInput) => boolean;
        createRuntimeContext?: (integrationContext: QueuedForeignSubtreeIntegrationContext, rendererCache: Map<string, unknown>) => TContext;
    }): ForeignChildRuntime;
    getRuntimeContext<TContext extends QueuedForeignSubtreeResolutionContext>(input: ComponentRenderInput, runtimeContextKey: string): TContext | undefined;
    resolveStringQueuedHtml<TContext extends QueuedForeignSubtreeResolutionContext>(options: ForeignSubtreeStringQueuedHtmlOptions): Promise<{
        assets: ProcessedAsset[];
        html: string;
    }>;
    resolveQueuedHtml<TContext extends QueuedForeignSubtreeResolutionContext>(options: ForeignSubtreeQueuedHtmlOptions<TContext>): Promise<{
        assets: ProcessedAsset[];
        html: string;
    }>;
    resolveQueuedForeignSubtreeTokens<TContext extends QueuedForeignSubtreeResolutionContext>(options: ResolveQueuedForeignSubtreeTokensOptions<TContext>): Promise<{
        assets: ProcessedAsset[];
        html: string;
    }>;
    executeComponentRender(options: ForeignSubtreeExecutionRenderOptions): Promise<ComponentRenderResult>;
    private getRendererCache;
    private withRendererCache;
    private getForeignOwnerIntegrationName;
    private resolveForeignChildInOwningRenderer;
    private resolveForeignSubtreeInOwningRenderer;
    private runInForeignOwningRenderer;
    resolveQueuedTokens(html: string, queuedResolutionsByToken: Map<string, QueuedForeignSubtreeResolution>, resolveToken: (token: string) => Promise<string>): Promise<string>;
    private createForeignSubtreeToken;
    private ensureRuntimeContext;
}
export {};