const apiKey = 'your-api-key';
const url = 'https://image.nalitek.com/api/generate';

fetch(url, {
    method: 'POST',
    headers: {
        'X-API-Key': apiKey,
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({
        prompt: 'beautiful sunset over mountains, professional photography',
        width: 512,           // Быстрая генерация в низком разрешении
        height: 512,
        smart_upscale: true,  // Автоматическое увеличение до HD
        target_width: 2048,
        target_height: 2048,
        model: 'flux-dev'
    })
})
.then(res => res.json())
.then(data => {
    console.log(`Image ID: ${data.image_id}`);
    console.log(`Generation ID: ${data.generation_id}`);
});

$apiKey = 'your-api-key';
$url = 'https://image.nalitek.com/api/generate';

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode([
    'prompt' => 'beautiful sunset over mountains, professional photography',
    'width' => 512,           // Быстрая генерация в низком разрешении
    'height' => 512,
    'smart_upscale' => true,  // Автоматическое увеличение до HD
    'target_width' => 2048,
    'target_height' => 2048,
    'model' => 'flux-dev'
]));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'X-API-Key: ' . $apiKey,
    'Content-Type: application/json'
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
$data = json_decode($response, true);
echo "Image ID: " . $data['image_id'];

curl -X POST https://image.nalitek.com/api/generate \
  -H "X-API-Key: your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "beautiful sunset over mountains, professional photography",
    "width": 512,
    "height": 512,
    "smart_upscale": true,
    "target_width": 2048,
    "target_height": 2048,
    "model": "flux-dev"
  }'

import requests
import time

class FluxAPI:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "https://image.nalitek.com"
        self.headers = {"X-API-Key": api_key, "Content-Type": "application/json"}

    def generate_image(self, prompt, **kwargs):
        """Генерация изображения по промпту"""
        url = f"{self.base_url}/api/generate"

        data = {
            "prompt": prompt,
            "negative_prompt": kwargs.get("negative_prompt", ""),
            "width": kwargs.get("width", 1024),
            "height": kwargs.get("height", 1024),
            "steps": kwargs.get("steps", 30),
            "guidance_scale": kwargs.get("guidance_scale", 7.5),
            "seed": kwargs.get("seed", -1),
            "model": kwargs.get("model", "flux-dev"),
            "format": kwargs.get("format", "png")
        }

        if "lora_id" in kwargs:
            data["lora_id"] = kwargs["lora_id"]
            
        # Добавляем параметры smart_upscale если указаны
        if kwargs.get("smart_upscale"):
            data["smart_upscale"] = kwargs.get("smart_upscale")
            if "target_width" in kwargs:
                data["target_width"] = kwargs["target_width"]
            if "target_height" in kwargs:
                data["target_height"] = kwargs["target_height"]

        response = requests.post(url, json=data, headers=self.headers)

        if response.status_code == 201:
            result = response.json()
            print(f"✅ Success! Generation ID: {result['generation_id']}")
            print(f"📍 Progress URL: {result['progress_url']}")
            print(f"🌱 Seed: {result['seed']}")
            return result
        else:
            print(f"❌ Error: {response.status_code}")
            print(response.json())
            return None

    def check_status(self, image_id):
        """Проверка статуса генерации"""
        url = f"{self.base_url}/api/images/{image_id}"
        response = requests.get(url, headers=self.headers)
        return response.json()

    def wait_for_completion(self, image_id, timeout=120):
        """Ожидание завершения генерации"""
        start_time = time.time()

        while time.time() - start_time < timeout:
            status = self.check_status(image_id)

            if status['status'] == 'completed':
                print(f"✅ Completed! URL: {status['url']}")
                return status
            elif status['status'] == 'failed':
                print(f"❌ Failed: {status.get('error_message')}")
                return status

            time.sleep(2)

        print(f"⏱️ Timeout after {timeout} seconds")
        return None

# Использование
api = FluxAPI("your-api-key")

# Пример 1: Простая генерация (smart upscale включен по умолчанию)
# При запросе 1024x1024, сгенерирует в 512x512 и масштабирует до 1024x1024
image = api.generate_image(
    prompt="cyberpunk city at night, neon lights",
    width=1024,             # Целевой размер 1024x1024
    height=1024,            # Автоматически генерирует в 512x512 и масштабирует
    steps=30,
    guidance_scale=7.5
)

# Пример 2: Отключение smart upscale для прямой генерации
image = api.generate_image(
    prompt="detailed portrait",
    width=512,
    height=512,
    smart_upscale=False,    # Генерировать напрямую в 512x512
    steps=30
)
if image:
    result = api.wait_for_completion(image['image_id'])
    print(f"Generated and upscaled to {result['dimensions']}")

# Расширенная генерация с LoRA
image = api.generate_image(
    prompt="beautiful japanese garden, cherry blossoms, koi pond",
    negative_prompt="blurry, low quality, distorted",
    width=1024,
    height=1024,
    steps=50,
    guidance_scale=8.0,
    model="flux-dev",
    lora_id="anime-style-v2"
)

# Генерация с автоматическим upscale
# Генерируем в низком разрешении для скорости, затем автоматически увеличиваем
image = api.generate_image(
    prompt="ultra realistic portrait, 8k quality, professional photography",
    width=512,           # Генерируем в низком разрешении
    height=512,
    smart_upscale=True,  # Включаем автоматический upscale
    target_width=2048,   # Целевой размер после upscale
    target_height=2048,
    steps=30,
    model="flux-dev"
)
if image:
    result = api.wait_for_completion(image['image_id'])
    print(f"Image automatically upscaled to {result['dimensions']}")

class FluxAPI {
    constructor(apiKey) {
        this.apiKey = apiKey;
        this.baseUrl = 'https://image.nalitek.com';
    }

    async generateImage(prompt, options = {}) {
        const url = `${this.baseUrl}/api/generate`;

        const data = {
            prompt: prompt,
            negative_prompt: options.negative_prompt || '',
            width: options.width || 1024,
            height: options.height || 1024,
            steps: options.steps || 30,
            guidance_scale: options.guidance_scale || 7.5,
            seed: options.seed || -1,
            model: options.model || 'flux-dev',
            format: options.format || 'png'
        };

        if (options.lora_id) {
            data.lora_id = options.lora_id;
        }
        
        // Добавляем параметры smart_upscale если указаны
        if (options.smart_upscale) {
            data.smart_upscale = true;
            if (options.target_width) {
                data.target_width = options.target_width;
            }
            if (options.target_height) {
                data.target_height = options.target_height;
            }
        }

        try {
            const response = await fetch(url, {
                method: 'POST',
                headers: {
                    'X-API-Key': this.apiKey,
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify(data)
            });

            if (response.status === 201) {
                const result = await response.json();
                console.log(`✅ Success! Generation ID: ${result.generation_id}`);
                console.log(`📍 Progress URL: ${result.progress_url}`);
                return result;
            } else {
                const error = await response.json();
                console.error(`❌ Error: ${response.status}`, error);
                return null;
            }
        } catch (error) {
            console.error('Request failed:', error);
            return null;
        }
    }

    async checkStatus(imageId) {
        const url = `${this.baseUrl}/api/images/${imageId}`;
        const response = await fetch(url, {
            headers: { 'X-API-Key': this.apiKey }
        });
        return response.json();
    }

    async waitForCompletion(imageId, timeout = 120000) {
        const startTime = Date.now();

        while (Date.now() - startTime < timeout) {
            const status = await this.checkStatus(imageId);

            if (status.status === 'completed') {
                console.log(`✅ Completed! URL: ${status.url}`);
                return status;
            } else if (status.status === 'failed') {
                console.error(`❌ Failed: ${status.error_message}`);
                return status;
            }

            await new Promise(resolve => setTimeout(resolve, 2000));
        }

        console.error(`⏱️ Timeout after ${timeout}ms`);
        return null;
    }
}

// Использование
const api = new FluxAPI('your-api-key');

// Простая генерация с автоматическим upscale
async function generateSimple() {
    const image = await api.generateImage('cyberpunk city at night, neon lights', {
        width: 512,           // Генерируем быстро в низком разрешении
        height: 512,
        smart_upscale: true,  // Автоматически увеличиваем после генерации
        target_width: 2048,   // Финальный размер
        target_height: 2048
    });
    if (image) {
        const result = await api.waitForCompletion(image.image_id);
        console.log(`Generated and upscaled to ${result.dimensions}`);
    }
}

// Расширенная генерация
async function generateAdvanced() {
    const image = await api.generateImage('beautiful japanese garden', {
        negative_prompt: 'blurry, low quality',
        width: 1024,
        height: 1024,
        steps: 50,
        guidance_scale: 8.0,
        model: 'flux-dev',
        lora_id: 'anime-style-v2'
    });

    if (image) {
        const result = await api.waitForCompletion(image.image_id);
    }
}

// Генерация с автоматическим upscale
async function generateWithSmartUpscale() {
    const image = await api.generateImage('ultra realistic portrait, 8k quality', {
        width: 512,           // Генерируем в низком разрешении для скорости
        height: 512,
        smart_upscale: true,  // Включаем автоматический upscale
        target_width: 2048,   // Целевой размер после upscale
        target_height: 2048,
        steps: 30,
        model: 'flux-dev'
    });

    if (image) {
        const result = await api.waitForCompletion(image.image_id);
        console.log(`Image automatically upscaled to ${result.dimensions}`);
    }
}

generateSimple();
generateAdvanced();
generateWithSmartUpscale();

<?php

class FluxAPI {
    private $apiKey;
    private $baseUrl = 'https://image.nalitek.com';

    public function __construct($apiKey) {
        $this->apiKey = $apiKey;
    }

