@intlpullhq/cli 0.1.0

package/dist/chunk-S3EWA4QD.js

@@ -0,0 +1,995 @@
+import {
+  getAuthErrorMessage,
+  getGlobalConfig,
+  getProjectConfig,
+  getResolvedApiKey
+} from "./chunk-2T7ERBDS.js";
+
+// src/lib/api/base.ts
+var DEFAULT_API_URL = process.env.INTLPULL_API_URL || "https://api.intlpull.com";
+var DEFAULT_TIMEOUT_MS = 3e4;
+var BaseApiClient = class {
+  baseUrl;
+  apiKey;
+  timeout;
+  constructor() {
+    const globalConfig = getGlobalConfig();
+    this.baseUrl = globalConfig.apiUrl || DEFAULT_API_URL;
+    const resolved = getResolvedApiKey();
+    this.apiKey = resolved?.key || null;
+    this.timeout = DEFAULT_TIMEOUT_MS;
+  }
+  async request(endpoint, options = {}) {
+    if (!this.apiKey) {
+      throw new Error(getAuthErrorMessage());
+    }
+    const url = `${this.baseUrl}${endpoint}`;
+    const headers = {
+      "Content-Type": "application/json",
+      "X-API-Key": this.apiKey,
+      ...options.headers || {}
+    };
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    let response;
+    try {
+      response = await fetch(url, {
+        ...options,
+        headers,
+        signal: controller.signal
+      });
+    } catch (err) {
+      clearTimeout(timeoutId);
+      if (err instanceof Error && err.name === "AbortError") {
+        throw new Error(`Request timeout: Server did not respond within ${this.timeout / 1e3}s`);
+      }
+      if (err instanceof TypeError) {
+        throw new Error(`Network error: Unable to connect to ${this.baseUrl}. Check your internet connection.`);
+      }
+      throw new Error(`Request failed: ${err instanceof Error ? err.message : "Unknown network error"}`);
+    } finally {
+      clearTimeout(timeoutId);
+    }
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: `Request failed: ${response.status}` }));
+      throw new Error(error.error || `Request failed: ${response.status}`);
+    }
+    const text = await response.text();
+    if (!text) {
+      return {};
+    }
+    try {
+      return JSON.parse(text);
+    } catch {
+      throw new Error(`Invalid JSON response from API`);
+    }
+  }
+  async requestBlob(endpoint) {
+    if (!this.apiKey) {
+      throw new Error(getAuthErrorMessage());
+    }
+    const url = `${this.baseUrl}${endpoint}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    let response;
+    try {
+      response = await fetch(url, {
+        headers: {
+          "X-API-Key": this.apiKey
+        },
+        signal: controller.signal
+      });
+    } catch (err) {
+      clearTimeout(timeoutId);
+      if (err instanceof Error && err.name === "AbortError") {
+        throw new Error(`Request timeout: Server did not respond within ${this.timeout / 1e3}s`);
+      }
+      if (err instanceof TypeError) {
+        throw new Error(`Network error: Unable to connect to ${this.baseUrl}. Check your internet connection.`);
+      }
+      throw new Error(`Request failed: ${err instanceof Error ? err.message : "Unknown network error"}`);
+    } finally {
+      clearTimeout(timeoutId);
+    }
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Request failed" }));
+      throw new Error(error.error || "Request failed");
+    }
+    return response.blob();
+  }
+  async requestBlobWithJsonFallback(endpoint) {
+    if (!this.apiKey) {
+      throw new Error(getAuthErrorMessage());
+    }
+    const url = `${this.baseUrl}${endpoint}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    let response;
+    try {
+      response = await fetch(url, {
+        headers: {
+          "X-API-Key": this.apiKey
+        },
+        signal: controller.signal
+      });
+    } catch (err) {
+      clearTimeout(timeoutId);
+      if (err instanceof Error && err.name === "AbortError") {
+        throw new Error(`Request timeout: Server did not respond within ${this.timeout / 1e3}s`);
+      }
+      if (err instanceof TypeError) {
+        throw new Error(`Network error: Unable to connect to ${this.baseUrl}. Check your internet connection.`);
+      }
+      throw new Error(`Request failed: ${err instanceof Error ? err.message : "Unknown network error"}`);
+    } finally {
+      clearTimeout(timeoutId);
+    }
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Request failed" }));
+      throw new Error(error.error || "Request failed");
+    }
+    const contentType = response.headers.get("content-type") || "";
+    if (contentType.includes("application/json")) {
+      const jsonData = await response.json();
+      const jsonString = JSON.stringify(jsonData, null, 2);
+      return new Blob([jsonString], { type: "application/json" });
+    }
+    return response.blob();
+  }
+};
+
+// src/lib/api/projects.ts
+var ProjectsApi = class extends BaseApiClient {
+  async listProjects() {
+    return this.request("/api/v1/projects");
+  }
+  async getProject(projectId) {
+    return this.request(`/api/v1/projects/${projectId}`);
+  }
+  async createProject(data) {
+    return this.request("/api/v1/projects", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  /**
+   * Find a project by name (searches through all projects)
+   */
+  async findProjectByName(name) {
+    const { projects } = await this.listProjects();
+    const normalizedName = name.toLowerCase().trim();
+    return projects.find(
+      (p) => p.name.toLowerCase() === normalizedName || p.slug.toLowerCase() === normalizedName
+    ) || null;
+  }
+  /**
+   * Get project languages/settings
+   */
+  async getProjectLanguages(projectId) {
+    return this.request(`/api/v1/projects/${projectId}/language-settings`);
+  }
+  /**
+   * Add multiple languages to a project with optional skip_translation flag
+   */
+  async addLanguagesBulk(projectId, languages, skipTranslation = false) {
+    return this.request(`/api/v1/projects/${projectId}/language-settings/bulk`, {
+      method: "POST",
+      body: JSON.stringify({
+        languages,
+        skip_translation: skipTranslation
+      })
+    });
+  }
+  // Versions
+  async listVersions(projectId) {
+    return this.request(`/api/v1/projects/${projectId}/versions`);
+  }
+  async createVersion(projectId, data) {
+    return this.request(`/api/v1/projects/${projectId}/versions`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async downloadVersion(projectId, version) {
+    return this.requestBlob(`/api/v1/projects/${projectId}/versions/${version}/download`);
+  }
+};
+
+// src/lib/api/translations.ts
+var TranslationsApi = class extends BaseApiClient {
+  // Keys - uses import endpoint to create/update keys
+  async pushKeys(projectId, keys, language = "en", namespace, options) {
+    const content = {};
+    for (const k of keys) {
+      content[k.key] = k.value;
+    }
+    const fileName = namespace ? `${namespace}.json` : "push.json";
+    const result = await this.request(`/api/v1/projects/${projectId}/import`, {
+      method: "POST",
+      body: JSON.stringify({
+        content: JSON.stringify(content),
+        file_name: fileName,
+        language,
+        options: {
+          namespace_name: namespace || "common",
+          update_existing: true,
+          branch_id: options?.branchId,
+          platforms: options?.platforms
+        }
+      })
+    });
+    return {
+      keys_inserted: result.keys_inserted,
+      keys_updated: result.keys_updated,
+      keys_skipped: result.keys_skipped,
+      translations_inserted: result.translations_inserted,
+      translations_updated: result.translations_updated
+    };
+  }
+  async getKeys(projectId, namespace) {
+    const params = namespace ? `?namespace=${namespace}` : "";
+    return this.request(`/api/v1/projects/${projectId}/keys${params}`);
+  }
+  // Translations - uses export/download endpoint
+  async pullTranslations(projectId, options) {
+    const params = new URLSearchParams();
+    params.set("format", "json");
+    if (options.languages?.length) {
+      options.languages.forEach((lang) => params.append("languages", lang));
+    }
+    if (options.branch) {
+      params.set("branch", options.branch);
+    }
+    if (options.platform) {
+      params.set("platform", options.platform);
+    }
+    return this.request(`/api/v1/projects/${projectId}/export/download?${params.toString()}`);
+  }
+  // Glossary
+  async searchGlossary(query, options) {
+    const params = new URLSearchParams();
+    params.set("q", query);
+    if (options?.limit) params.set("limit", String(options.limit));
+    if (options?.language) params.set("language", options.language);
+    return this.request(`/api/v1/glossary/search?${params.toString()}`);
+  }
+  async addGlossaryTerm(data) {
+    const config = getProjectConfig();
+    if (!config?.projectId) {
+      throw new Error("No project configured. Run `npx @intlpullhq/cli init` first.");
+    }
+    return this.request(`/api/v1/projects/${config.projectId}/glossary`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async exportGlossary(glossaryId) {
+    const config = getProjectConfig();
+    if (!config?.projectId) {
+      throw new Error("No project configured. Run `npx @intlpullhq/cli init` first.");
+    }
+    const params = glossaryId ? `?glossary_id=${glossaryId}` : "";
+    return this.request(`/api/v1/projects/${config.projectId}/glossary/export${params}`);
+  }
+  // Translation Memory
+  async searchTM(data) {
+    const config = getProjectConfig();
+    if (!config?.projectId) {
+      throw new Error("No project configured. Run `npx @intlpullhq/cli init` first.");
+    }
+    return this.request(`/api/v1/projects/${config.projectId}/memory/search`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async addTMEntry(data) {
+    const config = getProjectConfig();
+    if (!config?.projectId) {
+      throw new Error("No project configured. Run `npx @intlpullhq/cli init` first.");
+    }
+    return this.request(`/api/v1/projects/${config.projectId}/memory`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async getTMStats() {
+    const config = getProjectConfig();
+    if (!config?.projectId) {
+      throw new Error("No project configured. Run `npx @intlpullhq/cli init` first.");
+    }
+    return this.request(`/api/v1/projects/${config.projectId}/memory/stats`);
+  }
+};
+
+// src/lib/api/import-export.ts
+var ImportExportApi = class extends BaseApiClient {
+  // Export
+  async exportTranslations(projectId, options) {
+    const params = new URLSearchParams();
+    params.set("format", options.format);
+    if (options.languages?.length) {
+      params.set("languages", options.languages.join(","));
+    }
+    if (options.namespaces?.length) {
+      params.set("namespaces", options.namespaces.join(","));
+    }
+    if (options.branch) {
+      params.set("branch", options.branch);
+    }
+    if (options.platform) {
+      params.set("platform", options.platform);
+    }
+    return this.requestBlobWithJsonFallback(
+      `/api/v1/projects/${projectId}/export/download?${params.toString()}`
+    );
+  }
+  /**
+   * Import translations from file content
+   */
+  async importTranslations(projectId, content, fileName, language, options) {
+    return this.request(`/api/v1/projects/${projectId}/import`, {
+      method: "POST",
+      body: JSON.stringify({
+        content,
+        file_name: fileName,
+        language,
+        options: options || {}
+      })
+    });
+  }
+};
+
+// src/lib/api/workflows.ts
+var WorkflowsApi = class extends BaseApiClient {
+  /**
+   * Get workflow settings for a project
+   */
+  async getWorkflowSettings(projectId) {
+    return this.request(`/api/v1/projects/${projectId}/workflows/settings`);
+  }
+  /**
+   * List all workflows for a project
+   */
+  async listWorkflows(projectId) {
+    return this.request(`/api/v1/projects/${projectId}/workflows`);
+  }
+  /**
+   * Get pending approvals for a project
+   */
+  async getPendingApprovals(projectId) {
+    return this.request(`/api/v1/projects/${projectId}/workflows/pending`);
+  }
+  /**
+   * Get approval history for a translation
+   */
+  async getApprovalHistory(projectId, translationId) {
+    return this.request(`/api/v1/projects/${projectId}/translations/${translationId}/approvals`);
+  }
+  /**
+   * Approve a translation at the current stage
+   */
+  async approveTranslation(projectId, translationId, comment) {
+    return this.request(`/api/v1/projects/${projectId}/translations/${translationId}/approve`, {
+      method: "POST",
+      body: JSON.stringify({ comment })
+    });
+  }
+  /**
+   * Reject a translation with feedback
+   */
+  async rejectTranslation(projectId, translationId, reason) {
+    return this.request(`/api/v1/projects/${projectId}/translations/${translationId}/reject`, {
+      method: "POST",
+      body: JSON.stringify({ reason })
+    });
+  }
+  /**
+   * Get lock status for a translation
+   */
+  async getLockStatus(projectId, translationId) {
+    return this.request(`/api/v1/projects/${projectId}/translations/${translationId}/lock`);
+  }
+  /**
+   * Lock a translation
+   */
+  async lockTranslation(projectId, translationId, reason) {
+    return this.request(`/api/v1/projects/${projectId}/translations/${translationId}/lock`, {
+      method: "POST",
+      body: JSON.stringify({ reason })
+    });
+  }
+  /**
+   * Unlock a translation
+   */
+  async unlockTranslation(projectId, translationId) {
+    return this.request(`/api/v1/projects/${projectId}/translations/${translationId}/lock`, {
+      method: "DELETE"
+    });
+  }
+  /**
+   * Get all locked translations for a project
+   */
+  async getLockedTranslations(projectId) {
+    return this.request(`/api/v1/projects/${projectId}/workflows/locked`);
+  }
+};
+
+// src/lib/api/api-keys.ts
+var ApiKeysApi = class extends BaseApiClient {
+  /**
+   * List organization-level API keys (not project-scoped)
+   */
+  async listAPIKeys() {
+    return this.request("/api/v1/api-keys");
+  }
+  /**
+   * List all API keys (organization-level + project-scoped)
+   */
+  async listAllAPIKeys() {
+    return this.request("/api/v1/api-keys/all");
+  }
+  /**
+   * List API keys for a specific project
+   */
+  async listProjectAPIKeys(projectId) {
+    return this.request(`/api/v1/projects/${projectId}/api-keys`);
+  }
+  /**
+   * Create an organization-level API key
+   * If project_id is provided, creates a project-scoped key instead
+   */
+  async createAPIKey(options) {
+    if (options.project_id) {
+      return this.request(`/api/v1/projects/${options.project_id}/api-keys`, {
+        method: "POST",
+        body: JSON.stringify({
+          name: options.name,
+          description: options.description,
+          expires_in_days: options.expires_in_days
+        })
+      });
+    }
+    return this.request("/api/v1/api-keys", {
+      method: "POST",
+      body: JSON.stringify(options)
+    });
+  }
+  /**
+   * Create a project-scoped API key
+   */
+  async createProjectAPIKey(projectId, options) {
+    return this.request(`/api/v1/projects/${projectId}/api-keys`, {
+      method: "POST",
+      body: JSON.stringify(options)
+    });
+  }
+  /**
+   * Revoke an API key
+   */
+  async revokeAPIKey(keyId) {
+    return this.request(`/api/v1/api-keys/${keyId}`, {
+      method: "DELETE"
+    });
+  }
+  /**
+   * Revoke a project-scoped API key
+   */
+  async revokeProjectAPIKey(projectId, keyId) {
+    return this.request(`/api/v1/projects/${projectId}/api-keys/${keyId}`, {
+      method: "DELETE"
+    });
+  }
+};
+
+// src/lib/api/emails.ts
+var EmailsApi = class extends BaseApiClient {
+  /**
+   * List email templates for a project
+   */
+  async listEmailTemplates(projectId) {
+    return this.request(`/api/v1/projects/${projectId}/email-templates`);
+  }
+  /**
+   * Get a single email template by slug with content
+   */
+  async getEmailTemplateBySlug(projectId, slug, language) {
+    const url = language ? `/api/v1/projects/${projectId}/email-templates/slug/${slug}?lang=${language}` : `/api/v1/projects/${projectId}/email-templates/slug/${slug}`;
+    const response = await this.request(url);
+    return response.template;
+  }
+  /**
+   * Get a single email template by ID with content
+   */
+  async getEmailTemplate(projectId, templateId, language) {
+    const url = language ? `/api/v1/projects/${projectId}/email-templates/${templateId}?lang=${language}` : `/api/v1/projects/${projectId}/email-templates/${templateId}`;
+    const response = await this.request(url);
+    return response.template;
+  }
+  /**
+   * Get HTML content for a specific language
+   */
+  async getHtmlContent(projectId, templateId, language) {
+    return this.request(
+      `/api/v1/projects/${projectId}/email-templates/${templateId}/content/${language}`
+    );
+  }
+  /**
+   * Create a new email template
+   */
+  async createEmailTemplate(projectId, data) {
+    return this.request(`/api/v1/projects/${projectId}/email-templates`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  /**
+   * Update an email template
+   */
+  async updateEmailTemplate(projectId, templateId, data) {
+    return this.request(`/api/v1/projects/${projectId}/email-templates/${templateId}`, {
+      method: "PUT",
+      body: JSON.stringify(data)
+    });
+  }
+  /**
+   * Update HTML properties (source HTML/CSS)
+   */
+  async updateHtmlProperties(projectId, templateId, properties) {
+    const response = await this.request(
+      `/api/v1/projects/${projectId}/email-templates/${templateId}/html/properties`,
+      {
+        method: "PATCH",
+        body: JSON.stringify({ html_properties: properties })
+      }
+    );
+    return response.template;
+  }
+  /**
+   * Set HTML translation for a specific language
+   */
+  async setHtmlTranslation(projectId, templateId, data) {
+    return this.request(
+      `/api/v1/projects/${projectId}/email-templates/${templateId}/html/translation`,
+      {
+        method: "PUT",
+        body: JSON.stringify(data)
+      }
+    );
+  }
+  /**
+   * Delete an email template
+   */
+  async deleteEmailTemplate(projectId, templateId) {
+    return this.request(`/api/v1/projects/${projectId}/email-templates/${templateId}`, {
+      method: "DELETE"
+    });
+  }
+  /**
+   * Publish an email template
+   */
+  async publishEmailTemplate(projectId, templateId, notes) {
+    const response = await this.request(
+      `/api/v1/projects/${projectId}/email-templates/${templateId}/publish`,
+      {
+        method: "POST",
+        body: JSON.stringify({ notes })
+      }
+    );
+    return response.template;
+  }
+  /**
+   * Render an email template with variables
+   */
+  async renderEmailTemplate(projectId, slug, language, variables) {
+    return this.request(`/api/v1/projects/${projectId}/email-templates/${slug}/render`, {
+      method: "POST",
+      body: JSON.stringify({ language, variables })
+    });
+  }
+  /**
+   * Get email template GitHub integration status
+   */
+  async getEmailGitHubIntegration(projectId) {
+    return this.request(`/api/v1/projects/${projectId}/email-templates/github`);
+  }
+  /**
+   * Sync email templates with GitHub (pull or push)
+   */
+  async syncEmailTemplates(projectId, options) {
+    return this.request(`/api/v1/projects/${projectId}/email-templates/github/sync`, {
+      method: "POST",
+      body: JSON.stringify(options)
+    });
+  }
+  /**
+   * Get email template sync logs
+   */
+  async getEmailSyncLogs(projectId) {
+    return this.request(`/api/v1/projects/${projectId}/email-templates/github/logs`);
+  }
+};
+
+// src/lib/api/billing.ts
+var PLAN_LIMITS = {
+  free: {
+    strings: 500,
+    teamMembers: 30,
+    price: 0,
+    otaEnabled: false,
+    branchesEnabled: false,
+    ssoEnabled: false
+  },
+  starter: {
+    strings: 5e3,
+    teamMembers: 30,
+    price: 12,
+    otaEnabled: false,
+    branchesEnabled: false,
+    ssoEnabled: false
+  },
+  growth: {
+    strings: 15e3,
+    teamMembers: 30,
+    price: 49,
+    otaEnabled: false,
+    branchesEnabled: true,
+    ssoEnabled: false
+  },
+  business: {
+    strings: 5e4,
+    teamMembers: 30,
+    price: 149,
+    otaEnabled: true,
+    branchesEnabled: true,
+    ssoEnabled: false
+  },
+  pro: {
+    strings: 1e5,
+    teamMembers: 30,
+    price: 399,
+    otaEnabled: true,
+    branchesEnabled: true,
+    ssoEnabled: true
+  },
+  professional: {
+    // Legacy alias
+    strings: 1e5,
+    teamMembers: 30,
+    price: 399,
+    otaEnabled: true,
+    branchesEnabled: true,
+    ssoEnabled: true
+  },
+  enterprise: {
+    strings: -1,
+    // unlimited
+    teamMembers: -1,
+    price: -1,
+    otaEnabled: true,
+    branchesEnabled: true,
+    ssoEnabled: true
+  }
+};
+var BillingApi = class extends BaseApiClient {
+  /**
+   * Get current billing info including plan and usage
+   */
+  async getBillingInfo() {
+    return this.request("/api/v1/billing");
+  }
+  /**
+   * Get plan limits for a given plan name
+   */
+  getPlanLimits(planName) {
+    return PLAN_LIMITS[planName.toLowerCase()] || PLAN_LIMITS.free;
+  }
+  /**
+   * Check if uploading a certain number of strings would exceed the plan limit
+   * This counts unique source language keys only (translations don't count toward limit)
+   */
+  async checkUsageLimit(requestedStrings) {
+    const billing = await this.getBillingInfo();
+    const limits = this.getPlanLimits(billing.plan.name);
+    const isUnlimited = limits.strings < 0;
+    const currentStrings = billing.usage.strings_used;
+    const maxStrings = limits.strings;
+    if (isUnlimited) {
+      return {
+        allowed: true,
+        plan: billing.plan.name,
+        current_strings: currentStrings,
+        max_strings: -1,
+        requested_strings: requestedStrings,
+        would_exceed_by: 0,
+        is_unlimited: true
+      };
+    }
+    const projectedTotal = Math.max(currentStrings, requestedStrings);
+    const wouldExceedBy = projectedTotal > maxStrings ? projectedTotal - maxStrings : 0;
+    return {
+      allowed: projectedTotal <= maxStrings,
+      plan: billing.plan.name,
+      current_strings: currentStrings,
+      max_strings: maxStrings,
+      requested_strings: requestedStrings,
+      would_exceed_by: wouldExceedBy,
+      is_unlimited: false
+    };
+  }
+  /**
+   * Format a number for display (with commas)
+   */
+  formatNumber(num) {
+    if (num < 0) return "Unlimited";
+    return num.toLocaleString();
+  }
+};
+
+// src/lib/api/documents.ts
+var DocumentsApi = class extends BaseApiClient {
+  async listDocuments(projectId) {
+    return this.request(`/api/v1/projects/${projectId}/documents`);
+  }
+  async getDocument(projectId, documentId) {
+    return this.request(`/api/v1/projects/${projectId}/documents/${documentId}`);
+  }
+  async uploadDocument(projectId, file, filename, sourceLang, targetLangs) {
+    if (!this.apiKey) {
+      throw new Error(getAuthErrorMessage());
+    }
+    const formData = new FormData();
+    formData.append("file", file, filename);
+    if (sourceLang) formData.append("source_language", sourceLang);
+    if (targetLangs && targetLangs.length > 0) {
+      formData.append("target_languages", targetLangs.join(","));
+    }
+    const url = `${this.baseUrl}/api/v1/projects/${projectId}/documents`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "X-API-Key": this.apiKey
+          // Do NOT set Content-Type, let browser/node set boundary
+        },
+        body: formData,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({ error: `Request failed: ${response.status}` }));
+        throw new Error(error.error || `Request failed: ${response.status}`);
+      }
+      return response.json();
+    } catch (err) {
+      clearTimeout(timeoutId);
+      throw new Error(`Upload failed: ${err instanceof Error ? err.message : "Unknown error"}`);
+    }
+  }
+  async downloadDocument(projectId, documentId, language) {
+    const blob = await this.requestBlob(`/api/v1/projects/${projectId}/documents/${documentId}/export?language=${language}`);
+    return blob.arrayBuffer();
+  }
+};
+
+// src/lib/api/index.ts
+var ApiClient = class {
+  projects;
+  translations;
+  importExport;
+  workflows;
+  apiKeys;
+  emails;
+  billing;
+  documents;
+  constructor() {
+    this.projects = new ProjectsApi();
+    this.translations = new TranslationsApi();
+    this.importExport = new ImportExportApi();
+    this.workflows = new WorkflowsApi();
+    this.apiKeys = new ApiKeysApi();
+    this.emails = new EmailsApi();
+    this.emails = new EmailsApi();
+    this.billing = new BillingApi();
+    this.documents = new DocumentsApi();
+  }
+  // Documents API
+  listDocuments(projectId) {
+    return this.documents.listDocuments(projectId);
+  }
+  getDocument(projectId, documentId) {
+    return this.documents.getDocument(projectId, documentId);
+  }
+  // Helper type for file upload since passing Blob from CLI can be tricky (Node.js doesn't have File/Blob in older versions, but we target Node 18+)
+  uploadDocument(projectId, file, filename, sourceLang, targetLangs) {
+    return this.documents.uploadDocument(projectId, file, filename, sourceLang, targetLangs);
+  }
+  downloadDocument(projectId, documentId, language) {
+    return this.documents.downloadDocument(projectId, documentId, language);
+  }
+  // Projects API
+  listProjects() {
+    return this.projects.listProjects();
+  }
+  getProject(projectId) {
+    return this.projects.getProject(projectId);
+  }
+  createProject(data) {
+    return this.projects.createProject(data);
+  }
+  findProjectByName(name) {
+    return this.projects.findProjectByName(name);
+  }
+  getProjectLanguages(projectId) {
+    return this.projects.getProjectLanguages(projectId);
+  }
+  addLanguagesBulk(projectId, languages, skipTranslation = false) {
+    return this.projects.addLanguagesBulk(projectId, languages, skipTranslation);
+  }
+  listVersions(projectId) {
+    return this.projects.listVersions(projectId);
+  }
+  createVersion(projectId, data) {
+    return this.projects.createVersion(projectId, data);
+  }
+  downloadVersion(projectId, version) {
+    return this.projects.downloadVersion(projectId, version);
+  }
+  // Translations API
+  pushKeys(projectId, keys, language, namespace, options) {
+    return this.translations.pushKeys(projectId, keys, language, namespace, options);
+  }
+  getKeys(projectId, namespace) {
+    return this.translations.getKeys(projectId, namespace);
+  }
+  pullTranslations(projectId, options) {
+    return this.translations.pullTranslations(projectId, options);
+  }
+  searchGlossary(query, options) {
+    return this.translations.searchGlossary(query, options);
+  }
+  addGlossaryTerm(data) {
+    return this.translations.addGlossaryTerm(data);
+  }
+  exportGlossary(glossaryId) {
+    return this.translations.exportGlossary(glossaryId);
+  }
+  searchTM(data) {
+    return this.translations.searchTM(data);
+  }
+  addTMEntry(data) {
+    return this.translations.addTMEntry(data);
+  }
+  getTMStats() {
+    return this.translations.getTMStats();
+  }
+  // Import/Export API
+  exportTranslations(projectId, options) {
+    return this.importExport.exportTranslations(projectId, options);
+  }
+  importTranslations(projectId, content, fileName, language, options) {
+    return this.importExport.importTranslations(projectId, content, fileName, language, options);
+  }
+  // Workflows API
+  getWorkflowSettings(projectId) {
+    return this.workflows.getWorkflowSettings(projectId);
+  }
+  listWorkflows(projectId) {
+    return this.workflows.listWorkflows(projectId);
+  }
+  getPendingApprovals(projectId) {
+    return this.workflows.getPendingApprovals(projectId);
+  }
+  getApprovalHistory(projectId, translationId) {
+    return this.workflows.getApprovalHistory(projectId, translationId);
+  }
+  approveTranslation(projectId, translationId, comment) {
+    return this.workflows.approveTranslation(projectId, translationId, comment);
+  }
+  rejectTranslation(projectId, translationId, reason) {
+    return this.workflows.rejectTranslation(projectId, translationId, reason);
+  }
+  getLockStatus(projectId, translationId) {
+    return this.workflows.getLockStatus(projectId, translationId);
+  }
+  lockTranslation(projectId, translationId, reason) {
+    return this.workflows.lockTranslation(projectId, translationId, reason);
+  }
+  unlockTranslation(projectId, translationId) {
+    return this.workflows.unlockTranslation(projectId, translationId);
+  }
+  getLockedTranslations(projectId) {
+    return this.workflows.getLockedTranslations(projectId);
+  }
+  // API Keys API
+  listAPIKeys() {
+    return this.apiKeys.listAPIKeys();
+  }
+  listAllAPIKeys() {
+    return this.apiKeys.listAllAPIKeys();
+  }
+  listProjectAPIKeys(projectId) {
+    return this.apiKeys.listProjectAPIKeys(projectId);
+  }
+  createAPIKey(options) {
+    return this.apiKeys.createAPIKey(options);
+  }
+  createProjectAPIKey(projectId, options) {
+    return this.apiKeys.createProjectAPIKey(projectId, options);
+  }
+  revokeAPIKey(keyId) {
+    return this.apiKeys.revokeAPIKey(keyId);
+  }
+  revokeProjectAPIKey(projectId, keyId) {
+    return this.apiKeys.revokeProjectAPIKey(projectId, keyId);
+  }
+  // Emails API
+  listEmailTemplates(projectId) {
+    return this.emails.listEmailTemplates(projectId);
+  }
+  getEmailTemplateBySlug(projectId, slug, language) {
+    return this.emails.getEmailTemplateBySlug(projectId, slug, language);
+  }
+  getEmailTemplate(projectId, templateId, language) {
+    return this.emails.getEmailTemplate(projectId, templateId, language);
+  }
+  getHtmlContent(projectId, templateId, language) {
+    return this.emails.getHtmlContent(projectId, templateId, language);
+  }
+  createEmailTemplate(projectId, data) {
+    return this.emails.createEmailTemplate(projectId, data);
+  }
+  updateEmailTemplate(projectId, templateId, data) {
+    return this.emails.updateEmailTemplate(projectId, templateId, data);
+  }
+  updateHtmlProperties(projectId, templateId, properties) {
+    return this.emails.updateHtmlProperties(projectId, templateId, properties);
+  }
+  setHtmlTranslation(projectId, templateId, data) {
+    return this.emails.setHtmlTranslation(projectId, templateId, data);
+  }
+  deleteEmailTemplate(projectId, templateId) {
+    return this.emails.deleteEmailTemplate(projectId, templateId);
+  }
+  publishEmailTemplate(projectId, templateId, notes) {
+    return this.emails.publishEmailTemplate(projectId, templateId, notes);
+  }
+  renderEmailTemplate(projectId, slug, language, variables) {
+    return this.emails.renderEmailTemplate(projectId, slug, language, variables);
+  }
+  getEmailGitHubIntegration(projectId) {
+    return this.emails.getEmailGitHubIntegration(projectId);
+  }
+  syncEmailTemplates(projectId, options) {
+    return this.emails.syncEmailTemplates(projectId, options);
+  }
+  getEmailSyncLogs(projectId) {
+    return this.emails.getEmailSyncLogs(projectId);
+  }
+  // Billing API
+  getBillingInfo() {
+    return this.billing.getBillingInfo();
+  }
+  checkUsageLimit(requestedStrings) {
+    return this.billing.checkUsageLimit(requestedStrings);
+  }
+};
+function createApiClient() {
+  return new ApiClient();
+}
+
+export {
+  BaseApiClient,
+  ProjectsApi,
+  TranslationsApi,
+  ImportExportApi,
+  WorkflowsApi,
+  ApiKeysApi,
+  EmailsApi,
+  PLAN_LIMITS,
+  BillingApi,
+  DocumentsApi,
+  ApiClient,
+  createApiClient
+};