#!/usr/bin/env node

const fs = require('fs');
const path = require('path');
const yaml = require('js-yaml');

// Parsear arguments
const args = process.argv.slice(2);
const reportArg = args.find(arg => arg.startsWith('--report='));
const specArg = args.find(arg => arg.startsWith('--spec='));

if (!reportArg || !specArg) {
    console.error('❌ Error: Must specify --report=<path> and --spec=<path>');
    process.exit(1);
}

const reportPath = reportArg.split('=')[1];
const specPath = specArg.split('=')[1];

// Verify files exist
if (!fs.existsSync(reportPath)) {
    console.error(`❌ Error: Report file not found: ${reportPath}`);
    process.exit(1);
}

if (!fs.existsSync(specPath)) {
    console.error(`❌ Error: Specification file not found: ${specPath}`);
    process.exit(1);
}

if (!fs.existsSync('./docs.json')) {
    console.error('❌ Error: docs.json file not found');
    process.exit(1);
}

// Load data
const report = JSON.parse(fs.readFileSync(reportPath, 'utf8'));
const spec = yaml.load(fs.readFileSync(specPath, 'utf8'));
const docsJson = JSON.parse(fs.readFileSync('./docs.json', 'utf8'));

// Map tags to friendly service names
const TAG_TO_SERVICE_MAP = {
    'text-to-image': 'text-to-image',
    'image-to-video': 'image-to-video',
    'image-upscaler': 'image-upscaler',
    'image-relight': 'image-relight',
    'image-style-transfer': 'image-style-transfer',
    'mystic': 'mystic',
    'classifier': 'classifier',
    'resources': 'resources',
    'icons': 'icons',
    'remove-background': 'remove-background',
    'icon-generation': 'icon-generation',
    'loras': 'mystic', // LoRAs belong to Mystic
    'reimagine-flux': 'text-to-image/reimagine-flux'
};

async function main() {
    try {
        console.log('📝 Generating documentation for new endpoints...');
        
        if (!report.hasChanges) {
            console.log('ℹ️ No changes to process');
            return;
        }
        
        // Process each service with new endpoints
        for (const [tag, endpoints] of Object.entries(report.endpointsByService)) {
            console.log(`\n🏷️ Processing service: ${tag}`);
            
            const servicePath = getServicePath(tag);
            const serviceDir = path.join('./api-reference', servicePath);
            
            // Create directory if it doesn't exist
            if (!fs.existsSync(serviceDir)) {
                fs.mkdirSync(serviceDir, { recursive: true });
                console.log(`📁 Created directory: ${serviceDir}`);
            }
            
            // Generate MDX file for each endpoint
            for (const endpoint of endpoints) {
                await generateEndpointMDX(endpoint, serviceDir, spec);
            }
            
            // Update docs.json
            updateDocsJson(tag, endpoints, servicePath);
        }
        
        // Save updated docs.json
        fs.writeFileSync('./docs.json', JSON.stringify(docsJson, null, 2));
        console.log('\n✅ docs.json updated');
        
        console.log('\n🎉 Generation completed successfully');
    } catch (error) {
        console.error('❌ Error:', error);
        process.exit(1);
    }
}

function getServicePath(tag) {
    return TAG_TO_SERVICE_MAP[tag] || tag.toLowerCase().replace(/\s+/g, '-');
}

async function generateEndpointMDX(endpoint, serviceDir, spec) {
    const filename = generateFileName(endpoint);
    const filepath = path.join(serviceDir, filename);
    
    // If file already exists, don't overwrite
    if (fs.existsSync(filepath)) {
        console.log(`⚠️ File already exists, skipping: ${filename}`);
        return;
    }
    
    // Get complete endpoint details from spec
    const pathItem = spec.paths[endpoint.path];
    const operation = pathItem[endpoint.method.toLowerCase()];
    
    // Create MDX content
    const content = generateMDXContent(endpoint, operation);
    
    // Write file
    fs.writeFileSync(filepath, content);
    console.log(`✅ Created: ${filename}`);
}

function generateFileName(endpoint) {
    const pathParts = endpoint.path.split('/').filter(Boolean);
    const methodPart = endpoint.method.toLowerCase();
    
    // If path has parameters, add descriptive suffix
    const hasParams = endpoint.path.includes('{');
    const suffix = hasParams ? '-by-id' : '';
    
    return `${methodPart}-${pathParts[pathParts.length - 1]}${suffix}.mdx`;
}