    public function generateImage($prompt, $options = []) {
        $url = $this->baseUrl . '/api/generate';

        $data = array_merge([
            'prompt' => $prompt,
            'negative_prompt' => '',
            'width' => 1024,
            'height' => 1024,
            'steps' => 30,
            'guidance_scale' => 7.5,
            'seed' => -1,
            'model' => 'flux-dev',
            'format' => 'png'
        ], $options);
        
        // Добавляем параметры smart_upscale если указаны
        if (isset($options['smart_upscale']) && $options['smart_upscale']) {
            $data['smart_upscale'] = true;
            if (isset($options['target_width'])) {
                $data['target_width'] = $options['target_width'];
            }
            if (isset($options['target_height'])) {
                $data['target_height'] = $options['target_height'];
            }
        }

        $ch = curl_init($url);
        curl_setopt($ch, CURLOPT_POST, true);
        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
        curl_setopt($ch, CURLOPT_HTTPHEADER, [
            'X-API-Key: ' . $this->apiKey,
            'Content-Type: application/json'
        ]);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);

        if ($httpCode === 201) {
            $result = json_decode($response, true);
            echo "✅ Success! Generation ID: " . $result['generation_id'] . "\n";
            echo "📍 Progress URL: " . $result['progress_url'] . "\n";
            return $result;
        } else {
            echo "❌ Error: HTTP $httpCode\n";
            echo $response . "\n";
            return null;
        }
    }

    public function checkStatus($imageId) {
        $url = $this->baseUrl . '/api/images/' . $imageId;

        $ch = curl_init($url);
        curl_setopt($ch, CURLOPT_HTTPHEADER, ['X-API-Key: ' . $this->apiKey]);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

        $response = curl_exec($ch);
        curl_close($ch);

        return json_decode($response, true);
    }

    public function waitForCompletion($imageId, $timeout = 120) {
        $startTime = time();

        while (time() - $startTime < $timeout) {
            $status = $this->checkStatus($imageId);

            if ($status['status'] === 'completed') {
                echo "✅ Completed! URL: " . $status['url'] . "\n";
                return $status;
            } elseif ($status['status'] === 'failed') {
                echo "❌ Failed: " . $status['error_message'] . "\n";
                return $status;
            }

            sleep(2);
        }

        echo "⏱️ Timeout after $timeout seconds\n";
        return null;
    }
}

// Использование
$api = new FluxAPI('your-api-key');

// Простая генерация с автоматическим upscale
$image = $api->generateImage('cyberpunk city at night, neon lights', [
    'width' => 512,           // Генерируем быстро в низком разрешении
    'height' => 512,
    'smart_upscale' => true,  // Автоматически увеличиваем после генерации
    'target_width' => 2048,   // Финальный размер
    'target_height' => 2048
]);
if ($image) {
    $result = $api->waitForCompletion($image['image_id']);
    echo "Generated and upscaled to " . $result['dimensions'] . "\n";
}

// Расширенная генерация
$image = $api->generateImage('beautiful japanese garden', [
    'negative_prompt' => 'blurry, low quality',
    'width' => 1024,
    'height' => 1024,
    'steps' => 50,
    'guidance_scale' => 8.0,
    'model' => 'flux-dev',
    'lora_id' => 'anime-style-v2'
]);

if ($image) {
    $result = $api->waitForCompletion($image['image_id']);
}

// Генерация с автоматическим upscale
$image = $api->generateImage('ultra realistic portrait, 8k quality', [
    'width' => 512,           // Генерируем в низком разрешении
    'height' => 512,
    'smart_upscale' => true,  // Включаем автоматический upscale
    'target_width' => 2048,   // Целевой размер после upscale
    'target_height' => 2048,
    'steps' => 30,
    'model' => 'flux-dev'
]);

if ($image) {
    $result = $api->waitForCompletion($image['image_id']);
    echo "Image automatically upscaled to " . $result['dimensions'] . "\n";
}

import requests

def transform_image(api_key, image_path, prompt, **kwargs):
    """Трансформация изображения с img2img"""
    url = "https://image.nalitek.com/api/img2img"
    headers = {"X-API-Key": api_key}

    # Подготовка файла
    with open(image_path, 'rb') as f:
        files = {'image': (image_path, f, 'image/png')}

        # Подготовка данных
        data = {
            'prompt': prompt,
            'negative_prompt': kwargs.get('negative_prompt', ''),
            'strength': kwargs.get('strength', 0.75),
            'steps': kwargs.get('steps', 30),
            'seed': kwargs.get('seed', -1),
            'width': kwargs.get('width', 1024),
            'height': kwargs.get('height', 1024),
            'guidance_scale': kwargs.get('guidance_scale', 7.5),
            'format': kwargs.get('format', 'png'),
            'model': kwargs.get('model', 'flux-dev')
        }
        
        # Добавляем параметры smart_upscale если указаны
        if kwargs.get('smart_upscale'):
            data['smart_upscale'] = 'true'
            if kwargs.get('target_width'):
                data['target_width'] = kwargs.get('target_width')
            if kwargs.get('target_height'):
                data['target_height'] = kwargs.get('target_height')
        
        # Добавляем lora_models если указаны
        if kwargs.get('lora_models'):
            data['lora_models[]'] = kwargs.get('lora_models')

        # Отправка запроса
        response = requests.post(url, headers=headers, files=files, data=data)

    if response.status_code == 201:
        result = response.json()
        print(f"✅ Success! Image URL: {result['url']}")
        print(f"📐 Dimensions: {result['dimensions']}")
        print(f"🌱 Seed: {result['seed']}")
        return result
    else:
        print(f"❌ Error: {response.status_code}")
        print(response.json())
        return None

# Использование с автоматическим upscale
result = transform_image(
    api_key="your-api-key",
    image_path="input.png",
    prompt="transform to cyberpunk style, neon lights, ultra HD",
    negative_prompt="blurry, low quality",
    width=512,              # Трансформируем в низком разрешении для скорости
    height=512,
    smart_upscale=True,     # Автоматически увеличиваем после трансформации
    target_width=2048,      # Финальный размер
    target_height=2048,
    strength=0.8,
    steps=40
)

# Загрузка результата
if result:
    image_url = result['url']
    response = requests.get(image_url)
    with open('output.png', 'wb') as f:
        f.write(response.content)
    print("✅ Image saved as output.png")

# Трансформация с автоматическим upscale
result = transform_image(
    api_key="your-api-key",
    image_path="input.png",
    prompt="ultra HD quality, 8k resolution",
    smart_upscale=True,     # Включаем автоматический upscale
    target_width=2048,      # Целевой размер
    target_height=2048,
    strength=0.7,
    steps=30
)
if result:
    print(f"Image transformed and upscaled to {result['dimensions']}")

async function transformImage(apiKey, imageFile, prompt, options = {}) {
    const url = 'https://image.nalitek.com/api/img2img';

    // Создание FormData
    const formData = new FormData();
    formData.append('image', imageFile);
    formData.append('prompt', prompt);
    formData.append('negative_prompt', options.negative_prompt || '');
    formData.append('strength', options.strength || 0.75);
    formData.append('steps', options.steps || 30);
    formData.append('seed', options.seed || -1);
    formData.append('width', options.width || 1024);
    formData.append('height', options.height || 1024);
    formData.append('guidance_scale', options.guidance_scale || 7.5);
    formData.append('format', options.format || 'png');
    formData.append('model', options.model || 'flux-dev');
    
    // Добавляем параметры smart_upscale если указаны
    if (options.smart_upscale) {
        formData.append('smart_upscale', 'true');
        if (options.target_width) {
            formData.append('target_width', options.target_width);
        }
        if (options.target_height) {
            formData.append('target_height', options.target_height);
        }
    }
    
    // Добавляем lora_models если указаны
    if (options.lora_models && options.lora_models.length > 0) {
        options.lora_models.forEach(lora => {
            formData.append('lora_models[]', lora);
        });
    }

    try {
        const response = await fetch(url, {
            method: 'POST',
            headers: {
                'X-API-Key': apiKey
            },
            body: formData
        });

        if (response.status === 201) {
            const result = await response.json();
            console.log(`✅ Success! Image URL: ${result.url}`);
            console.log(`📐 Dimensions: ${result.dimensions}`);
            console.log(`🌱 Seed: ${result.seed}`);
            return result;
        } else {
            const error = await response.json();
            console.error(`❌ Error: ${response.status}`, error);
            return null;
        }
    } catch (error) {
        console.error('Request failed:', error);
        return null;
    }
}

// Использование с input элементом
document.getElementById('fileInput').addEventListener('change', async (event) => {
    const file = event.target.files[0];
    if (file) {
        // Пример с автоматическим upscale
        const result = await transformImage(
            'your-api-key',
            file,
            'transform to cyberpunk style, neon lights, ultra HD',
            {
                width: 512,           // Трансформируем в низком разрешении
                height: 512,
                smart_upscale: true,  // Автоматически увеличиваем после
                target_width: 2048,   // Финальный размер
                target_height: 2048,
                negative_prompt: 'blurry, low quality',
                strength: 0.8,
                steps: 40
            }
        );
        
        // Пример с автоматическим upscale
        const resultWithUpscale = await transformImage(
            'your-api-key',
            file,
            'ultra HD quality, 8k resolution',
            {
                width: 512,           // Трансформируем в низком разрешении
                height: 512,
                smart_upscale: true,  // Включаем автоматический upscale
                target_width: 2048,   // Целевой размер
                target_height: 2048,
                strength: 0.7,
                steps: 30
            }
        );

        if (result) {
            // Отобразить результат
            document.getElementById('resultImage').src = result.url;
        }
    }
});

// Использование с URL изображения
async function transformFromUrl(imageUrl) {
    const response = await fetch(imageUrl);
    const blob = await response.blob();
    const file = new File([blob], 'image.png', { type: 'image/png' });

    return await transformImage(
        'your-api-key',
        file,
        'make it artistic painting style'
    );
}

