DeepL 🌍

let deepl = ProtectMyAPI.deepLService()
 
let result = try await deepl.translateText(
    text: "Hello, how are you?",
    targetLang: "DE" // German
)
 
print("Translation: \(result.translations.first?.text ?? "")")
print("Detected language: \(result.translations.first?.detectedSourceLanguage ?? "")")

val deepl = ProtectMyAPIAI.deepLService()
 
val result = deepl.translateText(
    text = "Hello, how are you?",
    targetLang = "DE"
)
 
println("Translation: ${result.translations.firstOrNull()?.text}")
println("Detected language: ${result.translations.firstOrNull()?.detectedSourceLanguage}")

final deepl = ProtectMyAPIAI.deepLService();
 
final result = await deepl.translateText(
  text: "Hello, how are you?",
  targetLang: "DE",
);
 
print("Translation: ${result.translations.first?.text}");
print("Detected language: ${result.translations.first?.detectedSourceLanguage}");

let result = try await deepl.translateText(
    text: "Bonjour le monde",
    sourceLang: "FR", // French
    targetLang: "EN-US" // American English
)

val result = deepl.translateText(
    text = "Bonjour le monde",
    sourceLang = "FR",
    targetLang = "EN-US"
)

final result = await deepl.translateText(
  text: "Bonjour le monde",
  sourceLang: "FR",
  targetLang: "EN-US",
);

let result = try await deepl.translateText(
    texts: [
        "Good morning",
        "How are you?",
        "See you later"
    ],
    targetLang: "ES" // Spanish
)
 
for translation in result.translations {
    print(translation.text)
}
// Buenos días
// ¿Cómo estás?
// Hasta luego

val result = deepl.translateText(
    texts = listOf(
        "Good morning",
        "How are you?",
        "See you later"
    ),
    targetLang = "ES"
)
 
result.translations.forEach { println(it.text) }

final result = await deepl.translateText(
  texts: [
    "Good morning",
    "How are you?",
    "See you later",
  ],
  targetLang: "ES",
);
 
for (final translation in result.translations) {
  print(translation.text);
}

// Formal translation (e.g., "Sie" in German)
let formal = try await deepl.translateText(
    text: "How are you?",
    targetLang: "DE",
    options: DeepLTranslateOptions(
        formality: .more // more, less, default, preferMore, preferLess
    )
)
// "Wie geht es Ihnen?"
 
// Informal translation (e.g., "du" in German)
let informal = try await deepl.translateText(
    text: "How are you?",
    targetLang: "DE",
    options: DeepLTranslateOptions(
        formality: .less
    )
)
// "Wie geht es dir?"

val formal = deepl.translateText(
    text = "How are you?",
    targetLang = "DE",
    options = DeepLTranslateOptions(
        formality = Formality.MORE
    )
)
 
val informal = deepl.translateText(
    text = "How are you?",
    targetLang = "DE",
    options = DeepLTranslateOptions(
        formality = Formality.LESS
    )
)

final formal = await deepl.translateText(
  text: "How are you?",
  targetLang: "DE",
  options: DeepLTranslateOptions(
    formality: Formality.more,
  ),
);
 
final informal = await deepl.translateText(
  text: "How are you?",
  targetLang: "DE",
  options: DeepLTranslateOptions(
    formality: Formality.less,
  ),
);

let result = try await deepl.translateText(
    text: "Welcome to <b>our store</b>!",
    targetLang: "FR",
    options: DeepLTranslateOptions(
        preserveFormatting: true,
        tagHandling: .xml // Handle XML/HTML tags
    )
)
// "Bienvenue dans <b>notre magasin</b> !"

val result = deepl.translateText(
    text = "Welcome to <b>our store</b>!",
    targetLang = "FR",
    options = DeepLTranslateOptions(
        preserveFormatting = true,
        tagHandling = TagHandling.XML
    )
)

final result = await deepl.translateText(
  text: "Welcome to <b>our store</b>!",
  targetLang: "FR",
  options: DeepLTranslateOptions(
    preserveFormatting: true,
    tagHandling: TagHandling.xml,
  ),
);

let result = try await deepl.translateText(
    text: "The API returns a response object",
    targetLang: "DE",
    options: DeepLTranslateOptions(
        glossaryId: "your-glossary-id" // Pre-created glossary
    )
)

val result = deepl.translateText(
    text = "The API returns a response object",
    targetLang = "DE",
    options = DeepLTranslateOptions(
        glossaryId = "your-glossary-id"
    )
)

