@nocobase/plugin-localization 2.1.0-beta.9 → 2.2.0-alpha.1

package/dist/server/tasks/localization-ai-translate.js

@@ -0,0 +1,606 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var localization_ai_translate_exports = {};
+__export(localization_ai_translate_exports, {
+  LOCALIZATION_AI_TRANSLATE_TASK_TYPE: () => LOCALIZATION_AI_TRANSLATE_TASK_TYPE,
+  LocalizationAITranslateTask: () => LocalizationAITranslateTask,
+  pickBuiltInResourceReference: () => pickBuiltInResourceReference
+});
+module.exports = __toCommonJS(localization_ai_translate_exports);
+var import_plugin_async_task_manager = require("@nocobase/plugin-async-task-manager");
+var import_messages = require("@langchain/core/messages");
+var import_translation_scope = require("../translation-scope");
+const LOCALIZATION_AI_TRANSLATE_TASK_TYPE = "localization:ai-translate";
+const DEFAULT_TRANSLATION_WORKER_COUNT = 10;
+const MIN_TRANSLATION_WORKER_COUNT = 1;
+const MAX_TRANSLATION_WORKER_COUNT = 20;
+const TRANSLATION_CHUNK_SIZE = 200;
+const elapsed = (start) => Date.now() - start;
+const truncateForLog = (value, maxLength = 500) => value.length > maxLength ? `${value.slice(0, maxLength)}...` : value;
+const LEGACY_SYMBOL_TRANSLATIONS = /* @__PURE__ */ new Set(["<", "=", ">"]);
+const isString = (value) => typeof value === "string" && value.length > 0;
+const getTranslationWorkerCount = () => {
+  const value = Number.parseInt(process.env.AI_LOCALIZATION_CONCURRENCY || "", 10);
+  if (Number.isInteger(value) && value >= MIN_TRANSLATION_WORKER_COUNT && value <= MAX_TRANSLATION_WORKER_COUNT) {
+    return value;
+  }
+  return DEFAULT_TRANSLATION_WORKER_COUNT;
+};
+const pickBuiltInResourceReference = (row, references, locales) => {
+  var _a;
+  for (const locale of [locales.primary, locales.fallback].filter(isString)) {
+    const translation = (_a = references.get(locale)) == null ? void 0 : _a.get(String(row.id));
+    if (translation) {
+      return { locale, translation };
+    }
+  }
+  return {};
+};
+class LocalizationAITranslationError extends Error {
+  constructor(message, details) {
+    super(message);
+    this.details = details;
+    this.name = "LocalizationAITranslationError";
+  }
+}
+class LocalizationAITranslateTask extends import_plugin_async_task_manager.TaskType {
+  static type = LOCALIZATION_AI_TRANSLATE_TASK_TYPE;
+  async execute() {
+    var _a, _b;
+    const params = this.record.params;
+    const locale = params.locale || "en-US";
+    const employeeUsername = params.employeeUsername || "lina";
+    const aiPlugin = this.app.pm.get("ai");
+    if (!(aiPlugin == null ? void 0 : aiPlugin.aiConversationsManager) || !(aiPlugin == null ? void 0 : aiPlugin.aiEmployeesManager)) {
+      throw new Error("AI plugin is not available");
+    }
+    const employee = await aiPlugin.aiEmployeesManager.getEmployee(employeeUsername);
+    if (!employee) {
+      throw new Error(`AI employee "${employeeUsername}" not found`);
+    }
+    const resolvedModel = await aiPlugin.aiEmployeesManager.resolveModel(employee, params.model);
+    const { provider, model, service } = await aiPlugin.aiManager.getLLMService(resolvedModel);
+    const defaultReferenceLocale = await this.getSystemDefaultLocale();
+    const builtInMatchResources = await this.app.localeManager.getBuiltInResources("en-US");
+    const referenceLocales = this.resolveReferenceLocales(params.referenceLocales, defaultReferenceLocale);
+    const findTextsOptions = await (0, import_translation_scope.buildFindTextsOptions)({
+      app: this.app,
+      mode: params.mode,
+      locale,
+      scope: params.scope || "all",
+      textIds: params.textIds,
+      fields: ["id", "text", "module"],
+      sort: ["id"]
+    });
+    const workerCount = getTranslationWorkerCount();
+    const chunkSize = TRANSLATION_CHUNK_SIZE;
+    const countStart = Date.now();
+    const total = await this.countTexts(findTextsOptions);
+    (_a = this.logger) == null ? void 0 : _a.debug("Localization AI translation task started", {
+      taskId: this.record.id,
+      mode: params.mode,
+      locale,
+      total,
+      countElapsedMs: elapsed(countStart),
+      workerCount,
+      chunkSize,
+      defaultReferenceLocale,
+      referenceLocales,
+      scope: params.scope || "all",
+      provider: service == null ? void 0 : service.provider,
+      llmService: service == null ? void 0 : service.name,
+      model
+    });
+    let translated = 0;
+    let chunkIndex = 0;
+    this.reportProgress({ total, current: 0 });
+    const repository = this.app.db.getRepository("localizationTexts");
+    const chunk = params.mode === "selected" ? repository.chunk.bind(repository) : repository.chunkWithCursor.bind(repository);
+    await chunk({
+      ...findTextsOptions,
+      chunkSize,
+      callback: async (rows) => {
+        var _a2, _b2, _c;
+        chunkIndex += 1;
+        const chunkStart = Date.now();
+        const textRows = rows.map((row) => (0, import_translation_scope.normalizeTextRecord)(row)).filter(Boolean);
+        const rowsWithScope = textRows.map((row) => ({
+          row,
+          isBuiltIn: (0, import_translation_scope.isBuiltInText)(row, builtInMatchResources)
+        }));
+        (_a2 = this.logger) == null ? void 0 : _a2.debug("Localization AI translation chunk loaded", {
+          taskId: this.record.id,
+          chunkIndex,
+          rows: textRows.length,
+          workerCount,
+          translated,
+          total
+        });
+        for (let start = 0; start < rowsWithScope.length; start += workerCount) {
+          if (this.isCanceled) {
+            throw new import_plugin_async_task_manager.CancelError();
+          }
+          const batchStart = Date.now();
+          const batch = rowsWithScope.slice(start, start + workerCount);
+          const items = await this.buildTranslationItems(batch, referenceLocales, chunkIndex);
+          await Promise.all(
+            items.map(
+              (item, index) => this.translateItem({
+                workerIndex: index + 1,
+                item,
+                total,
+                getTranslated: () => translated,
+                incrementTranslated: () => {
+                  translated += 1;
+                  return translated;
+                },
+                locale,
+                employeeUsername,
+                employee,
+                provider,
+                service,
+                model
+              })
+            )
+          );
+          (_b2 = this.logger) == null ? void 0 : _b2.debug("Localization AI translation batch completed", {
+            taskId: this.record.id,
+            chunkIndex,
+            batchSize: items.length,
+            referenceTranslations: items.filter((item) => item.referenceTranslation).length,
+            elapsedMs: elapsed(batchStart),
+            translated,
+            total
+          });
+        }
+        (_c = this.logger) == null ? void 0 : _c.debug("Localization AI translation chunk completed", {
+          taskId: this.record.id,
+          chunkIndex,
+          rows: textRows.length,
+          elapsedMs: elapsed(chunkStart),
+          translated,
+          total
+        });
+      }
+    });
+    (_b = this.logger) == null ? void 0 : _b.debug("Localization AI translation task completed", {
+      taskId: this.record.id,
+      translated,
+      total
+    });
+    return {
+      translated,
+      total
+    };
+  }
+  async countTexts(options) {
+    return await this.app.db.getRepository("localizationTexts").count(options);
+  }
+  async getLocaleReferences(textIds, locale) {
+    const references = /* @__PURE__ */ new Map();
+    if (!textIds.length) {
+      return references;
+    }
+    const rows = await this.app.db.getRepository("localizationTranslations").find({
+      fields: ["textId", "translation"],
+      filter: {
+        textId: {
+          $in: textIds
+        },
+        locale
+      }
+    });
+    for (const row of rows) {
+      const record = typeof row.toJSON === "function" ? row.toJSON() : row;
+      if ((record == null ? void 0 : record.textId) != null && record.translation) {
+        references.set(String(record.textId), record.translation);
+      }
+    }
+    return references;
+  }
+  async getReferenceMaps(textIds, locales) {
+    const result = /* @__PURE__ */ new Map();
+    await Promise.all(
+      Array.from(new Set(locales)).map(async (locale) => {
+        result.set(locale, await this.getLocaleReferences(textIds, locale));
+      })
+    );
+    return result;
+  }
+  async getBuiltInReferenceMaps(rows, locales) {
+    const result = /* @__PURE__ */ new Map();
+    if (!rows.length) {
+      return result;
+    }
+    await Promise.all(
+      Array.from(new Set(locales)).map(async (locale) => {
+        var _a;
+        const resources = await this.app.localeManager.getCacheResources(locale);
+        const references = /* @__PURE__ */ new Map();
+        for (const row of rows) {
+          const moduleName = (0, import_translation_scope.getModuleName)(row);
+          if (!moduleName) {
+            continue;
+          }
+          const modules = Array.from(/* @__PURE__ */ new Set([(0, import_translation_scope.normalizeModuleName)(moduleName), moduleName]));
+          for (const module2 of modules) {
+            const translation = (_a = resources == null ? void 0 : resources[module2]) == null ? void 0 : _a[row.text];
+            if (translation) {
+              references.set(String(row.id), translation);
+              break;
+            }
+          }
+        }
+        result.set(locale, references);
+      })
+    );
+    return result;
+  }
+  pickDbReference(row, references, locales) {
+    var _a;
+    for (const locale of [locales.primary, locales.fallback].filter(isString)) {
+      const translation = (_a = references.get(locale)) == null ? void 0 : _a.get(String(row.id));
+      if (translation) {
+        return { locale, translation };
+      }
+    }
+    return {};
+  }
+  async getSystemDefaultLocale() {
+    var _a;
+    const systemSetting = await ((_a = this.app.db.getRepository("systemSettings")) == null ? void 0 : _a.findOne());
+    const enabledLanguages = (systemSetting == null ? void 0 : systemSetting.get("enabledLanguages")) || [];
+    return (enabledLanguages == null ? void 0 : enabledLanguages[0]) || process.env.APP_LANG || "en-US";
+  }
+  resolveReferenceLocales(referenceLocales, defaultReferenceLocale) {
+    var _a, _b, _c, _d;
+    return {
+      builtIn: {
+        primary: ((_a = referenceLocales == null ? void 0 : referenceLocales.builtIn) == null ? void 0 : _a.primary) || "zh-CN",
+        fallback: ((_b = referenceLocales == null ? void 0 : referenceLocales.builtIn) == null ? void 0 : _b.fallback) || "ja-JP"
+      },
+      custom: {
+        primary: ((_c = referenceLocales == null ? void 0 : referenceLocales.custom) == null ? void 0 : _c.primary) || defaultReferenceLocale,
+        fallback: ((_d = referenceLocales == null ? void 0 : referenceLocales.custom) == null ? void 0 : _d.fallback) || "zh-CN"
+      }
+    };
+  }
+  async buildTranslationItems(batch, referenceLocales, chunkIndex) {
+    const builtInRows = batch.filter((item) => item.isBuiltIn).map((item) => item.row);
+    const customTextIds = batch.filter((item) => !item.isBuiltIn).map((item) => item.row.id);
+    const builtInReferences = await this.getBuiltInReferenceMaps(
+      builtInRows,
+      [referenceLocales.builtIn.primary, referenceLocales.builtIn.fallback].filter(isString)
+    );
+    const customReferences = await this.getReferenceMaps(
+      customTextIds,
+      [referenceLocales.custom.primary, referenceLocales.custom.fallback].filter(isString)
+    );
+    return batch.map(({ row, isBuiltIn }) => {
+      const references = isBuiltIn ? referenceLocales.builtIn : referenceLocales.custom;
+      const reference = isBuiltIn ? pickBuiltInResourceReference(row, builtInReferences, references) : this.pickDbReference(row, customReferences, references);
+      return {
+        row,
+        chunkIndex,
+        referenceTranslation: reference.translation,
+        referenceLocale: reference.locale,
+        isBuiltIn
+      };
+    });
+  }
+  async translateItem(options) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const {
+      workerIndex,
+      item,
+      total,
+      getTranslated,
+      incrementTranslated,
+      locale,
+      employeeUsername,
+      employee,
+      provider,
+      service,
+      model
+    } = options;
+    if (this.isCanceled) {
+      throw new import_plugin_async_task_manager.CancelError();
+    }
+    const { row, chunkIndex, referenceTranslation, referenceLocale, isBuiltIn } = item;
+    try {
+      const textStart = Date.now();
+      (_c = (_a = this.logger) == null ? void 0 : _a.trace) == null ? void 0 : _c.call(_a, "Localization AI translation text started", {
+        taskId: this.record.id,
+        workerIndex,
+        chunkIndex,
+        textId: row.id,
+        textLength: ((_b = row.text) == null ? void 0 : _b.length) ?? 0,
+        hasReferenceTranslation: Boolean(referenceTranslation),
+        referenceLocale,
+        isBuiltIn,
+        translated: getTranslated(),
+        total
+      });
+      const isLegacySymbolTranslation = LEGACY_SYMBOL_TRANSLATIONS.has(row.text);
+      if (isLegacySymbolTranslation) {
+        (_e = (_d = this.logger) == null ? void 0 : _d.trace) == null ? void 0 : _e.call(_d, "Localization AI translation legacy symbol skipped", {
+          taskId: this.record.id,
+          workerIndex,
+          chunkIndex,
+          textId: row.id,
+          text: row.text
+        });
+      }
+      const translation = isLegacySymbolTranslation ? row.text : await this.translateText({
+        text: row.text,
+        module: row.module,
+        referenceTranslation,
+        referenceLocale,
+        isBuiltIn,
+        locale,
+        employeeUsername,
+        employee,
+        provider,
+        service,
+        model
+      });
+      const aiElapsedMs = elapsed(textStart);
+      const writeStart = Date.now();
+      await this.app.db.getRepository("localizationTranslations").updateOrCreate({
+        filterKeys: ["textId", "locale"],
+        values: {
+          textId: row.id,
+          locale,
+          translation
+        }
+      });
+      const writeElapsedMs = elapsed(writeStart);
+      const translated = incrementTranslated();
+      this.reportProgress({ total, current: translated });
+      (_g = this.logger) == null ? void 0 : _g.debug("Localization AI translation text completed", {
+        taskId: this.record.id,
+        workerIndex,
+        chunkIndex,
+        textId: row.id,
+        textLength: ((_f = row.text) == null ? void 0 : _f.length) ?? 0,
+        translationLength: translation.length,
+        aiElapsedMs,
+        writeElapsedMs,
+        totalElapsedMs: elapsed(textStart),
+        translated,
+        total
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const details = {
+        id: row.id,
+        text: row.text,
+        error: message
+      };
+      (_h = this.logger) == null ? void 0 : _h.error(`Failed to translate localization text ${row.id}: ${message}`, { error });
+      if (error instanceof import_plugin_async_task_manager.CancelError) {
+        throw error;
+      }
+      throw new LocalizationAITranslationError(`Failed to translate localization text ${row.id}: ${message}`, details);
+    }
+  }
+  async translateText(options) {
+    var _a, _b, _c, _d, _e, _f;
+    const {
+      text,
+      module: module2,
+      referenceTranslation,
+      referenceLocale,
+      isBuiltIn,
+      locale,
+      employeeUsername,
+      provider,
+      service,
+      model,
+      employee
+    } = options;
+    const setupStart = Date.now();
+    const sourceText = text;
+    const targetLang = this.getLanguageName(locale);
+    const context = this.buildProviderContext({
+      systemPrompt: this.getEmployeeSystemPrompt(employee),
+      sourceText,
+      targetLang,
+      referenceTranslation
+    });
+    const invokeStart = Date.now();
+    (_b = (_a = this.logger) == null ? void 0 : _a.trace) == null ? void 0 : _b.call(_a, "Localization AI translation invoke started", {
+      taskId: this.record.id,
+      textLength: (text == null ? void 0 : text.length) ?? 0,
+      sourceTextLength: (sourceText == null ? void 0 : sourceText.length) ?? 0,
+      locale,
+      targetLang,
+      module: module2,
+      employeeUsername,
+      provider: service == null ? void 0 : service.provider,
+      llmService: service == null ? void 0 : service.name,
+      model,
+      hasReferenceTranslation: Boolean(referenceTranslation),
+      referenceLocale,
+      isBuiltIn
+    });
+    const result = await provider.invoke(context);
+    const invokeElapsedMs = elapsed(invokeStart);
+    (_d = (_c = this.logger) == null ? void 0 : _c.trace) == null ? void 0 : _d.call(_c, "Localization AI translation invoke completed", {
+      taskId: this.record.id,
+      textLength: (text == null ? void 0 : text.length) ?? 0,
+      sourceTextLength: (sourceText == null ? void 0 : sourceText.length) ?? 0,
+      locale,
+      targetLang,
+      module: module2,
+      employeeUsername,
+      provider: service == null ? void 0 : service.provider,
+      llmService: service == null ? void 0 : service.name,
+      model,
+      hasReferenceTranslation: Boolean(referenceTranslation),
+      referenceLocale,
+      isBuiltIn,
+      setupElapsedMs: elapsed(setupStart) - invokeElapsedMs,
+      invokeElapsedMs,
+      totalElapsedMs: elapsed(setupStart)
+    });
+    const translation = this.extractTextContent(result == null ? void 0 : result.content).trim();
+    if (!translation) {
+      throw new Error("LLM service returned empty translation");
+    }
+    (_f = (_e = this.logger) == null ? void 0 : _e.trace) == null ? void 0 : _f.call(_e, "Localization AI translation result extracted", {
+      taskId: this.record.id,
+      textLength: (text == null ? void 0 : text.length) ?? 0,
+      sourceTextLength: (sourceText == null ? void 0 : sourceText.length) ?? 0,
+      translationLength: translation.length,
+      locale,
+      targetLang,
+      module: module2,
+      employeeUsername,
+      provider: service == null ? void 0 : service.provider,
+      llmService: service == null ? void 0 : service.name,
+      model,
+      hasReferenceTranslation: Boolean(referenceTranslation),
+      referenceLocale,
+      isBuiltIn,
+      sourceText: truncateForLog(sourceText),
+      referenceTranslation: referenceTranslation ? truncateForLog(referenceTranslation) : void 0,
+      translation: truncateForLog(translation)
+    });
+    return translation;
+  }
+  getEmployeeSystemPrompt(employee) {
+    var _a, _b;
+    return ((_a = employee == null ? void 0 : employee.get) == null ? void 0 : _a.call(employee, "about")) || ((_b = employee == null ? void 0 : employee.get) == null ? void 0 : _b.call(employee, "defaultPrompt")) || (employee == null ? void 0 : employee.about) || (employee == null ? void 0 : employee.defaultPrompt) || "";
+  }
+  buildProviderContext(options) {
+    const { systemPrompt, sourceText, targetLang, referenceTranslation } = options;
+    const prompt = (systemPrompt || "").trim();
+    const reference = referenceTranslation ? `Refer to the following translation:
+${sourceText} is translated as ${referenceTranslation}
+
+` : "";
+    const task = `Translate the following text into ${targetLang}. Output only the translated result without any additional explanation:
+${sourceText}
+`;
+    const content = [prompt, `${reference}${task}`].filter(Boolean).join("\n\n");
+    return {
+      messages: [new import_messages.HumanMessage(content)]
+    };
+  }
+  getLanguageName(locale) {
+    const normalized = locale.replace("_", "-");
+    const map = {
+      "en-US": "English",
+      "zh-CN": "Chinese",
+      "zh-TW": "Traditional Chinese",
+      "ja-JP": "Japanese",
+      "ko-KR": "Korean",
+      "fr-FR": "French",
+      "de-DE": "German",
+      "es-ES": "Spanish",
+      "it-IT": "Italian",
+      "pt-PT": "Portuguese",
+      "pt-BR": "Portuguese",
+      "ru-RU": "Russian",
+      "th-TH": "Thai",
+      "vi-VN": "Vietnamese",
+      "id-ID": "Indonesian",
+      "ms-MY": "Malay",
+      "ar-SA": "Arabic",
+      "hi-IN": "Hindi",
+      "tr-TR": "Turkish",
+      "nl-NL": "Dutch",
+      "pl-PL": "Polish",
+      "sv-SE": "Swedish",
+      "da-DK": "Danish",
+      "fi-FI": "Finnish",
+      "uk-UA": "Ukrainian"
+    };
+    if (map[normalized]) {
+      return map[normalized];
+    }
+    const language = normalized.split("-")[0];
+    const languageMap = {
+      en: "English",
+      zh: "Chinese",
+      ja: "Japanese",
+      ko: "Korean",
+      fr: "French",
+      de: "German",
+      es: "Spanish",
+      it: "Italian",
+      pt: "Portuguese",
+      ru: "Russian",
+      th: "Thai",
+      vi: "Vietnamese",
+      id: "Indonesian",
+      ms: "Malay",
+      ar: "Arabic",
+      hi: "Hindi",
+      tr: "Turkish",
+      nl: "Dutch",
+      pl: "Polish",
+      sv: "Swedish",
+      da: "Danish",
+      fi: "Finnish",
+      uk: "Ukrainian"
+    };
+    return languageMap[language] || language;
+  }
+  extractTextContent(content) {
+    if (typeof content === "string") {
+      return content;
+    }
+    if (Array.isArray(content)) {
+      return content.map((item) => {
+        if (typeof item === "string") {
+          return item;
+        }
+        if (item && typeof item === "object") {
+          if ("type" in item && item.type === "text") {
+            return typeof item.text === "string" ? item.text : "";
+          }
+          if ("content" in item) {
+            return this.extractTextContent(item.content);
+          }
+        }
+        return "";
+      }).join("").trim();
+    }
+    if (content && typeof content === "object" && "content" in content) {
+      return this.extractTextContent(content.content);
+    }
+    return "";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LOCALIZATION_AI_TRANSLATE_TASK_TYPE,
+  LocalizationAITranslateTask,
+  pickBuiltInResourceReference
+});

package/dist/server/translation-scope.d.ts

@@ -0,0 +1,31 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+export type TranslationScope = 'all' | 'builtIn' | 'custom';
+export type LocalizationTextRecord = {
+    id: string | number;
+    text: string;
+    module?: string;
+    translation?: string;
+    translationId?: string | number;
+};
+type BuildFindTextsOptions = {
+    app: any;
+    mode: string;
+    locale: string;
+    scope: TranslationScope;
+    textIds?: Array<string | number>;
+    fields?: string[];
+    sort?: string[];
+};
+export declare const normalizeTextRecord: (row: any) => LocalizationTextRecord | undefined;
+export declare const getModuleName: (row: LocalizationTextRecord) => string;
+export declare const normalizeModuleName: (module: string) => string;
+export declare const isBuiltInText: (row: LocalizationTextRecord, resources: Record<string, Record<string, string>>) => boolean;
+export declare const buildFindTextsOptions: (options: BuildFindTextsOptions) => Promise<any>;
+export {};