@lionrapid/cli 0.2.1 → 0.3.0

package/dist/commands/push.js

@@ -5,6 +5,11 @@
  * rows via `sync/batch`; the server then queues machine translation for the
  * configured target locales.
  *
+ * `sync/batch` answers 202 Accepted — the rows are QUEUED, not yet stored. So
+ * every batch also yields job ids ({@link PushedJob}), which is the only thing
+ * that lets a caller tell "the backend stored this" from "the backend dropped
+ * it". Without them a push that dead-letters looks exactly like one that worked.
+ *
  * `--target <locale>` mode uploads an already-translated target file as drafts
  * via `targets/batch`, optionally publishing them with `--publish`.
  */
@@ -13,6 +18,8 @@ import { resolve } from 'node:path';
 import { ConfigError } from '../config.js';
 import { getAdapter } from '../adapters/index.js';
 import { chunk } from './context.js';
+// The server's enforced ceiling is 1000 items per sync/targets batch (Pydantic
+// `max_length` on the request model) — 500 stays comfortably under it.
 const BATCH = 500;
 export async function runPush(config, client, opts) {
     const mode = opts.target ? 'target' : 'source';
@@ -27,11 +34,13 @@ export async function runPush(config, client, opts) {
             'it in the dashboard before pushing target translations.');
     }
     const files = [];
+    const jobs = [];
     // Publishing (mark-ready) needs an editor token; if asked to publish without
     // one, we still upload the drafts and report that publishing was skipped.
     const canPublish = mode === 'target' && opts.publish === true && client.canPublish;
     const publishSkipped = mode === 'target' && opts.publish === true && !client.canPublish;
     let pushed = 0;