function generateMDXContent(endpoint, operation) {
    const { method, path } = endpoint;
    
    // Simplified MDX template - only frontmatter with OpenAPI reference
    return `---
openapi: ${method.toLowerCase()} ${path}
---`;
}

function updateDocsJson(tag, endpoints, servicePath) {
    // Find the Documentation tab
    const docTab = docsJson.navigation.tabs.find(tab => tab.tab === 'Documentation');
    if (!docTab) return;
    
    // Find APIs group
    const apisGroup = docTab.groups.find(g => g.group === 'APIs');
    if (!apisGroup) return;
    
    // Find or create service group
    let serviceGroup = findServiceGroup(apisGroup, tag, servicePath);
    
    if (!serviceGroup) {
        // Create new group if it doesn't exist
        serviceGroup = {
            group: formatServiceName(tag),
            pages: []
        };
        apisGroup.pages.push(serviceGroup);
    }
    
    // Add new pages
    endpoints.forEach(endpoint => {
        const filename = generateFileName(endpoint);
        const pagePath = `api-reference/${servicePath}/${filename.replace('.mdx', '')}`;
        
        // Check if page already exists
        const exists = serviceGroup.pages.some(p => 
            typeof p === 'string' ? p === pagePath : p.pages?.includes(pagePath)
        );
        
        if (!exists) {
            serviceGroup.pages.push(pagePath);
            console.log(`📄 Added to docs.json: ${pagePath}`);
        }
    });
}

function findServiceGroup(apisGroup, tag, servicePath) {
    // Search in direct pages
    for (const page of apisGroup.pages) {
        if (typeof page === 'object' && page.group) {
            // Check if it's the correct group by name or paths
            if (page.group.toLowerCase().includes(tag.toLowerCase())) {
                return page;
            }
            
            // Search in subgroups
            if (page.pages) {
                for (const subpage of page.pages) {
                    if (typeof subpage === 'object' && subpage.group) {
                        if (subpage.pages?.some(p => p.includes(servicePath))) {
                            return subpage;
                        }
                    }
                }
            }
        }
    }
    
    return null;
}

function formatServiceName(tag) {
    const nameMap = {
        'text-to-image': 'Text to Image API',
        'image-to-video': 'Image to Video API',
        'image-upscaler': 'Image Upscaler API',
        'image-relight': 'Image Relight API',
        'image-style-transfer': 'Style Transfer API',
        'mystic': 'Mystic API',
        'classifier': 'AI Classifier API',
        'resources': 'Resources API',
        'icons': 'Icons API',
        'remove-background': 'Remove Background API',
        'icon-generation': 'Icon Generation API'
    };
    
    return nameMap[tag] || tag.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ') + ' API';
}

// Execute
main().catch(console.error);

#!/usr/bin/env node

const fs = require('fs');
const path = require('path');
const yaml = require('js-yaml');
const SwaggerParser = require('@apidevtools/swagger-parser');

// Configuration
const API_REFERENCE_DIR = path.join(process.cwd(), 'api-reference');
const DOCS_JSON_PATH = path.join(process.cwd(), 'docs.json');

// Parse command line arguments
const args = process.argv.slice(2);
const specArg = args.find(arg => arg.startsWith('--spec='));
const outputArg = args.find(arg => arg.startsWith('--output='));

if (!specArg) {
    console.error('❌ Error: Must specify --spec=<path>');
    process.exit(1);
}

const specPath = specArg.split('=')[1];
const outputPath = outputArg ? outputArg.split('=')[1] : './sync-report.json';

async function main() {
    try {
        console.log('🔍 Analyzing OpenAPI specification...');
        
        // Load and parse OpenAPI spec
        const api = await SwaggerParser.validate(specPath);
        console.log(`✅ API: ${api.info.title} v${api.info.version}`);
        
        // Get existing endpoints
        const existingEndpoints = getExistingEndpoints();
        
        // Analyze new endpoints
        const analysis = analyzeEndpoints(api, existingEndpoints);
        
        // Generate report
        const report = generateReport(analysis);
        
        // Save report
        fs.writeFileSync(outputPath, JSON.stringify(report, null, 2));
        console.log(`📊 Report saved to: ${outputPath}`);
        
        // Exit with appropriate code
        process.exit(report.hasChanges ? 0 : 0);
        
    } catch (error) {
        console.error('❌ Error:', error.message);
        process.exit(1);
    }
}

