/**
 * Fine-tuning Types and Interfaces
 */
export declare enum FineTuningStatus {
    PENDING = "pending",
    VALIDATING = "validating",
    QUEUED = "queued",
    RUNNING = "running",
    SUCCEEDED = "succeeded",
    FAILED = "failed",
    CANCELLED = "cancelled"
}
export declare enum FineTuningProvider {
    OPENAI = "openai",
    ANTHROPIC = "anthropic",
    COHERE = "cohere",
    GOOGLE = "google",
    CUSTOM = "custom"
}
export declare enum TrainingDataFormat {
    JSONL = "jsonl",
    CSV = "csv",
    PARQUET = "parquet",
    CHAT_ML = "chat_ml"
}
export interface TrainingExample {
    /** Unique example ID */
    id?: string;
    /** Input prompt or messages */
    prompt?: string;
    messages?: Array<{
        role: 'system' | 'user' | 'assistant';
        content: string;
    }>;
    /** Expected completion */
    completion?: string;
    /** Optional metadata */
    metadata?: Record<string, unknown>;
    /** Example weight for training */
    weight?: number;
}
export interface TrainingDataset {
    /** Dataset ID */
    id: string;
    /** Dataset name */
    name: string;
    /** Description */
    description?: string;
    /** Format of the data */
    format: TrainingDataFormat;
    /** Training examples */
    examples: TrainingExample[];
    /** Validation split ratio (0-1) */
    validationSplit?: number;
    /** Total number of examples */
    totalExamples: number;
    /** Dataset size in bytes */
    sizeBytes: number;
    /** S3/storage location */
    storageUri?: string;
    /** Created timestamp */
    createdAt: Date;
    /** Updated timestamp */
    updatedAt: Date;
    /** Creator user ID */
    createdBy: string;
    /** Tags for organization */
    tags?: string[];
}
export interface FineTuningConfig {
    /** Base model to fine-tune */
    baseModel: string;
    /** Training dataset ID */
    trainingDatasetId: string;
    /** Validation dataset ID (optional) */
    validationDatasetId?: string;
    /** Number of training epochs */
    epochs?: number;
    /** Batch size */
    batchSize?: number;
    /** Learning rate */
    learningRate?: number;
    /** Learning rate multiplier */
    learningRateMultiplier?: number;
    /** Prompt loss weight */
    promptLossWeight?: number;
    /** Classification positive class */
    classificationPositiveClass?: string;
    /** Number of classes for classification */
    classificationNClasses?: number;
    /** Early stopping patience */
    earlyStoppingPatience?: number;
    /** Suffix for fine-tuned model name */
    suffix?: string;
    /** Provider-specific configuration */
    providerConfig?: Record<string, unknown>;
}
export interface FineTuningJob {
    /** Job ID */
    id: string;
    /** Job name */
    name: string;
    /** Provider (OpenAI, Anthropic, etc.) */
    provider: FineTuningProvider;
    /** Current status */
    status: FineTuningStatus;
    /** Base model */
    baseModel: string;
    /** Fine-tuned model ID (when completed) */
    fineTunedModel?: string;
    /** Training configuration */
    config: FineTuningConfig;
    /** Training dataset */
    trainingDataset: TrainingDataset;
    /** Validation dataset */
    validationDataset?: TrainingDataset;
    /** Training metrics */
    metrics?: FineTuningMetrics;
    /** Error information if failed */
    error?: {
        message: string;
        code?: string;
        details?: Record<string, unknown>;
    };
    /** Estimated completion time */
    estimatedCompletionTime?: Date;
    /** Started timestamp */
    startedAt?: Date;
    /** Completed timestamp */
    completedAt?: Date;
    /** Created timestamp */
    createdAt: Date;
    /** Creator user ID */
    createdBy: string;
    /** Project ID */
    projectId: string;
    /** Cost estimate */
    estimatedCost?: number;
    /** Actual cost */
    actualCost?: number;
    /** Provider job ID */
    providerJobId?: string;
    /** Hyperparameters used */
    hyperparameters?: Record<string, unknown>;
    /** Model version/checkpoints */
    checkpoints?: ModelCheckpoint[];
}
export interface FineTuningMetrics {
    /** Training loss */
    trainingLoss?: number[];
    /** Validation loss */
    validationLoss?: number[];
    /** Training accuracy */
    trainingAccuracy?: number[];
    /** Validation accuracy */
    validationAccuracy?: number[];
    /** Training tokens processed */
    trainingTokens?: number;
    /** Validation tokens processed */
    validationTokens?: number;
    /** Current epoch */
    currentEpoch?: number;
    /** Total epochs */
    totalEpochs?: number;
    /** Training samples seen */
    trainingSteps?: number;
    /** Best validation loss */
    bestValidationLoss?: number;
    /** Custom metrics */
    customMetrics?: Record<string, number[]>;
}
export interface ModelCheckpoint {
    /** Checkpoint ID */
    id: string;
    /** Checkpoint name */
    name: string;
    /** Epoch number */
    epoch: number;
    /** Training step */
    step: number;
    /** Validation loss at checkpoint */
    validationLoss?: number;
    /** Training loss at checkpoint */
    trainingLoss?: number;
    /** Storage URI */
    storageUri: string;
    /** Created timestamp */
    createdAt: Date;
    /** Is this the best checkpoint? */
    isBest?: boolean;
}
export interface FineTuningJobCreate {
    /** Job name */
    name: string;
    /** Provider */
    provider: FineTuningProvider;
    /** Base model */
    baseModel: string;
    /** Training configuration */
    config: FineTuningConfig;
    /** Project ID */
    projectId: string;
    /** Creator user ID */
    createdBy: string;
    /** Auto-deploy when completed */
    autoDeploy?: boolean;
}
export interface FineTuningJobUpdate {
    /** Update job name */
    name?: string;
    /** Update status (for cancellation) */
    status?: FineTuningStatus;
    /** Update metrics */
    metrics?: Partial<FineTuningMetrics>;
}
export interface FineTuningJobFilter {
    /** Filter by project */
    projectId?: string;
    /** Filter by status */
    status?: FineTuningStatus[];
    /** Filter by provider */
    provider?: FineTuningProvider[];
    /** Filter by base model */
    baseModel?: string;
    /** Filter by creator */
    createdBy?: string;
    /** Created after date */
    createdAfter?: Date;
    /** Created before date */
    createdBefore?: Date;
}
export interface DatasetValidationResult {
    /** Is dataset valid? */
    valid: boolean;
    /** Total examples */
    totalExamples: number;
    /** Valid examples */
    validExamples: number;
    /** Invalid examples */
    invalidExamples: number;
    /** Validation errors */
    errors: Array<{
        exampleId?: string;
        line?: number;
        message: string;
        field?: string;
    }>;
    /** Warnings */
    warnings: Array<{
        exampleId?: string;
        line?: number;
        message: string;
    }>;
    /** Dataset statistics */
    statistics?: {
        avgPromptLength?: number;
        avgCompletionLength?: number;
        avgTokensPerExample?: number;
        minTokens?: number;
        maxTokens?: number;
    };
}
export interface FineTuningEstimate {
    /** Estimated training time (seconds) */
    estimatedTimeSeconds: number;
    /** Estimated cost (USD) */
    estimatedCostUSD: number;
    /** Training tokens */
    trainingTokens: number;
    /** Validation tokens */
    validationTokens?: number;
    /** Epochs */
    epochs: number;
    /** Provider-specific info */
    providerInfo?: Record<string, unknown>;
}
//# sourceMappingURL=types.d.ts.map