<?php

function transformImage($apiKey, $imagePath, $prompt, $options = []) {
    $url = 'https://image.nalitek.com/api/img2img';

    // Подготовка файла
    $cFile = new CURLFile($imagePath, mime_content_type($imagePath), basename($imagePath));

    // Подготовка данных
    $data = array_merge([
        'image' => $cFile,
        'prompt' => $prompt,
        'negative_prompt' => '',
        'strength' => 0.75,
        'steps' => 30,
        'seed' => -1,
        'width' => 1024,
        'height' => 1024,
        'guidance_scale' => 7.5,
        'format' => 'png',
        'model' => 'flux-dev'
    ], $options);
    
    // Добавляем параметры smart_upscale если указаны
    if (isset($options['smart_upscale']) && $options['smart_upscale']) {
        $data['smart_upscale'] = 'true';
        if (isset($options['target_width'])) {
            $data['target_width'] = $options['target_width'];
        }
        if (isset($options['target_height'])) {
            $data['target_height'] = $options['target_height'];
        }
    }
    
    // Добавляем lora_models если указаны
    if (isset($options['lora_models']) && is_array($options['lora_models'])) {
        foreach ($options['lora_models'] as $index => $lora) {
            $data["lora_models[$index]"] = $lora;
        }
    }

    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_POSTFIELDS, $data);
    curl_setopt($ch, CURLOPT_HTTPHEADER, ['X-API-Key: ' . $apiKey]);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    if ($httpCode === 201) {
        $result = json_decode($response, true);
        echo "✅ Success! Image URL: " . $result['url'] . "\n";
        echo "📐 Dimensions: " . $result['dimensions'] . "\n";
        echo "🌱 Seed: " . $result['seed'] . "\n";
        return $result;
    } else {
        echo "❌ Error: HTTP $httpCode\n";
        echo $response . "\n";
        return null;
    }
}

// Использование с автоматическим upscale
$result = transformImage(
    'your-api-key',
    'input.png',
    'transform to cyberpunk style, neon lights, ultra HD',
    [
        'width' => 512,           // Трансформируем в низком разрешении
        'height' => 512,
        'smart_upscale' => true,  // Автоматически увеличиваем после
        'target_width' => 2048,   // Финальный размер
        'target_height' => 2048,
        'negative_prompt' => 'blurry, low quality',
        'strength' => 0.8,
        'steps' => 40
    ]
);

// Загрузка результата
if ($result) {
    $imageContent = file_get_contents($result['url']);
    file_put_contents('output.png', $imageContent);
    echo "✅ Image saved as output.png\n";
}

// Пример с автоматическим upscale
$resultWithUpscale = transformImage(
    'your-api-key',
    'input.png',
    'ultra HD quality, 8k resolution',
    [
        'width' => 512,           // Трансформируем в низком разрешении
        'height' => 512,
        'smart_upscale' => true,  // Включаем автоматический upscale
        'target_width' => 2048,   // Целевой размер
        'target_height' => 2048,
        'strength' => 0.7,
        'steps' => 30
    ]
);

if ($resultWithUpscale) {
    echo "Image transformed and upscaled to " . $resultWithUpscale['dimensions'] . "\n";
}

// Пример с загрузкой через форму
if ($_SERVER['REQUEST_METHOD'] === 'POST' && isset($_FILES['image'])) {
    $uploadedFile = $_FILES['image']['tmp_name'];
    $prompt = $_POST['prompt'] ?? 'transform to artistic style';

    $result = transformImage(
        'your-api-key',
        $uploadedFile,
        $prompt,
        [
            'strength' => floatval($_POST['strength'] ?? 0.75),
            'steps' => intval($_POST['steps'] ?? 30)
        ]
    );

    if ($result) {
        header('Content-Type: application/json');
        echo json_encode($result);
    }
}

import requests

def upscale_image(api_key, image_id, scale=2, face_enhance=False, denoise=0.5):
    """Увеличение разрешения изображения"""
    url = f"https://image.nalitek.com/api/upscale/{image_id}"
    headers = {
        "X-API-Key": api_key,
        "Content-Type": "application/json"
    }

    data = {
        "scale": scale,
        "face_enhance": face_enhance,
        "denoise": denoise
    }

    response = requests.post(url, json=data, headers=headers)

    if response.status_code == 201:
        result = response.json()
        print(f"✅ Success! Upscaled URL: {result['url']}")
        print(f"📐 New dimensions: {result['dimensions']}")
        print(f"🔍 Scale: {result['scale']}x")
        return result
    else:
        print(f"❌ Error: {response.status_code}")
        print(response.json())
        return None

# Простое увеличение в 2 раза
result = upscale_image(
    api_key="your-api-key",
    image_id=4738,
    scale=2
)

# Увеличение в 4 раза с улучшением лиц
result = upscale_image(
    api_key="your-api-key",
    image_id=4738,
    scale=4,
    face_enhance=True,
    denoise=0.7
)

async function upscaleImage(apiKey, imageId, options = {}) {
    const url = `https://image.nalitek.com/api/upscale/${imageId}`;

    const data = {
        scale: options.scale || 2,
        face_enhance: options.face_enhance || false,
        denoise: options.denoise || 0.5
    };

    try {
        const response = await fetch(url, {
            method: 'POST',
            headers: {
                'X-API-Key': apiKey,
                'Content-Type': 'application/json'
            },
            body: JSON.stringify(data)
        });

        if (response.status === 201) {
            const result = await response.json();
            console.log(`✅ Success! Upscaled URL: ${result.url}`);
            console.log(`📐 New dimensions: ${result.dimensions}`);
            console.log(`🔍 Scale: ${result.scale}x`);
            return result;
        } else {
            const error = await response.json();
            console.error(`❌ Error: ${response.status}`, error);
            return null;
        }
    } catch (error) {
        console.error('Request failed:', error);
        return null;
    }
}

// Простое увеличение в 2 раза
upscaleImage('your-api-key', 123);

// Увеличение в 4 раза с улучшением лиц
upscaleImage('your-api-key', 123, {
    scale: 4,
    face_enhance: true,
    denoise: 0.7
});

<?php

function upscaleImage($apiKey, $imageId, $options = []) {
    $url = "https://image.nalitek.com/api/upscale/$imageId";

    $data = array_merge([
        'scale' => 2,
        'face_enhance' => false,
        'denoise' => 0.5
    ], $options);

    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
        'X-API-Key: ' . $apiKey,
        'Content-Type: application/json'
    ]);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    if ($httpCode === 201) {
        $result = json_decode($response, true);
        echo "✅ Success! Upscaled URL: " . $result['url'] . "\n";
        echo "📐 New dimensions: " . $result['dimensions'] . "\n";
        echo "🔍 Scale: " . $result['scale'] . "x\n";
        return $result;
    } else {
        echo "❌ Error: HTTP $httpCode\n";
        echo $response . "\n";
        return null;
    }
}

// Простое увеличение в 2 раза
$result = upscaleImage('your-api-key', 123);

// Увеличение в 4 раза с улучшением лиц
$result = upscaleImage('your-api-key', 123, [
    'scale' => 4,
    'face_enhance' => true,
    'denoise' => 0.7
]);

async function checkImageStatus(imageId) {
    const response = await fetch(
        `https://image.nalitek.com/api/get/${imageId}`,
        {
            headers: {
                'X-API-Key': 'your_api_key'
            }
        }
    );
    
    const status = await response.json();
    console.log(`Status: ${status.status}`);
    
    if (status.status === 'completed') {
        console.log(`Image URL: ${status.url}`);
        return status.url;
    } else if (status.status === 'failed') {
        throw new Error(status.message);
    }
    
    // Повторить через 2 секунды
    await new Promise(resolve => setTimeout(resolve, 2000));
    return checkImageStatus(imageId);
}

# Проверка статуса изображения с ID 123
curl -X GET \
  https://image.nalitek.com/api/get/123 \
  -H "X-API-Key: your_api_key"

# Ответ для завершенной генерации:
# {
#   "status": "completed",
#   "url": "/uploads/images/flux_20250902_193838_c5dcc7ee.png",
#   "message": "Изображение успешно сгенерировано"
# }

async function checkApiStatus() {
    const url = 'https://image.nalitek.com/api/status';

    try {
        const response = await fetch(url);

        if (response.status === 200) {
            const status = await response.json();
            console.log(`✅ API Status: ${status.status}`);
            console.log(`📦 Version: ${status.version}`);

            // Проверка сервисов
            for (const [service, state] of Object.entries(status.services)) {
                const icon = state === 'operational' ? '✅' : '❌';
                console.log(`${icon} ${service}: ${state}`);
            }

            // Проверка моделей
            console.log('\n📊 Models:');
            for (const [model, info] of Object.entries(status.models)) {
                console.log(`  ${model}:`);
                console.log(`    Status: ${info.status}`);
                console.log(`    Queue: ${info.queue_size} tasks`);
                console.log(`    Avg time: ${info.avg_generation_time}s`);
            }

            return status;
        } else {
            console.error(`❌ API returned status code: ${response.status}`);
            return null;
        }
    } catch (error) {
        console.error(`❌ Failed to reach API: ${error}`);
        return null;
    }
}

// Использование
checkApiStatus().then(status => {
    if (status && status.status === 'operational') {
        console.log('\n✅ API is ready for requests!');
    } else {
        console.log('\n⚠️ API may be experiencing issues');
    }
});

<?php

