@saplingai/sapling-js 1.0.45 → 1.0.52

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,30 @@ client
   })
 ```
 
+### 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 +191,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 +233,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.52",
   "description": "JavaScript library for using the Sapling.ai API.",
   "type": "module",
   "main": "./sapling/client.js",

package/sapling/client.d.ts

@@ -32,12 +32,137 @@ 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 = {
    sent_scores?: boolean,
 }
 
+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 = {
    top_k?: number,
    segments?: boolean,
@@ -59,6 +184,10 @@ export type ClassifyResponse = {
    multi_label: boolean;
 }
 
+export type ClassifyBatchResponse = {
+   results: ClassifyResponse[];
+}
+
 export type SeoOptions = {
    keywords?: string[],
    suggestions?: boolean,
@@ -137,9 +266,14 @@ export type QualityRubric = {
 export type QualityResponse = {
    score: number;
    sentences?: QualitySentenceScore[];
+   truncated?: boolean;
    rubric?: QualityRubric;
 }
 
+export type QualityBatchResponse = {
+   results: QualityResponse[];
+}
+
 export type PIIType = 'email' | 'phone' | 'ssn' | 'credit_card' | 'ip_address' | 'iban' | 'us_bank_routing';
 
 export type PIIOptions = {
@@ -162,19 +296,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 +385,43 @@ 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 UserDetails = {
    userId?: string,
    anonUser?: boolean,
@@ -233,12 +440,39 @@ export declare class Client {
    acceptComplete(completeUUID: string, query: string, completion: string, sessionId?: string): Promise<AxiosResponse>;
    tone(text: 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 | string[], options?: AIDetectOptions): Promise<AxiosResponse>;
+   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>>;
 }

package/sapling/client.js

@@ -3,6 +3,58 @@ import { v4 as uuidv4 } from 'uuid';
 
 // Value types an extract() field may declare; 'string' is the default.
 const EXTRACT_FIELD_TYPES = ['string', 'number', 'integer', 'boolean', 'date', 'list'];
+// Registers translate() accepts; the API rejects anything else with a 400.
+const TRANSLATE_FORMALITIES = ['formal', 'informal'];
+const SUMMARIZE_LENGTHS = ['short', 'medium', 'long'];
+// Reading levels simplify() accepts; the API rejects anything else with a 400.
+const SIMPLIFY_READING_LEVELS = ['plain', 'elementary', 'middle_school', 'high_school'];
+
+// Shared by styleguide() and saveStyleguideRuleset(). Shape/type checks only —
+// size limits (rule/description length) are server configuration and enforced
+// there with a clear 400 (see classify()).
+const validateStyleguideRules = (rules, method) => {
+  const isValidRule = (rule) => {
+    if (typeof rule === 'string') {
+      return rule.trim().length > 0;
+    }
+    if (rule == null || typeof rule !== 'object' || Array.isArray(rule)) {
+      return false;
+    }
+    if (typeof rule.name !== 'string' || rule.name.trim().length === 0) {
+      return false;
+    }
+    if (rule.description !== undefined && typeof rule.description !== 'string') {
+      return false;
+    }
+    // Reject unknown keys so a typo like `{ name, descrption: '...' }` fails
+    // here rather than being forwarded to the API as a malformed rule (the
+    // classify()/extract() convention; the MCP object schema is `.strict()`).
+    const allowed = new Set(['name', 'description']);
+    if (Object.keys(rule).some((key) => !allowed.has(key))) {
+      return false;
+    }
+    return true;
+  };
+
+  if (
+    !Array.isArray(rules)
+    || rules.length < 1
+    || rules.length > 20
+    // Array.from() materializes holes in sparse arrays as `undefined` (which
+    // isValidRule rejects); a bare `.every()` would skip them and let a hole
+    // through to be serialized as `null`.
+    || !Array.from(rules).every(isValidRule)
+  ) {
+    throw new TypeError(`${method}: rules must be an array of 1 to 20 non-empty strings or `
+      + '{name, description?} objects (string name, optional string description).');
+  }
+
+  const names = rules.map(
+    (rule) => (typeof rule === 'string' ? rule : rule.name).trim().toLowerCase());
+  if (names.length !== new Set(names).size) {
+    throw new TypeError(`${method}: rule names must be unique (case-insensitive).`);
+  }
+};
 
 export class Client {
   constructor(apiKey, options = {}) {
@@ -60,6 +112,11 @@ export class Client {
       data.advanced_edits = options.advancedEdits;
     }
 
+    // Omitted unless set; an explicit null is forwarded so the API rejects it.
+    if (options.includeErrorCategories !== undefined) {
+      data.include_error_categories = options.includeErrorCategories;
+    }
+
     if (userDetails) {
       const { userId, anonUser } = userDetails;
       data.user_id = userId;
@@ -195,8 +252,11 @@ export class Client {
    * from the text, so this is extraction, not inference: a value that isn't stated is
    * reported missing rather than guessed. Finding nothing is a normal 200.
    *
-   * @param {string} text - The document to extract from, plain text or HTML (the API caps
-   *   it at 10,000 characters).
+   * @param {string|string[]} text - The document to extract from, plain text or HTML (the
+   *   API caps it at 10,000 characters). Pass an array of 1–10 strings to extract from a
+   *   batch in one request (sent as the API's `texts` parameter; combined length capped at
+   *   10,000 chars) — the response is then `{results: [...]}` with one
+   *   single-response-shaped entry per input, in order.
    * @param {Array<string|{name: string, type?: string, description?: string, required?: boolean}>} fields -
    *   The fields to pull out (1–20): field names, or objects. `type` is one of 'string'
    *   (default), 'number', 'integer', 'boolean', 'date' (returned as YYYY-MM-DD) or 'list'.
@@ -215,7 +275,20 @@ export class Client {
     // context length) are server configuration and enforced there with a clear
     // 400 — mirroring them here would drift the day they change (and JS
     // `length` counts UTF-16 units, not the characters the API counts).
-    if (typeof text !== 'string' || text.trim().length === 0) {
+    // An array of texts is the batch form (sent as `texts`, one result per
+    // item); the 1–10 item bound is structural like the field count below.
+    const isBatch = Array.isArray(text);
+    if (isBatch) {
+      // for...of (not text.every) so holes in a sparse array are visited as
+      // undefined and rejected, rather than skipped.
+      let ok = text.length >= 1 && text.length <= 10;
+      for (const item of text) {
+        ok = ok && typeof item === 'string' && item.trim().length > 0;
+      }
+      if (!ok) {
+        throw new TypeError('extract: texts must be an array of 1 to 10 non-empty strings.');
+      }
+    } else if (typeof text !== 'string' || text.trim().length === 0) {
       throw new TypeError('extract: text must be a non-empty string.');
     }
 
@@ -268,7 +341,7 @@ export class Client {
     }
 
     let data = {
-      text,
+      ...(isBatch ? { texts: text } : { text }),
       fields,
       key: this.apiKey,
     }
@@ -286,11 +359,182 @@ export class Client {
     return this.axiosPromise(url, 'post', data);
   }
 
+  /**
+   * Translate text into a target language with an LLM.
+   *
+   * Line breaks, markup and placeholders are preserved in place, and the response
+   * reports the language the text was actually written in (detected — never assumed
+   * from the hint): `translation`, `source_lang`/`source_lang_name` (`'und'`/`null`
+   * when undetermined) and the normalized `target_lang`/`target_lang_name`.
+   *
+   * @param {string|string[]} text - The text to translate (the API caps it at
+   *   5,000 characters). Markup and whitespace are preserved, not stripped.
+   *   Pass an array of 1-10 strings to translate a batch in one request (sent
+   *   as the API's `texts` parameter; combined length up to 5,000 characters,
+   *   same target/source/formality applied to every item). A batch response is
+   *   `{results: [...]}` with one single-response-shaped entry per input, in
+   *   order.
+   * @param {string} targetLang - Language to translate into: an ISO 639 code
+   *   ('fr', 'zh-TW') or an English language 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.
+   * @param {Object} [options]
+   * @param {string} [options.source_lang] - Optional hint for the source language,
+   *   same forms as targetLang. The text itself wins if they disagree.
+   * @param {string} [options.formality] - Optional register: 'formal'
+   *   (vous/Sie/usted) or 'informal' (tu/du/tú). Omit for the model default.
+   * @returns {Promise<AxiosResponse>}
+   */
+  translate(text, targetLang, options = {}) {
+    const url = `${this.urlEndpoint}translate`;
+
+    // Shape/type checks only; the language vocabulary and length caps are
+    // server configuration enforced there with a clear 400 (mirroring the
+    // 176-language table here would drift the day it changes).
+    // An array of texts is the batch form (SAP-398, sent as `texts`, one
+    // result per item); the 1–10 item bound is structural like safety's.
+    const isBatch = Array.isArray(text);
+    if (isBatch) {
+      // for...of (not text.every) so holes in a sparse array are visited as
+      // undefined and rejected, rather than skipped.
+      let ok = text.length >= 1 && text.length <= 10;
+      if (ok) {
+        for (const item of text) {
+          if (typeof item !== 'string' || item.trim().length === 0) {
+            ok = false;
+            break;
+          }
+        }
+      }
+      if (!ok) {
+        throw new TypeError('translate: texts must be an array of 1 to 10 non-empty strings.');
+      }
+    } else if (typeof text !== 'string' || text.trim().length === 0) {
+      throw new TypeError('translate: text must be a non-empty string.');
+    }
+    if (typeof targetLang !== 'string' || targetLang.trim().length === 0) {
+      throw new TypeError('translate: targetLang must be a non-empty string (an ISO 639 '
+        + 'code like "fr" or an English language name like "French").');
+    }
+
+    let data = {
+      ...(isBatch ? { texts: text } : { text }),
+      target_lang: targetLang,
+      key: this.apiKey,
+    }
+
+    // `!== undefined` (not `!= null`) so an explicit `null` is rejected as a
+    // bad type rather than silently treated as "omitted" (same as extract's
+    // context handling).
+    if (options?.source_lang !== undefined) {
+      if (typeof options.source_lang !== 'string' || options.source_lang.trim().length === 0) {
+        throw new TypeError('translate: source_lang must be a non-empty string.');
+      }
+      data.source_lang = options.source_lang;
+    }
+    if (options?.formality !== undefined) {
+      if (!TRANSLATE_FORMALITIES.includes(options.formality)) {
+        throw new TypeError('translate: formality must be one of '
+          + `${TRANSLATE_FORMALITIES.join(', ')}.`);
+      }
+      data.formality = options.formality;
+    }
+
+    return this.axiosPromise(url, 'post', data);
+  }
+
+  /**
+   * Summarize a document, webpage or email thread into a prose summary plus
+   * key points.
+   *
+   * Returns `summary` (the prose summary), `key_points` (an array of strings),
+   * `length` (the option the summary was generated with) and `result`
+   * (mirrors `summary` — the endpoint's original response key, kept for
+   * backward compatibility).
+   *
+   * @param {string|string[]} text - The document to summarize, plain text or
+   *   HTML (tags are stripped; the API caps it at 20,000 characters). Pass an
+   *   array of 1-10 strings to summarize a batch in one request (sent as the
+   *   API's `texts` parameter; combined length up to 20,000 characters, same
+   *   length option applied to every item). A batch response is
+   *   `{results: [...]}` with one single-response-shaped entry per input, in
+   *   order.
+   * @param {Object} [options]
+   * @param {string} [options.length] - Optional summary length: 'short',
+   *   'medium' (the default) or 'long'.
+   * @returns {Promise<AxiosResponse>}
+   */
+  summarize(text, options = {}) {
+    const url = `${this.urlEndpoint}summarize`;
+
+    // An array of texts is the batch form (SAP-399, sent as `texts`, one
+    // result per item); the 1–10 item bound is structural like translate's.
+    const isBatch = Array.isArray(text);
+    if (isBatch) {
+      // for...of (not text.every) so holes in a sparse array are visited as
+      // undefined and rejected, rather than skipped.
+      let ok = text.length >= 1 && text.length <= 10;
+      if (ok) {
+        for (const item of text) {
+          if (typeof item !== 'string' || item.trim().length === 0) {
+            ok = false;
+            break;
+          }
+        }
+      }
+      if (!ok) {
+        throw new TypeError('summarize: texts must be an array of 1 to 10 non-empty strings.');
+      }
+    } else if (typeof text !== 'string' || text.trim().length === 0) {
+      throw new TypeError('summarize: text must be a non-empty string.');
+    }
+
+    let data = {
+      ...(isBatch ? { texts: text } : { text }),
+      key: this.apiKey,
+    }
+
+    // `!== undefined` (not `!= null`) so an explicit `null` is rejected as a
+    // bad type rather than silently treated as "omitted" (same as translate's
+    // formality handling).
+    if (options?.length !== undefined) {
+      if (!SUMMARIZE_LENGTHS.includes(options.length)) {
+        throw new TypeError('summarize: length must be one of '
+          + `${SUMMARIZE_LENGTHS.join(', ')}.`);
+      }
+      data.length = options.length;
+    }
+
+    return this.axiosPromise(url, 'post', data);
+  }
+
   langdetect(text, options = {}) {
     const url = `${this.urlEndpoint}langdetect`;
 
+    // An array of texts is the batch form (SAP-397, sent as `texts`, one
+    // result per item); the 1–10 item bound is structural like classify's.
+    // The single (string) form is passed through unvalidated, as it always
+    // has been — the server answers a clear 400.
+    const isBatch = Array.isArray(text);
+    if (isBatch) {
+      // for...of (not text.every) so holes in a sparse array are visited as
+      // undefined and rejected, rather than skipped.
+      let ok = text.length >= 1 && text.length <= 10;
+      if (ok) {
+        for (const item of text) {
+          if (typeof item !== 'string' || item.trim().length === 0) {
+            ok = false;
+            break;
+          }
+        }
+      }
+      if (!ok) {
+        throw new TypeError('langdetect: texts must be an array of 1 to 10 non-empty strings.');
+      }
+    }
+
     let data = {
-      text,
+      ...(isBatch ? { texts: text } : { text }),
       key: this.apiKey,
     }
 
@@ -314,7 +558,11 @@ export class Client {
    * empty), `scores` (one `{label, score}` per input label, descending), a one-sentence
    * `rationale` and the echoed `multi_label` mode.
    *
-   * @param {string} text - Text to classify, plain text or HTML (the API caps it at 10,000 chars).
+   * @param {string|string[]} text - Text to classify, plain text or HTML (the API caps it
+   *   at 10,000 chars). Pass an array of 1–10 strings to classify a batch in one request
+   *   (sent as the API's `texts` parameter; combined length capped at 10,000 chars) — the
+   *   response is then `{results: [...]}` with one single-response-shaped entry per input,
+   *   in order.
    * @param {Array<string|{name: string, description?: string}>} labels - Candidate labels
    *   (2–20). Names unique case-insensitively; the API caps names at 50 and descriptions at 200 chars.
    * @param {Object} [options]
@@ -333,7 +581,20 @@ export class Client {
     // context length) are server configuration and enforced there with a
     // clear 400 — mirroring them here would drift the day they change (and
     // JS `length` counts UTF-16 units, not the characters the API counts).
-    if (typeof text !== 'string' || text.trim().length === 0) {
+    // An array of texts is the batch form (sent as `texts`, one result per
+    // item); the 1–10 item bound is structural like the label count below.
+    const isBatch = Array.isArray(text);
+    if (isBatch) {
+      // for...of (not text.every) so holes in a sparse array are visited as
+      // undefined and rejected, rather than skipped.
+      let ok = text.length >= 1 && text.length <= 10;
+      for (const item of text) {
+        ok = ok && typeof item === 'string' && item.trim().length > 0;
+      }
+      if (!ok) {
+        throw new TypeError('classify: texts must be an array of 1 to 10 non-empty strings.');
+      }
+    } else if (typeof text !== 'string' || text.trim().length === 0) {
       throw new TypeError('classify: text must be a non-empty string.');
     }
 
@@ -379,7 +640,7 @@ export class Client {
     }
 
     let data = {
-      text,
+      ...(isBatch ? { texts: text } : { text }),
       labels,
       key: this.apiKey,
     }
@@ -477,12 +738,30 @@ export class Client {
     const url = `${this.urlEndpoint}quality`;
 
     // Shape/type checks only; size limits are server configuration (see seo()).
-    if (typeof text !== 'string' || text.trim().length === 0) {
+    // An array of texts is the batch form (SAP-400, sent as `texts`, one
+    // result per item); the 1–10 item bound is structural like classify's.
+    const isBatch = Array.isArray(text);
+    if (isBatch) {
+      // for...of (not text.every) so holes in a sparse array are visited as
+      // undefined and rejected, rather than skipped.
+      let ok = text.length >= 1 && text.length <= 10;
+      if (ok) {
+        for (const item of text) {
+          if (typeof item !== 'string' || item.trim().length === 0) {
+            ok = false;
+            break;
+          }
+        }
+      }
+      if (!ok) {
+        throw new TypeError('quality: texts must be an array of 1 to 10 non-empty strings.');
+      }
+    } else if (typeof text !== 'string' || text.trim().length === 0) {
       throw new TypeError('quality: text must be a non-empty string.');
     }
 
     let data = {
-      text,
+      ...(isBatch ? { texts: text } : { text }),
       key: this.apiKey,
     }
 
@@ -508,12 +787,30 @@ export class Client {
     const url = `${this.urlEndpoint}safety`;
 
     // Shape/type checks only; size limits are server configuration (see seo()).
-    if (typeof text !== 'string' || text.trim().length === 0) {
+    // An array of texts is the batch form (SAP-397, sent as `texts`, one
+    // result per item); the 1–10 item bound is structural like classify's.
+    const isBatch = Array.isArray(text);
+    if (isBatch) {
+      // for...of (not text.every) so holes in a sparse array are visited as
+      // undefined and rejected, rather than skipped.
+      let ok = text.length >= 1 && text.length <= 10;
+      if (ok) {
+        for (const item of text) {
+          if (typeof item !== 'string' || item.trim().length === 0) {
+            ok = false;
+            break;
+          }
+        }
+      }
+      if (!ok) {
+        throw new TypeError('safety: texts must be an array of 1 to 10 non-empty strings.');
+      }
+    } else if (typeof text !== 'string' || text.trim().length === 0) {
       throw new TypeError('safety: text must be a non-empty string.');
     }
 
     let data = {
-      text,
+      ...(isBatch ? { texts: text } : { text }),
       key: this.apiKey,
     }
 
@@ -526,6 +823,12 @@ export class Client {
       }
       data.threshold = options.threshold;
     }
+    if (options?.spans !== undefined) {
+      if (typeof options.spans !== 'boolean') {
+        throw new TypeError('safety: spans must be a boolean.');
+      }
+      data.spans = options.spans;
+    }
 
     return this.axiosPromise(url, 'post', data);
   }
@@ -533,8 +836,30 @@ export class Client {
   aidetect(text, options = {}) {
     const url = `${this.urlEndpoint}aidetect`;
 
+    // An array of texts is the batch form (SAP-403, sent as `texts`, one
+    // result per item); the 1–10 item bound is structural like classify's.
+    // The single form keeps its historical no-validation behavior (the
+    // server 400s clearly on a bad `text`).
+    const isBatch = Array.isArray(text);
+    if (isBatch) {
+      // for...of (not text.every) so holes in a sparse array are visited as
+      // undefined and rejected, rather than skipped.
+      let ok = text.length >= 1 && text.length <= 10;
+      if (ok) {
+        for (const item of text) {
+          if (typeof item !== 'string' || item.trim().length === 0) {
+            ok = false;
+            break;
+          }
+        }
+      }
+      if (!ok) {
+        throw new TypeError('aidetect: texts must be an array of 1 to 10 non-empty strings.');
+      }
+    }
+
     let data = {
-      text,
+      ...(isBatch ? { texts: text } : { text }),
       key: this.apiKey,
     }
 
@@ -545,6 +870,265 @@ export class Client {
     return this.axiosPromise(url, 'post', data);
   }
 
+  /**
+   * Check a text for compliance with style rules you supply (house style,
+   * brand voice, editorial guidelines). Only the listed rules are enforced.
+   *
+   * Returns `violations` (one `{rule, text, start, end, note, suggestion}`
+   * entry per violation, most important first — `start`/`end` index the
+   * submitted text and are null when the passage cannot be located), `rules`
+   * (the checked rule names) and `compliant` (true when no violations were
+   * found). The text is checked exactly as submitted — markup is NOT
+   * stripped, so offsets always index the string you sent.
+   *
+   * @param {string|string[]} text - The text to check (the API caps it at
+   *   10,000 characters), or an array of 1–10 texts for the batch form (sent
+   *   as the API's `texts` parameter; combined length up to 10,000
+   *   characters, same rules applied to every item). A batch response is
+   *   `{results: [...]}` with one single-response-shaped entry per input, in
+   *   order, each item's violation offsets indexing that item's own text.
+   * @param {Array<string|{name: string, description?: string}>|string} rules
+   *   - 1 to 20 style rules: a rule name (max 80 chars) or a
+   *   `{name, description}` object whose optional description (max 400
+   *   chars) carries the nuance the model follows. Names must be unique
+   *   case-insensitively. OR a string: the name of a saved ruleset (see
+   *   saveStyleguideRuleset()) to check against, matched case-insensitively
+   *   within the API key's account.
+   * @returns {Promise<AxiosResponse>}
+   */
+  styleguide(text, rules) {
+    const url = `${this.urlEndpoint}styleguide`;
+
+    // Shape/type checks only. Size limits (text/rule/description length) are
+    // server configuration and enforced there with a clear 400 (see
+    // classify()).
+    // An array of texts is the batch form (SAP-412, sent as `texts`, one
+    // result per item); the 1–10 item bound is structural like classify's.
+    const isBatch = Array.isArray(text);
+    if (isBatch) {
+      // for...of (not text.every) so holes in a sparse array are visited as
+      // undefined and rejected, rather than skipped.
+      let ok = text.length >= 1 && text.length <= 10;
+      if (ok) {
+        for (const item of text) {
+          if (typeof item !== 'string' || item.trim().length === 0) {
+            ok = false;
+            break;
+          }
+        }
+      }
+      if (!ok) {
+        throw new TypeError('styleguide: texts must be an array of 1 to 10 non-empty strings.');
+      }
+    } else if (typeof text !== 'string' || text.trim().length === 0) {
+      throw new TypeError('styleguide: text must be a non-empty string.');
+    }
+
+    // A string names a saved ruleset (see saveStyleguideRuleset()) and is
+    // sent as the API's `ruleset` parameter in place of inline `rules`.
+    const isSavedRuleset = typeof rules === 'string';
+    if (isSavedRuleset) {
+      if (rules.trim().length === 0) {
+        throw new TypeError('styleguide: ruleset name must be a non-empty string.');
+      }
+    } else {
+      validateStyleguideRules(rules, 'styleguide');
+    }
+
+    let data = {
+      ...(isBatch ? { texts: text } : { text }),
+      ...(isSavedRuleset ? { ruleset: rules } : { rules }),
+      key: this.apiKey,
+    }
+
+    return this.axiosPromise(url, 'post', data);
+  }
+
+  /**
+   * List the saved style-guide rulesets of this API key's account (its team,
+   * for team-scoped keys — a team's rulesets are shared by every caller of
+   * its keys). Requires a per-account API key.
+   *
+   * Returns `rulesets`: `{name, rules, created_at, updated_at}` entries whose
+   * `rules` are the normalized `{name, description}` objects the check
+   * endpoint applies.
+   *
+   * @returns {Promise<AxiosResponse>}
+   */
+  styleguideRulesets() {
+    const url = `${this.urlEndpoint}styleguide/rulesets`;
+    // Not axiosPromise: this is a GET and the key rides the query string.
+    return axios({
+      url,
+      method: 'get',
+      params: { key: this.apiKey },
+      timeout: this.timeout,
+    });
+  }
+
+  /**
+   * Create — or replace, when the name already exists (matched
+   * case-insensitively) — a saved style-guide ruleset, so later
+   * `styleguide(text, name)` calls check against it by name. Owned by the
+   * API key's account (its team, for team-scoped keys). Requires a
+   * per-account API key.
+   *
+   * Returns `ruleset` (the saved `{name, rules, created_at, updated_at}`)
+   * and `created` (false when an existing ruleset was replaced).
+   *
+   * @param {string} name - The ruleset name (the API caps it at 100
+   *   characters; surrounding/duplicate whitespace is normalized).
+   * @param {Array<string|{name: string, description?: string}>} rules - The
+   *   rules to save; same shape and bounds as styleguide()'s inline rules.
+   * @returns {Promise<AxiosResponse>}
+   */
+  saveStyleguideRuleset(name, rules) {
+    const url = `${this.urlEndpoint}styleguide/rulesets`;
+    if (typeof name !== 'string' || name.trim().length === 0) {
+      throw new TypeError('saveStyleguideRuleset: name must be a non-empty string.');
+    }
+    validateStyleguideRules(rules, 'saveStyleguideRuleset');
+
+    let data = {
+      name,
+      rules,
+      key: this.apiKey,
+    }
+
+    return this.axiosPromise(url, 'post', data);
+  }
+
+  /**
+   * Delete a saved style-guide ruleset by name (matched case-insensitively;
+   * 404 when no such ruleset exists). Requires a per-account API key.
+   *
+   * @param {string} name - The ruleset name to delete.
+   * @returns {Promise<AxiosResponse>}
+   */
+  deleteStyleguideRuleset(name) {
+    const url = `${this.urlEndpoint}styleguide/rulesets`;
+    if (typeof name !== 'string' || name.trim().length === 0) {
+      throw new TypeError('deleteStyleguideRuleset: name must be a non-empty string.');
+    }
+    // The name rides the query string: some HTTP stacks drop DELETE bodies,
+    // and the API accepts the query form for exactly that reason.
+    return axios({
+      url,
+      method: 'delete',
+      params: { key: this.apiKey, name },
+      timeout: this.timeout,
+    });
+  }
+
+  /**
+   * Rewrite a text in plain language at a target reading level, keeping all
+   * of its content, structure and language — nothing is summarized or
+   * dropped.
+   *
+   * Returns `simplified` (the rewrite, structure preserved), the applied
+   * `reading_level`, the `lang` the readability scores were computed for
+   * (detected when not supplied) and, when that language supports scoring, a
+   * `readability` block: `{before: {grade, ease}, after: {grade, ease}}`
+   * Flesch-Kincaid scores, so the improvement is verifiable.
+   *
+   * @param {string|string[]} text - The text to simplify (the API caps it at
+   *   5,000 characters), or an array of 1–10 texts for the batch form (sent
+   *   as the API's `texts` parameter; combined length up to 5,000
+   *   characters, same options applied to every item). A batch response is
+   *   `{results: [...]}` with one single-response-shaped entry per input, in
+   *   order; with `lang` omitted, each item's language (and readability
+   *   scores) is detected on its own. Sent to the model as submitted —
+   *   markup and line structure are preserved, not stripped.
+   * @param {Object} [options]
+   * @param {string} [options.reading_level] - Target audience: 'plain'
+   *   (plain-language style for a general audience, the API default),
+   *   'elementary' (~US grade 3-5), 'middle_school' (~grade 6-8) or
+   *   'high_school' (~grade 9-10).
+   * @param {string[]} [options.preserve_terms] - Up to 20 terms (each up to
+   *   100 characters) the rewrite must keep exactly as written — product
+   *   names, defined legal terms. A rewrite that drops one is refused
+   *   server-side rather than returned.
+   * @param {string} [options.lang] - ISO 639-1 code used to pick the
+   *   readability formula for the before/after scores. Omit for
+   *   auto-detection (falls back to 'en'). The rewrite itself always stays
+   *   in the text's own language.
+   * @returns {Promise<AxiosResponse>}
+   */
+  simplify(text, options = {}) {
+    const url = `${this.urlEndpoint}simplify`;
+
+    // Shape/type checks only. Size limits (text/term length) are server
+    // configuration and enforced there with a clear 400 (see classify()).
+    // An array of texts is the batch form (SAP-412, sent as `texts`, one
+    // result per item); the 1–10 item bound is structural like classify's.
+    const isBatch = Array.isArray(text);
+    if (isBatch) {
+      // for...of (not text.every) so holes in a sparse array are visited as
+      // undefined and rejected, rather than skipped.
+      let ok = text.length >= 1 && text.length <= 10;
+      if (ok) {
+        for (const item of text) {
+          if (typeof item !== 'string' || item.trim().length === 0) {
+            ok = false;
+            break;
+          }
+        }
+      }
+      if (!ok) {
+        throw new TypeError('simplify: texts must be an array of 1 to 10 non-empty strings.');
+      }
+    } else if (typeof text !== 'string' || text.trim().length === 0) {
+      throw new TypeError('simplify: text must be a non-empty string.');
+    }
+
+    let data = {
+      ...(isBatch ? { texts: text } : { text }),
+      key: this.apiKey,
+    }
+
+    // `!== undefined` (not `!= null`) so an explicit `null` is rejected as a
+    // bad type rather than silently treated as "omitted" (same as translate's
+    // option handling).
+    if (options?.reading_level !== undefined) {
+      if (!SIMPLIFY_READING_LEVELS.includes(options.reading_level)) {
+        throw new TypeError('simplify: reading_level must be one of '
+          + `${SIMPLIFY_READING_LEVELS.join(', ')}.`);
+      }
+      data.reading_level = options.reading_level;
+    }
+    if (options?.preserve_terms !== undefined) {
+      const terms = options.preserve_terms;
+      // An empty list is a valid no-op (callers may build it dynamically); it
+      // is simply omitted from the payload below rather than rejected.
+      // for...of (not terms.every) so holes in a sparse array are visited as
+      // undefined and rejected, rather than skipped.
+      let ok = Array.isArray(terms) && terms.length <= 20;
+      if (ok) {
+        for (const term of terms) {
+          if (typeof term !== 'string' || term.trim().length === 0) {
+            ok = false;
+            break;
+          }
+        }
+      }
+      if (!ok) {
+        throw new TypeError('simplify: preserve_terms must be an array of up to 20 '
+          + 'non-empty strings.');
+      }
+      if (terms.length > 0) {
+        data.preserve_terms = terms;
+      }
+    }
+    if (options?.lang !== undefined) {
+      if (typeof options.lang !== 'string' || options.lang.trim().length === 0) {
+        throw new TypeError('simplify: lang must be a non-empty string.');
+      }
+      data.lang = options.lang;
+    }
+
+    return this.axiosPromise(url, 'post', data);
+  }
+
   pii(text, options = {}) {
     const url = `${this.urlEndpoint}pii`;
 
@@ -577,4 +1161,106 @@ export class Client {
 
     return this.axiosPromise(url, 'post', data);
   }
+
+  /**
+   * Named-entity recognition: people, organizations, locations, dates, times,
+   * money amounts, percentages, quantities, products, and events, each with
+   * character offsets into the exact text submitted (nothing is stripped or
+   * normalized, so spans apply directly to your copy of the document).
+   * Complements pii(): that finds checksum-validated identifiers, this finds
+   * names and real-world references.
+   *
+   * @param {string|string[]} text - The text to analyze, or an array of 1–10
+   *   texts for the batch form (sent as the API's `texts` parameter; combined
+   *   length up to 10,000 characters, same types applied to every item). A
+   *   batch response is `{results: [...]}` with one single-response-shaped
+   *   entry per input, in order, each item's spans indexing that item's own
+   *   text.
+   * @param {Object} [options]
+   * @param {string[]} [options.types] - Entity types to recognize (subset of
+   *   the API's supported types). Default: all of them.
+   */
+  ner(text, options = {}) {
+    const url = `${this.urlEndpoint}ner`;
+
+    // Shape/type checks only; the set of valid entity types is server
+    // configuration and enforced there with a clear 400 (see pii()).
+    // An array of texts is the batch form (SAP-395 series, sent as `texts`,
+    // one result per item); the 1–10 item bound is structural like classify's.
+    const isBatch = Array.isArray(text);
+    if (isBatch) {
+      // for...of (not text.every) so holes in a sparse array are visited as
+      // undefined and rejected, rather than skipped.
+      let ok = text.length >= 1 && text.length <= 10;
+      if (ok) {
+        for (const item of text) {
+          if (typeof item !== 'string' || item.trim().length === 0) {
+            ok = false;
+            break;
+          }
+        }
+      }
+      if (!ok) {
+        throw new TypeError('ner: texts must be an array of 1 to 10 non-empty strings.');
+      }
+    } else if (typeof text !== 'string' || text.trim().length === 0) {
+      throw new TypeError('ner: text must be a non-empty string.');
+    }
+
+    let data = {
+      ...(isBatch ? { texts: text } : { text }),
+      key: this.apiKey,
+    }
+
+    // `!== undefined` (not `!= null`) so an explicit `null` is rejected as a bad
+    // type rather than silently treated as "omitted", matching pii().
+    // Reject an empty list too: the MCP schema requires at least one type
+    // (min(1)), so an empty array is typed-valid input that would otherwise
+    // become an avoidable API error.
+    if (options?.types !== undefined) {
+      if (!Array.isArray(options.types) || options.types.length === 0
+        || !Array.from(options.types).every((type) => typeof type === 'string' && type.trim().length > 0)) {
+        throw new TypeError('ner: types must be a non-empty array of non-empty strings.');
+      }
+      data.types = options.types;
+    }
+
+    return this.axiosPromise(url, 'post', data);
+  }
+
+  /**
+   * Check whether an account-wide block (expired key/subscription,
+   * depleted credits, billing limit, trial daily allowance, monthly quota)
+   * stops this API key from making billable calls, and if so why and for
+   * how long. Works while the key is blocked, which is when it is most
+   * useful: call it after an unexpected 402 or monthly-quota 429 instead of
+   * parsing the error text. It does not reflect a single endpoint's
+   * short-term rate limit (each endpoint has its own bucket), so a
+   * "Capacity used." 429 elsewhere can coexist with api_access: true — use
+   * that 429's retry_after / X-RateLimit-* headers instead. Unbilled, but each call draws a fixed 2,000
+   * characters from its own rate-limit bucket, so don't poll it per request.
+   * Requires a per-account API key; the public demo key and MCP OAuth
+   * access tokens get a 403.
+   *
+   * Always returns `api_access`, `blocked_reason` (null, or one of
+   * key_expired, subscription_expired, credits_depleted,
+   * monthly_billing_limit, trial_daily_limit, monthly_quota_exhausted),
+   * `message` and `usage` ({monthly_quota_chars}); `retry_after` (seconds)
+   * only when blocked. Keys that are not team-scoped also get
+   * `usage.month_start`/`usage.chars_this_month`, `subscription`, `credits`
+   * and, for free-trial accounts, `trial`.
+   *
+   * @returns {Promise<AxiosResponse>}
+   */
+  accountStatus() {
+    const url = `${this.urlEndpoint}account/status`;
+    // Not axiosPromise: this is a GET and the key rides the query string,
+    // like styleguideRulesets().
+    return axios({
+      url,
+      method: 'get',
+      params: { key: this.apiKey },
+      timeout: this.timeout,
+    });
+  }
 }