import { type JsonObject } from '../contracts/common';
import { type CompiledMenuItemNode, type CompiledMenuProjection, type MenuAccessRequirement, type MenuActionRegistration, type MenuContributionProviderRegistration, type MenuDefinition, type MenuNavigationTarget, type MenuPageRef, type MenuPageRegistration, type MenuRuntimeBundle } from '../contracts/menu';
export type MenuCompilationErrorCode = 'duplicate-definition' | 'duplicate-registration' | 'unsupported-surface' | 'invalid-page-application' | 'unknown-page' | 'unknown-action' | 'unknown-contribution-provider' | 'unsupported-contribution-surface' | 'unknown-permission' | 'missing-input-schema' | 'unknown-input-schema' | 'invalid-input' | 'conflicting-navigation-target';
export declare class MenuCompilationError extends Error {
    readonly code: MenuCompilationErrorCode;
    readonly path: string;
    constructor(code: MenuCompilationErrorCode, path: string, message: string);
}
export type MenuInputValidator = (value: JsonObject) => unknown;
export interface CompileMenuRuntimeBundleInput {
    applicationId: string;
    supportedSurfaces: readonly string[];
    sourceVersion: string;
    definitions: readonly MenuDefinition[];
    pages: readonly MenuPageRegistration[];
    actions: readonly MenuActionRegistration[];
    contributionProviders: readonly MenuContributionProviderRegistration[];
    permissionCodes: readonly string[];
    inputValidators?: ReadonlyMap<string, MenuInputValidator>;
    sourceMap?: Readonly<Record<string, string>>;
    /** Enable isolation only after successfully loading complete catalogs for these applications. */
    missingPagePolicy?: {
        completeApplicationIds: readonly string[];
        /** Explicit restricted audience when the removed target's original policy is unavailable. */
        unavailableAccess: MenuAccessRequirement;
    };
}
export interface MenuCompilationDiagnostic {
    code: 'missing-page';
    severity: 'warning';
    applicationId: string;
    surface: string;
    menuId: string;
    nodeId: string;
    page: MenuPageRef;
    path: string;
}
export interface MenuAccessContext {
    sessionResolved: boolean;
    authenticated: boolean;
    permissionCodes: readonly string[];
    featureFlags: Readonly<Record<string, boolean>>;
}
export type MenuAccessDenialReason = 'session-unresolved' | 'authentication' | 'permission-all' | 'permission-any' | 'required-permission' | 'feature-flag';
export interface MenuAccessDecision {
    allowed: boolean;
    reasons: readonly MenuAccessDenialReason[];
}
export type MenuNavigationResolution = {
    status: 'resolved';
    target: MenuNavigationTarget;
} | {
    status: 'unmatched';
} | {
    status: 'invalid';
    reason: 'invalid-activation' | 'unknown-activation' | 'page-mismatch';
};
export interface CompiledMenuRuntimeBundle {
    document: MenuRuntimeBundle;
    /** Authoring diagnostics; never included in the ordinary menu document. */
    diagnostics: readonly MenuCompilationDiagnostic[];
    menusByKey: ReadonlyMap<string, CompiledMenuProjection>;
    navigationTargetsByKey: ReadonlyMap<string, MenuNavigationTarget>;
    serverInputByTargetKey: ReadonlyMap<string, JsonObject>;
    /** Evaluates visibility/access only. Callers must separately block dispatch when `item.disabled === true`. */
    evaluateItemAccess(item: CompiledMenuItemNode, context: MenuAccessContext): MenuAccessDecision;
    /** Resolves route identity and input; it does not authorize interaction with a disabled placement. */
    resolveNavigationTarget(page: MenuPageRef, explicitActivationId?: string): MenuNavigationResolution;
    selectedNodeIds(menu: CompiledMenuProjection, page: MenuPageRef, activationId?: string): ReadonlySet<string>;
}
export declare const resolveMenuActivationId: (page: MenuPageRef, activationId?: string) => string;
export declare const readMenuActivationFromSearch: (search: string | URLSearchParams) => string | undefined;
export declare const serializeMenuActivationSearch: (search: string | URLSearchParams, page: MenuPageRef, activationId?: string) => string;
export declare const isCompiledMenuItemSelected: (item: CompiledMenuItemNode, page: MenuPageRef, activationId?: string) => boolean;
/** Compiles source definitions into one browser-safe application bundle and a server-only input index. */
export declare const compileMenuRuntimeBundle: (input: CompileMenuRuntimeBundleInput) => CompiledMenuRuntimeBundle;
//# sourceMappingURL=menu-compiler.d.ts.map