/**
 * Type definitions matching Apple's FoundationModels API
 */
/**
 * Availability status of the system language model
 */
export declare enum Availability {
    /** Model is available and ready to use */
    Available = "available",
    /** Model is unavailable - device not eligible */
    DeviceNotEligible = "deviceNotEligible",
    /** Model is unavailable - Apple Intelligence not enabled */
    AppleIntelligenceNotEnabled = "appleIntelligenceNotEnabled",
    /** Model is unavailable - model not ready (downloading or initializing) */
    ModelNotReady = "modelNotReady"
}
/**
 * Use case for specialized language models
 */
export declare enum UseCase {
    /** Specialized for content tagging, entity extraction, and topic detection */
    ContentTagging = "contentTagging"
}
/**
 * Represents a language model available in FoundationModels
 * (Used internally for compatibility)
 */
export interface LanguageModelInfo {
    /** Unique identifier for the model */
    id: string;
    /** Human-readable name of the model */
    name: string;
    /** Maximum number of tokens the model can generate */
    maxTokens: number;
}
/**
 * Sampling mode for text generation
 */
export declare enum SamplingMode {
    /** Deterministic - always picks highest probability token */
    Greedy = "greedy",
    /** Random sampling from the probability distribution */
    Random = "random"
}
/**
 * Options for customizing text generation
 */
export interface GenerationOptions {
    /** Sampling mode */
    sampling?: SamplingMode;
    /** Temperature for randomness/creativity (0.0 to 2.0) */
    temperature?: number;
    /** Maximum number of tokens to generate */
    maximumResponseTokens?: number;
}
/**
 * Instructions provide context, role, and preferences for model responses
 */
export declare class Instructions {
    readonly text: string;
    constructor(text: string);
}
/**
 * Guardrails for safety filtering
 */
export declare class Guardrails {
    private static _default?;
    static get default(): Guardrails;
    private constructor();
}
/**
 * Represents a tool call made by the model
 */
export interface ToolCall {
    /** Name of the tool being called */
    name: string;
    /** Arguments passed to the tool (structured data) */
    arguments: Record<string, any>;
}
/**
 * Entry in the conversation transcript
 */
export type TranscriptEntry = {
    type: 'prompt';
    content: string;
} | {
    type: 'response';
    content: string;
} | {
    type: 'instructions';
    instructions: Instructions;
} | {
    type: 'toolCalls';
    calls: ToolCall[];
} | {
    type: 'toolOutput';
    output: ToolOutput;
};
/**
 * Response from the language model
 */
export interface Response<Content> {
    /** The generated content */
    content: Content;
    /** The sequence of user and assistant messages */
    transcriptEntries: TranscriptEntry[];
}
/**
 * Tool output wrapper
 */
export declare class ToolOutput {
    readonly value: string | any;
    constructor(value: string | any);
}
/**
 * Tool interface for dynamic actions and runtime data fetching
 * Maps to: Tool protocol in Swift FoundationModels
 *
 * Tools enable the model to perform actions like searching, fetching data,
 * or calling APIs. The model determines when a tool is needed, generates
 * appropriate arguments, and the framework handles execution automatically.
 *
 * @example
 * ```typescript
 * class WeatherTool implements Tool {
 *   name = 'getWeather';
 *   description = 'Gets current weather for a location';
 *
 *   async call(args: { city: string }): Promise<ToolOutput> {
 *     const weather = await fetchWeather(args.city);
 *     return new ToolOutput(`Weather in ${args.city}: ${weather}`);
 *   }
 * }
 *
 * const session = new LanguageModelSession({
 *   tools: [new WeatherTool()]
 * });
 * ```
 */
export interface Tool {
    /** Unique identifier for the tool */
    name: string;
    /** Description of what the tool does (helps model decide when to use it) */
    description: string;
    /**
     * Executes the tool with the provided arguments
     * @param args Structured arguments generated by the model
     * @returns ToolOutput containing the result
     */
    call(args: Record<string, any>): Promise<ToolOutput>;
}
/**
 * Configuration for text generation (legacy)
 */
export interface GenerationConfig {
    /** Maximum number of tokens to generate */
    maxTokens?: number;
    /** Temperature for sampling (0.0 to 1.0) */
    temperature?: number;
    /** Top-p sampling parameter */
    topP?: number;
    /** Stop sequences */
    stopSequences?: string[];
}
/**
 * Finish reason for generation (legacy)
 */
export declare enum FinishReason {
    /** Generation completed naturally */
    Stop = "stop",
    /** Hit maximum token limit */
    Length = "length",
    /** Content filtered */
    ContentFilter = "contentFilter",
    /** Unknown or other reason */
    Unknown = "unknown"
}
/**
 * Result from text generation (legacy)
 */
export interface GenerationResult {
    /** Generated text */
    text: string;
    /** Reason why generation finished */
    finishReason: FinishReason;
}
/**
 * Role of a message in a conversation (legacy)
 */
export declare enum MessageRole {
    /** System message that sets the context */
    System = "system",
    /** Message from the user */
    User = "user",
    /** Message from the assistant */
    Assistant = "assistant"
}
/**
 * A message in a conversation (legacy)
 */
export interface Message {
    /** Role of the message sender */
    role: MessageRole;
    /** Content of the message */
    content: string;
}
/**
 * Configuration for LanguageModelSession (legacy)
 */
export interface SessionConfig {
    /** System prompt to set the context */
    systemPrompt?: string;
    /** Default generation configuration for the session */
    generationConfig?: GenerationConfig;
}
/**
 * Parameters for generating text (internal)
 */
export interface GenerateTextParams {
    /** The input prompt */
    prompt: string;
    /** Optional model ID to use */
    modelId?: string;
    /** Maximum tokens to generate */
    maxTokens?: number;
    /** Temperature for sampling */
    temperature?: number;
}
/**
 * Parameters for streaming text generation (internal)
 */
export interface GenerateStreamParams extends GenerateTextParams {
    /** Callback for each chunk of generated text */
    onChunk: (chunk: string) => void;
}
/**
 * Response wrapper from Swift executable (internal)
 */
export interface SwiftResponse<T = any> {
    success: boolean;
    data?: T;
    error?: string;
}
//# sourceMappingURL=types.d.ts.map