{
  "person_image_id": "VT_PERSON_123",
  "outfit_image_id": "VT_OUTFIT_456",
  "prompt": "professional portrait, high quality",
  "resolution": "high",
  "num_images": 2,
  "style": "studio"
}

const virtualTryOn = async (personImageId, outfitImageId) => {
  const response = await fetch('https://api.bitstudio.ai/images/virtual-try-on', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      person_image_id: personImageId,
      outfit_image_id: outfitImageId,
      resolution: "standard",
      num_images: 1
    })
  });
  
  const results = await response.json();
  return results[0]; // Returns the first generated image info
};

// After uploading person and outfit images and getting their IDs
const tryOnResult = await virtualTryOn('IMG_123', 'IMG_456');
console.log('Generation started:', tryOnResult.id);

// Poll for completion
const pollForCompletion = async (imageId) => {
  let complete = false;
  while (!complete) {
    const response = await fetch(`https://api.bitstudio.ai/images/${imageId}`, {
      headers: { 'Authorization': 'Bearer YOUR_API_KEY' }
    });
    
    const imageData = await response.json();
    
    if (imageData.status === 'completed') {
      complete = true;
      return imageData;
    } else if (imageData.status === 'failed') {
      throw new Error('Image generation failed');
    }
    
    // Wait 2 seconds before polling again
    await new Promise(resolve => setTimeout(resolve, 2000));
  }
};

// Get the completed image
const finalImage = await pollForCompletion(tryOnResult.id);
console.log('Image is ready:', finalImage.path);

[
  {
    "id": "GEN_789",
    "status": "pending",
    "task": "virtual-try-on",
    "estimated_completion": "2024-02-20T15:00:00Z",
    "credits_used": 2,
    "source_image_ids": [
      "VT_PERSON_123",
      "VT_OUTFIT_456"
    ]
  }
]

const uploadImage = async (file, type) => {
  const formData = new FormData();
  formData.append('file', file);
  formData.append('type', type);
  
  const response = await fetch('https://api.bitstudio.ai/images', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY'
    },
    body: formData
  });
  
  const result = await response.json();
  return result;
};

// Upload person image
const personImg = document.querySelector('#personImageInput').files[0];
const personImageData = await uploadImage(personImg, 'virtual-try-on-person');

// Upload outfit image
const outfitImg = document.querySelector('#outfitImageInput').files[0];
const outfitImageData = await uploadImage(outfitImg, 'virtual-try-on-outfit');

// Now use the returned image IDs for virtual try-on
console.log('Person Image ID:', personImageData.id);
console.log('Outfit Image ID:', outfitImageData.id);

{
  "id": "IMG_123",
  "type": "virtual-try-on-person",
  "path": "https://media.bitstudio.ai/user-content/u123/image.jpg",
  "status": "completed",
  "width_px": 1024,
  "height_px": 1024,
  "is_generated": false,
  "for_training": false,
  "created_timestamp": "2024-02-20T14:30:00Z",
  "versions": []
}

{
  "prompt": "editorial studio campaign, clean white sweep",
  "generate_mode": "presets",
  "num_images": 2,
  "aspect_ratio": "3:4",
  "resolution": "standard",
  "model_version": "nano-banana-2",
  "asset_ids": [
    "MODEL_ASSET_123",
    "PRESET_ASSET_456"
  ],
  "model_text": "use the avatar identity, relaxed standing pose",
  "outfit_text": "keep the jacket open and the product fully visible",
  "outfit_asset_ids": [
    "JACKET_ASSET_789",
    "TROUSERS_ASSET_012"
  ]
}

POST /assets
{
  "type": "model",
  "alias": "Face Avatar",
  "class": "female",
  "characteristics": "freckles, dark hair",
  "display_image": "https://example.com/avatar.jpg"
}

POST /assets/preset-analysis
{
  "image_ids": [
    "PRESET_REF_IMAGE_1",
    "PRESET_REF_IMAGE_2"
  ]
}

POST /assets
{
  "type": "outfit",
  "alias": "Black leather jacket",
  "sku": "JACKET-BLK-001",
  "display_image": "https://example.com/jacket-front.jpg",
  "tag_ids": [
    "FOLDER_OR_TAG_ID"
  ]
}

{
  "prompt": "minimal ecommerce studio campaign",
  "generate_mode": "presets",
  "num_images": 1,
  "model_version": "nano-banana-2",
  "asset_ids": [
    "MODEL_ASSET_123"
  ],
  "outfit_asset_id": "OUTFIT_ASSET_456",
  "outfit_text": "make the jacket the hero product"
}

