/**
 * createProvider — by-name factory for any built-in LLMProvider.
 *
 * Pattern: Abstract Factory (GoF) over the concrete provider factories.
 * Role:    Convenience entry point. Useful for config-driven setups
 *          where the provider is chosen at runtime (env var, feature
 *          flag, tenant preference).
 * Emits:   N/A.
 *
 * @example
 *   const kind = (process.env.LLM_PROVIDER ?? 'anthropic') as ProviderKind;
 *   const provider = createProvider({
 *     kind,
 *     apiKey: process.env.LLM_API_KEY,
 *     defaultModel: process.env.LLM_MODEL,
 *   } as CreateProviderOptions);
 *
 * For provider-specific options (Bedrock region, Ollama host, Browser
 * apiUrl, etc.) construct the underlying factory directly — this
 * helper deliberately exposes only the common subset.
 */
import type { LLMProvider } from '../types.js';
import { type MockProviderOptions } from './MockProvider.js';
import { type AnthropicProviderOptions } from './AnthropicProvider.js';
import { type OpenAIProviderOptions } from './OpenAIProvider.js';
import { type BedrockProviderOptions } from './BedrockProvider.js';
import { type BrowserAnthropicProviderOptions } from './BrowserAnthropicProvider.js';
import { type BrowserOpenAIProviderOptions } from './BrowserOpenAIProvider.js';
/** Built-in provider kinds. Custom providers don't go through this factory. */
export type ProviderKind = 'mock' | 'anthropic' | 'openai' | 'ollama' | 'bedrock' | 'browser-anthropic' | 'browser-openai';
/**
 * Common subset of options accepted across all built-in providers.
 * Provider-specific keys (region for Bedrock, host for Ollama,
 * organization for OpenAI, apiUrl for browser) are passed through
 * verbatim — TypeScript narrows by `kind`.
 */
export type CreateProviderOptions = ({
    readonly kind: 'mock';
} & MockProviderOptions) | ({
    readonly kind: 'anthropic';
} & AnthropicProviderOptions) | ({
    readonly kind: 'openai';
} & OpenAIProviderOptions) | ({
    readonly kind: 'ollama';
} & OpenAIProviderOptions & {
    readonly host?: string;
}) | ({
    readonly kind: 'bedrock';
} & BedrockProviderOptions) | ({
    readonly kind: 'browser-anthropic';
} & BrowserAnthropicProviderOptions) | ({
    readonly kind: 'browser-openai';
} & BrowserOpenAIProviderOptions);
/**
 * Build any built-in LLMProvider from a tagged options object.
 */
export declare function createProvider(options: CreateProviderOptions): LLMProvider;
/** What `providerFromEnv()` resolved: the provider + the `model` to pass to
 *  `Agent.create({ provider, model })`, and which `kind` was detected. */
export interface ProviderFromEnv {
    readonly provider: LLMProvider;
    readonly model: string;
    readonly kind: 'azure-openai' | 'anthropic' | 'openai' | 'mock';
}
/**
 * Resolve an `LLMProvider` from environment variables — drop your company's
 * values in `.env` and the right provider is configured automatically, with no
 * code branching. (Node only — reads `process.env`; the vendor SDK is lazy-loaded
 * only for the detected provider.)
 *
 * Detection order (first match wins):
 *   1. **Azure OpenAI** — `AZURE_OPENAI_API_KEY` + (`AZURE_OPENAI_ENDPOINT` |
 *      `OPENAI_BASE_URL`) [+ `AZURE_OPENAI_API_VERSION`, `AZURE_OPENAI_DEPLOYMENT`|`MODEL_NAME`]
 *   2. **Anthropic** — `ANTHROPIC_API_KEY`
 *   3. **OpenAI** — `OPENAI_API_KEY`
 * Otherwise throws (or returns the mock when `{ fallbackToMock: true }`).
 *
 * @example
 *   import { providerFromEnv } from 'agentfootprint';
 *   const { provider, model, kind } = providerFromEnv({ fallbackToMock: true });
 *   const agent = Agent.create({ provider, model }).build();
 */
export declare function providerFromEnv(opts?: {
    readonly fallbackToMock?: boolean;
}): ProviderFromEnv;
//# sourceMappingURL=createProvider.d.ts.map