import { type CustomProviderModel } from '../connect';
import { type ProviderAuthMode, type ProviderCapabilities, type ProviderDescriptor, type ProviderRegistry } from '../providers/ProviderRegistry';
import { type SessionAffinityStore } from './SessionAffinityStore';
import type { AuthContext } from '../../auth/AuthContext';
import type { GatewayProtocol } from '../types';
import { EmbeddingModelPolicy } from '../../../ai/service/EmbeddingModelPolicy';
export type GatewayCredentialHealth = 'healthy' | 'reauthRequired' | 'disabled' | 'error' | 'invalid' | 'unknown';
export type GatewayQuotaStatus = 'available' | 'unsupported' | 'exhausted' | 'error';
export type ModelRouteSource = 'alias' | 'explicit-provider' | 'exact-model' | 'default-provider' | 'default-model';
export interface GatewayCredentialCandidate {
    id: string;
    credentialIri: string;
    provider: string;
    authMode: ProviderAuthMode;
    enabled: boolean;
    priority?: number;
    models?: string[];
    /** Display names the Pod recorded for `models`, keyed by model id. */
    modelNames?: Record<string, string>;
    customModels?: CustomProviderModel[];
    defaultModel?: string;
    health?: GatewayCredentialHealth;
    quota?: {
        status: GatewayQuotaStatus;
    };
    cooldownUntil?: Date;
    metadata?: Record<string, unknown>;
}
export interface ModelRouterCredentialLookupInput {
    webId: string;
    deployment: string;
    auth?: AuthContext;
}
export interface ModelRouterOptions {
    registry: ProviderRegistry;
    affinityStore: SessionAffinityStore;
    credentials(input: ModelRouterCredentialLookupInput): Promise<GatewayCredentialCandidate[]>;
    selectionRepository?: GatewayModelSelectionRepository;
    defaultProvider?: string;
    defaultModel?: string;
    /** Deployment policy for embedding models; defaults to allow-all (Local). */
    embeddingModelPolicy?: EmbeddingModelPolicy;
    now?: () => Date;
}
export interface GatewayModelSelection {
    provider: string;
    models: Array<string | {
        id: string;
        modelType?: string;
        status?: 'active' | 'inactive';
        displayName?: string;
    }>;
    version?: string;
    defaultModel?: string;
}
export interface GatewayModelSelectionRepository {
    listActiveSelections(input: {
        webId: string;
        auth?: AuthContext;
    }): Promise<GatewayModelSelection[]>;
}
export interface GatewayModelProjection {
    id: string;
    object: 'model';
    owned_by: string;
    context_window?: number;
    capabilities?: ProviderCapabilities;
    protocols?: GatewayProtocol[];
    custom?: boolean;
    display_name?: string;
    modalities?: {
        input?: string[];
        output?: string[];
    };
    custom_capabilities?: string[];
}
export interface ModelRouterVisibleModelsInput {
    webId: string;
    deployment: string;
    auth?: AuthContext;
}
export interface ModelRouteInput {
    webId: string;
    deployment: string;
    auth?: AuthContext;
    model?: string;
    conversationId?: string;
    explicitCredentialId?: string;
    rawPrompt?: string;
}
export interface ModelRouteFailoverState {
    allowedBeforeFirstEvent: boolean;
    committed: boolean;
    clientEventEmitted: boolean;
}
export interface ModelRouteResult {
    provider: ProviderDescriptor;
    model: string;
    credential: GatewayCredentialCandidate;
    source: ModelRouteSource;
    affinityKey?: string;
    failover: ModelRouteFailoverState;
}
export declare class ModelRouter {
    private readonly registry;
    private readonly affinityStore;
    private readonly credentials;
    private readonly selectionRepository?;
    private readonly defaultProvider?;
    private readonly defaultModel?;
    private readonly embeddingModelPolicy;
    private readonly now;
    constructor(options: ModelRouterOptions);
    route(input: ModelRouteInput, excludeCredentialIds?: ReadonlySet<string>): Promise<ModelRouteResult>;
    markClientEventEmitted(route: ModelRouteResult): ModelRouteFailoverState;
    canFailOver(route: ModelRouteResult): boolean;
    recordCooldown(input: {
        webId: string;
        deployment: string;
        credentialId: string;
        until: Date;
    }): Promise<void>;
    listVisibleModels(input: ModelRouterVisibleModelsInput): Promise<GatewayModelProjection[]>;
    private visibleTargets;
    private hasUsableCredential;
    private resolveTarget;
    private resolveSelectedTarget;
    private visibleTargetMatches;
    private findSelectedDefaultProviderTarget;
    private findSelectedDefaultModelTarget;
    private parseExplicitProviderModel;
    private findExactModelTarget;
    private findDefaultProviderTarget;
    private findDefaultModelTarget;
    private selectExplicitCredential;
    private selectCredential;
    private isCredentialUsable;
    private effectiveCooldownUntil;
    private credentialMatchesProvider;
    private routeProviderIdForCredential;
    private credentialVisibleModels;
    private isCredentialModelVisible;
    /**
     * A Pod can declare any capability on a custom model. Embedding is the one
     * capability a deployment gates through its own catalog, so never advertise an
     * embedding model the catalog does not provide. Other declared capabilities
     * keep their existing behavior.
     */
    private visibleCustomCapabilities;
}