const pollImage = async (imageId) => {
  while (true) {
    const response = await fetch('https://api.bitstudio.ai/images/' + imageId, {
      headers: { Authorization: 'Bearer YOUR_API_KEY' }
    });

    const image = await response.json();
    if (image.status === 'completed') return image;
    if (image.status === 'failed') throw new Error('Image generation failed');

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

const generateImage = async () => {
  const response = await fetch('https://api.bitstudio.ai/images/generate', {
    method: 'POST',
    headers: {
      Authorization: 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      prompt: 'editorial studio campaign, clean white sweep',
      generate_mode: 'presets',
      num_images: 1,
      aspect_ratio: '3:4',
      resolution: 'standard',
      model_version: 'nano-banana-2',
      asset_ids: ['MODEL_ASSET_123', 'PRESET_ASSET_456'],
      outfit_asset_ids: ['JACKET_ASSET_789'],
      outfit_text: 'make the jacket the hero product'
    })
  });

  const pendingImages = await response.json();
  return pollImage(pendingImages[0].id);
};

const finalImage = await generateImage();
console.log('Image is ready:', finalImage.path);

[
  {
    "id": "GEN_456",
    "status": "pending",
    "task": "generate",
    "aspect_ratio": "3:4",
    "resolution": "standard",
    "asset_ids": [
      "MODEL_ASSET_123",
      "PRESET_ASSET_456",
      "JACKET_ASSET_789"
    ],
    "source_image_ids": [
      "OUTFIT_IMAGE_789"
    ],
    "model_text": "use the avatar identity, relaxed standing pose",
    "outfit_text": "keep the jacket open and the product fully visible",
    "set_text": "editorial studio campaign, clean white sweep"
  }
]

{
  "upscale_factor": 2,
  "denoise": 0.3
}

const upscaleImage = async (imageId) => {
  const response = await fetch(`https://api.bitstudio.ai/images/${imageId}/upscale`, {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      upscale_factor: 2,
      denoise: 0.3
    })
  });
  
  const result = await response.json();
  return result;
};

// Call the function to upscale an image
const upscaleResult = await upscaleImage('IMG_123');
console.log('Upscaling started:', upscaleResult.id);

// Poll for completion
const pollForCompletion = async (imageId) => {
  let complete = false;
  while (!complete) {
    const response = await fetch(`https://api.bitstudio.ai/images/${imageId}`, {
      headers: { 'Authorization': 'Bearer YOUR_API_KEY' }
    });
    
    const imageData = await response.json();
    
    if (imageData.status === 'completed') {
      complete = true;
      return imageData;
    } else if (imageData.status === 'failed') {
      throw new Error('Image upscaling failed');
    }
    
    // Wait 2 seconds before polling again
    await new Promise(resolve => setTimeout(resolve, 2000));
  }
};

// Get the upscaled image details
const finalImage = await pollForCompletion(upscaleResult[0].id);
console.log('Upscaled image is ready:', finalImage);

[
  {
    "id": "UPSCALE_123",
    "status": "pending",
    "task": "upscale",
    "source_image_ids": [
      "ORIGINAL_123"
    ],
    "base_image_version_id": "VERSION_456"
  }
]

{
  "mask_image_id": "MASK_123",
  "reference_image_id": "REF_456",
  "prompt": "Sunny beach with palm trees",
  "denoise": 1,
  "num_images": 1
}

const inpaintImage = async (imageId, maskImageId, prompt) => {
  const response = await fetch(`https://api.bitstudio.ai/images/${imageId}/inpaint`, {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      mask_image_id: maskImageId,
      prompt: prompt,
      denoise: 1.0,
      num_images: 1
    })
  });
  
  const result = await response.json();
  return result;
};

// Call the function to inpaint an image
const inpaintResult = await inpaintImage('BASE_123', 'MASK_456', 'Replace with a beautiful beach');
console.log('Inpainting started:', inpaintResult[0].id);

// Poll for completion as in previous examples
const finalImage = await pollForCompletion(inpaintResult[0].id);
console.log('Inpainted image is ready:', finalImage.path);

[
  {
    "id": "INPAINT_123",
    "status": "pending",
    "task": "inpaint",
    "source_image_ids": [
      "BASE_123",
      "MASK_456"
    ],
    "estimated_completion": "2024-02-20T15:30:00Z",
    "credits_used": 1
  }
]

{
  "prompt": "Change the background to a beach scene",
  "resolution": "standard",
  "num_images": 1,
  "seed": 42
}

const editImage = async (imageId, prompt) => {
  const response = await fetch(`https://api.bitstudio.ai/images/${imageId}/edit`, {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      prompt: prompt,
      resolution: 'standard',
      num_images: 1,
      seed: 42
    })
  });
  
  const result = await response.json();
  return result;
};

// Call the function to edit an image
const editResult = await editImage('IMG_123', 'Add a sunset in the background');
console.log('Edit started, updated image:', editResult);

// The response is the parent image snapshot, so editResult.path still points to the original image.
// Find the pending edit version and poll its source_image_id until the job image completes.
const editVersion = editResult.versions.find(v => v.version_type === 'edited');
const finalImage = await pollImage(editVersion.source_image_id);
console.log('Completed edit image URL:', finalImage.path);

{
  "id": "IMG_123",
  "status": "pending",
  "task": "edit",
  "path": "https://media.bitstudio.ai/gen/original.jpg",
  "versions": [
    {
      "id": "VERSION_789",
      "version_type": "edited",
      "source_image_id": "EDIT_456",
      "status": "pending"
    }
  ],
  "credits_used": 1,
  "created_timestamp": "2024-02-20T14:30:00Z"
}

{
  "prompt": "gentle camera zoom, cinematic lighting"
}

const imageToVideo = async (imageId, prompt) => {
  const response = await fetch(`https://api.bitstudio.ai/images/${imageId}/video`, {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      prompt: prompt,
    })
  });
  
  const result = await response.json();
  return result;
};

// Call the function to create video from an image
const videoResult = await imageToVideo('IMG_123', 'gentle camera zoom in, soft wind in hair');
console.log('Video generation started:', videoResult.id);

// Poll for completion as in previous examples
const finalVideo = await pollForCompletion(videoResult.id);
console.log('Video is ready:', finalVideo.path);

{
  "id": "VIDEO_123",
  "status": "pending",
  "task": "image-to-video",
  "source_image_id": "IMG_123",
  "estimated_completion": "2024-02-20T15:45:00Z",
  "credits_used": 15
}