Zylang API

curl -X POST https://zylang-api.onrender.com/api/translate \
  -H "Content-Type: application/json" \
  -H "X-API-Key: zylang_YOUR_KEY" \
  -d '{
    "text": "Press any key to continue",
    "target_lang": "tr",
    "game_genre": "rpg",
    "game_context": "ui",
    "tone": "epic"
  }'

curl -X POST https://zylang-api.onrender.com/api/v2/translate \
  -H "Content-Type: application/json" \
  -H "X-API-Key: zylang_YOUR_KEY" \
  -d '{
    "text": "You have been slain by {killer}!",
    "target_lang": "tr",
    "game_genre": "rpg",
    "game_context": "combat",
    "tone": "dark",
    "key": "COMBAT_DEATH_MSG",
    "file_path": "strings/combat.json",
    "comment": "Death message shown when player dies"
  }'

{
  "original": "You have been slain by {killer}!",
  "translated": "{killer} tarafindan katledildin!",
  "target_lang": "tr",
  "char_count": 33,
  "tone_used": "dark",
  "glossary_count": 0,
  "string_type": "combat_message",
  "classification": "COMBAT",
  "classification_method": "context_engine",
  "strategy": "adaptive",
  "strategy_notes": ["placeholder_detected: {killer}"],
  "validation_passed": true,
  "validation_issues": [],
  "repair_attempts": 0,
  "must_preserve": ["{killer}"],
  "format_rules": ["preserve_placeholders"],
  "quality_score": 0,
  "quality_passed": true,
  "quality_issues": []
}

curl -X POST https://zylang-api.onrender.com/api/v2/translate/review \
  -H "Content-Type: application/json" \
  -H "X-API-Key: zylang_YOUR_KEY" \
  -d '{
    "original": "Game Over",
    "translated": "Oyun Bitti",
    "target_lang": "tr",
    "game_genre": "rpg",
    "tone": "epic"
  }'

{
  "quality_score": 85,
  "quality_passed": true,
  "quality_issues": [],
  "improved_text": null
}

# strings.json contents:
# { "menu_play": "Play", "menu_quit": "Quit", "hud_health": "Health: {value}" }

curl -X POST https://zylang-api.onrender.com/api/translate/batch \
  -H "X-API-Key: zylang_YOUR_KEY" \
  -F "file=@strings.json" \
  -F "target_lang=tr" \
  -F "game_genre=rpg" \
  -F "tone=epic"

{
  "status": "ok",
  "translated": {
    "menu_play": "Oyna",
    "menu_quit": "Cikis",
    "hud_health": "Can: {value}"
  }
}

using UnityEngine;
using UnityEngine.Networking;
using System.Collections;
using System.Text;

public class ZylangTranslator : MonoBehaviour
{
    private const string API_URL = "https://zylang-api.onrender.com/api/v2/translate";
    private const string API_KEY = "zylang_YOUR_KEY";

    public IEnumerator Translate(string text, string targetLang,
                                  System.Action<string> onComplete)
    {
        var body = JsonUtility.ToJson(new TranslateReq {
            text = text,
            target_lang = targetLang,
            game_genre = "rpg"
        });

        var request = new UnityWebRequest(API_URL, "POST");
        request.uploadHandler = new UploadHandlerRaw(
            Encoding.UTF8.GetBytes(body));
        request.downloadHandler = new DownloadHandlerBuffer();
        request.SetRequestHeader("Content-Type", "application/json");
        request.SetRequestHeader("X-API-Key", API_KEY);

        yield return request.SendWebRequest();

        if (request.result == UnityWebRequest.Result.Success)
        {
            var res = JsonUtility.FromJson<TranslateRes>(
                request.downloadHandler.text);
            onComplete?.Invoke(res.translated);
        }
    }

    [System.Serializable]
    class TranslateReq {
        public string text;
        public string target_lang;
        public string game_genre;
    }

    [System.Serializable]
    class TranslateRes {
        public string translated;
    }
}

