Referencia de API

const editor = new QwenImageEdit({
  apiKey: 'tu-clave-api-aqui',
  region: 'us-east-1' // opcional
});

editText(opciones: EditTextOptions): Promise<EditResult>

interface EditTextOptions {
  imagen: string;           // Ruta o URL de la imagen
  prompt: string;           // Descripción de la edición
  idioma?: string;          // Idioma del texto (por defecto: 'auto')
  fuente?: string;          // Familia de fuente
  tamaño?: 'pequeño' | 'mediano' | 'grande' | number;
  color?: string;           // Color en hex, rgb o nombre
  posicion?: Posicion;      // Posición del texto
  preservarEstilo?: boolean; // Mantener estilo original
  opacidad?: number;        // Opacidad (0-1)
}

interface Posicion {
  x?: number;               // Coordenada X
  y?: number;               // Coordenada Y
  alineacion?: 'izquierda' | 'centro' | 'derecha';
  vertical?: 'arriba' | 'centro' | 'abajo';
}

interface EditResult {
  imagenUrl: string;        // URL de la imagen editada
  imagenOriginal: string;   // URL de la imagen original
  metadatos: {
    ancho: number;
    alto: number;
    formato: string;
    tamaño: number;         // Tamaño en bytes
  };
  procesamiento: {
    tiempoMs: number;
    modelo: string;
    version: string;
  };
}

const resultado = await editor.editText({
  imagen: './mi-imagen.jpg',
  prompt: 'Cambiar "Hola" por "Adiós" manteniendo el estilo',
  idioma: 'es',
  preservarEstilo: true
});

console.log('Imagen editada:', resultado.imagenUrl);

editElement(opciones: EditElementOptions): Promise<EditResult>

interface EditElementOptions {
  imagen: string;
  prompt: string;
  accion?: 'agregar' | 'modificar' | 'eliminar';
  estilo?: string;
  posicion?: Posicion;
  tamaño?: 'pequeño' | 'mediano' | 'grande';
  opacidad?: number;
  fusion?: 'natural' | 'suave' | 'fuerte';
}

const resultado = await editor.editElement({
  imagen: './paisaje.jpg',
  prompt: 'Agregar un árbol en el lado izquierdo',
  accion: 'agregar',
  estilo: 'fotorrealista',
  fusion: 'natural'
});

transferStyle(opciones: StyleTransferOptions): Promise<EditResult>

interface StyleTransferOptions {
  imagen: string;
  estilo: string | EstiloPredefinido;
  intensidad?: number;      // 0-1
  preservarDetalles?: boolean;
  paleta?: string[];
  filtros?: string[];
  contraste?: number;
  saturacion?: number;
}

type EstiloPredefinido = 
  | 'acuarela'
  | 'oleo'
  | 'anime'
  | 'cartoon'
  | 'vintage'
  | 'minimalista'
  | 'cyberpunk'
  | 'art-deco';

const resultado = await editor.transferStyle({
  imagen: './retrato.jpg',
  estilo: 'anime',
  intensidad: 0.8,
  preservarDetalles: true
});

analyzeImage(opciones: AnalyzeOptions): Promise<AnalysisResult>

interface AnalyzeOptions {
  imagen: string;
  detectar: DetectionType[];
  idioma?: string;
}

type DetectionType = 
  | 'texto'
  | 'objetos'
  | 'rostros'
  | 'colores'
  | 'estilo'
  | 'calidad';

interface AnalysisResult {
  texto?: TextoDetectado[];
  objetos?: ObjetoDetectado[];
  rostros?: RostroDetectado[];
  colores?: ColorInfo[];
  estilo?: EstiloInfo;
  calidad?: CalidadInfo;
}

interface TextoDetectado {
  contenido: string;
  idioma: string;
  confianza: number;
  posicion: BoundingBox;
  fuente?: string;
  tamaño?: number;
  color?: string;
}

interface ObjetoDetectado {
  nombre: string;
  categoria: string;
  confianza: number;
  posicion: BoundingBox;
}

interface BoundingBox {
  x: number;
  y: number;
  ancho: number;
  alto: number;
}

