// Traditional cloud AI integration
async function generateContent(prompt: string) {
    // Send data to remote API
    const response = await fetch('https://api.ai-service.com/generate', {
        method: 'POST',
        headers: {
            'Authorization': `Bearer ${process.env.API_KEY}`,
            'Content-Type': 'application/json'
        },
        body: JSON.stringify({
            prompt: prompt,
            model: 'gpt-4',
            max_tokens: 1000
        })
    });
    
    // Parse response
    const data = await response.json();
    return data.choices[0].text;
}

// TypeScript developer experience
import { OksanaServices } from '@oksana/foundation';

// Initialize with zero configuration
const oksana = new OksanaServices({
    privacy: 'maximum',
    processing: 'on-device',
    brandProfile: './brand-config.json'
});

// Generate content with type safety
const result = await oksana.content.generate({
    input: userVoiceNote,
    format: ['article', 'linkedin', 'twitter'],
    brandValidation: true,
    seoOptimization: true
});

// TypeScript knows the exact return type
result.article.text        // string
result.article.wordCount   // number
result.linkedin.post       // string
result.twitter.thread      // Tweet[]

// Level 1: Basic generation
const simple = await oksana.generate("Write about AI");

// Level 2: Add formatting
const formatted = await oksana.generate("Write about AI", {
    format: 'article',
    length: 1000
});

// Level 3: Full control
const advanced = await oksana.generate("Write about AI", {
    format: 'article',
    length: 1000,
    tone: 'technical',
    audience: 'developers',
    brandValidation: true,
    seoKeywords: ['AI', 'machine learning'],
    designSystem: 'quantum-spatial',
    multiChannel: ['blog', 'linkedin', 'twitter']
});

// Monitor generation process
const generator = oksana.content.generate(prompt);

generator.on('stage', (stage) => {
    console.log(`Stage: ${stage.name} (${stage.progress}%)`);
});

generator.on('validation', (result) => {
    console.log(`Brand score: ${result.brandAlignment}`);
});

generator.on('complete', (content) => {
    console.log(`Generated: ${content.text.length} words`);
});

const result = await generator.execute();

import { useOksana } from '@oksana/react';

function ContentCreator() {
    const { generate, loading, error } = useOksana();
    
    const handleGenerate = async (voiceNote: AudioBlob) => {
        const content = await generate({
            input: voiceNote,
            format: ['article', 'linkedin']
        });
        
        setArticle(content.article);
        setLinkedInPost(content.linkedin);
    };
    
    return (
        <div>
            <VoiceRecorder onComplete={handleGenerate} />
            {loading && <Spinner />}
            {error && <ErrorMessage error={error} />}
            {article && <ArticlePreview content={article} />}
        </div>
    );
}

import { OksanaService } from '@oksana/node';
import express from 'express';

const app = express();
const oksana = new OksanaService({
    brandConfig: './brand-profile.json'
});

app.post('/api/generate', async (req, res) => {
    try {
        const content = await oksana.generate({
            input: req.body.prompt,
            format: req.body.format,
            brandValidation: true
        });
        
        res.json({ success: true, content });
    } catch (error) {
        res.status(500).json({ success: false, error: error.message });
    }
});

// Automatic GDPR compliance
const oksana = new OksanaServices({
    privacy: {
        dataRetention: 'user-controlled',
        processing: 'on-device-only',
        rightToErasure: 'immediate',
        dataPortability: 'full-export'
    }
});

// All requirements met automatically:
// ✅ Data minimization (only what's needed)
// ✅ Purpose limitation (explicit use only)
// ✅ Storage limitation (user-controlled retention)
// ✅ Integrity (on-device encryption)
// ✅ Confidentiality (never leaves device)

try {
    const content = await oksana.generate(prompt);
} catch (error) {
    if (error instanceof OksanaValidationError) {
        // Brand validation failed
        console.log(`Brand score: ${error.score}`);
        console.log(`Issues: ${error.issues}`);
    } else if (error instanceof OksanaProcessingError) {
        // M4 processing error
        console.log(`Stage: ${error.stage}`);
        console.log(`Recovery: ${error.suggestion}`);
    } else if (error instanceof OksanaConfigError) {
        // Configuration issue
        console.log(`Config problem: ${error.field}`);
    }
}

// Detailed logging for development
const oksana = new OksanaServices({
    debug: true,
    verbose: true,
    performanceMetrics: true
});

// Output:
// [Oksana] Initializing M4 Neural Engine... 12ms
// [Oksana] Loading brand profile... 8ms
// [Oksana] Processing input... 45ms
// [Oksana] Brand validation: 0.94/1.00
// [Oksana] Total: 65ms

import { OksanaTest } from '@oksana/testing';

describe('Content Generation', () => {
    const tester = new OksanaTest({
        brandProfile: './test-brand.json'
    });
    
    it('should validate brand voice', async () => {
        const result = await tester.generate({
            input: 'Test prompt',
            expectBrandScore: 0.9
        });
        
        expect(result.brandAlignment).toBeGreaterThan(0.9);
    });
    
    it('should process within latency target', async () => {
        const result = await tester.generate({
            input: 'Test prompt',
            expectLatency: 100 // ms
        });
        
        expect(result.latency).toBeLessThan(100);
    });
});

// Before: OpenAI
const openai = new OpenAI({ apiKey: process.env.KEY });
const response = await openai.chat.completions.create({
    model: "gpt-4",
    messages: [{ role: "user", content: prompt }]
});

// After: Oksana (similar API)
const oksana = new OksanaServices();
const response = await oksana.generate({
    input: prompt,
    format: 'text'
});

// Before: Anthropic Claude
const anthropic = new Anthropic({ apiKey: process.env.KEY });
const message = await anthropic.messages.create({
    model: "claude-3-opus",
    messages: [{ role: "user", content: prompt }]
});

// After: Oksana
const oksana = new OksanaServices();
const message = await oksana.generate({ input: prompt });