import type { ConnectCredentialRecord } from '../connect';
import type { ProviderSecret } from '../credentials/CredentialVault';
import { ProviderHttpTransport } from '../../service/provider-http-transport';
import type { ProviderProductDescriptor, ProviderRegistry } from '../providers/ProviderRegistry';
import { type DiscoveredProviderModelType } from './ProviderModelType';
export interface DiscoveredProviderModel {
    id: string;
    displayName?: string;
    capabilities?: string[];
    /**
     * What the model is for, inferred from the provider payload.
     *
     * Discovery keeps embedding models in the list, and every consumer of this
     * shape - the Pod row written on sync, the settings model list, the embedding
     * allowlist - reads the type from here. Dropping it stores an embedding model
     * as an ordinary one, which is how it disappears from model management.
     */
    modelType?: DiscoveredProviderModelType;
    availability?: 'available' | 'unavailable';
    metadata?: {
        sources?: ProviderModelDiscoverySource[];
    };
}
export interface ProviderModelDiscoverySource {
    credential: string;
    source: string;
    status: 'available' | 'unavailable' | 'error';
    error?: string;
}
export interface ModelsCredentialRecord extends ConnectCredentialRecord {
    baseUrl?: string;
    proxyUrl?: string;
}
export interface ProviderModelsFetchInput {
    credential: ModelsCredentialRecord;
    secret: ProviderSecret;
    signal?: AbortSignal;
}
export interface ProviderModelsAdapter {
    readonly provider?: string;
    readonly protocol?: string;
    fetch(input: ProviderModelsFetchInput): Promise<DiscoveredProviderModel[]>;
}
export declare class ProviderModelsFetchError extends Error {
    readonly providerStatus: number;
    readonly retryAfter?: string | null;
    readonly providerMessage?: string;
    constructor(providerStatus: number, retryAfter?: string | null, providerMessage?: string);
}
/**
 * The upstream returned HTTP 2xx but still reported a business failure.
 * Keep this separate from transport/status failures so the management API can
 * surface a sanitized provider message without ever echoing credentials.
 */
export declare class ProviderModelsResponseError extends Error {
    readonly safeMessage: string;
    constructor(message: string);
}
export interface OpenAiCompatibleModelsAdapterOptions {
    provider?: string;
    protocol?: 'openai-models';
    registry?: ProviderRegistry;
    defaultBaseUrl?: string;
    safeBaseUrls?: string[];
    product?: ProviderProductDescriptor;
    fetchImpl?: typeof fetch;
    transport?: ProviderHttpTransport;
}
export interface CodexSubscriptionModelsAdapterOptions {
    transport?: ProviderHttpTransport;
    clientVersion?: string;
}
/** Discovers the models currently enabled for a ChatGPT Codex subscription. */
export declare class CodexSubscriptionModelsAdapter implements ProviderModelsAdapter {
    readonly protocol = "codex-models";
    private readonly transport;
    private readonly clientVersion;
    constructor(options?: CodexSubscriptionModelsAdapterOptions);
    fetch(input: ProviderModelsFetchInput): Promise<DiscoveredProviderModel[]>;
}
export declare class OpenAiCompatibleModelsAdapter implements ProviderModelsAdapter {
    readonly provider?: string;
    readonly protocol: string;
    private readonly registry?;
    private readonly defaultBaseUrl?;
    private readonly safeBaseUrls;
    private readonly product?;
    private readonly transport;
    constructor(options: OpenAiCompatibleModelsAdapterOptions);
    fetch(input: ProviderModelsFetchInput): Promise<DiscoveredProviderModel[]>;
}
export declare const ANTHROPIC_MODELS_BASE_URL = "https://api.anthropic.com/v1";
export declare const ANTHROPIC_MODELS_VERSION = "2023-06-01";
export declare class AnthropicModelsAdapter implements ProviderModelsAdapter {
    readonly provider = "anthropic";
    readonly protocol = "anthropic-models";
    private readonly defaultBaseUrl;
    private readonly safeBaseUrls;
    private readonly product?;
    private readonly transport;
    constructor(options?: {
        defaultBaseUrl?: string;
        safeBaseUrls?: string[];
        product?: ProviderProductDescriptor;
        fetchImpl?: typeof fetch;
        transport?: ProviderHttpTransport;
    });
    fetch(input: ProviderModelsFetchInput): Promise<DiscoveredProviderModel[]>;
}
export declare function resolveSafeModelsBaseUrl(configuredBaseUrl: string | undefined, defaultBaseUrl: string, safeBaseUrls: readonly string[], allowCredentialBaseUrl?: boolean): string;
export declare function normalizeDiscoveredModels(payload: unknown): DiscoveredProviderModel[];