final result = await deepl.translateText(
  text: "The API returns a response object",
  targetLang: "DE",
  options: DeepLTranslateOptions(
    glossaryId: "your-glossary-id",
  ),
);

let result = try await deepl.translateText(
    text: "Dr. Smith went to Washington. He arrived at noon.",
    targetLang: "DE",
    options: DeepLTranslateOptions(
        splitSentences: .nonewlines // off, on, nonewlines
    )
)

val result = deepl.translateText(
    text = "Dr. Smith went to Washington. He arrived at noon.",
    targetLang = "DE",
    options = DeepLTranslateOptions(
        splitSentences = SplitSentences.NONEWLINES
    )
)

final result = await deepl.translateText(
  text: "Dr. Smith went to Washington. He arrived at noon.",
  targetLang: "DE",
  options: DeepLTranslateOptions(
    splitSentences: SplitSentences.nonewlines,
  ),
);

// Upload document for translation
let document = try await deepl.translateDocument(
    fileURL: documentURL,
    targetLang: "FR",
    options: DeepLDocumentOptions(
        formality: .more
    )
)
 
print("Document ID: \(document.documentId)")
print("Key: \(document.documentKey)")
 
// Check translation status
let status = try await deepl.getDocumentStatus(
    documentId: document.documentId,
    documentKey: document.documentKey
)
 
print("Status: \(status.status)") // queued, translating, done, error
print("Progress: \(status.secondsRemaining ?? 0) seconds remaining")
 
// Download translated document
if status.status == "done" {
    let translatedData = try await deepl.downloadDocument(
        documentId: document.documentId,
        documentKey: document.documentKey
    )
    // Save translatedData to file
}

val document = deepl.translateDocument(
    file = documentFile,
    targetLang = "FR",
    options = DeepLDocumentOptions(
        formality = Formality.MORE
    )
)
 
println("Document ID: ${document.documentId}")
 
val status = deepl.getDocumentStatus(
    documentId = document.documentId,
    documentKey = document.documentKey
)
 
println("Status: ${status.status}")
 
if (status.status == "done") {
    val translatedData = deepl.downloadDocument(
        documentId = document.documentId,
        documentKey = document.documentKey
    )
}

final document = await deepl.translateDocument(
  file: documentFile,
  targetLang: "FR",
  options: DeepLDocumentOptions(
    formality: Formality.more,
  ),
);
 
print("Document ID: ${document.documentId}");
 
final status = await deepl.getDocumentStatus(
  documentId: document.documentId,
  documentKey: document.documentKey,
);
 
print("Status: ${status.status}");
 
if (status.status == "done") {
  final translatedData = await deepl.downloadDocument(
    documentId: document.documentId,
    documentKey: document.documentKey,
  );
}

// Get source languages
let sourceLanguages = try await deepl.getSourceLanguages()
for lang in sourceLanguages {
    print("\(lang.language): \(lang.name)")
}
 
// Get target languages
let targetLanguages = try await deepl.getTargetLanguages()
for lang in targetLanguages {
    print("\(lang.language): \(lang.name)")
    print("  Supports formality: \(lang.supportsFormality)")
}

val sourceLanguages = deepl.getSourceLanguages()
sourceLanguages.forEach { lang ->
    println("${lang.language}: ${lang.name}")
}
 
val targetLanguages = deepl.getTargetLanguages()
targetLanguages.forEach { lang ->
    println("${lang.language}: ${lang.name}")
    println("  Supports formality: ${lang.supportsFormality}")
}

final sourceLanguages = await deepl.getSourceLanguages();
for (final lang in sourceLanguages) {
  print("${lang.language}: ${lang.name}");
}
 
final targetLanguages = await deepl.getTargetLanguages();
for (final lang in targetLanguages) {
  print("${lang.language}: ${lang.name}");
  print("  Supports formality: ${lang.supportsFormality}");
}

let usage = try await deepl.getUsage()
 
print("Characters used: \(usage.characterCount)")
print("Character limit: \(usage.characterLimit)")
print("Documents used: \(usage.documentCount ?? 0)")
print("Document limit: \(usage.documentLimit ?? 0)")

val usage = deepl.getUsage()
 
println("Characters used: ${usage.characterCount}")
println("Character limit: ${usage.characterLimit}")
println("Documents used: ${usage.documentCount}")
println("Document limit: ${usage.documentLimit}")

final usage = await deepl.getUsage();
 
print("Characters used: ${usage.characterCount}");
print("Character limit: ${usage.characterLimit}");
print("Documents used: ${usage.documentCount}");
print("Document limit: ${usage.documentLimit}");