"use strict";
/**
 * Basic usage examples for agentic-synth
 */
Object.defineProperty(exports, "__esModule", { value: true });
const index_js_1 = require("../src/index.js");
// Example 1: Basic time-series generation
async function basicTimeSeries() {
    const synth = (0, index_js_1.createSynth)({
        provider: 'gemini',
        apiKey: process.env.GEMINI_API_KEY
    });
    const result = await synth.generateTimeSeries({
        count: 100,
        interval: '1h',
        metrics: ['temperature', 'humidity'],
        trend: 'up',
        seasonality: true
    });
    console.log('Generated time-series data:');
    console.log(result.data.slice(0, 5));
    console.log('Metadata:', result.metadata);
}
// Example 2: Event generation
async function generateEvents() {
    const synth = (0, index_js_1.createSynth)({
        provider: 'gemini'
    });
    const result = await synth.generateEvents({
        count: 50,
        eventTypes: ['page_view', 'button_click', 'form_submit'],
        distribution: 'poisson',
        userCount: 25,
        timeRange: {
            start: new Date(Date.now() - 24 * 60 * 60 * 1000),
            end: new Date()
        }
    });
    console.log('Generated events:');
    console.log(result.data.slice(0, 5));
}
// Example 3: Structured data with schema
async function generateStructured() {
    const synth = (0, index_js_1.createSynth)();
    const schema = {
        id: { type: 'string', required: true },
        name: { type: 'string', required: true },
        email: { type: 'string', required: true },
        age: { type: 'number', required: true },
        address: {
            type: 'object',
            required: false,
            properties: {
                street: { type: 'string' },
                city: { type: 'string' },
                country: { type: 'string' }
            }
        }
    };
    const result = await synth.generateStructured({
        count: 20,
        schema,
        format: 'json'
    });
    console.log('Generated user data:');
    console.log(result.data.slice(0, 3));
}
// Example 4: Streaming generation
async function streamingGeneration() {
    const synth = (0, index_js_1.createSynth)({
        streaming: true
    });
    console.log('Streaming time-series data:');
    for await (const dataPoint of synth.generateStream('timeseries', {
        count: 50,
        interval: '5m',
        metrics: ['cpu', 'memory']
    })) {
        console.log('Received:', dataPoint);
    }
}
// Example 5: Batch generation
async function batchGeneration() {
    const synth = (0, index_js_1.createSynth)();
    const batches = [
        { count: 10, schema: { id: { type: 'string' }, value: { type: 'number' } } },
        { count: 15, schema: { id: { type: 'string' }, value: { type: 'number' } } },
        { count: 20, schema: { id: { type: 'string' }, value: { type: 'number' } } }
    ];
    const results = await synth.generateBatch('structured', batches, 2);
    console.log('Batch results:');
    results.forEach((result, i) => {
        console.log(`Batch ${i + 1}: ${result.metadata.count} records in ${result.metadata.duration}ms`);
    });
}
// Example 6: Using OpenRouter
async function useOpenRouter() {
    const synth = (0, index_js_1.createSynth)({
        provider: 'openrouter',
        apiKey: process.env.OPENROUTER_API_KEY,
        model: 'anthropic/claude-3.5-sonnet'
    });
    const result = await synth.generateTimeSeries({
        count: 30,
        interval: '10m',
        metrics: ['requests_per_second']
    });
    console.log('Generated with OpenRouter:');
    console.log(result.metadata);
}
// Example 7: With caching
async function withCaching() {
    const synth = (0, index_js_1.createSynth)({
        cacheStrategy: 'memory',
        cacheTTL: 600 // 10 minutes
    });
    // First call - will generate
    console.time('First call');
    const result1 = await synth.generateTimeSeries({
        count: 50,
        interval: '1h',
        metrics: ['value']
    });
    console.timeEnd('First call');
    console.log('Cached:', result1.metadata.cached);
    // Second call with same params - should hit cache
    console.time('Second call');
    const result2 = await synth.generateTimeSeries({
        count: 50,
        interval: '1h',
        metrics: ['value']
    });
    console.timeEnd('Second call');
    console.log('Cached:', result2.metadata.cached);
}
// Example 8: Error handling
async function errorHandling() {
    const synth = (0, index_js_1.createSynth)();
    try {
        await synth.generateStructured({
            count: 10
            // Missing schema - will throw ValidationError
        });
    }
    catch (error) {
        if (error.name === 'ValidationError') {
            console.error('Validation error:', error.message);
        }
        else {
            console.error('Unexpected error:', error);
        }
    }
}
// Run examples
async function runExamples() {
    console.log('=== Example 1: Basic Time-Series ===');
    await basicTimeSeries();
    console.log('\n=== Example 2: Events ===');
    await generateEvents();
    console.log('\n=== Example 3: Structured Data ===');
    await generateStructured();
    console.log('\n=== Example 5: Batch Generation ===');
    await batchGeneration();
    console.log('\n=== Example 7: Caching ===');
    await withCaching();
    console.log('\n=== Example 8: Error Handling ===');
    await errorHandling();
}
// Uncomment to run
// runExamples().catch(console.error);
//# sourceMappingURL=basic-usage.js.map