function checkApiStatus() {
    $url = 'https://image.nalitek.com/api/status';

    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_TIMEOUT, 5);

    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    if ($httpCode === 200) {
        $status = json_decode($response, true);
        echo "✅ API Status: " . $status['status'] . "\n";
        echo "📦 Version: " . $status['version'] . "\n";

        // Проверка сервисов
        foreach ($status['services'] as $service => $state) {
            $icon = $state === 'operational' ? '✅' : '❌';
            echo "$icon $service: $state\n";
        }

        // Проверка моделей
        echo "\n📊 Models:\n";
        foreach ($status['models'] as $model => $info) {
            echo "  $model:\n";
            echo "    Status: " . $info['status'] . "\n";
            echo "    Queue: " . $info['queue_size'] . " tasks\n";
            echo "    Avg time: " . $info['avg_generation_time'] . "s\n";
        }

        return $status;
    } else {
        echo "❌ API returned status code: $httpCode\n";
        return null;
    }
}

// Использование
$status = checkApiStatus();

// Проверка перед началом работы
if ($status && $status['status'] === 'operational') {
    echo "\n✅ API is ready for requests!\n";
} else {
    echo "\n⚠️ API may be experiencing issues\n";
}

import requests

class ImageManager:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "https://image.nalitek.com"
        self.headers = {"X-API-Key": api_key}

    def get_images(self, page=1, per_page=20, **filters):
        """Получение списка изображений"""
        url = f"{self.base_url}/api/images"

        params = {
            'page': page,
            'per_page': per_page
        }

        # Добавление фильтров
        if 'status' in filters:
            params['status'] = filters['status']
        if 'is_upscaled' in filters:
            params['is_upscaled'] = filters['is_upscaled']
        if 'sort' in filters:
            params['sort'] = filters['sort']

        response = requests.get(url, params=params, headers=self.headers)

        if response.status_code == 200:
            data = response.json()
            print(f"📸 Found {data['total']} images")
            print(f"📄 Page {data['current_page']} of {data['total_pages']}")

            for image in data['images']:
                print(f"\n🆔 ID: {image['id']}")
                print(f"📝 Prompt: {image['prompt'][:50]}...")
                print(f"📐 Size: {image['width']}x{image['height']}")
                print(f"✅ Status: {image['status']}")

            return data
        else:
            print(f"❌ Error: {response.status_code}")
            return None

    def get_image_details(self, image_id):
        """Получение деталей изображения"""
        url = f"{self.base_url}/api/images/{image_id}"
        response = requests.get(url, headers=self.headers)

        if response.status_code == 200:
            image = response.json()
            print(f"🆔 Image ID: {image['id']}")
            print(f"📝 Prompt: {image['prompt']}")
            print(f"🔗 URL: {image['url']}")
            print(f"📐 Dimensions: {image['width']}x{image['height']}")
            print(f"🌱 Seed: {image['seed']}")
            print(f"⏱️ Generation time: {image['generation_time']}s")
            return image
        else:
            print(f"❌ Error: {response.status_code}")
            return None

    def delete_image(self, image_id):
        """Удаление изображения"""
        url = f"{self.base_url}/api/images/{image_id}"
        response = requests.delete(url, headers=self.headers)

        if response.status_code == 204:
            print(f"✅ Image {image_id} deleted successfully")
            return True
        else:
            print(f"❌ Error: {response.status_code}")
            return False

    def get_all_images(self):
        """Получение всех изображений (с пагинацией)"""
        all_images = []
        page = 1

        while True:
            data = self.get_images(page=page, per_page=100)
            if not data:
                break

            all_images.extend(data['images'])

            if page >= data['total_pages']:
                break

            page += 1

        print(f"\n📊 Total images collected: {len(all_images)}")
        return all_images

# Использование
manager = ImageManager("your-api-key")

# Получить последние изображения
manager.get_images(page=1, per_page=10)

# Получить только завершенные изображения
manager.get_images(status='completed', sort='date_desc')

# Получить детали конкретного изображения
manager.get_image_details(4738)

# Удалить изображение
manager.delete_image(4739)

# Получить все изображения
all_images = manager.get_all_images()

class ImageManager {
    constructor(apiKey) {
        this.apiKey = apiKey;
        this.baseUrl = 'https://image.nalitek.com';
    }

    async getImages(page = 1, perPage = 20, filters = {}) {
        const url = new URL(`${this.baseUrl}/api/images`);

        // Добавление параметров
        url.searchParams.append('page', page);
        url.searchParams.append('per_page', perPage);

        // Добавление фильтров
        if (filters.status) url.searchParams.append('status', filters.status);
        if (filters.is_upscaled !== undefined) {
            url.searchParams.append('is_upscaled', filters.is_upscaled);
        }
        if (filters.sort) url.searchParams.append('sort', filters.sort);

        try {
            const response = await fetch(url, {
                headers: { 'X-API-Key': this.apiKey }
            });

            if (response.status === 200) {
                const data = await response.json();
                console.log(`📸 Found ${data.total} images`);
                console.log(`📄 Page ${data.current_page} of ${data.total_pages}`);

                data.images.forEach(image => {
                    console.log(`\n🆔 ID: ${image.id}`);
                    console.log(`📝 Prompt: ${image.prompt.substring(0, 50)}...`);
                    console.log(`📐 Size: ${image.width}x${image.height}`);
                    console.log(`✅ Status: ${image.status}`);
                });

                return data;
            } else {
                console.error(`❌ Error: ${response.status}`);
                return null;
            }
        } catch (error) {
            console.error('Request failed:', error);
            return null;
        }
    }

    async getImageDetails(imageId) {
        const url = `${this.baseUrl}/api/images/${imageId}`;

        try {
            const response = await fetch(url, {
                headers: { 'X-API-Key': this.apiKey }
            });

            if (response.status === 200) {
                const image = await response.json();
                console.log(`🆔 Image ID: ${image.id}`);
                console.log(`📝 Prompt: ${image.prompt}`);
                console.log(`🔗 URL: ${image.url}`);
                console.log(`📐 Dimensions: ${image.width}x${image.height}`);
                console.log(`🌱 Seed: ${image.seed}`);
                console.log(`⏱️ Generation time: ${image.generation_time}s`);
                return image;
            } else {
                console.error(`❌ Error: ${response.status}`);
                return null;
            }
        } catch (error) {
            console.error('Request failed:', error);
            return null;
        }
    }

    async deleteImage(imageId) {
        const url = `${this.baseUrl}/api/images/${imageId}`;

        try {
            const response = await fetch(url, {
                method: 'DELETE',
                headers: { 'X-API-Key': this.apiKey }
            });

            if (response.status === 204) {
                console.log(`✅ Image ${imageId} deleted successfully`);
                return true;
            } else {
                console.error(`❌ Error: ${response.status}`);
                return false;
            }
        } catch (error) {
            console.error('Request failed:', error);
            return false;
        }
    }

    async getAllImages() {
        const allImages = [];
        let page = 1;
        let totalPages = 1;

        while (page <= totalPages) {
            const data = await this.getImages(page, 100);
            if (!data) break;

            allImages.push(...data.images);
            totalPages = data.total_pages;
            page++;
        }

        console.log(`\n📊 Total images collected: ${allImages.length}`);
        return allImages;
    }
}

// Использование
const manager = new ImageManager('your-api-key');

// Получить последние изображения
manager.getImages(1, 10);

// Получить только завершенные изображения
manager.getImages(1, 20, { status: 'completed', sort: 'date_desc' });

// Получить детали конкретного изображения
manager.getImageDetails(123);

// Удалить изображение
manager.deleteImage(456);

// Получить все изображения
manager.getAllImages();

<?php

class ImageManager {
    private $apiKey;
    private $baseUrl = 'https://image.nalitek.com';

    public function __construct($apiKey) {
        $this->apiKey = $apiKey;
    }

    public function getImages($page = 1, $perPage = 20, $filters = []) {
        $url = $this->baseUrl . '/api/images';

        $params = [
            'page' => $page,
            'per_page' => $perPage
        ];

        // Добавление фильтров
        if (isset($filters['status'])) {
            $params['status'] = $filters['status'];
        }
        if (isset($filters['is_upscaled'])) {
            $params['is_upscaled'] = $filters['is_upscaled'];
        }
        if (isset($filters['sort'])) {
            $params['sort'] = $filters['sort'];
        }

        $url .= '?' . http_build_query($params);

        $ch = curl_init($url);
        curl_setopt($ch, CURLOPT_HTTPHEADER, ['X-API-Key: ' . $this->apiKey]);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);

        if ($httpCode === 200) {
            $data = json_decode($response, true);
            echo "📸 Found {$data['total']} images\n";
            echo "📄 Page {$data['current_page']} of {$data['total_pages']}\n";

            foreach ($data['images'] as $image) {
                echo "\n🆔 ID: {$image['id']}\n";
                echo "📝 Prompt: " . substr($image['prompt'], 0, 50) . "...\n";
                echo "📐 Size: {$image['width']}x{$image['height']}\n";
                echo "✅ Status: {$image['status']}\n";
            }

            return $data;
        } else {
            echo "❌ Error: HTTP $httpCode\n";
            return null;
        }
    }

    public function getImageDetails($imageId) {
        $url = $this->baseUrl . "/api/images/$imageId";

        $ch = curl_init($url);
        curl_setopt($ch, CURLOPT_HTTPHEADER, ['X-API-Key: ' . $this->apiKey]);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);

        if ($httpCode === 200) {
            $image = json_decode($response, true);
            echo "🆔 Image ID: {$image['id']}\n";
            echo "📝 Prompt: {$image['prompt']}\n";
            echo "🔗 URL: {$image['url']}\n";
            echo "📐 Dimensions: {$image['width']}x{$image['height']}\n";
            echo "🌱 Seed: {$image['seed']}\n";
            echo "⏱️ Generation time: {$image['generation_time']}s\n";
            return $image;
        } else {
            echo "❌ Error: HTTP $httpCode\n";
            return null;
        }
    }

    public function deleteImage($imageId) {
        $url = $this->baseUrl . "/api/images/$imageId";

        $ch = curl_init($url);
        curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');
        curl_setopt($ch, CURLOPT_HTTPHEADER, ['X-API-Key: ' . $this->apiKey]);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);

        if ($httpCode === 204) {
            echo "✅ Image $imageId deleted successfully\n";
            return true;
        } else {
            echo "❌ Error: HTTP $httpCode\n";
            return false;
        }
    }
}

