import { generate } from 'synthdata-gen';
import type { ExampleSchema } from 'synthdata-gen';

const schema: ExampleSchema = {
  fields: {
    instruction: { type: 'string', min: 10, max: 200, description: 'A clear instruction' },
    output: { type: 'string', min: 20, max: 1000, description: 'The expected response' },
    category: { type: 'enum', enum: ['coding', 'writing', 'reasoning'] },
  },
};

const result = await generate(schema, { count: 100 });

console.log(result.data);   // GeneratedExample[]
console.log(result.stats);  // GenerationStats

import { generate } from 'synthdata-gen';
import type { LlmFunction } from 'synthdata-gen';

const myLlm: LlmFunction = async (messages, options) => {
  const response = await callMyProvider(messages, options);
  return {
    content: response.text,
    usage: {
      promptTokens: response.usage.prompt_tokens,
      completionTokens: response.usage.completion_tokens,
      totalTokens: response.usage.total_tokens,
    },
  };
};

const result = await generate(schema, {
  llm: myLlm,
  count: 500,
  batchSize: 5,
  format: 'openai',
  seeds: [
    { instruction: 'Explain recursion', output: 'Recursion is when a function calls itself...', category: 'coding' },
  ],
  costTracking: {
    promptTokenCost: 0.000003,
    completionTokenCost: 0.000015,
    currency: 'USD',
  },
});

console.log(result.exported);          // OpenAI fine-tuning JSONL string
console.log(result.stats.cost);        // { promptTokens, completionTokens, totalCost, currency }
console.log(result.stats.durationMs);  // wall-clock time

function generate(schema: ExampleSchema, options: GenerateOptions): Promise<GenerateResult>

function validate(
  examples: Record<string, unknown>[],
  schema: ExampleSchema,
  config?: ValidationConfig,
): ValidationResult[]

interface ValidationResult {
  valid: boolean;
  index: number;
  errors: ValidationError[];
}

interface ValidationError {
  path: string[];
  message: string;
  code: string;
}

function validateExample(
  example: Record<string, unknown>,
  schema: ExampleSchema,
  config?: ValidationConfig,
): ValidationError[]

function deduplicate(
  examples: Record<string, unknown>[],
  options?: Partial<DedupOptions>,
): Promise<DedupResult>

interface DedupResult {
  data: Record<string, unknown>[];   // Deduplicated examples
  removed: number;                    // Number of duplicates removed
  pairs: Array<[number, number, number]>;  // [indexA, indexB, similarity]
}

function exportAs(
  examples: Record<string, unknown>[],
  format: ExportFormat,
  options?: ExportOptions,
): string

import { exportOpenAI, exportAlpaca, exportShareGPT, exportCSV, exportJSONL } from 'synthdata-gen';

import {
  generateExample,
  generateExamples,
  buildSchemaPrompt,
  buildSystemPrompt,
  parseJsonResponse,
} from 'synthdata-gen';

const schema: ExampleSchema = {
  fields: {
    question: { type: 'string', min: 10, max: 500, description: 'A natural language question' },
    answer: { type: 'string', min: 20, max: 2000, pattern: '^[A-Z]' },
    category: { type: 'enum', enum: ['science', 'history', 'technology'] },
    difficulty: { type: 'integer', min: 1, max: 5 },
    score: { type: 'number', min: 0, max: 100 },
    active: { type: 'boolean' },
    tags: { type: 'array', items: { type: 'string' }, min: 1, max: 5 },
    metadata: {
      type: 'object',
      properties: {
        source: { type: 'string' },
        verified: { type: 'boolean' },
      },
      requiredFields: ['source'],
    },
  },
  required: ['question', 'answer', 'category'],
};

const config: ValidationConfig = {
  // Global string field length constraints
  minFieldLength: 10,
  maxFieldLength: 5000,

  // Quality heuristics
  heuristics: {
    nonEmpty: true,           // Reject empty/whitespace-only required string fields
    noPlaceholder: true,      // Reject placeholder text (lorem ipsum, TODO, TBD, N/A, etc.)
    noDuplicateFields: {      // Reject examples where specified field pairs are identical
      pairs: [['question', 'answer']],
    },
    minWordCount: {           // Enforce minimum word count on specified fields
      fields: ['answer'],
      min: 5,
    },
  },

  // Custom validators
  custom: [
    {
      name: 'no-question-in-output',
      validate: (example) => ({
        valid: !String(example.answer).endsWith('?'),
        message: 'Answer should not end with a question mark',
      }),
    },
  ],
};

const diversity: DiversityConfig = {
  temperature: {
    min: 0.3,
    max: 1.2,
    strategy: 'cycle',  // 'linear' | 'cycle' | 'random'
  },
  topics: ['algorithms', 'databases', 'networking', 'security'],
  negativeExampleRatio: 0.1,
  negativeInstructions: 'Generate an example with a subtle factual error.',
  constraintVariation: [
    { instruction: 'Write in a formal academic tone.' },
    { instruction: 'Write in a casual conversational tone.' },
  ],
};

