import { ToSVGClient } from "tosvg-api";

const client = new ToSVGClient("tosvg_live_your_api_key");
const result = await client.imageToSvg("./photo.png");
// result.svg → <svg xmlns="http://www.w3.org/2000/svg">...</svg>

import { ToSVGClient } from "tosvg-api";

const client = new ToSVGClient("tosvg_live_your_api_key");

// Convert image to SVG
const result = await client.imageToSvg("./photo.png");
console.log(result.svg); // SVG XML string
console.log(result.fileSize); // SVG size in bytes

// Remove background
const bg = await client.removeBackground("./photo.png", {
  returnBase64: true,
});
console.log(bg.image); // base64 encoded image

// Resize image
const resized = await client.resizeImage("./photo.png", {
  width: 800,
  height: 600,
});
console.log(resized.dimensions); // { width: 800, height: 600 }

// Direct
const client = new ToSVGClient("tosvg_live_your_api_key");

// From environment variable (recommended)
const client = new ToSVGClient(process.env.TOSVG_API_KEY!);

const client = new ToSVGClient("tosvg_live_your_api_key", {
  baseUrl: "https://tosvg.com/api/v1", // API base URL
  timeout: 30000, // Request timeout (ms)
  retryOnRateLimit: true, // Auto-retry on 429
  maxRetries: 3, // Max retry attempts
});

const result = await client.imageToSvg("./images/photo.png");

import { readFileSync } from "node:fs";

const buffer = readFileSync("./images/photo.png");
const result = await client.imageToSvg(buffer);

import { createReadStream } from "node:fs";

const stream = createReadStream("./images/photo.png");
const result = await client.imageToSvg(stream);

const result = await client.imageToSvg(image, options?);

// Black & white, spline mode
const result = await client.imageToSvg("./logo.png", {
  colorMode: "bw",
  mode: "spline",
  colorPrecision: 8,
});

// Write SVG to file
import { writeFileSync } from "node:fs";
writeFileSync("./logo.svg", result.svg);

const result = await client.removeBackground(image, options?);

// Get base64 result with high-accuracy model
const result = await client.removeBackground("./portrait.jpg", {
  provider: "rembg",
  model: "isnet-general-use",
  returnBase64: true,
});

// Decode and save
import { writeFileSync } from "node:fs";
writeFileSync("./portrait-nobg.png", Buffer.from(result.image, "base64"));

const result = await client.resizeImage(image, options);

const result = await client.resizeImage("./photo.png", {
  width: 1200,
  height: 630,
  format: "webp",
  quality: 80,
  maintainAspectRatio: true,
});

console.log(result.dimensions); // { width: 1200, height: 630 }
console.log(result.size); // file size in bytes

const health = await client.healthCheck();
console.log(health.status); // 'healthy'
console.log(health.services); // { image_conversion: 'operational', ... }

const formats = await client.getSupportedFormats();
console.log(formats.formats); // { png: { max_size: '10MB', ... }, ... }
console.log(formats.maxDimensions); // '4096x4096 pixels'

const models = await client.getModels();
console.log(models.models); // ['u2net', 'silueta', ...]
console.log(models.availableProviders); // ['rembg', 'withoutbg']

// Filter by provider
const rembgModels = await client.getModels("rembg");

const limits = await client.getResizeLimits();
console.log(limits.maxDimensions); // { width: 4096, height: 4096 }
console.log(limits.qualityRange); // { min: 1, max: 100, default: 90 }

// After any API call, check remaining quota
const info = client.getRateLimitInfo();
if (info) {
  console.log(`Remaining: ${info.remaining}/${info.limit}`);
  console.log(`Resets at: ${info.resetAt.toISOString()}`);
}

// Disable auto retry
const client = new ToSVGClient("tosvg_live_key", {
  retryOnRateLimit: false,
});

import {
  ToSVGClient,
  AuthenticationError,
  ValidationError,
  RateLimitError,
  ToSVGError,
} from "tosvg-api";

const client = new ToSVGClient(process.env.TOSVG_API_KEY!);