// Использование
$manager = new ImageManager('your-api-key');

// Получить последние изображения
$manager->getImages(1, 10);

// Получить только завершенные изображения
$manager->getImages(1, 20, ['status' => 'completed', 'sort' => 'date_desc']);

// Получить детали конкретного изображения
$manager->getImageDetails(123);

// Удалить изображение
$manager->deleteImage(456);

class UserAPI {
    constructor(apiKey) {
        this.apiKey = apiKey;
        this.baseUrl = 'https://image.nalitek.com';
    }

    async getProfile() {
        const url = `${this.baseUrl}/api/user/profile`;

        try {
            const response = await fetch(url, {
                headers: { 'X-API-Key': this.apiKey }
            });

            if (response.status === 200) {
                const profile = await response.json();
                console.log(`👤 User: ${profile.username}`);
                console.log(`📧 Email: ${profile.email}`);
                console.log(`🎯 Plan: ${profile.plan}`);
                console.log(`🎨 Default model: ${profile.settings.default_model}`);
                return profile;
            } else {
                console.error(`❌ Error: ${response.status}`);
                return null;
            }
        } catch (error) {
            console.error('Request failed:', error);
            return null;
        }
    }

    async updateProfile(updates) {
        const url = `${this.baseUrl}/api/user/profile`;

        try {
            const response = await fetch(url, {
                method: 'PUT',
                headers: {
                    'X-API-Key': this.apiKey,
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify(updates)
            });

            if (response.status === 200) {
                const profile = await response.json();
                console.log('✅ Profile updated successfully');
                return profile;
            } else {
                console.error(`❌ Error: ${response.status}`);
                return null;
            }
        } catch (error) {
            console.error('Request failed:', error);
            return null;
        }
    }

    async updateSettings(settings) {
        return this.updateProfile({ settings });
    }

    async changePassword(currentPassword, newPassword) {
        const url = `${this.baseUrl}/api/user/password`;

        try {
            const response = await fetch(url, {
                method: 'POST',
                headers: {
                    'X-API-Key': this.apiKey,
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify({
                    current_password: currentPassword,
                    new_password: newPassword
                })
            });

            if (response.status === 200) {
                console.log('✅ Password changed successfully');
                return true;
            } else {
                console.error(`❌ Error: ${response.status}`);
                return false;
            }
        } catch (error) {
            console.error('Request failed:', error);
            return false;
        }
    }
}

// Использование
const userApi = new UserAPI('your-api-key');

// Получить профиль
userApi.getProfile();

// Обновить настройки
userApi.updateSettings({
    default_model: 'flux-schnell',
    default_quality: 'ultra',
    email_notifications: false
});

// Изменить пароль
userApi.changePassword('old_password', 'new_secure_password');

<?php

class UserAPI {
    private $apiKey;
    private $baseUrl = 'https://image.nalitek.com';

    public function __construct($apiKey) {
        $this->apiKey = $apiKey;
    }

    public function getProfile() {
        $url = $this->baseUrl . '/api/user/profile';

        $ch = curl_init($url);
        curl_setopt($ch, CURLOPT_HTTPHEADER, ['X-API-Key: ' . $this->apiKey]);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);

        if ($httpCode === 200) {
            $profile = json_decode($response, true);
            echo "👤 User: {$profile['username']}\n";
            echo "📧 Email: {$profile['email']}\n";
            echo "🎯 Plan: {$profile['plan']}\n";
            echo "🎨 Default model: {$profile['settings']['default_model']}\n";
            return $profile;
        } else {
            echo "❌ Error: HTTP $httpCode\n";
            return null;
        }
    }

    public function updateProfile($updates) {
        $url = $this->baseUrl . '/api/user/profile';

        $ch = curl_init($url);
        curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'PUT');
        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($updates));
        curl_setopt($ch, CURLOPT_HTTPHEADER, [
            'X-API-Key: ' . $this->apiKey,
            'Content-Type: application/json'
        ]);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);

        if ($httpCode === 200) {
            echo "✅ Profile updated successfully\n";
            return json_decode($response, true);
        } else {
            echo "❌ Error: HTTP $httpCode\n";
            return null;
        }
    }

    public function updateSettings($settings) {
        return $this->updateProfile(['settings' => $settings]);
    }

    public function changePassword($currentPassword, $newPassword) {
        $url = $this->baseUrl . '/api/user/password';

        $data = [
            'current_password' => $currentPassword,
            'new_password' => $newPassword
        ];

        $ch = curl_init($url);
        curl_setopt($ch, CURLOPT_POST, true);
        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
        curl_setopt($ch, CURLOPT_HTTPHEADER, [
            'X-API-Key: ' . $this->apiKey,
            'Content-Type: application/json'
        ]);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);

        if ($httpCode === 200) {
            echo "✅ Password changed successfully\n";
            return true;
        } else {
            echo "❌ Error: HTTP $httpCode\n";
            return false;
        }
    }
}

// Использование
$userApi = new UserAPI('your-api-key');

// Получить профиль
$profile = $userApi->getProfile();

// Обновить настройки
$userApi->updateSettings([
    'default_model' => 'flux-schnell',
    'default_quality' => 'ultra',
    'email_notifications' => false
]);

// Изменить пароль
$userApi->changePassword('old_password', 'new_secure_password');

class APIKeyManager {
    constructor(apiKey) {
        this.apiKey = apiKey;
        this.baseUrl = 'https://image.nalitek.com';
    }

    async listKeys() {
        const url = `${this.baseUrl}/api/user/api-keys`;

        try {
            const response = await fetch(url, {
                headers: { 'X-API-Key': this.apiKey }
            });

            if (response.status === 200) {
                const keys = await response.json();
                console.log(`🔑 Total API keys: ${keys.api_keys.length}`);

                keys.api_keys.forEach(key => {
                    console.log(`\n🆔 ID: ${key.id}`);
                    console.log(`📝 Name: ${key.name}`);
                    console.log(`🔑 Prefix: ${key.prefix}`);
                    console.log(`📅 Created: ${key.created_at}`);
                    console.log(`⏰ Last used: ${key.last_used_at}`);
                    console.log(`📊 Usage: ${key.usage.total_requests} requests`);
                });

                return keys;
            } else {
                console.error(`❌ Error: ${response.status}`);
                return null;
            }
        } catch (error) {
            console.error('Request failed:', error);
            return null;
        }
    }

    async createKey(name, ipWhitelist = null, rateLimit = null) {
        const url = `${this.baseUrl}/api/user/api-keys`;

        const data = { name };
        if (ipWhitelist) data.ip_whitelist = ipWhitelist;
        if (rateLimit) data.rate_limit = rateLimit;

        try {
            const response = await fetch(url, {
                method: 'POST',
                headers: {
                    'X-API-Key': this.apiKey,
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify(data)
            });

            if (response.status === 201) {
                const keyData = await response.json();
                console.log('✅ API key created successfully');
                console.log(`🔑 Key: ${keyData.key}`);
                console.log('⚠️  Save this key! It won\'t be shown again.');
                return keyData;
            } else {
                console.error(`❌ Error: ${response.status}`);
                return null;
            }
        } catch (error) {
            console.error('Request failed:', error);
            return null;
        }
    }

    async deleteKey(keyId) {
        const url = `${this.baseUrl}/api/user/api-keys/${keyId}`;

        try {
            const response = await fetch(url, {
                method: 'DELETE',
                headers: { 'X-API-Key': this.apiKey }
            });

            if (response.status === 204) {
                console.log(`✅ API key ${keyId} deleted successfully`);
                return true;
            } else {
                console.error(`❌ Error: ${response.status}`);
                return false;
            }
        } catch (error) {
            console.error('Request failed:', error);
            return false;
        }
    }
}

// Использование
const manager = new APIKeyManager('your-api-key');

// Список ключей
manager.listKeys();

// Создать новый ключ
manager.createKey(
    'Production API Key',
    ['192.168.1.1', '10.0.0.1'],
    1000
);

// Удалить ключ
manager.deleteKey(123);

<?php

class APIKeyManager {
    private $apiKey;
    private $baseUrl = 'https://image.nalitek.com';

    public function __construct($apiKey) {
        $this->apiKey = $apiKey;
    }

    public function listKeys() {
        $url = $this->baseUrl . '/api/user/api-keys';

        $ch = curl_init($url);
        curl_setopt($ch, CURLOPT_HTTPHEADER, ['X-API-Key: ' . $this->apiKey]);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);

        if ($httpCode === 200) {
            $keys = json_decode($response, true);
            echo "🔑 Total API keys: " . count($keys['api_keys']) . "\n";

            foreach ($keys['api_keys'] as $key) {
                echo "\n🆔 ID: {$key['id']}\n";
                echo "📝 Name: {$key['name']}\n";
                echo "🔑 Prefix: {$key['prefix']}\n";
                echo "📅 Created: {$key['created_at']}\n";
                echo "⏰ Last used: {$key['last_used_at']}\n";
                echo "📊 Usage: {$key['usage']['total_requests']} requests\n";
            }

            return $keys;
        } else {
            echo "❌ Error: HTTP $httpCode\n";
            return null;
        }
    }

