@saplingai/sapling-js 1.0.45 → 1.0.53

package/README.md

@@ -76,6 +76,14 @@ You should see something like the following output:
 }
 ```
 
+If you only need to apply the corrections, pass `includeErrorCategories: false`. The API then
+skips error classification (faster and lighter), and each edit comes back without
+`error_type`, `general_error_type` or classifier-generated descriptions:
+
+```javascript
+client.edits('I have a apple!', undefined, { includeErrorCategories: false, autoApply: true })
+```
+
 ### Text classification
 
 Zero-shot classification with your own labels (plain names or `{ name, description }` objects, 2–20):
@@ -94,6 +102,103 @@ client
   })
 ```
 
+### AI content detection
+
+```javascript
+const { data } = await client.aidetect(documentText);
+// { score: 0.05, ai_fraction: 0.51, text: '...', version: '...',
+//   sentence_scores: [{ sentence: '...', score: 0.97, start: 0, end: 112 }, ...],
+//   tokens: [...], token_probs: [...] }
+```
+
+`score` (0–1) rates the whole text, so a document that is only partly AI-written can score low;
+`ai_fraction` is the share of the text in sentences scoring ≥ 0.5 (null when nothing could be
+scored), which flags those documents. `sentence_scores` use the same model and 0.5 threshold, and
+`start`/`end` index `text` in Unicode code points (`end` exclusive) — slice with
+`Array.from(text).slice(start, end).join('')` if the text may contain emoji. A response may also
+carry an advisory `language` (`{ code, name, confidence }`) when the text is confidently
+identified; the detector is trained on English. Options: `sent_scores` (default true),
+`score_string` (HTML heatmap), `version` (pin a model). Pass an array of 1–10 texts for the batch
+form, which answers `{ results: [...] }` in input order.
+
+### Rephrase, sentiment and readability statistics
+
+```javascript
+const { data: rephrased } = await client.rephrase('hey, can u send it over', {
+  mapping: 'informal_to_formal', // default 'paraphrase'
+  num_results: 3,                // 1–8, default 5
+});
+// { results: [{ hash: '...', original: '...', replacement: 'Could you please send it over?',
+//               rephrase_type: 'informal_to_formal', model_version: '...' }, ...] }
+
+const { data: sentiment } = await client.sentiment('Love the new release. The install was painful.');
+// { overall: [[0.71, 'POSITIVE'], [0.29, 'NEGATIVE']],
+//   results: [[[0.99, 'POSITIVE']], [[0.95, 'NEGATIVE'], ...]],
+//   sents: ['Love the new release.', 'The install was painful.'] }
+
+const { data: stats } = await client.statistics(documentText, { lang: 'en' });
+// { chars: 1234, words: 210, sentences: 12, reading_time_sec: 47.55, reading_time_min: 1,
+//   readability: 8.2, readability_scores: { flesch_reading_ease: 64.1, gunning_fog: 10.3, ... } }
+```
+
+`rephrase()` mappings: `paraphrase`, `reword`, `expand`, `shorten`, `summarize`,
+`passive_to_active`, `active_to_passive`, `informal_to_formal`, `formal_to_informal`,
+`sentence_split`, `generate_title`, `generate_acronym`, `generate_meta_description`,
+`switch_tone` (with `tone_mapping`) and `switch_tense` (with `tense_mapping`). Sentiment labels
+are `POSITIVE`, `NEUTRAL` and `NEGATIVE`, as `[probability, label]` pairs, most likely first;
+a text with no sentences (markup or punctuation only) gets a 204 with an empty body (`data === ''`),
+and one the API cannot split into sentences gets a 200 with `[]`.
+`statistics()` is unbilled; `lang` is one of `en`, `de`, `es`, `fr`, `it`, `nl`, `pl`, `ru`, `ar`
+or `auto` and picks the readability formulas (`readability_scores` is empty for `auto`).
+
+### Similar terms, profanity and the custom dictionary
+
+```javascript
+const { data: similar } = await client.similarTerms('pet');
+// { neighbors: [[0.81, 'dog'], [0.78, 'cat'], [0.75, 'puppy']],
+//   synonyms: ['darling', 'favorite', 'favourite', ...] }
+
+const { data: profanity } = await client.profanity('This is so damn stupid.');
+// { toks: ['This', 'is', 'so', 'damn', 'stupid.'], labels: [0, 0, 0, 1, 1] }
+
+// Words the grammar and spelling checks should accept (product names, jargon).
+const { data: entry } = await client.addDictionaryEntry('Sapling', { case_sensitive: true });
+// { id: '...', entry: 'Sapling', case_sensitive: true, created_at: '...', updated_at: '...' }
+const { data: entries } = await client.dictionaryEntries(); // a bare array, sorted by entry
+await client.deleteDictionaryEntry(entry.id);               // 204, empty body
+```
+
+`similarTerms()` returns up to five `[similarity, term]` neighbors (similarity 0–1, most similar
+first) plus WordNet `synonyms` (multi-word ones use underscores); only the first 100 characters of
+the query are used. `profanity()` splits the text on whitespace and labels each token 1 (profane)
+or 0. Both are unbilled. `addDictionaryEntry()` answers 400 for a duplicate entry or one with more
+than two digits; `deleteDictionaryEntry()` answers 400 (not 404) for an id that is not this
+account's.
+
+### Style-guide rulesets
+
+Check text against style rules inline, or save a named ruleset once (owned by
+your API key's account — its team, for team-scoped keys) and check against it
+by name:
+
+```javascript
+// Define the house style once…
+await client.saveStyleguideRuleset('House Style', [
+  'no exclamation marks',
+  { name: 'no jargon', description: 'No corporate buzzwords or filler.' },
+]);
+
+// …then check against it by name (names match case-insensitively).
+const response = await client.styleguide('Our synergy-driven solution!!', 'House Style');
+console.log(response.data);
+// { violations: [{ rule: 'no jargon', text: 'synergy-driven solution', ... }],
+//   rules: ['no exclamation marks', 'no jargon'], compliant: false }
+
+// List and delete:
+await client.styleguideRulesets();          // { rulesets: [{ name, rules, ... }] }
+await client.deleteStyleguideRuleset('House Style');
+```
+
 ## Frontend Quickstart
 
 The SDK provides a way to automatically apply edit suggestions to any HTML contenteditable and textarea elements.
@@ -159,6 +264,28 @@ as `YYYY-MM-DD`, or `'list'`), and every value must be grounded in a quote from
 extraction, not inference, so a value that isn't stated is reported in `missing` rather than
 guessed.
 
