import { aiModelResource, aiProviderResource } from '@undefineds.co/models';
import type { AuthContext } from '../../auth/AuthContext';
import type { InternalPodAccessTokenProvider } from '../pod/HostedPodDataAccess';
import { type PodBaseUrlResolver } from '../pod/PodBaseUrlResolver';
export type PodSelectedModelStatus = 'active' | 'inactive';
export interface PodSelectedModel {
    /** Base-relative id of the AI model resource (for example, openai.ttl#gpt-5). */
    id: string;
    displayName?: string;
    modelType: string;
    status: PodSelectedModelStatus;
    createdAt?: Date;
    updatedAt?: Date;
}
export interface PodModelSelection {
    provider: string;
    models: PodSelectedModel[];
    version: string;
    /** Base-relative model resource id, when a provider default is configured. */
    defaultModel?: string;
}
export interface PodModelSelectionDb {
    init?: (...resources: unknown[]) => Promise<void>;
    select(): {
        from(resource: typeof aiProviderResource | typeof aiModelResource): {
            execute?(): Promise<Record<string, unknown>[]>;
            where(condition: unknown): {
                execute(): Promise<Record<string, unknown>[]>;
            };
        };
    };
    findById<T = Record<string, unknown>>(resource: typeof aiProviderResource | typeof aiModelResource, id: string): Promise<T | null>;
    insert(resource: typeof aiProviderResource | typeof aiModelResource): {
        values(value: Record<string, unknown>): {
            execute(): Promise<unknown[]>;
        };
    };
    updateById<T = Record<string, unknown>>(resource: typeof aiProviderResource | typeof aiModelResource, id: string, patch: Record<string, unknown>): Promise<T | null>;
    deleteById(resource: typeof aiProviderResource | typeof aiModelResource, id: string): Promise<boolean>;
    transaction?<T>(transaction: (tx: PodModelSelectionDb) => Promise<T>): Promise<T>;
}
export interface PodModelSelectionRepositoryOptions {
    internalPodAccess?: InternalPodAccessTokenProvider;
    podBaseUrlResolver?: PodBaseUrlResolver;
    dbFactory?: (input: {
        owner: string;
        podUrl: string;
        auth?: AuthContext;
        fetch: typeof fetch;
        aiProvider: typeof aiProviderResource;
        aiModel: typeof aiModelResource;
    }) => Promise<PodModelSelectionDb>;
    /** Provider ids used by listActiveSelections; custom providers remain listable via listSelection. */
    providerIds?: readonly string[];
    now?: () => Date;
}
export interface ListSelectionInput {
    webId: string;
    provider: string;
    auth?: AuthContext;
}
export interface ReplaceSelectionInput extends ListSelectionInput {
    models: readonly PodSelectedModelInput[];
    defaultModel?: string;
    expectedVersion?: string;
}
export interface ReconcileAvailabilityInput extends ListSelectionInput {
    discoveredModels: readonly DiscoveredModelInput[];
}
export type PodSelectedModelInput = string | (Pick<PodSelectedModel, 'id' | 'modelType'> & Partial<Pick<PodSelectedModel, 'displayName' | 'status'>>);
export type DiscoveredModelInput = Pick<PodSelectedModel, 'id' | 'modelType'> & Partial<Pick<PodSelectedModel, 'displayName'>>;
export interface ListActiveSelectionsInput {
    webId: string;
    auth?: AuthContext;
}
export declare const DEFAULT_MODEL_SELECTION_PROVIDERS: readonly ["openai", "anthropic", "kimi", "bailian", "deepseek"];
/**
 * The selected-model adapter deliberately uses only the shared ai-config
 * resources. Selection state is represented by aiModel rows: unpicked rows
 * are removed, while a picked model that disappears from a complete provider
 * discovery is retained with status="inactive".
 */
export declare class PodModelSelectionRepository {
    private readonly dbFactory;
    private readonly internalPodAccess?;
    private readonly podBaseUrlResolver?;
    private readonly providerIds;
    private readonly now;
    constructor(options?: PodModelSelectionRepositoryOptions);
    listSelection(input: ListSelectionInput): Promise<PodModelSelection>;
    replaceSelection(input: ReplaceSelectionInput): Promise<PodModelSelection>;
    private replaceSelectionLocked;
    reconcileAvailability(input: ReconcileAvailabilityInput): Promise<PodModelSelection>;
    listActiveSelections(input: ListActiveSelectionsInput): Promise<PodModelSelection[]>;
    private readActiveSelection;
    private findSelectedModel;
    private readSelection;
    private findProvider;
    private dbForOwner;
    private runAtomic;
}
export declare class ModelSelectionBlockedError extends Error {
    readonly code = "BLOCKED/NEEDS_CONTEXT";
    readonly evidence: string;
    readonly recommendation = "Upgrade @undefineds.co/models and @undefineds.co/drizzle-solid with a plain-LDP eq(aiModel.isProvidedBy, providerIri) query helper before adding a raw SPARQL fallback.";
    constructor(evidence: string, cause?: unknown);
}
export declare function computeSelectionVersion(providerIri: string, defaultModel: string | undefined, models: readonly PodSelectedModel[]): string;