    public function createKey($name, $ipWhitelist = null, $rateLimit = null) {
        $url = $this->baseUrl . '/api/user/api-keys';

        $data = ['name' => $name];
        if ($ipWhitelist) $data['ip_whitelist'] = $ipWhitelist;
        if ($rateLimit) $data['rate_limit'] = $rateLimit;

        $ch = curl_init($url);
        curl_setopt($ch, CURLOPT_POST, true);
        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
        curl_setopt($ch, CURLOPT_HTTPHEADER, [
            'X-API-Key: ' . $this->apiKey,
            'Content-Type: application/json'
        ]);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);

        if ($httpCode === 201) {
            $keyData = json_decode($response, true);
            echo "✅ API key created successfully\n";
            echo "🔑 Key: {$keyData['key']}\n";
            echo "⚠️  Save this key! It won't be shown again.\n";
            return $keyData;
        } else {
            echo "❌ Error: HTTP $httpCode\n";
            return null;
        }
    }

    public function deleteKey($keyId) {
        $url = $this->baseUrl . "/api/user/api-keys/$keyId";

        $ch = curl_init($url);
        curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');
        curl_setopt($ch, CURLOPT_HTTPHEADER, ['X-API-Key: ' . $this->apiKey]);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);

        if ($httpCode === 204) {
            echo "✅ API key $keyId deleted successfully\n";
            return true;
        } else {
            echo "❌ Error: HTTP $httpCode\n";
            return false;
        }
    }
}

// Использование
$manager = new APIKeyManager('your-api-key');

// Список ключей
$manager->listKeys();

// Создать новый ключ
$manager->createKey(
    'Production API Key',
    ['192.168.1.1', '10.0.0.1'],
    1000
);

// Удалить ключ
$manager->deleteKey(123);

class BatchProcessor {
    constructor(apiKey) {
        this.apiKey = apiKey;
        this.baseUrl = 'https://image.nalitek.com';
    }

    async batchGenerate(prompts, commonParams = {}) {
        const url = `${this.baseUrl}/api/batch/generate`;

        // Подготовка batch данных
        const batch = prompts.map(prompt => ({
            prompt,
            ...commonParams
        }));

        const data = {
            batch,
            webhook_url: 'https://your-webhook.com/batch-complete'
        };

        try {
            const response = await fetch(url, {
                method: 'POST',
                headers: {
                    'X-API-Key': this.apiKey,
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify(data)
            });

            if (response.status === 201) {
                const result = await response.json();
                console.log(`✅ Batch created: ${result.batch_id}`);
                console.log(`📊 Total jobs: ${result.total_jobs}`);
                console.log(`⏱️ Estimated time: ${result.estimated_time}s`);
                return result;
            } else {
                console.error(`❌ Error: ${response.status}`);
                return null;
            }
        } catch (error) {
            console.error('Request failed:', error);
            return null;
        }
    }

    async checkBatchStatus(batchId) {
        const url = `${this.baseUrl}/api/batch/${batchId}`;

        try {
            const response = await fetch(url, {
                headers: { 'X-API-Key': this.apiKey }
            });

            if (response.status === 200) {
                const status = await response.json();
                console.log(`📊 Batch ${batchId}:`);
                console.log(`  Completed: ${status.completed}/${status.total}`);
                console.log(`  Failed: ${status.failed}`);
                console.log(`  Status: ${status.status}`);
                return status;
            }
            return null;
        } catch (error) {
            console.error('Request failed:', error);
            return null;
        }
    }

    async waitForBatch(batchId, timeout = 600000) {
        const startTime = Date.now();

        while (Date.now() - startTime < timeout) {
            const status = await this.checkBatchStatus(batchId);

            if (status && status.status === 'completed') {
                console.log('✅ Batch completed!');
                return status;
            } else if (status && status.status === 'failed') {
                console.log('❌ Batch failed!');
                return status;
            }

            await new Promise(resolve => setTimeout(resolve, 5000));
        }

        console.log(`⏱️ Timeout after ${timeout}ms`);
        return null;
    }
}

// Использование
const processor = new BatchProcessor('your-api-key');

// Создание batch с разными промптами
const prompts = [
    'cyberpunk city at night',
    'beautiful japanese garden',
    'abstract art with vibrant colors',
    'portrait of a robot',
    'underwater coral reef'
];

async function runBatch() {
    const batch = await processor.batchGenerate(prompts, {
        width: 1024,
        height: 1024,
        steps: 30,
        model: 'flux-dev'
    });

    if (batch) {
        const result = await processor.waitForBatch(batch.batch_id);

        if (result) {
            result.jobs.forEach(job => {
                console.log(`\n🖼️ Image ${job.id}: ${job.url}`);
            });
        }
    }
}

runBatch();

<?php

class BatchProcessor {
    private $apiKey;
    private $baseUrl = 'https://image.nalitek.com';

    public function __construct($apiKey) {
        $this->apiKey = $apiKey;
    }

    public function batchGenerate($prompts, $commonParams = []) {
        $url = $this->baseUrl . '/api/batch/generate';

        // Подготовка batch данных
        $batch = [];
        foreach ($prompts as $prompt) {
            $item = array_merge(['prompt' => $prompt], $commonParams);
            $batch[] = $item;
        }

        $data = [
            'batch' => $batch,
            'webhook_url' => 'https://your-webhook.com/batch-complete'
        ];

        $ch = curl_init($url);
        curl_setopt($ch, CURLOPT_POST, true);
        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
        curl_setopt($ch, CURLOPT_HTTPHEADER, [
            'X-API-Key: ' . $this->apiKey,
            'Content-Type: application/json'
        ]);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);

        if ($httpCode === 201) {
            $result = json_decode($response, true);
            echo "✅ Batch created: {$result['batch_id']}\n";
            echo "📊 Total jobs: {$result['total_jobs']}\n";
            echo "⏱️ Estimated time: {$result['estimated_time']}s\n";
            return $result;
        } else {
            echo "❌ Error: HTTP $httpCode\n";
            return null;
        }
    }

    public function checkBatchStatus($batchId) {
        $url = $this->baseUrl . "/api/batch/$batchId";

        $ch = curl_init($url);
        curl_setopt($ch, CURLOPT_HTTPHEADER, ['X-API-Key: ' . $this->apiKey]);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);

        if ($httpCode === 200) {
            $status = json_decode($response, true);
            echo "📊 Batch $batchId:\n";
            echo "  Completed: {$status['completed']}/{$status['total']}\n";
            echo "  Failed: {$status['failed']}\n";
            echo "  Status: {$status['status']}\n";
            return $status;
        }
        return null;
    }

    public function waitForBatch($batchId, $timeout = 600) {
        $startTime = time();

        while (time() - $startTime < $timeout) {
            $status = $this->checkBatchStatus($batchId);

            if ($status && $status['status'] === 'completed') {
                echo "✅ Batch completed!\n";
                return $status;
            } elseif ($status && $status['status'] === 'failed') {
                echo "❌ Batch failed!\n";
                return $status;
            }

            sleep(5);
        }

        echo "⏱️ Timeout after {$timeout}s\n";
        return null;
    }
}

// Использование
$processor = new BatchProcessor('your-api-key');

// Создание batch с разными промптами
$prompts = [
    'cyberpunk city at night',
    'beautiful japanese garden',
    'abstract art with vibrant colors',
    'portrait of a robot',
    'underwater coral reef'
];

$batch = $processor->batchGenerate($prompts, [
    'width' => 1024,
    'height' => 1024,
    'steps' => 30,
    'model' => 'flux-dev'
]);

if ($batch) {
    $result = $processor->waitForBatch($batch['batch_id']);

    if ($result) {
        foreach ($result['jobs'] as $job) {
            echo "\n🖼️ Image {$job['id']}: {$job['url']}\n";
        }
    }
}

class AdminAPI {
    constructor(adminApiKey) {
        this.apiKey = adminApiKey;
        this.baseUrl = 'https://image.nalitek.com';
    }

    async getUsers(page = 1, perPage = 50) {
        const url = new URL(`${this.baseUrl}/api/admin/users`);
        url.searchParams.append('page', page);
        url.searchParams.append('per_page', perPage);

        try {
            const response = await fetch(url, {
                headers: { 'X-API-Key': this.apiKey }
            });

            if (response.status === 200) {
                const data = await response.json();
                console.log(`👥 Total users: ${data.total}`);

                data.users.forEach(user => {
                    console.log(`\n👤 ${user.username} (${user.email})`);
                    console.log(`   Plan: ${user.plan}`);
                    console.log(`   Quota: ${user.quota.daily_generations}/day`);
                    console.log(`   Created: ${user.created_at}`);
                });

                return data;
            } else {
                console.error(`❌ Error: ${response.status}`);
                return null;
            }
        } catch (error) {
            console.error('Request failed:', error);
            return null;
        }
    }

    async getStatistics() {
        const url = `${this.baseUrl}/api/admin/statistics`;

        try {
            const response = await fetch(url, {
                headers: { 'X-API-Key': this.apiKey }
            });

            if (response.status === 200) {
                const stats = await response.json();
                console.log('📊 System Statistics:');
                console.log(`   Total users: ${stats.total_users}`);
                console.log(`   Active users (24h): ${stats.active_users_24h}`);
                console.log(`   Total generations: ${stats.total_generations}`);
                console.log(`   Generations today: ${stats.generations_today}`);
                console.log(`   Storage used: ${stats.storage_used_gb} GB`);
                console.log(`   Revenue this month: ${stats.revenue_month}`);
                return stats;
            } else {
                console.error(`❌ Error: ${response.status}`);
                return null;
            }
        } catch (error) {
            console.error('Request failed:', error);
            return null;
        }
    }