// ZylangSubsystem.h
#include "Http.h"
#include "Json.h"

void UZylangSubsystem::Translate(
    const FString& Text, const FString& TargetLang,
    TFunction<void(FString)> OnComplete)
{
    auto Request = FHttpModule::Get().CreateRequest();
    Request->SetURL(TEXT("https://zylang-api.onrender.com/api/v2/translate"));
    Request->SetVerb(TEXT("POST"));
    Request->SetHeader(TEXT("Content-Type"), TEXT("application/json"));
    Request->SetHeader(TEXT("X-API-Key"), TEXT("zylang_YOUR_KEY"));

    TSharedPtr<FJsonObject> Body = MakeShareable(new FJsonObject);
    Body->SetStringField("text", Text);
    Body->SetStringField("target_lang", TargetLang);
    Body->SetStringField("game_genre", "rpg");

    FString BodyStr;
    TSharedRef<TJsonWriter<>> Writer =
        TJsonWriterFactory<>::Create(&BodyStr);
    FJsonSerializer::Serialize(Body.ToSharedRef(), Writer);
    Request->SetContentAsString(BodyStr);

    Request->OnProcessRequestComplete().BindLambda(
        [OnComplete](FHttpRequestPtr, FHttpResponsePtr Response, bool) {
            TSharedPtr<FJsonObject> Json;
            TSharedRef<TJsonReader<>> Reader =
                TJsonReaderFactory<>::Create(Response->GetContentAsString());
            FJsonSerializer::Deserialize(Reader, Json);
            OnComplete(Json->GetStringField("translated"));
        });

    Request->ProcessRequest();
}

extends Node

const API_URL = "https://zylang-api.onrender.com/api/v2/translate"
const API_KEY = "zylang_YOUR_KEY"

func translate(text: String, target_lang: String) -> String:
    var http = HTTPRequest.new()
    add_child(http)

    var headers = [
        "Content-Type: application/json",
        "X-API-Key: " + API_KEY
    ]

    var body = JSON.stringify({
        "text": text,
        "target_lang": target_lang,
        "game_genre": "rpg"
    })

    http.request(API_URL, headers, HTTPClient.METHOD_POST, body)
    var result = await http.request_completed

    var json = JSON.parse_string(result[3].get_string_from_utf8())
    http.queue_free()
    return json["translated"]

# Usage:
# var tr_text = await translate("Game Over", "tr")

import requests
import json

API_KEY = "zylang_YOUR_KEY"
API_URL = "https://zylang-api.onrender.com/api/v2/translate"

def translate(text: str, target_lang: str, genre: str = "rpg") -> str:
    response = requests.post(API_URL, json={
        "text": text,
        "target_lang": target_lang,
        "game_genre": genre,
    }, headers={
        "X-API-Key": API_KEY,
    })
    response.raise_for_status()
    return response.json()["translated"]

# For batch translation:
def translate_file(file_path: str, target_lang: str):
    with open(file_path) as f:
        strings = json.load(f)

    translated = {}
    for key, text in strings.items():
        translated[key] = translate(text, target_lang)

    with open(f"{file_path.replace('.json', '')}_{target_lang}.json", "w") as f:
        json.dump(translated, f, ensure_ascii=False, indent=2)

# translate_file("strings/ui.json", "tr")

const API_KEY = "zylang_YOUR_KEY";
const API_URL = "https://zylang-api.onrender.com/api/v2/translate";

async function translate(
  text: string,
  targetLang: string,
  genre = "rpg"
): Promise<string> {
  const res = await fetch(API_URL, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "X-API-Key": API_KEY,
    },
    body: JSON.stringify({
      text,
      target_lang: targetLang,
      game_genre: genre,
    }),
  });

  if (!res.ok) throw new Error(`Zylang API error: ${res.status}`);
  const data = await res.json();
  return data.translated;
}

// Usage:
// const tr = await translate("Game Over", "tr");