+    let firstError;
     for (const file of config.files) {
         const adapter = getAdapter(file.format);
         const namespace = file.namespace ?? config.namespace;
@@ -41,32 +50,68 @@ export async function runPush(config, client, opts) {
             files.push({ file: relPath, count: 0, skipped: true });
             continue;
         }
-        const parseLocale = mode === 'source' ? config.sourceLocale : opts.target;
-        const entries = adapter.parse(readFileSync(absPath, 'utf8'), { locale: parseLocale });
-        const items = entries.map((e) => ({ key: e.key, value: e.value }));
-        // Dry run: parse + count only, never touch the network.
-        if (!opts.dryRun) {
-            for (const batch of chunk(items, BATCH)) {
-                if (mode === 'source') {
-                    await client.syncBatch(config.sourceLocale, namespace, batch);
-                }
-                else {
-                    await client.targetsBatch(opts.target, namespace, batch);
-                    if (canPublish) {
-                        for (const it of batch) {
-                            await client.markReady(opts.target, namespace, it.key);
+        // One bad file/namespace must not zero out the rest of the push (a rate
+        // limit on a many-namespace site, one corrupt file). Record the failure
+        // and move on — sync/batch upserts by composite key, so re-running push
+        // retries just the failures (partial progress, exit 5).
+        try {
+            const parseLocale = mode === 'source' ? config.sourceLocale : opts.target;
+            const entries = adapter.parse(readFileSync(absPath, 'utf8'), { locale: parseLocale });
+            const items = entries.map((e) => ({ key: e.key, value: e.value }));
+            // Dry run: parse + count only, never touch the network.
+            if (!opts.dryRun) {
+                for (const batch of chunk(items, BATCH)) {
+                    if (mode === 'source') {
+                        const queued = await client.syncBatch(config.sourceLocale, namespace, batch);
+                        // Every id, not just job_id: a batch spanning several locales queues
+                        // one job each, and the ones after the first would otherwise be
+                        // unobservable. Reported as they happen so a later total failure
+                        // cannot take the earlier receipts down with it.
+                        for (const id of queued.job_ids) {
+                            const job = {
+                                id,
+                                file: relPath,
+                                namespace,
+                                keys: batch.length,
+                                status: queued.status || 'pending',
+                            };
+                            jobs.push(job);
+                            opts.onJob?.(job);
+                        }
+                    }
+                    else {
+                        await client.targetsBatch(opts.target, namespace, batch);
+                        if (canPublish) {
+                            for (const it of batch) {
+                                await client.markReady(opts.target, namespace, it.key);
+                            }
                         }
                     }
                 }
             }
+            pushed += items.length;
+            files.push({ file: relPath, count: items.length });
+        }
+        catch (err) {
+            firstError ??= err;
+            files.push({
+                file: relPath,
+                count: 0,
+                error: err instanceof Error ? err.message : String(err),
+            });
         }
-        pushed += items.length;
-        files.push({ file: relPath, count: items.length });
+    }
+    // Partial progress is a result; total failure keeps today's error contract —
+    // rethrow the first error so the exit-code mapping is unchanged.
+    const attempted = files.filter((f) => !f.skipped);
+    if (attempted.length > 0 && attempted.every((f) => f.error) && firstError !== undefined) {
+        throw firstError;
     }
     return {
         mode,
         pushed,
         files,
+        jobs,
         ...(publishSkipped ? { publishSkipped: true } : {}),
         ...(opts.dryRun ? { dryRun: true } : {}),
     };

package/dist/commands/snapshot.js

@@ -13,7 +13,8 @@
  * surface with no re-derivation.
  */
 import { mkdirSync, writeFileSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
+import { dirname } from 'node:path';
+import { assertInside } from './context.js';
 export const DEFAULT_SNAPSHOT_DIR = 'snapshots';
 export async function runSnapshot(config, client, opts) {
     const out = opts.out ?? DEFAULT_SNAPSHOT_DIR;
@@ -41,7 +42,7 @@ export async function runSnapshot(config, client, opts) {
                 translations: bundle.translations, // raw — styles preserved
             };
             const rel = `${out}/${locale}.${namespace}.json`;
-            const abs = resolve(opts.cwd, rel);
+            const abs = assertInside(opts.cwd, rel);
             mkdirSync(dirname(abs), { recursive: true });
             writeFileSync(abs, `${JSON.stringify(snapshot, null, 2)}\n`);
             files.push({ path: rel, locale, namespace, keys });

package/dist/commands/status.d.ts

@@ -0,0 +1,76 @@
+/**
+ * `status` — answer the question a 202 leaves open: did the backend actually
+ * store what `push` sent?
+ *
+ * `push` reports what the CLI put on the wire. The server queues that work and
+ * answers 202, so a clean push is still compatible with the job failing later.
+ * This command closes the loop three ways:
+ *
+ *   status <job-id>  → GET /sync/jobs/{id}, the server's own verdict
+ *   status [list]    → every job this machine pushed, newest first
+ *   (nothing local)  → fall back to queue-health + the dead-letter queue
+ *
+ * Everything degrades. With no network, the local history is still shown and
+ * every line is marked as last-known rather than current; with no config or API
+ * key (running from some other directory) the disk view still works.
+ */
+import { type LionRapidApiClient, type QueueHealth, type SyncJobStatus } from '../api-client.js';
+import { type JobHistoryEntry } from '../job-history.js';
+/** Where a line's status came from — the difference between "is" and "was". */
+export type StatusSource = 
+/** Fetched from the server just now. */
+'server'
+/** Read from `~/.lionrapid/jobs.json` — last known, not current. */
+ | 'local'
+/** Terminal on disk: last known IS current, the server cannot change it. */
+ | 'local-final';
+export interface JobView {
+    id: string;
+    status: string;
+    source: StatusSource;
+    /** What this machine recorded when it pushed (absent for a server-only job). */
+    history?: JobHistoryEntry;
+    /** The server's answer (absent when offline, or when answered from disk). */
+    job?: SyncJobStatus;
+}
+export interface StatusResult {
+    mode: 'job' | 'list';
+    jobs: JobView[];
+    /** Path of the history file the listing came from. */
+    historyPath: string;
+    /** Set when the server could not be reached — everything shown is last-known. */
+    offline?: string;
+    /** Queue fallback, only when there is nothing local to show. */
+    queue?: QueueHealth;
+    deadLettered?: SyncJobStatus[];
+    /** Why the queue fallback is missing (e.g. the key lacks `ops:queue`). */
+    queueUnavailable?: string;
+    /** `status <id>`: the id is known neither to the server nor to this machine. */
+    notFound?: boolean;
+}
+export interface StatusOptions {
+    /** A job id, `list`, or nothing (both of the latter mean "list"). */
+    jobId?: string;
+    /** Override the history file (tests; also keeps a push's receipts together). */
+    historyPath?: string;
+    /**
+     * The API client. Omitted when there is no config/API key here — the command
+     * then reports from disk only.
+     */
+    client?: LionRapidApiClient;
+    /** Limit the listing to jobs pushed to this server. */
+    server?: string;
+}
+/** True for the bare command and the explicit `list` form. */
+export declare function isListRequest(jobId?: string): boolean;
+export declare function runStatus(opts?: StatusOptions): Promise<StatusResult>;
+/**
+ * One-line verdict for a job state, in the terms the incident was about: were
+ * these rows stored or not. Shared by the detail and list renderings.
+ */
+export declare function explainStatus(view: JobView): {
+    icon: string;
+    label: string;
+    detail: string;
+};
+//# sourceMappingURL=status.d.ts.map

package/dist/commands/status.js

@@ -0,0 +1,221 @@
+/**
+ * `status` — answer the question a 202 leaves open: did the backend actually
+ * store what `push` sent?
+ *
+ * `push` reports what the CLI put on the wire. The server queues that work and
+ * answers 202, so a clean push is still compatible with the job failing later.
+ * This command closes the loop three ways:
+ *
+ *   status <job-id>  → GET /sync/jobs/{id}, the server's own verdict
+ *   status [list]    → every job this machine pushed, newest first
+ *   (nothing local)  → fall back to queue-health + the dead-letter queue
+ *
+ * Everything degrades. With no network, the local history is still shown and
+ * every line is marked as last-known rather than current; with no config or API
+ * key (running from some other directory) the disk view still works.
+ */
+import { ApiError, NetworkError, } from '../api-client.js';
+import { defaultJobHistoryPath, isTerminalJobStatus, readJobHistory, updateJobStatuses, } from '../job-history.js';
+import { mapLimit } from './context.js';
+/**
+ * How many stale (non-terminal) jobs a bare `status` re-checks against the
+ * server. A listing is a glance, not a poll loop: the newest unresolved jobs
+ * are the ones anyone is actually waiting on, and the rest still print from
+ * disk — labelled as such, never silently stale.
+ */
+const MAX_REFRESH = 20;
+const REFRESH_CONCURRENCY = 4;
+/** True for the bare command and the explicit `list` form. */
+export function isListRequest(jobId) {
+    return jobId === undefined || jobId === 'list';
+}
+export async function runStatus(opts = {}) {
+    const historyPath = opts.historyPath ?? defaultJobHistoryPath();
+    const history = readJobHistory(historyPath);
+    return isListRequest(opts.jobId)
+        ? listJobs(history, historyPath, opts)
+        : showJob(opts.jobId, history, historyPath, opts);
+}
+/** `status <job-id>` — the server's verdict, or the local receipt if it can't answer. */
+async function showJob(jobId, history, historyPath, opts) {
+    const recorded = history.find((e) => e.id === jobId);
+    const base = { mode: 'job', jobs: [], historyPath };
+    // Already final: the server cannot change its mind, and after ~1h it has
+    // forgotten the job entirely. Answer from the receipt and skip the call.
+    if (recorded && isTerminalJobStatus(recorded.status)) {
+        return { ...base, jobs: [localView(recorded)] };
+    }
+    if (!opts.client) {
+        // No client at all (no config or no key here). The receipt is all there is.
+        return recorded
+            ? { ...base, jobs: [localView(recorded)], offline: 'no API key or project config here' }
+            : { ...base, notFound: true, offline: 'no API key or project config here' };
+    }
+    try {
+        const job = await opts.client.getSyncJob(jobId);
+        if (recorded) {
+            persist(historyPath, [patchFor(job)]);
+        }
+        return { ...base, jobs: [{ id: jobId, status: job.status, source: 'server', history: recorded, job }] };
+    }
+    catch (err) {
+        // A 404 is an answer, not a failure: the id is unknown, or the job finished
+        // long enough ago that the server purged it (~1h retention). A job we
+        // already knew to be final never reaches here — it short-circuits above.
+        if (err instanceof ApiError && err.status === 404) {
+            if (recorded) {
+                persist(historyPath, [{ id: jobId, status: 'gone', checkedAt: new Date().toISOString() }]);
+                return { ...base, jobs: [{ ...localView({ ...recorded, status: 'gone' }), source: 'server' }] };
+            }
+            return { ...base, notFound: true };
+        }
+        if (!(err instanceof NetworkError))
+            throw err;
+        // Unreachable server: show the receipt, clearly marked as last-known.
+        if (!recorded)
+            return { ...base, notFound: true, offline: err.message };
+        return { ...base, jobs: [localView(recorded)], offline: err.message };
+    }
+}
+/** Bare `status` / `status list` — the local job log, refreshed where it matters. */
+async function listJobs(history, historyPath, opts) {
+    const scoped = opts.server ? history.filter((e) => e.server === opts.server) : history;
+    if (scoped.length === 0) {
+        // Nothing local — ask the server what its queue looks like instead of
+        // shrugging. This is also the honest answer for "I pushed from another
+        // machine / another checkout".
+        return { mode: 'list', jobs: [], historyPath, ...(await queueFallback(opts.client)) };
+    }
+    const stale = scoped.filter((e) => !isTerminalJobStatus(e.status)).slice(0, MAX_REFRESH);
+    const views = new Map();
+    let offline;
+    if (opts.client && stale.length > 0) {
+        const client = opts.client;
+        const patches = [];
+        const refreshed = await mapLimit(stale, REFRESH_CONCURRENCY, async (entry) => {
+            try {
+                return await client.getSyncJob(entry.id);
+            }
+            catch (err) {
+                if (err instanceof ApiError && err.status === 404)
+                    return 'gone';
+                if (err instanceof NetworkError) {
+                    offline ??= err.message;
+                    return undefined;
+                }
+                throw err;
+            }
+        });
+        refreshed.forEach((job, i) => {
+            const entry = stale[i];
+            if (job === undefined)
+                return;
+            if (job === 'gone') {
+                patches.push({ id: entry.id, status: 'gone', checkedAt: new Date().toISOString() });
+                views.set(entry.id, { id: entry.id, status: 'gone', source: 'server', history: entry });
+                return;
+            }
+            patches.push(patchFor(job));
+            views.set(entry.id, { id: entry.id, status: job.status, source: 'server', history: entry, job });
+        });
+        persist(historyPath, patches);
+    }
+    else if (!opts.client) {
+        offline = 'no API key or project config here';
+    }
+    const jobs = scoped.map((entry) => views.get(entry.id) ?? localView(entry));
+    return { mode: 'list', jobs, historyPath, ...(offline ? { offline } : {}) };
+}
+/** Queue-wide view for when this machine has no receipts to show. */
+async function queueFallback(client) {
+    if (!client)
+        return { queueUnavailable: 'no API key or project config here' };
+    try {
+        const [queue, deadLettered] = await Promise.all([
+            client.getQueueHealth(),
+            client.getDeadLetterQueue(),
+        ]);
+        return { queue, deadLettered };
+    }
+    catch (err) {
+        if (err instanceof NetworkError)
+            return { offline: err.message };
+        // 403 is the common one: queue introspection needs the `ops:queue` scope,
+        // which publishable pk_ keys do not carry.
+        if (err instanceof ApiError) {
+            return {
+                queueUnavailable: err.status === 403
+                    ? 'this API key may not read the queue (needs a master key)'
+                    : `server returned ${err.status}`,
+            };
+        }
+        throw err;
+    }
+}
+function localView(entry) {
+    return {
+        id: entry.id,
+        status: entry.status,
+        source: isTerminalJobStatus(entry.status) ? 'local-final' : 'local',
+        history: entry,
+    };
+}
+function patchFor(job) {
+    return {
+        id: job.jobId,
+        status: job.status,
+        checkedAt: new Date().toISOString(),
+        error: job.error,
+        deadLetterReason: job.deadLetterReason,
+    };
+}
+/** History writes are best-effort — a read-only home must not fail `status`. */
+function persist(historyPath, patches) {
+    if (patches.length > 0)
+        updateJobStatuses(patches, historyPath);
+}
+/**
+ * One-line verdict for a job state, in the terms the incident was about: were
+ * these rows stored or not. Shared by the detail and list renderings.
+ */
+export function explainStatus(view) {
+    const dead = view.job?.isDeadLettered === true || view.status === 'failed';
+    switch (true) {
+        case dead:
+            return {
+                icon: '✖',
+                label: 'dead-lettered',
+                detail: 'the backend gave up — these rows were NOT stored',
+            };
+        case view.status === 'completed':
+            return { icon: '✓', label: 'completed', detail: storedDetail(view) };
+        case view.status === 'retry_pending':
+            return {
+                icon: '⚠',
+                label: 'retrying',
+                detail: 'a previous attempt failed; the backend will try again',
+            };
+        case view.status === 'processing':
+            return { icon: '·', label: 'processing', detail: 'the backend is storing these rows now' };
+        case view.status === 'pending':
+            return { icon: '·', label: 'queued', detail: 'accepted, not stored yet' };
+        case view.status === 'gone':
+            return {
+                icon: '?',
+                label: 'gone',
+                detail: 'the server no longer has this job — finished jobs are kept ~1h',
+            };
+        default:
+            return { icon: '?', label: view.status || 'unknown', detail: '' };
+    }
+}
+/** "128 key(s) stored (5 added, 3 updated)" when the server reported counts. */
+function storedDetail(view) {
+    const result = view.job?.result;
+    const added = typeof result?.['keys_added'] === 'number' ? result['keys_added'] : undefined;
+    const updated = typeof result?.['keys_updated'] === 'number' ? result['keys_updated'] : undefined;
+    if (added === undefined && updated === undefined)
+        return 'the rows were stored';
+    return `stored — ${added ?? 0} added, ${updated ?? 0} updated`;
+}
+//# sourceMappingURL=status.js.map

package/dist/commands/types.js

@@ -14,6 +14,7 @@ import { dirname, resolve } from 'node:path';
 import { getAdapter } from '../adapters/index.js';
 import { generateDts } from '../types-gen/generate.js';
 import { extractParams, IcuError } from '../types-gen/extract.js';
+import { assertInside } from './context.js';
 const DEFAULT_OUTPUT = 'types/translations.d.ts';
 /** Map every source key to its ICU message text (first definition wins). */
 export function collectSourceKeyTexts(config, cwd) {
@@ -50,7 +51,7 @@ export async function collectServerKeyTexts(config, client) {
 function writeDts(keyTexts, config, opts) {
     const dts = generateDts(keyTexts, { strictIcu: opts.strictIcu });
     const output = opts.output ?? config.typesOutput ?? DEFAULT_OUTPUT;
-    const abs = resolve(opts.cwd, output);
+    const abs = assertInside(opts.cwd, output);
     mkdirSync(dirname(abs), { recursive: true });
     writeFileSync(abs, dts);
     return { keys: keyTexts.size, output };

package/dist/commands/validate.d.ts

@@ -9,12 +9,13 @@
  */
 import type { LionRapidConfig } from '../config.js';
 import type { LionRapidApiClient } from '../api-client.js';
-export type ValidateIssueType = 'missing' | 'empty' | 'orphan';
+export type ValidateIssueType = 'missing' | 'empty' | 'orphan' | 'locked';
 export interface ValidateIssue {
     locale: string;
     namespace: string;
     type: ValidateIssueType;
-    key: string;
+    /** Absent for namespace-level issues (`locked`). */
+    key?: string;
 }
 export interface ValidateResult {
     ok: boolean;
@@ -23,6 +24,8 @@ export interface ValidateResult {
 }
 export interface ValidateOptions {
     cwd: string;
+    /** Treat locked (423) namespaces as a warning instead of a failure. */
+    allowLocked?: boolean;
 }
 export declare function runValidate(config: LionRapidConfig, client: LionRapidApiClient, opts: ValidateOptions): Promise<ValidateResult>;
 //# sourceMappingURL=validate.d.ts.map

package/dist/commands/validate.js

@@ -29,6 +29,12 @@ export async function runValidate(config, client, opts) {
     for (const locale of config.targetLocales) {
         for (const [namespace, sourceKeys] of sourceByNs) {
             const bundle = await client.getNamespace(locale, namespace);
+            // A locked (423) namespace has nothing approved for delivery yet — one
+            // namespace-level issue, not N spurious `missing` per source key.
+            if (bundle.locked) {
+                issues.push({ locale, namespace, type: 'locked' });
+                continue;
+            }
             const translations = bundle.translations;
             const have = new Set(Object.keys(translations));
             for (const key of sourceKeys) {
@@ -36,13 +42,20 @@ export async function runValidate(config, client, opts) {
                     issues.push({ locale, namespace, type: 'missing', key });
             }
             for (const [key, value] of Object.entries(translations)) {
-                if (!value.text.trim())
+                // Defensive: a value that isn't a real ContentUnit counts as empty
+                // rather than crashing the run (the client normalizes these, but
+                // `validate` is also driven directly in tests and by embedders).
+                if (typeof value?.text !== 'string' || !value.text.trim()) {
                     issues.push({ locale, namespace, type: 'empty', key });
+                }
                 if (!sourceKeys.has(key))
                     issues.push({ locale, namespace, type: 'orphan', key });
             }
         }
     }
-    return { ok: issues.length === 0, sourceKeys: totalSourceKeys, issues };
+    // `locked` fails by default (nothing is deliverable); `allowLocked`
+    // downgrades it so brand-new namespaces don't block CI.
+    const blocking = opts.allowLocked ? issues.filter((i) => i.type !== 'locked') : issues;
+    return { ok: blocking.length === 0, sourceKeys: totalSourceKeys, issues };
 }
 //# sourceMappingURL=validate.js.map

package/dist/config.d.ts

@@ -17,14 +17,29 @@ export type FileFormat = (typeof FILE_FORMATS)[number];
  * `target` path is one shared file and does not need a `{locale}` placeholder.
  */
 export declare const MULTI_LOCALE_FORMATS: ReadonlySet<FileFormat>;
-/** One source→target file mapping. `target` carries a `{locale}` placeholder. */
+/**
+ * One source→target file mapping. `target` carries a `{locale}` placeholder.
+ *
+ * `source` may be a glob (`*`/`?`, e.g. `locales/en/*.json`); then `target`
+ * and `namespace` must carry a `{basename}` token, and the entry expands at
+ * config load ({@link expandGlobEntries}) into one concrete entry per matched
+ * file with `{basename}` replaced by the file's extension-less name.
+ */
 export interface FileEntry {
     format: FileFormat;
     source: string;
     target: string;
     /** Optional per-entry namespace override (defaults to the top-level namespace). */
     namespace?: string;
+    /**
+     * Write dotted keys flat on `pull` (JSON/YAML only): a pushed `hero.title`
+     * stays `"hero.title"` instead of re-nesting into `{hero: {title}}`, so
+     * flat-keyed consumers (CMS imports, webhook payloads) round-trip.
+     */
+    flat?: boolean;
 }
+/** True when a `files[].source` is a glob pattern rather than a concrete path. */
+export declare function isGlobSource(source: string): boolean;
 export interface LionRapidConfig {
     project: string;
     server: string;
@@ -60,8 +75,33 @@ export declare class ApiKeyError extends Error {
 export declare function findConfigPath(cwd?: string): string | null;
 /** Parse + validate a YAML config string into a typed config. */
 export declare function parseConfig(rawYaml: string): LionRapidConfig;
+/**
+ * Expand glob `files` entries into one concrete entry per matched file: the
+ * match's extension-less basename substitutes the `{basename}` token in
+ * `target` and `namespace`. Non-glob entries pass through untouched; matches
+ * come back sorted (deterministic expansion). A glob matching nothing warns
+ * instead of silently vanishing — a typo'd pattern must not no-op a push.
+ *
+ * Called at config load (loadOfflineContext / doctor), so every command
+ * downstream only ever sees concrete entries.
+ */
+export declare function expandGlobEntries(files: FileEntry[], cwd: string, warn?: (message: string) => void): FileEntry[];
 /** Read + parse + validate the config at `path`. */
 export declare function loadConfig(path: string): LionRapidConfig;
+/** Where the CLI reads/writes credentials: `~/.lionrapid/credentials`. */
+export declare function defaultCredentialsPath(): string;
+/**
+ * Reject a key that can't travel in an HTTP header (fetch encodes headers as
+ * Latin-1 and throws an obscure ByteString error otherwise). The classic case
+ * is copying the dashboard's truncated key display, `sk_eng_…last4` — that
+ * ellipsis is U+2026, not part of the key.
+ */
+export declare function assertKeyCharset(key: string): string;
+/**
+ * Server URLs that have a scoped entry in the credentials file. Lets `init`
+ * default its server to the one you just logged into instead of asking again.
+ */
+export declare function listCredentialServers(credentialsPath?: string): string[];
 export interface ResolveApiKeyOptions {
     /** Environment to read `LIONRAPID_API_KEY` from (defaults to process.env). */
     env?: NodeJS.ProcessEnv;