    async updateUserQuota(userId, dailyGenerations, dailyUpscales) {
        const url = `${this.baseUrl}/api/admin/user/${userId}/quota`;

        try {
            const response = await fetch(url, {
                method: 'POST',
                headers: {
                    'X-API-Key': this.apiKey,
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify({
                    daily_generations: dailyGenerations,
                    daily_upscales: dailyUpscales
                })
            });

            if (response.status === 200) {
                console.log(`✅ Quota updated for user ${userId}`);
                return true;
            } else {
                console.error(`❌ Error: ${response.status}`);
                return false;
            }
        } catch (error) {
            console.error('Request failed:', error);
            return false;
        }
    }
}

// Использование
const admin = new AdminAPI('admin-api-key');

// Получить пользователей
admin.getUsers(1);

// Получить статистику
admin.getStatistics();

// Обновить квоты
admin.updateUserQuota(123, 500, 100);

<?php

class AdminAPI {
    private $apiKey;
    private $baseUrl = 'https://image.nalitek.com';

    public function __construct($adminApiKey) {
        $this->apiKey = $adminApiKey;
    }

    public function getUsers($page = 1, $perPage = 50) {
        $url = $this->baseUrl . '/api/admin/users';
        $url .= '?' . http_build_query(['page' => $page, 'per_page' => $perPage]);

        $ch = curl_init($url);
        curl_setopt($ch, CURLOPT_HTTPHEADER, ['X-API-Key: ' . $this->apiKey]);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);

        if ($httpCode === 200) {
            $data = json_decode($response, true);
            echo "👥 Total users: {$data['total']}\n";

            foreach ($data['users'] as $user) {
                echo "\n👤 {$user['username']} ({$user['email']})\n";
                echo "   Plan: {$user['plan']}\n";
                echo "   Quota: {$user['quota']['daily_generations']}/day\n";
                echo "   Created: {$user['created_at']}\n";
            }

            return $data;
        } else {
            echo "❌ Error: HTTP $httpCode\n";
            return null;
        }
    }

    public function getStatistics() {
        $url = $this->baseUrl . '/api/admin/statistics';

        $ch = curl_init($url);
        curl_setopt($ch, CURLOPT_HTTPHEADER, ['X-API-Key: ' . $this->apiKey]);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);

        if ($httpCode === 200) {
            $stats = json_decode($response, true);
            echo "📊 System Statistics:\n";
            echo "   Total users: {$stats['total_users']}\n";
            echo "   Active users (24h): {$stats['active_users_24h']}\n";
            echo "   Total generations: {$stats['total_generations']}\n";
            echo "   Generations today: {$stats['generations_today']}\n";
            echo "   Storage used: {$stats['storage_used_gb']} GB\n";
            echo "   Revenue this month: \${$stats['revenue_month']}\n";
            return $stats;
        } else {
            echo "❌ Error: HTTP $httpCode\n";
            return null;
        }
    }

    public function updateUserQuota($userId, $dailyGenerations, $dailyUpscales) {
        $url = $this->baseUrl . "/api/admin/user/$userId/quota";

        $data = [
            'daily_generations' => $dailyGenerations,
            'daily_upscales' => $dailyUpscales
        ];

        $ch = curl_init($url);
        curl_setopt($ch, CURLOPT_POST, true);
        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
        curl_setopt($ch, CURLOPT_HTTPHEADER, [
            'X-API-Key: ' . $this->apiKey,
            'Content-Type: application/json'
        ]);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);

        if ($httpCode === 200) {
            echo "✅ Quota updated for user $userId\n";
            return true;
        } else {
            echo "❌ Error: HTTP $httpCode\n";
            return false;
        }
    }
}

// Использование
$admin = new AdminAPI('admin-api-key');

// Получить пользователей
$admin->getUsers(1);

// Получить статистику
$admin->getStatistics();

// Обновить квоты
$admin->updateUserQuota(123, 500, 100);

// flux-api-sdk.js
/**
 * FLUX API SDK for JavaScript
 * Complete integration example
 */

class FluxAPISDK {
    constructor(apiKey, baseUrl = 'https://image.nalitek.com') {
        this.apiKey = apiKey;
        this.baseUrl = baseUrl;
    }

    /**
     * Generate an image from text prompt
     */
    async generate(options = {}) {
        const url = `${this.baseUrl}/api/generate`;

        const data = {
            prompt: options.prompt,
            negative_prompt: options.negative_prompt || '',
            width: options.width || 1024,
            height: options.height || 1024,
            steps: options.steps || 30,
            guidance_scale: options.guidance_scale || 7.5,
            seed: options.seed || -1,
            model: options.model || 'flux-dev',
            format: options.format || 'png'
        };

        if (options.lora_id) data.lora_id = options.lora_id;
        if (options.webhook_url) data.webhook_url = options.webhook_url;

        const response = await fetch(url, {
            method: 'POST',
            headers: {
                'X-API-Key': this.apiKey,
                'Content-Type': 'application/json'
            },
            body: JSON.stringify(data)
        });

        if (response.status === 201) {
            const result = await response.json();

            if (options.waitForCompletion !== false) {
                return await this.waitForImage(result.image_id);
            }

            return result;
        } else {
            const error = await response.json();
            throw new Error(`API Error ${response.status}: ${error.error}`);
        }
    }

    /**
     * Transform an existing image
     */
    async img2img(imageFile, options = {}) {
        const url = `${this.baseUrl}/api/img2img`;

        const formData = new FormData();
        formData.append('image', imageFile);
        formData.append('prompt', options.prompt);
        formData.append('negative_prompt', options.negative_prompt || '');
        formData.append('strength', options.strength || 0.75);
        formData.append('steps', options.steps || 30);
        formData.append('guidance_scale', options.guidance_scale || 7.5);
        formData.append('seed', options.seed || -1);

        const response = await fetch(url, {
            method: 'POST',
            headers: {
                'X-API-Key': this.apiKey
            },
            body: formData
        });

        if (response.status === 201) {
            const result = await response.json();

            if (options.waitForCompletion !== false && result.image_id) {
                return await this.waitForImage(result.image_id);
            }

            return result;
        } else {
            const error = await response.json();
            throw new Error(`API Error ${response.status}: ${error.error}`);
        }
    }

    /**
     * Upscale an image
     */
    async upscale(imageId, options = {}) {
        const url = `${this.baseUrl}/api/upscale/${imageId}`;

        const data = {
            scale: options.scale || 2,
            face_enhance: options.face_enhance || false,
            denoise: options.denoise || 0.5
        };

        const response = await fetch(url, {
            method: 'POST',
            headers: {
                'X-API-Key': this.apiKey,
                'Content-Type': 'application/json'
            },
            body: JSON.stringify(data)
        });

        if (response.status === 201) {
            return await response.json();
        } else {
            const error = await response.json();
            throw new Error(`API Error ${response.status}: ${error.error}`);
        }
    }

    /**
     * Get image details
     */
    async getImage(imageId) {
        const url = `${this.baseUrl}/api/images/${imageId}`;

        const response = await fetch(url, {
            headers: { 'X-API-Key': this.apiKey }
        });

        if (response.status === 200) {
            return await response.json();
        } else {
            const error = await response.json();
            throw new Error(`API Error ${response.status}: ${error.error}`);
        }
    }

    /**
     * List images with filters
     */
    async listImages(options = {}) {
        const url = new URL(`${this.baseUrl}/api/images`);

        url.searchParams.append('page', options.page || 1);
        url.searchParams.append('per_page', options.per_page || 20);
        url.searchParams.append('sort', options.sort || 'date_desc');

        if (options.status) url.searchParams.append('status', options.status);
        if (options.is_upscaled !== undefined) {
            url.searchParams.append('is_upscaled', options.is_upscaled);
        }

        const response = await fetch(url, {
            headers: { 'X-API-Key': this.apiKey }
        });

        if (response.status === 200) {
            return await response.json();
        } else {
            const error = await response.json();
            throw new Error(`API Error ${response.status}: ${error.error}`);
        }
    }

    /**
     * Delete an image
     */
    async deleteImage(imageId) {
        const url = `${this.baseUrl}/api/images/${imageId}`;

        const response = await fetch(url, {
            method: 'DELETE',
            headers: { 'X-API-Key': this.apiKey }
        });

        return response.status === 204;
    }

    /**
     * Get available LoRA models
     */
    async getLoras() {
        const url = `${this.baseUrl}/api/loras`;

        const response = await fetch(url, {
            headers: { 'X-API-Key': this.apiKey }
        });

        if (response.status === 200) {
            const data = await response.json();
            return data.loras;
        } else {
            const error = await response.json();
            throw new Error(`API Error ${response.status}: ${error.error}`);
        }
    }

    /**
     * Get user statistics
     */
    async getUserStats() {
        const url = `${this.baseUrl}/api/user/stats`;

        const response = await fetch(url, {
            headers: { 'X-API-Key': this.apiKey }
        });

        if (response.status === 200) {
            return await response.json();
        } else {
            const error = await response.json();
            throw new Error(`API Error ${response.status}: ${error.error}`);
        }
    }

    /**
     * Check API status
     */
    async checkApiStatus() {
        const url = `${this.baseUrl}/api/status`;

        const response = await fetch(url);

        if (response.status === 200) {
            return await response.json();
        } else {
            throw new Error(`API Error ${response.status}`);
        }
    }

    /**
     * Batch generate images
     */
    async batchGenerate(prompts, commonParams = {}, webhookUrl = null) {
        const url = `${this.baseUrl}/api/batch/generate`;

        const batch = prompts.slice(0, 10).map(prompt => ({
            prompt,
            ...commonParams
        }));

        const data = { batch };
        if (webhookUrl) data.webhook_url = webhookUrl;

        const response = await fetch(url, {
            method: 'POST',
            headers: {
                'X-API-Key': this.apiKey,
                'Content-Type': 'application/json'
            },
            body: JSON.stringify(data)
        });

        if (response.status === 201) {
            return await response.json();
        } else {
            const error = await response.json();
            throw new Error(`API Error ${response.status}: ${error.error}`);
        }
    }