function getExistingEndpoints() {
    const endpoints = new Set();
    
    // Leer estructura actual de api-reference
    function scanDirectory(dir) {
        if (!fs.existsSync(dir)) return;
        
        const items = fs.readdirSync(dir);
        items.forEach(item => {
            const fullPath = path.join(dir, item);
            const stat = fs.statSync(fullPath);
            
            if (stat.isDirectory()) {
                scanDirectory(fullPath);
            } else if (item.endsWith('.mdx')) {
                // Extract endpoint info from file
                const content = fs.readFileSync(fullPath, 'utf8');
                const openapiMatch = content.match(/openapi:\s*(\w+)\s+(.+)/);
                if (openapiMatch) {
                    const [, method, path] = openapiMatch;
                    endpoints.add(`${method.toUpperCase()} ${path}`);
                }
            }
        });
    }
    
    scanDirectory(API_REFERENCE_DIR);
    return endpoints;
}

function analyzeEndpoints(api, existingEndpoints) {
    const newEndpoints = [];
    const modifiedEndpoints = [];
    const allEndpoints = [];
    
    // Iterate over all paths
    Object.entries(api.paths || {}).forEach(([path, pathItem]) => {
        Object.entries(pathItem).forEach(([method, operation]) => {
            // Skip if not an HTTP method
            if (!['get', 'post', 'put', 'patch', 'delete'].includes(method)) return;
            
            const endpointKey = `${method.toUpperCase()} ${path}`;
            const endpointInfo = {
                method: method.toUpperCase(),
                path,
                operationId: operation.operationId,
                summary: operation.summary,
                description: operation.description,
                tags: operation.tags || [],
                deprecated: operation.deprecated || false,
                security: operation.security || api.security || [],
                parameters: operation.parameters || [],
                requestBody: operation.requestBody,
                responses: operation.responses
            };
            
            allEndpoints.push(endpointInfo);
            
            if (!existingEndpoints.has(endpointKey)) {
                newEndpoints.push(endpointInfo);
            }
        });
    });
    
    return {
        newEndpoints,
        modifiedEndpoints,
        allEndpoints,
        totalEndpoints: allEndpoints.length,
        existingCount: existingEndpoints.size
    };
}

function generateReport(analysis) {
    const { newEndpoints, allEndpoints, totalEndpoints, existingCount } = analysis;
    
    // Agrupar endpoints por tag/servicio
    const endpointsByTag = {};
    newEndpoints.forEach(endpoint => {
        const tag = endpoint.tags[0] || 'general';
        if (!endpointsByTag[tag]) {
            endpointsByTag[tag] = [];
        }
        endpointsByTag[tag].push(endpoint);
    });
    
    // Generar resumen
    const summary = newEndpoints.length > 0 
        ? `Found ${newEndpoints.length} new endpoints across ${Object.keys(endpointsByTag).length} services`
        : 'No new endpoints found';
    
    return {
        timestamp: new Date().toISOString(),
        hasChanges: newEndpoints.length > 0,
        summary,
        statistics: {
            totalEndpoints,
            existingEndpoints: existingCount,
            newEndpoints: newEndpoints.length,
            endpointsByTag: Object.entries(endpointsByTag).map(([tag, endpoints]) => ({
                tag,
                count: endpoints.length
            }))
        },
        newEndpoints: newEndpoints.map(endpoint => ({
            method: endpoint.method,
            path: endpoint.path,
            operationId: endpoint.operationId,
            summary: endpoint.summary,
            tags: endpoint.tags,
            deprecated: endpoint.deprecated
        })),
        endpointsByService: endpointsByTag
    };
}

// Ejecutar script
main(); 

#!/usr/bin/env node

const fs = require('fs');
const path = require('path');

// Parse arguments
const args = process.argv.slice(2);
const reportArg = args.find(arg => arg.startsWith('--report='));

if (!reportArg) {
    console.error('❌ Error: Must specify --report=<path>');
    process.exit(1);
}

const reportPath = reportArg.split('=')[1];

// Verify file exists
if (!fs.existsSync(reportPath)) {
    console.error(`❌ Error: Report file not found: ${reportPath}`);
    process.exit(1);
}

// Load report
const report = JSON.parse(fs.readFileSync(reportPath, 'utf8'));

// Formatear fecha actual
function formatDate() {
    const date = new Date();
    const months = ['January', 'February', 'March', 'April', 'May', 'June', 
                   'July', 'August', 'September', 'October', 'November', 'December'];
    return `${months[date.getMonth()]} ${date.getDate()}, ${date.getFullYear()}`;
}