const retry: RetryConfig = {
  maxRetries: 3,            // Maximum retry attempts per batch
  includeFeedback: true,    // Include validation error feedback in retry prompt
  backoff: 'exponential',   // 'none' | 'linear' | 'exponential'
  backoffMs: 1000,          // Base backoff delay in milliseconds
};

const costTracking: CostConfig = {
  promptTokenCost: 0.000003,      // Cost per prompt token
  completionTokenCost: 0.000015,  // Cost per completion token
  currency: 'USD',
};

import { validateExample } from 'synthdata-gen';

const errors = validateExample(
  { instruction: 'Hi', output: 123, category: 'invalid' },
  schema,
);

for (const err of errors) {
  console.log(`[${err.code}] ${err.path.join('.')}: ${err.message}`);
}
// [too_small] instruction: String must contain at least 10 character(s), received 2
// [invalid_type] output: Expected string, received number
// [invalid_enum_value] category: Invalid enum value. Expected one of ["coding", ...], received "invalid"

// Throws: "Semantic dedup requires an embedder function"
await deduplicate(examples, { strategy: 'semantic' });

// Throws: "Unsupported export format: xml"
exportAs(examples, 'xml' as ExportFormat);

const result = await generate(schema, {
  count: 100,
  llm: myLlm,
  systemPrompt: 'You are a medical expert generating training data.\n\n{schema_description}',
  additionalInstructions: 'All examples must be about cardiology.',
});

import { deduplicate } from 'synthdata-gen';

const result = await deduplicate(newExamples, {
  strategy: 'exact',
  existingData: existingDataset,
});

console.log(`Removed ${result.removed} duplicates of existing data`);

const result = await deduplicate(examples, {
  strategy: 'semantic',
  threshold: 0.92,
  embedder: async (text) => {
    const response = await openai.embeddings.create({
      model: 'text-embedding-3-small',
      input: text,
    });
    return response.data[0].embedding;
  },
});

const result = await deduplicate(examples, {
  strategy: 'near',
  threshold: 0.85,
  ngramSize: 2,
  fields: ['instruction'],  // Only compare instruction fields
});

import { exportOpenAI, exportAlpaca } from 'synthdata-gen';

const qaData = [
  { question: 'What is TCP?', answer: 'TCP is a connection-oriented protocol.' },
];

// Map question -> user, answer -> assistant
const openai = exportOpenAI(qaData, {
  fieldMap: { user: 'question', assistant: 'answer' },
  systemPrompt: 'You are a networking expert.',
});

// Map question -> instruction, answer -> output
const alpaca = exportAlpaca(qaData, {
  fieldMap: { instruction: 'question', output: 'answer' },
});

const result = await generate(schema, {
  llm: myLlm,
  count: 1000,
  batchSize: 10,            // 10 examples per LLM call
  structuredOutput: true,   // Request JSON mode if provider supports it
});

import { generateExample, generateExamples } from 'synthdata-gen';

// Single example, deterministic with seed
const example = generateExample(schema, 42);

// Multiple examples, deterministic with base seed
const examples = generateExamples(schema, 100, 42);

import { buildSchemaPrompt, buildSystemPrompt } from 'synthdata-gen';

const schemaPrompt = buildSchemaPrompt(schema);
// "Generate a JSON object with the following structure:\n{ ... }"

const systemPrompt = buildSystemPrompt(schema, undefined, 'Focus on edge cases.');
// Full system prompt with schema description and additional instructions

import { parseJsonResponse } from 'synthdata-gen';

const objects = parseJsonResponse('Here is the result:\n```json\n{"key": "value"}\n```\nDone!');
// [{ key: "value" }]

const array = parseJsonResponse('[{"a": 1}, {"b": 2}]');
// [{ a: 1 }, { b: 2 }]

import type {
  // LLM interface
  Message,
  LlmCallOptions,
  LlmResponse,
  LlmFunction,

  // Schema
  FieldType,
  SchemaField,
  ExampleSchema,

  // Generation
  GeneratedExample,
  DiversityConfig,
  HeuristicsConfig,
  CustomValidator,
  ValidationConfig,
  RetryConfig,
  CostConfig,
  DedupOptions,
  GenerateOptions,
  ExportFormat,
  ExportOptions,

  // Results
  GenerateResult,
  GenerationStats,
  ValidationResult,
  ValidationError,
  DedupResult,
} from 'synthdata-gen';

interface QAPair {
  question: string;
  answer: string;
  category: string;
}

const result = await generate(schema, { count: 10 });
const data = result.data as GeneratedExample<QAPair>[];