    /**
     * Wait for image generation to complete
     */
    async waitForImage(imageId, timeout = 120000) {
        const startTime = Date.now();

        while (Date.now() - startTime < timeout) {
            const image = await this.getImage(imageId);

            if (image.status === 'completed') {
                return image;
            } else if (image.status === 'failed') {
                throw new Error(`Generation failed: ${image.error_message}`);
            }

            await new Promise(resolve => setTimeout(resolve, 2000));
        }

        throw new Error(`Generation timeout after ${timeout}ms`);
    }
}

// Example usage
(async () => {
    // Initialize SDK
    const sdk = new FluxAPISDK('your-api-key');

    try {
        // Check API status
        const status = await sdk.checkApiStatus();
        console.log(`API Status: ${status.status}`);

        // Generate an image
        const image = await sdk.generate({
            prompt: 'beautiful sunset over mountains, professional photography',
            width: 1024,
            height: 1024,
            steps: 30,
            model: 'flux-dev'
        });
        console.log(`Generated image: ${image.url}`);

        // Upscale the image
        const upscaled = await sdk.upscale(image.id, { scale: 2 });
        console.log(`Upscaled image: ${upscaled.url}`);

        // Get user statistics
        const stats = await sdk.getUserStats();
        console.log(`Remaining generations: ${stats.quota.remaining_generations}`);

        // List available LoRA models
        const loras = await sdk.getLoras();
        loras.forEach(lora => {
            console.log(`LoRA: ${lora.name} (${lora.id})`);
        });

    } catch (error) {
        console.error(`Error: ${error.message}`);
    }
})();

// Export for use in other modules
if (typeof module !== 'undefined' && module.exports) {
    module.exports = FluxAPISDK;
}

<?php
/**
 * FLUX API SDK for PHP
 * Complete integration example
 */

class FluxAPISDK {
    private $apiKey;
    private $baseUrl;

    public function __construct($apiKey, $baseUrl = 'https://image.nalitek.com') {
        $this->apiKey = $apiKey;
        $this->baseUrl = $baseUrl;
    }

    /**
     * Generate an image from text prompt
     */
    public function generate($options = []) {
        $url = $this->baseUrl . '/api/generate';

        $data = array_merge([
            'prompt' => '',
            'negative_prompt' => '',
            'width' => 1024,
            'height' => 1024,
            'steps' => 30,
            'guidance_scale' => 7.5,
            'seed' => -1,
            'model' => 'flux-dev',
            'format' => 'png'
        ], $options);

        $response = $this->makeRequest('POST', $url, $data);

        if ($response['status'] === 201) {
            $result = $response['data'];

            if (!isset($options['wait_for_completion']) || $options['wait_for_completion']) {
                return $this->waitForImage($result['image_id']);
            }

            return $result;
        } else {
            throw new Exception("API Error {$response['status']}: {$response['data']['error']}");
        }
    }

    /**
     * Transform an existing image
     */
    public function img2img($imagePath, $options = []) {
        $url = $this->baseUrl . '/api/img2img';

        $cFile = new CURLFile($imagePath, mime_content_type($imagePath), basename($imagePath));

        $data = array_merge([
            'image' => $cFile,
            'prompt' => '',
            'negative_prompt' => '',
            'strength' => 0.75,
            'steps' => 30,
            'guidance_scale' => 7.5,
            'seed' => -1
        ], $options);

        $ch = curl_init($url);
        curl_setopt($ch, CURLOPT_POST, true);
        curl_setopt($ch, CURLOPT_POSTFIELDS, $data);
        curl_setopt($ch, CURLOPT_HTTPHEADER, ['X-API-Key: ' . $this->apiKey]);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);

        $responseData = json_decode($response, true);

        if ($httpCode === 201) {
            if (!isset($options['wait_for_completion']) || $options['wait_for_completion']) {
                if (isset($responseData['image_id'])) {
                    return $this->waitForImage($responseData['image_id']);
                }
            }
            return $responseData;
        } else {
            throw new Exception("API Error $httpCode: {$responseData['error']}");
        }
    }

    /**
     * Upscale an image
     */
    public function upscale($imageId, $options = []) {
        $url = $this->baseUrl . "/api/upscale/$imageId";

        $data = array_merge([
            'scale' => 2,
            'face_enhance' => false,
            'denoise' => 0.5
        ], $options);

        $response = $this->makeRequest('POST', $url, $data);

        if ($response['status'] === 201) {
            return $response['data'];
        } else {
            throw new Exception("API Error {$response['status']}: {$response['data']['error']}");
        }
    }

    /**
     * Get image details
     */
    public function getImage($imageId) {
        $url = $this->baseUrl . "/api/images/$imageId";

        $response = $this->makeRequest('GET', $url);

        if ($response['status'] === 200) {
            return $response['data'];
        } else {
            throw new Exception("API Error {$response['status']}: {$response['data']['error']}");
        }
    }

    /**
     * List images with filters
     */
    public function listImages($options = []) {
        $url = $this->baseUrl . '/api/images';

        $params = array_merge([
            'page' => 1,
            'per_page' => 20,
            'sort' => 'date_desc'
        ], $options);

        $url .= '?' . http_build_query($params);

        $response = $this->makeRequest('GET', $url);

        if ($response['status'] === 200) {
            return $response['data'];
        } else {
            throw new Exception("API Error {$response['status']}: {$response['data']['error']}");
        }
    }

    /**
     * Delete an image
     */
    public function deleteImage($imageId) {
        $url = $this->baseUrl . "/api/images/$imageId";

        $response = $this->makeRequest('DELETE', $url);

        return $response['status'] === 204;
    }

    /**
     * Get available LoRA models
     */
    public function getLoras() {
        $url = $this->baseUrl . '/api/loras';

        $response = $this->makeRequest('GET', $url);

        if ($response['status'] === 200) {
            return $response['data']['loras'];
        } else {
            throw new Exception("API Error {$response['status']}: {$response['data']['error']}");
        }
    }

    /**
     * Get user statistics
     */
    public function getUserStats() {
        $url = $this->baseUrl . '/api/user/stats';

        $response = $this->makeRequest('GET', $url);

        if ($response['status'] === 200) {
            return $response['data'];
        } else {
            throw new Exception("API Error {$response['status']}: {$response['data']['error']}");
        }
    }

    /**
     * Check API status
     */
    public function checkApiStatus() {
        $url = $this->baseUrl . '/api/status';

        $ch = curl_init($url);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);

        if ($httpCode === 200) {
            return json_decode($response, true);
        } else {
            throw new Exception("API Error $httpCode");
        }
    }

    /**
     * Batch generate images
     */
    public function batchGenerate($prompts, $commonParams = [], $webhookUrl = null) {
        $url = $this->baseUrl . '/api/batch/generate';

        $batch = [];
        foreach (array_slice($prompts, 0, 10) as $prompt) {
            $item = array_merge(['prompt' => $prompt], $commonParams);
            $batch[] = $item;
        }

        $data = ['batch' => $batch];
        if ($webhookUrl) {
            $data['webhook_url'] = $webhookUrl;
        }

        $response = $this->makeRequest('POST', $url, $data);

        if ($response['status'] === 201) {
            return $response['data'];
        } else {
            throw new Exception("API Error {$response['status']}: {$response['data']['error']}");
        }
    }

    /**
     * Wait for image generation to complete
     */
    private function waitForImage($imageId, $timeout = 120) {
        $startTime = time();

        while (time() - $startTime < $timeout) {
            $image = $this->getImage($imageId);

            if ($image['status'] === 'completed') {
                return $image;
            } elseif ($image['status'] === 'failed') {
                throw new Exception("Generation failed: " . $image['error_message']);
            }

            sleep(2);
        }

        throw new Exception("Generation timeout after $timeout seconds");
    }

    /**
     * Make HTTP request
     */
    private function makeRequest($method, $url, $data = null) {
        $ch = curl_init($url);

        if ($method === 'POST') {
            curl_setopt($ch, CURLOPT_POST, true);
            if ($data) {
                curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
            }
        } elseif ($method === 'DELETE') {
            curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');
        } elseif ($method === 'PUT') {
            curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'PUT');
            if ($data) {
                curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
            }
        }

        $headers = ['X-API-Key: ' . $this->apiKey];
        if ($method !== 'GET' && $method !== 'DELETE') {
            $headers[] = 'Content-Type: application/json';
        }

        curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);

        return [
            'status' => $httpCode,
            'data' => json_decode($response, true)
        ];
    }
}

// Example usage
try {
    // Initialize SDK
    $sdk = new FluxAPISDK('your-api-key');

    // Check API status
    $status = $sdk->checkApiStatus();
    echo "API Status: {$status['status']}\n";

    // Generate an image
    $image = $sdk->generate([
        'prompt' => 'beautiful sunset over mountains, professional photography',
        'width' => 1024,
        'height' => 1024,
        'steps' => 30,
        'model' => 'flux-dev'
    ]);
    echo "Generated image: {$image['url']}\n";

    // Upscale the image
    $upscaled = $sdk->upscale($image['id'], ['scale' => 2]);
    echo "Upscaled image: {$upscaled['url']}\n";

    // Get user statistics
    $stats = $sdk->getUserStats();
    echo "Remaining generations: {$stats['quota']['remaining_generations']}\n";

    // List available LoRA models
    $loras = $sdk->getLoras();
    foreach ($loras as $lora) {
        echo "LoRA: {$lora['name']} ({$lora['id']})\n";
    }

} catch (Exception $e) {
    echo "Error: " . $e->getMessage() . "\n";
}