// Generar el contenido del changelog
function generateChangelogEntry(report) {
    if (!report.hasChanges) {
        return null;
    }
    
    const date = formatDate();
    let content = `## ${date}\n\n`;
    
    // Main title
    content += `### New API Endpoints Added\n\n`;
    content += `We've added ${report.statistics.newEndpoints} new endpoints to enhance our API capabilities across multiple services.\n\n`;
    
    // Group by service
    Object.entries(report.endpointsByService).forEach(([tag, endpoints]) => {
        const serviceName = formatServiceName(tag);
        content += `#### ${serviceName}\n\n`;
        
        // List endpoints
        endpoints.forEach(endpoint => {
            const description = endpoint.summary || endpoint.description || 'New endpoint';
            content += `- **${endpoint.method} ${endpoint.path}**: ${description}\n`;
            if (endpoint.operationId) {
                content += `  - Operation ID: \`${endpoint.operationId}\`\n`;
            }
        });
        content += '\n';
    });
    
    // Add links to documentation
    content += `#### API Reference\n\n`;
    content += `For detailed information on how to use these new endpoints, please refer to our updated API documentation:\n\n`;
    
    content += `<div className="my-11">\n`;
    content += `  <Columns cols={2}>\n`;
    
    // Crear cards para cada servicio
    const uniqueServices = [...new Set(Object.keys(report.endpointsByService))];
    uniqueServices.forEach(tag => {
        const serviceName = formatServiceName(tag);
        const servicePath = getServicePath(tag);
        content += `    <Card title="${serviceName} API Reference" icon="code" href="/api-reference/${servicePath}">\n`;
        content += `      Updated API Reference for ${serviceName}\n`;
        content += `    </Card>\n`;
    });
    
    content += `  </Columns>\n`;
    content += `</div>\n\n`;
    
    return content;
}

// Formatear nombre del servicio
function formatServiceName(tag) {
    const nameMap = {
        'text-to-image': 'Text to Image',
        'image-to-video': 'Image to Video',
        'image-upscaler': 'Image Upscaler',
        'image-relight': 'Image Relight',
        'image-style-transfer': 'Style Transfer',
        'mystic': 'Mystic',
        'classifier': 'AI Classifier',
        'resources': 'Stock Resources',
        'icons': 'Icons',
        'remove-background': 'Remove Background',
        'icon-generation': 'Icon Generation',
        'loras': 'LoRAs (Mystic)',
        'reimagine-flux': 'Reimagine Flux'
    };
    
    return nameMap[tag] || tag.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ');
}

// Obtener ruta del servicio
function getServicePath(tag) {
    const pathMap = {
        'text-to-image': 'text-to-image',
        'image-to-video': 'image-to-video',
        'image-upscaler': 'image-upscaler',
        'image-relight': 'image-relight',
        'image-style-transfer': 'image-style-transfer',
        'mystic': 'mystic',
        'classifier': 'classifier',
        'resources': 'resources',
        'icons': 'icons',
        'remove-background': 'remove-background',
        'icon-generation': 'icon-generation',
        'loras': 'mystic',
        'reimagine-flux': 'text-to-image/reimagine-flux'
    };
    
    return pathMap[tag] || tag.toLowerCase().replace(/\s+/g, '-');
}

// Update changelog file
async function updateChangelog() {
    // Get current year
    const currentYear = new Date().getFullYear();
    const changelogPath = `./changelog/${currentYear}.mdx`;
    const changelogDir = './changelog';
    
    const newEntry = generateChangelogEntry(report);
    
    if (!newEntry) {
        console.log('ℹ️ No changes to add to changelog');
        return;
    }
    
    // Verify changelog directory exists
    if (!fs.existsSync(changelogDir)) {
        console.error(`❌ Error: Changelog directory not found: ${changelogDir}`);
        process.exit(1);
    }
    
    // If current year file doesn't exist, create it with basic frontmatter
    if (!fs.existsSync(changelogPath)) {
        console.log(`📝 Creating new changelog file for ${currentYear}...`);
        const frontmatter = `---
title: ${currentYear} Changelog
description: API updates and improvements for ${currentYear}
---

`;
        fs.writeFileSync(changelogPath, frontmatter);
    }
    
    // Read current changelog
    let currentContent = fs.readFileSync(changelogPath, 'utf8');
    
    // Find insertion point (after frontmatter)
    const frontmatterEnd = currentContent.indexOf('---', currentContent.indexOf('---') + 1) + 3;
    
    // Insert new entry after frontmatter
    const beforeContent = currentContent.substring(0, frontmatterEnd);
    const afterContent = currentContent.substring(frontmatterEnd);
    
    const updatedContent = beforeContent + '\n\n' + newEntry + afterContent;
    
    // Write updated file
    fs.writeFileSync(changelogPath, updatedContent);
    console.log(`✅ Changelog ${currentYear} updated with new endpoints`);
}