+## Translation
+
+Translate text into a target language, named by ISO 639 code (`'fr'`, `'zh-TW'`) or English
+name (`'French'`). Line breaks and markup are preserved, and the detected source language is
+reported alongside the translation:
+
+```javascript
+client
+  .translate('Hello world.\nSee you at 5pm.', 'fr', { formality: 'formal' })
+  .then(function (response) {
+    console.log(response.data);
+    // { translation: 'Bonjour le monde.\nÀ 17h.',
+    //   source_lang: 'en', source_lang_name: 'English',
+    //   target_lang: 'fr', target_lang_name: 'French' }
+  })
+```
+
+Region variants `zh-CN`/`zh-TW`/`zh-HK`, `pt-BR`/`pt-PT`, `en-GB`/`en-US`, `fr-CA` and
+`es-419` are supported as targets; the optional `source_lang` hint never overrides what the
+text actually is, and `formality` (`'formal'`/`'informal'`) picks the register where the
+target language distinguishes them.
+
 ## Further Documentation
 
 - Full Sapling HTTP API and SDK [documentation](https://sapling.ai/docs).
@@ -179,3 +306,34 @@ try {
   console.error(error.response?.status, error.response?.data ?? error.message);
 }
 ```
+
+API error bodies are JSON objects with a human-readable `msg`, for example
+`{ msg: 'Invalid API key.' }`. The one exception is the 4MB `413`, which uses
+`message`/`result` keys. When a `402` or `429` body has a numeric `retry_after`,
+the request can succeed after waiting that many seconds. Without it, retrying
+unchanged won't help. See
+[Rate Limits & Errors](https://sapling.ai/docs/rate_limits/).
+
+To find out why a key is blocked, and for how long, call `accountStatus()`. It
+is unbilled and works while the key is blocked. It reports account-wide blocks:
+an expired key or subscription, depleted credits, a billing limit, the trial
+daily allowance or the monthly quota. It does not report a single endpoint's
+short-term rate limit, because each endpoint has its own allowance. For a
+`Capacity used.` 429, use that response's `retry_after` instead:
+
+```javascript
+const { data } = await client.accountStatus();
+if (!data.api_access) {
+  // blocked_reason: key_expired | subscription_expired | credits_depleted |
+  //   monthly_billing_limit | trial_daily_limit | monthly_quota_exhausted
+  const retry = data.retry_after ? `, retry in ${data.retry_after}s` : '';
+  console.log(`${data.blocked_reason}: ${data.message}${retry}`);
+}
+```
+
+Every response includes `api_access`, `blocked_reason`, `message` and
+`usage.monthly_quota_chars`. Keys that aren't team-scoped also get the
+account's `subscription`, prepaid `credits`, `usage.chars_this_month` and, on a
+free trial, `trial`. See [Account Status](https://sapling.ai/docs/api/account-status/).
+Each call counts as 2,000 characters against the endpoint's own rate-limit
+bucket, so call it when something fails rather than before every request.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saplingai/sapling-js",
-  "version": "1.0.45",
+  "version": "1.0.53",
   "description": "JavaScript library for using the Sapling.ai API.",
   "type": "module",
   "main": "./sapling/client.js",

package/sapling/client.d.ts

@@ -32,10 +32,182 @@ export type EditOptions = {
    lang?: string,
    medical?: boolean,
    advancedEdits?: AdvancedEditOptions,
+   /** Defaults to true. false skips error classification: edits omit error_type,
+    *  general_error_type and classifier-generated descriptions. */
+   includeErrorCategories?: boolean,
 }
 
 export type AIDetectOptions = {
+   /** Include `sentence_scores` (server default true). */
    sent_scores?: boolean,
+   /** Include `score_string`, an HTML heatmap of the scored text. */
+   score_string?: boolean,
+   /** Pin a detector model version (e.g. `'20251027'`); omitted = current default. */
+   version?: string,
+}
+
+export type AIDetectSentenceScore = {
+   sentence: string;
+   /** Same model, 0–1 scale and 0.5 threshold as the overall `score`. */
+   score: number;
+   /** Offsets into the response `text` (`end` exclusive), counted in Unicode
+    *  code points — slice with `Array.from(text)` if it may contain emoji. */
+   start: number;
+   end: number;
+}
+
+export type AIDetectLanguage = {
+   code: string;
+   /** English display name; null for codes without one. */
+   name: string | null;
+   confidence: number;
+}
+
+export type AIDetectResponse = {
+   /** 0 (likely human-written) to 1 (likely AI-generated). */
+   score: number;
+   /** Share of the text in sentences scoring >= 0.5 (flags partially
+    *  AI-written documents); null when nothing could be scored. */
+   ai_fraction: number | null;
+   text: string;
+   tokens: string[];
+   token_probs: number[];
+   /** The pinned `version` when one was requested, otherwise an opaque
+    *  identifier of the default model — log it, don't parse it. */
+   version: string;
+   /** Present unless `sent_scores: false`. */
+   sentence_scores?: AIDetectSentenceScore[];
+   /** Present when `score_string: true`. */
+   score_string?: string;
+   /** Advisory detected language; omitted unless detection is high-confidence.
+    *  The detector is trained on English. */
+   language?: AIDetectLanguage;
+}
+
+export type AIDetectBatchResponse = {
+   results: AIDetectResponse[];
+}
+
+export type StyleguideRule = string | { name: string; description?: string };
+
+export type StyleguideViolation = {
+   rule: string;
+   text: string;
+   start: number | null;
+   end: number | null;
+   note: string;
+   suggestion: string;
+}
+
+export type StyleguideResponse = {
+   violations: StyleguideViolation[];
+   rules: string[];
+   compliant: boolean;
+}
+
+export type StyleguideBatchResponse = {
+   results: StyleguideResponse[];
+}
+
+export type StyleguideRuleset = {
+   name: string;
+   rules: { name: string; description: string }[];
+   created_at: string | null;
+   updated_at: string | null;
+}
+
+export type StyleguideRulesetsResponse = {
+   rulesets: StyleguideRuleset[];
+}
+
+export type SaveStyleguideRulesetResponse = {
+   ruleset: StyleguideRuleset;
+   created: boolean;
+}
+
+export type DeleteStyleguideRulesetResponse = {
+   deleted: string;
+}
+
+export type AccountBlockedReason =
+   | 'key_expired'
+   | 'subscription_expired'
+   | 'credits_depleted'
+   | 'monthly_billing_limit'
+   | 'trial_daily_limit'
+   | 'monthly_quota_exhausted';
+
+export type AccountCreditSummary = {
+   enabled: boolean;
+   currency: string;
+   alert_threshold_percent: number;
+   // Present only when `enabled` is true.
+   balance_credits?: number;
+   purchased_credits?: number;
+   consumed_credits?: number;
+   consumed_percent?: number;
+   low_balance?: boolean;
+   depleted?: boolean;
+   billing_mode?: string;
+   billing_mode_effective_at?: string | null;
+   metered_fallback_available?: boolean;
+   stops_when_depleted?: boolean;
+   billing_started_at?: string;
+   auto_topup?: { enabled: boolean; [field: string]: unknown };
+   [field: string]: unknown;
+}
+
+export type AccountStatusResponse = {
+   api_access: boolean;
+   blocked_reason: AccountBlockedReason | null;
+   message: string | null;
+   // Seconds until the block may clear; present only when blocked.
+   retry_after?: number;
+   usage: {
+      monthly_quota_chars: number | null;
+      // Omitted for team-scoped keys, like `subscription`, `credits` and `trial`.
+      month_start?: string;
+      chars_this_month?: number;
+   };
+   subscription?: {
+      active: boolean;
+      trial_only: boolean;
+      key_expired: boolean;
+   };
+   credits?: AccountCreditSummary;
+   // Present only for free-trial accounts.
+   trial?: {
+      daily_limit_chars: number | null;
+      chars_used_today: number;
+      resets_at: 'utc_midnight';
+   };
+}
+
+export type SimplifyReadingLevel = 'plain' | 'elementary' | 'middle_school' | 'high_school';
+
+export type SimplifyOptions = {
+   reading_level?: SimplifyReadingLevel,
+   preserve_terms?: string[],
+   lang?: string,
+}
+
+export type SimplifyReadabilityScores = {
+   grade: number;
+   ease: number;
+}
+
+export type SimplifyResponse = {
+   simplified: string;
+   reading_level: SimplifyReadingLevel;
+   lang: string;
+   readability?: {
+      before: SimplifyReadabilityScores;
+      after: SimplifyReadabilityScores;
+   };
+}
+
+export type SimplifyBatchResponse = {
+   results: SimplifyResponse[];
 }
 
 export type LangdetectOptions = {
@@ -59,6 +231,10 @@ export type ClassifyResponse = {
    multi_label: boolean;
 }
 
+export type ClassifyBatchResponse = {
+   results: ClassifyResponse[];
+}
+
 export type SeoOptions = {
    keywords?: string[],
    suggestions?: boolean,
@@ -137,10 +313,20 @@ export type QualityRubric = {
 export type QualityResponse = {
    score: number;
    sentences?: QualitySentenceScore[];
+   truncated?: boolean;
    rubric?: QualityRubric;
 }
 
-export type PIIType = 'email' | 'phone' | 'ssn' | 'credit_card' | 'ip_address' | 'iban' | 'us_bank_routing';
+export type QualityBatchResponse = {
+   results: QualityResponse[];
+}
+
+export type PIIDeterministicType = 'email' | 'phone' | 'ssn' | 'credit_card' | 'ip_address' | 'iban' | 'us_bank_routing';
+// Opt-in, LLM-backed named-entity PII types: detected only when listed in
+// `types` explicitly (a request without them stays deterministic-only), and
+// the text is then capped at 10,000 characters rather than 20,000.
+export type PIINerType = 'person' | 'organization' | 'location';
+export type PIIType = PIIDeterministicType | PIINerType;
 
 export type PIIOptions = {
    types?: PIIType[],
@@ -162,19 +348,55 @@ export type PIIResponse = {
    redacted_text?: string;
 }
 
+export type NERType = 'person' | 'organization' | 'location' | 'date' | 'time' |
+   'money' | 'percent' | 'quantity' | 'product' | 'event';
+
+export type NEROptions = {
+   types?: NERType[],
+}
+
+export type NEREntity = {
+   text: string;
+   type: NERType;
+   start: number;
+   end: number;
+}
+
+export type NERResponse = {
+   entities: NEREntity[];
+   types: NERType[];
+}
+
+export type NERBatchResponse = {
+   results: NERResponse[];
+}
+
+export type SafetyCategory = 'toxicity' | 'profanity' | 'harassment' | 'hate_speech' |
+   'self_harm' | 'sexual' | 'violence';
+
+export type SafetySpan = {
+   text: string;
+   start: number | null;
+   end: number | null;
+   scores: Partial<Record<SafetyCategory, number>>;
+   flagged_categories: SafetyCategory[];
+}
+
 export type SafetyResponse = {
-   toxicity: number;
-   profanity: number;
-   harassment: number;
-   hate_speech: number;
-   self_harm: number;
-   sexual: number;
-   violence: number;
-   flagged: string[];
+   scores: Record<SafetyCategory, number>;
+   flagged: boolean;
+   flagged_categories: SafetyCategory[];
+   threshold: number;
+   spans?: SafetySpan[];
+}
+
+export type SafetyBatchResponse = {
+   results: SafetyResponse[];
 }
 
 export type SafetyOptions = {
    threshold?: number,
+   spans?: boolean,
 }
 
 export type SpellcheckOptions = {
@@ -215,6 +437,142 @@ export type ExtractResponse = {
    missing: string[],
 }
 
+export type ExtractBatchResponse = {
+   results: ExtractResponse[];
+}
+
+export type TranslateOptions = {
+   source_lang?: string,
+   formality?: 'formal' | 'informal',
+}
+
+export type TranslateResponse = {
+   translation: string,
+   source_lang: string,
+   source_lang_name: string | null,
+   target_lang: string,
+   target_lang_name: string,
+}
+
+export type TranslateBatchResponse = {
+   results: TranslateResponse[];
+}
+
+export type SummarizeOptions = {
+   length?: 'short' | 'medium' | 'long',
+}
+
+export type SummarizeResponse = {
+   /** Mirrors `summary` — the endpoint's original response key. */
+   result: string,
+   summary: string,
+   key_points: string[],
+   length: 'short' | 'medium' | 'long',
+}
+
+export type SummarizeBatchResponse = {
+   results: SummarizeResponse[];
+}
+
+export type RephraseMapping =
+   'paraphrase' | 'passive_to_active' | 'active_to_passive' | 'informal_to_formal' |
+   'formal_to_informal' | 'sentence_split' | 'reword' | 'generate_title' | 'generate_acronym' |
+   'generate_meta_description' | 'summarize' | 'expand' | 'shorten' | 'switch_tone' | 'switch_tense';
+
+export type RephraseToneMapping =
+   'straightforward' | 'confident' | 'friendly' | 'empathetic' | 'professional' | 'casual' |
+   'diplomatic' | 'persuasive';
+
+export type RephraseTenseMapping =
+   'simple past' | 'past perfect' | 'past continuous' | 'past perfect continuous' |
+   'simple present' | 'present perfect' | 'present continuous' | 'present perfect continuous' |
+   'simple future' | 'future perfect' | 'future continuous' | 'future perfect continuous';
+
+export type RephraseOptions = {
+   /** Defaults to 'paraphrase'. */
+   mapping?: RephraseMapping,
+   /** Only used with mapping 'switch_tone'. Defaults to 'straightforward'. */
+   tone_mapping?: RephraseToneMapping,
+   /** Only used with mapping 'switch_tense'. Defaults to 'simple past'. */
+   tense_mapping?: RephraseTenseMapping,
+   /** Number of alternatives, 1-8 (default 5). Honored by paraphrase, informal_to_formal,
+    *  formal_to_informal, generate_title and generate_acronym. */
+   num_results?: number,
+   session_id?: string,
+}
+
+export type RephraseResult = {
+   hash: string,
+   original: string,
+   replacement: string,
+   rephrase_type: RephraseMapping,
+   model_version: string,
+}
+
+export type RephraseResponse = {
+   results: RephraseResult[],
+}
+
+export type SentimentLabel = 'POSITIVE' | 'NEUTRAL' | 'NEGATIVE';
+
+/** [probability, label] pairs, most likely first. */
+export type SentimentScores = Array<[number, SentimentLabel]>;
+
+export type SentimentResponse = {
+   overall: SentimentScores,
+   /** One entry per sentence, aligned with `sents`. */
+   results: SentimentScores[],
+   sents: string[],
+}
+
+export type StatisticsLang = 'en' | 'de' | 'es' | 'fr' | 'it' | 'nl' | 'pl' | 'ru' | 'ar' | 'auto';
+
+export type StatisticsOptions = {
+   /** Defaults to 'en'. */
+   lang?: StatisticsLang,
+}
+
+export type StatisticsResponse = {
+   chars: number,
+   words: number,
+   sentences: number,
+   reading_time_sec: number,
+   reading_time_min: number,
+   /** Flesch-Kincaid grade level; -3.4 when the text cannot be scored. */
+   readability: number,
+   /** Formula name -> score. The formulas present depend on `lang`; empty for 'auto'.
+    *  `text_standard` is a string (e.g. "8th and 9th grade"). */
+   readability_scores: Record<string, number | string>,
+}
+
+export type SimilarTermsResponse = {
+   /** Up to 5 [similarity, term] pairs (similarity 0-1), most similar first. */
+   neighbors: Array<[number, string]>,
+   /** WordNet lemma names; multi-word ones use underscores (e.g. "domestic_dog"). */
+   synonyms: string[],
+}
+
+export type ProfanityResponse = {
+   /** The text split on whitespace (punctuation stays attached). */
+   toks: string[],
+   /** Aligned with `toks`: 1 for profanity, 0 otherwise. */
+   labels: Array<0 | 1>,
+}
+
+export type DictionaryEntry = {
+   id: string,
+   entry: string,
+   case_sensitive: boolean,
+   /** RFC 1123 timestamp, e.g. "Wed, 07 Oct 2020 21:15:47 GMT". */
+   created_at: string,
+   updated_at: string,
+}
+
+export type AddDictionaryEntryOptions = {
+   /** Defaults to true. */
+   case_sensitive?: boolean,
+}
+
 export type UserDetails = {
    userId?: string,
    anonUser?: boolean,
@@ -232,13 +590,54 @@ export declare class Client {
    complete(query: string, sessionId?: string): Promise<AxiosResponse>;
    acceptComplete(completeUUID: string, query: string, completion: string, sessionId?: string): Promise<AxiosResponse>;
    tone(text: string): Promise<AxiosResponse>;
+   rephrase(text: string, options?: RephraseOptions): Promise<AxiosResponse<RephraseResponse>>;
+   /** A text with no sentences (e.g. markup or punctuation only) gets a 204 with an empty
+    *  body, so `data` is `''` then; a text the API cannot split into sentences gets a 200
+    *  with `[]`. Check `Array.isArray(data) || !data` before reading fields. */
+   sentiment(text: string): Promise<AxiosResponse<SentimentResponse | '' | never[]>>;
+   statistics(text: string, options?: StatisticsOptions): Promise<AxiosResponse<StatisticsResponse>>;
+   similarTerms(query: string): Promise<AxiosResponse<SimilarTermsResponse>>;
+   profanity(text: string): Promise<AxiosResponse<ProfanityResponse>>;
+   dictionaryEntries(): Promise<AxiosResponse<DictionaryEntry[]>>;
+   addDictionaryEntry(entry: string, options?: AddDictionaryEntryOptions): Promise<AxiosResponse<DictionaryEntry>>;
+   /** Answers 204 with an empty body. */
+   deleteDictionaryEntry(entryId: string): Promise<AxiosResponse<''>>;
    extract(text: string, fields: ExtractField[], options?: ExtractOptions): Promise<AxiosResponse<ExtractResponse>>;
-
-   aidetect(text: string, options?: AIDetectOptions): Promise<AxiosResponse>;
-   langdetect(text: string, options?: LangdetectOptions): Promise<AxiosResponse>;
+   extract(texts: string[], fields: ExtractField[], options?: ExtractOptions): Promise<AxiosResponse<ExtractBatchResponse>>;
+   extract(text: string | string[], fields: ExtractField[], options?: ExtractOptions): Promise<AxiosResponse<ExtractResponse | ExtractBatchResponse>>;
+   translate(text: string, targetLang: string, options?: TranslateOptions): Promise<AxiosResponse<TranslateResponse>>;
+   translate(texts: string[], targetLang: string, options?: TranslateOptions): Promise<AxiosResponse<TranslateBatchResponse>>;
+   translate(text: string | string[], targetLang: string, options?: TranslateOptions): Promise<AxiosResponse<TranslateResponse | TranslateBatchResponse>>;
+   summarize(text: string, options?: SummarizeOptions): Promise<AxiosResponse<SummarizeResponse>>;
+   summarize(texts: string[], options?: SummarizeOptions): Promise<AxiosResponse<SummarizeBatchResponse>>;
+   summarize(text: string | string[], options?: SummarizeOptions): Promise<AxiosResponse<SummarizeResponse | SummarizeBatchResponse>>;
+
+   aidetect(text: string, options?: AIDetectOptions): Promise<AxiosResponse<AIDetectResponse>>;
+   aidetect(texts: string[], options?: AIDetectOptions): Promise<AxiosResponse<AIDetectBatchResponse>>;
+   aidetect(text: string | string[], options?: AIDetectOptions): Promise<AxiosResponse<AIDetectResponse | AIDetectBatchResponse>>;
+   styleguide(text: string, rules: StyleguideRule[] | string): Promise<AxiosResponse<StyleguideResponse>>;
+   styleguide(texts: string[], rules: StyleguideRule[] | string): Promise<AxiosResponse<StyleguideBatchResponse>>;
+   styleguide(text: string | string[], rules: StyleguideRule[] | string): Promise<AxiosResponse<StyleguideResponse | StyleguideBatchResponse>>;
+   styleguideRulesets(): Promise<AxiosResponse<StyleguideRulesetsResponse>>;
+   saveStyleguideRuleset(name: string, rules: StyleguideRule[]): Promise<AxiosResponse<SaveStyleguideRulesetResponse>>;
+   deleteStyleguideRuleset(name: string): Promise<AxiosResponse<DeleteStyleguideRulesetResponse>>;
+   simplify(text: string, options?: SimplifyOptions): Promise<AxiosResponse<SimplifyResponse>>;
+   simplify(texts: string[], options?: SimplifyOptions): Promise<AxiosResponse<SimplifyBatchResponse>>;
+   simplify(text: string | string[], options?: SimplifyOptions): Promise<AxiosResponse<SimplifyResponse | SimplifyBatchResponse>>;
+   langdetect(text: string | string[], options?: LangdetectOptions): Promise<AxiosResponse>;
    quality(text: string, options?: QualityOptions): Promise<AxiosResponse<QualityResponse>>;
+   quality(texts: string[], options?: QualityOptions): Promise<AxiosResponse<QualityBatchResponse>>;
+   quality(text: string | string[], options?: QualityOptions): Promise<AxiosResponse<QualityResponse | QualityBatchResponse>>;
    pii(text: string, options?: PIIOptions): Promise<AxiosResponse<PIIResponse>>;
+   ner(text: string, options?: NEROptions): Promise<AxiosResponse<NERResponse>>;
+   ner(texts: string[], options?: NEROptions): Promise<AxiosResponse<NERBatchResponse>>;
+   ner(text: string | string[], options?: NEROptions): Promise<AxiosResponse<NERResponse | NERBatchResponse>>;
    safety(text: string, options?: SafetyOptions): Promise<AxiosResponse<SafetyResponse>>;
+   safety(texts: string[], options?: SafetyOptions): Promise<AxiosResponse<SafetyBatchResponse>>;
+   safety(text: string | string[], options?: SafetyOptions): Promise<AxiosResponse<SafetyResponse | SafetyBatchResponse>>;
    classify(text: string, labels: ClassifyLabel[], options?: ClassifyOptions): Promise<AxiosResponse<ClassifyResponse>>;
+   classify(texts: string[], labels: ClassifyLabel[], options?: ClassifyOptions): Promise<AxiosResponse<ClassifyBatchResponse>>;
+   classify(text: string | string[], labels: ClassifyLabel[], options?: ClassifyOptions): Promise<AxiosResponse<ClassifyResponse | ClassifyBatchResponse>>;
    seo(text: string, options?: SeoOptions): Promise<AxiosResponse<SeoResponse>>;
+   accountStatus(): Promise<AxiosResponse<AccountStatusResponse>>;
 }