import { z } from 'zod/v4';
import { LanguageModelV3, LanguageModelV3CallOptions, ProviderV3, ImageModelV3, EmbeddingModelV3 } from '@ai-sdk/provider';
import { FetchFunction } from '@ai-sdk/provider-utils';
import { ProviderErrorStructure, MetadataExtractor } from '@ai-sdk/openai-compatible';

declare const veniceLanguageModelOptionsSchema: z.ZodObject<{
    veniceParameters: z.ZodDefault<z.ZodObject<{
        enableWebSearch: z.ZodOptional<z.ZodEnum<{
            auto: "auto";
            off: "off";
            on: "on";
        }>>;
        enableWebScraping: z.ZodOptional<z.ZodBoolean>;
        enableWebCitations: z.ZodOptional<z.ZodBoolean>;
        enableE2ee: z.ZodOptional<z.ZodBoolean>;
        enableXSearch: z.ZodOptional<z.ZodBoolean>;
        stripThinkingResponse: z.ZodOptional<z.ZodBoolean>;
        disableThinking: z.ZodOptional<z.ZodBoolean>;
        includeVeniceSystemPrompt: z.ZodDefault<z.ZodBoolean>;
        characterSlug: z.ZodOptional<z.ZodString>;
        includeSearchResultsInStream: z.ZodOptional<z.ZodBoolean>;
        returnSearchResultsAsDocuments: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
    topLogprobs: z.ZodOptional<z.ZodInt>;
    maxCompletionTokens: z.ZodOptional<z.ZodInt>;
    maxTokens: z.ZodOptional<z.ZodInt>;
    minP: z.ZodOptional<z.ZodNumber>;
    promptCacheKey: z.ZodOptional<z.ZodString>;
    promptCacheRetention: z.ZodOptional<z.ZodEnum<{
        default: "default";
        extended: "extended";
        "24h": "24h";
    }>>;
    repetitionPenalty: z.ZodOptional<z.ZodNumber>;
    reasoning: z.ZodOptional<z.ZodObject<{
        effort: z.ZodOptional<z.ZodEnum<{
            none: "none";
            minimal: "minimal";
            low: "low";
            medium: "medium";
            high: "high";
            xhigh: "xhigh";
            max: "max";
        }>>;
        enabled: z.ZodOptional<z.ZodBoolean>;
        summary: z.ZodOptional<z.ZodEnum<{
            auto: "auto";
            concise: "concise";
            detailed: "detailed";
        }>>;
    }, z.core.$strip>>;
    reasoningEffort: z.ZodOptional<z.ZodEnum<{
        none: "none";
        minimal: "minimal";
        low: "low";
        medium: "medium";
        high: "high";
        xhigh: "xhigh";
        max: "max";
    }>>;
    stopTokenIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
    stream: z.ZodDefault<z.ZodBoolean>;
    streamOptions: z.ZodOptional<z.ZodObject<{
        includeUsage: z.ZodBoolean;
    }, z.core.$strip>>;
    user: z.ZodOptional<z.ZodString>;
    structuredOutputs: z.ZodOptional<z.ZodBoolean>;
    strictJsonSchema: z.ZodOptional<z.ZodBoolean>;
    parallelToolCalls: z.ZodOptional<z.ZodBoolean>;
    logprobs: z.ZodOptional<z.ZodBoolean>;
    maxTemp: z.ZodOptional<z.ZodNumber>;
    minTemp: z.ZodOptional<z.ZodNumber>;
    n: z.ZodDefault<z.ZodInt>;
}, z.core.$strip>;
type VeniceLanguageModelOptions = z.infer<typeof veniceLanguageModelOptionsSchema>;

interface VeniceChatConfig {
    provider: string;
    headers: () => Record<string, string | undefined>;
    url: (options: {
        modelId: string;
        path: string;
    }) => string;
    fetch?: FetchFunction;
    includeUsage?: boolean;
    errorStructure?: ProviderErrorStructure<any>;
    supportsStructuredOutputs?: boolean;
    supportedUrls?: () => LanguageModelV3['supportedUrls'];
    metadataExtractor?: MetadataExtractor;
}
declare class VeniceChatLanguageModel implements LanguageModelV3 {
    readonly specificationVersion = "v3";
    readonly modelId: string;
    readonly config: VeniceChatConfig;
    private readonly failedResponseHandler;
    private readonly successfulResponseHandler;
    private readonly successfulEventResponseHandler;
    private readonly chunkSchema;
    constructor(modelId: string, config: VeniceChatConfig);
    get provider(): string;
    private get providerOptionsName();
    get supportedUrls(): Record<string, RegExp[]> | PromiseLike<Record<string, RegExp[]>>;
    private getArgs;
    doGenerate(options: LanguageModelV3CallOptions): Promise<Awaited<ReturnType<LanguageModelV3['doGenerate']>>>;
    doStream(options: LanguageModelV3CallOptions): Promise<Awaited<ReturnType<LanguageModelV3['doStream']>>>;
}

interface VeniceProviderSettings {
    /**
     *Provider name.
     */
    name?: string;
    /**
     * API key for authentication
     */
    apiKey?: string;
    /**
     * Base URL for API calls
     */
    baseURL?: string;
    /**
     * Custom headers for requests
     */
    headers?: Record<string, string>;
    /**
     *Optional custom url query parameters to include in request urls.
     */
    queryParams?: Record<string, string>;
    /**
     * Custom fetch implementation
     */
    fetch?: FetchFunction;
    /**
     * Include usage information in streaming responses.
     */
    includeUsage?: boolean;
    /**
     * Whether the provider supports structured outputs in chat models.
     */
    supportsStructuredOutputs?: boolean;
}
interface VeniceProvider extends ProviderV3 {
    (modelId: string): VeniceChatLanguageModel;
    languageModel(modelId: string): VeniceChatLanguageModel;
    chatModel(modelId: string): VeniceChatLanguageModel;
    completionModel(modelId: string): LanguageModelV3;
    imageModel(modelId: string): ImageModelV3;
    embeddingModel(modelId: string): EmbeddingModelV3;
    /** @deprecated Use `embeddingModel` instead. */
    textEmbeddingModel(modelId: string): EmbeddingModelV3;
}
declare function createVenice(options?: VeniceProviderSettings): VeniceProvider;
declare const venice: VeniceProvider;

declare const VERSION: string;

export { VERSION, type VeniceLanguageModelOptions, type VeniceProvider, type VeniceProviderSettings, createVenice, venice };