// Execute
updateChangelog().catch(console.error); 

Generate a video from text or image using the MiniMax Hailuo-02 768p model.

Create a video from text/image - MiniMax Hailuo-02 768p

Image to Video

Text to Video

apiKey

Bad Request - The server could not understand the request due to invalid syntax.

Unauthorized - The client must authenticate itself to get the requested response.

Internal Server Error - The server has encountered a situation it doesn't know how to handle.

Create your dream projects with thousands of stunning resources. Try Freepik API for free and enjoy our monthly fresh content

Freepik API

Welcome

Welcome to Freepik API

Ready to harness the power of Freepik API?

Quickstart

Learn how to authenticate your requests to the Freepik API

Authentication

Webhooks are a powerful way to connect different systems and services. Learn about webhooks and how to integrate them securely.

Webhooks

Rate limiting

Introduction

Pricing

Rate Limiting

Image Generation - Mystic

Image Generation - Classic Fast

Upscaler - Magnific  

Stock Content

This section documents changes to the Freepik API, including all patch updates, bug fixes, new version releases, version deprecations, versions unsets, etc.

2024

Changelog

Create a video from an image using the Kling v2 model

Get the list of the kling-v2 tasks

Get the status of the kling-v2 task

Generate a video from an image using the Kling 1.6 Pro model.

Create a video from an image - Kling 1.6 pro model

Get the list of the kling-pro tasks

Get the status of the kling task

Generate a video from an image using the Kling 1.6 Std model.

Create a video from an image - Kling 1.6 standard model

Convert descriptive text input into images using AI. This endpoint accepts a variety of parameters to customize the generated images.

Create image from text - Mystic

Get the status of the Mystic task

Get the status of all Mystic tasks

Create you own custom style using LoRAs training

For now you can check the status of the training calling `v1/ai/loras`. We are working on it


LoRAs training for custom styles

Create you own custom character using LoRAs training

For now you can check the status of the training calling `v1/ai/loras`. We are working on it


LoRAs training for custom characters

Create image from text - Classic fast

Create image from text - Imagen3

Get the status of the Imagen3 task

Get the status of all Imagen3 tasks

Create image from text - Flux dev

Get the status of the flux-dev task

(Beta, synchronous) Reimagine Flux is a new AI model that allows you to generate images from text prompts.

(Beta) Reimagine Flux

This asynchronous endpoint enables image upscaling using advanced AI algorithms. Upon submission, it returns a unique `task_id` which can be used to track the progress of the upscaling process. For real-time production use, include the optional `webhook_url` parameter to receive an automated notification once the task has been completed. This allows for seamless integration and efficient task management without the need for continuous polling.


Upscale an image with Magnific

Get the status of the upscaling task

Get the status of all upscaling tasks

Relight an image using AI. This endpoint accepts a variety of parameters to customize the generated images.

Relight an image

Get the status of the relight task

Get the status of all relight tasks

Style transfer an image using AI

Get the status of all Style Transfer tasks

Get the status of the Style Transfer task

This endpoint removes the background from an image provided via a URL. The URLs in the response are temporary and valid for **5 minutes** only.

Remove the background of an image

Accepts an image file as input and analyzes it to determine the probability that the image was generated by artificial intelligence, providing a confidence score.

Analyzes an image to determine its likelihood of being AI-generated

Retrieve a list of resources based on various filter criteria such as orientation, content type, license, and more.

Get all resources

Retrieve the detailed information of a specific resource by its ID. This endpoint supports multiple resource types including PSD, vector, photo, and AI-generated content.

Get the detail of a resource (psd, vector or photo)

Get a list of icons based on the provided parameters and ordering criteria.

Retrieve all icons by specified order

Get detailed information about a specific icon identified by its unique ID.

Retrieve one icon by its unique ID

Download the specified icon by its unique ID in the requested format and size.

Download an icon

Download a specific resource by providing the resource ID. This endpoint supports downloading various types of resources including vectors, PSDs, photos, and AI-generated content.

Download a resource

Retrieve a resource by specifying both the resource ID and the format. This endpoint allows for precise downloading of resources in the desired format.

Get Started

APIs

Create a video from text/image - MiniMax Hailuo-02 768p

Authorizations

Body

Response