try {
  const result = await client.imageToSvg("./photo.png");
  console.log(result.svg);
} catch (error) {
  if (error instanceof RateLimitError) {
    console.log(`Rate limited. Retry after ${error.retryAfter} seconds.`);
  } else if (error instanceof ValidationError) {
    console.log("Validation failed:", error.errors);
    // { image: ['The image field is required.'], ... }
  } else if (error instanceof AuthenticationError) {
    console.log("Invalid API key");
  } else if (error instanceof ToSVGError) {
    console.log(`API error [${error.statusCode}]: ${error.message}`);
  }
}

error.message; // Human-readable error message
error.statusCode; // HTTP status code (undefined for NetworkError)
error.code; // API error code (e.g. 'INVALID_API_KEY')
error.response; // Raw API error response body

import type {
  ClientOptions,
  ImageToSvgOptions,
  ImageToSvgResult,
  RemoveBackgroundOptions,
  RemoveBackgroundResult,
  RemoveBackgroundFileResult,
  RemoveBackgroundBase64Result,
  ResizeImageOptions,
  ResizeImageResult,
  RateLimitInfo,
  HealthCheckResult,
  SupportedFormatsResult,
  BackgroundModelsResult,
  ResizeLimitsResult,
  FileInput,
} from "tosvg-api";

import { ToSVGClient } from "tosvg-api";
import type { ImageToSvgOptions, ImageToSvgResult } from "tosvg-api";

async function convertToSvg(
  filePath: string,
  options?: ImageToSvgOptions,
): Promise<ImageToSvgResult> {
  const client = new ToSVGClient(process.env.TOSVG_API_KEY!);
  return client.imageToSvg(filePath, options);
}

import { readdirSync, writeFileSync } from "node:fs";
import { join, parse } from "node:path";
import { ToSVGClient } from "tosvg-api";

const client = new ToSVGClient(process.env.TOSVG_API_KEY!);
const inputDir = "./images";
const outputDir = "./svgs";

const files = readdirSync(inputDir).filter((f) => /\.(png|jpg|jpeg)$/i.test(f));

for (const file of files) {
  const result = await client.imageToSvg(join(inputDir, file));
  const outputName = `${parse(file).name}.svg`;
  writeFileSync(join(outputDir, outputName), result.svg);
  console.log(`✓ ${file} → ${outputName} (${result.conversionTime}s)`);

  // Check rate limit
  const info = client.getRateLimitInfo();
  if (info && info.remaining < 5) {
    console.log("Rate limit approaching, pausing...");
    await new Promise((r) => setTimeout(r, 60_000));
  }
}

import { ToSVGClient } from "tosvg-api";
import { writeFileSync } from "node:fs";

const client = new ToSVGClient(process.env.TOSVG_API_KEY!);

// Step 1: Remove background
const nobg = await client.removeBackground("./product.jpg", {
  model: "isnet-general-use",
  returnBase64: true,
  format: "png",
});

// Step 2: Save the result
const imageBuffer = Buffer.from(nobg.image, "base64");
writeFileSync("./product-nobg.png", imageBuffer);

// Step 3: Resize for thumbnails
const thumb = await client.resizeImage(imageBuffer, {
  width: 200,
  height: 200,
  format: "webp",
  quality: 85,
});

console.log(`Thumbnail: ${thumb.dimensions.width}x${thumb.dimensions.height}`);

import express from "express";
import multer from "multer";
import { ToSVGClient, ValidationError } from "tosvg-api";

const app = express();
const upload = multer();
const client = new ToSVGClient(process.env.TOSVG_API_KEY!);

app.post("/convert", upload.single("image"), async (req, res) => {
  try {
    if (!req.file) {
      return res.status(400).json({ error: "No image uploaded" });
    }

    const result = await client.imageToSvg(req.file.buffer, {
      colorMode: (req.body.colorMode as "color" | "bw") || "color",
    });

    res.type("image/svg+xml").send(result.svg);
  } catch (error) {
    if (error instanceof ValidationError) {
      res.status(422).json({ errors: error.errors });
    } else {
      res.status(500).json({ error: "Conversion failed" });
    }
  }
});

app.listen(3000);