const analisis = await editor.analyzeImage({
  imagen: './documento.jpg',
  detectar: ['texto', 'objetos'],
  idioma: 'es'
});

console.log('Texto encontrado:', analisis.texto);
console.log('Objetos detectados:', analisis.objetos);

resizeImage(opciones: ResizeOptions): Promise<EditResult>

interface ResizeOptions {
  imagen: string;
  dimensiones: {
    ancho?: number;
    alto?: number;
  };
  recorte?: 'centrado' | 'inteligente' | 'manual';
  calidad?: number;         // 1-100
  formato?: 'jpg' | 'png' | 'webp';
  mantenerAspecto?: boolean;
}

enhanceImage(opciones: EnhanceOptions): Promise<EditResult>

interface EnhanceOptions {
  imagen: string;
  mejoras: MejoraType[];
  intensidad?: number;
}

type MejoraType = 
  | 'nitidez'
  | 'contraste'
  | 'brillo'
  | 'colores'
  | 'ruido'
  | 'desenfoque';

cleanImage(opciones: CleanOptions): Promise<EditResult>

interface CleanOptions {
  imagen: string;
  eliminar: ElementoAEliminar[];
  preservar?: string[];
}

type ElementoAEliminar = 
  | 'ruido'
  | 'artefactos'
  | 'marcas-agua'
  | 'texto'
  | 'objetos-pequeños';

interface QwenImageEditConfig {
  apiKey: string;
  region?: string;
  timeout?: number;         // Timeout en ms
  reintentos?: number;      // Número de reintentos
  cache?: boolean;          // Habilitar caché
  debug?: boolean;          // Modo debug
  endpoint?: string;        // Endpoint personalizado
}

const editor = new QwenImageEdit({
  apiKey: 'tu-clave',
  cache: true,
  cacheConfig: {
    ttl: 3600,              // TTL en segundos
    maxSize: 100,           // Máximo elementos en caché
    storage: 'memory'       // 'memory' | 'disk'
  }
});

interface QwenError {
  codigo: string;
  mensaje: string;
  detalles?: any;
  timestamp: string;
}

// Códigos de error comunes
type CodigoError = 
  | 'AUTH_INVALID'          // Clave API inválida
  | 'QUOTA_EXCEEDED'        // Cuota excedida
  | 'IMAGE_TOO_LARGE'       // Imagen muy grande
  | 'INVALID_FORMAT'        // Formato no soportado
  | 'PROCESSING_FAILED'     // Error en procesamiento
  | 'NETWORK_ERROR'         // Error de red
  | 'TIMEOUT'               // Timeout
  | 'RATE_LIMITED';         // Límite de velocidad

try {
  const resultado = await editor.editText({
    imagen: 'imagen.jpg',
    prompt: 'Editar texto'
  });
} catch (error) {
  switch (error.codigo) {
    case 'AUTH_INVALID':
      console.error('Clave API inválida');
      break;
    case 'QUOTA_EXCEEDED':
      console.error('Cuota excedida, actualiza tu plan');
      break;
    case 'IMAGE_TOO_LARGE':
      console.error('Imagen muy grande, redimensiona primero');
      break;
    default:
      console.error('Error desconocido:', error.mensaje);
  }
}

// Configurar webhook para procesamiento asíncrono
const resultado = await editor.editTextAsync({
  imagen: 'imagen-grande.jpg',
  prompt: 'Edición compleja',
  webhook: {
    url: 'https://tu-servidor.com/webhook',
    eventos: ['completado', 'error'],
    secreto: 'tu-secreto-webhook'
  }
});

console.log('ID de trabajo:', resultado.trabajoId);

const crypto = require('crypto');

function verificarWebhook(payload, firma, secreto) {
  const firmaEsperada = crypto
    .createHmac('sha256', secreto)
    .update(payload)
    .digest('hex');
  
  return crypto.timingSafeEqual(
    Buffer.from(firma),
    Buffer.from(firmaEsperada)
  );
}

npm install qwen-image-edit

pip install qwen-image-edit