@tillstack/cli 0.2.0

package/dist/api.js

@@ -0,0 +1,759 @@
+import { readFileSync } from 'node:fs';
+import { basename } from 'node:path';
+export class ApiError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+function authHeaders(opts) {
+    return opts.token ? { Authorization: `Bearer ${opts.token}` } : {};
+}
+async function parse(res) {
+    const text = await res.text().catch(() => '');
+    if (!res.ok) {
+        // Surface the server's error message when it sent JSON `{ error }`.
+        let msg = `${res.status}`;
+        try {
+            const j = JSON.parse(text);
+            if (typeof j.error === 'string')
+                msg = `${res.status}: ${j.error}`;
+            else
+                msg = `${res.status}: ${text.slice(0, 300)}`;
+        }
+        catch {
+            msg = `${res.status}: ${text.slice(0, 300)}`;
+        }
+        throw new ApiError(res.status, msg);
+    }
+    if (!text)
+        return undefined;
+    return JSON.parse(text);
+}
+/** Generic JSON request against the dashboard API. */
+export async function request(opts, method, path, body) {
+    const headers = { ...authHeaders(opts) };
+    let payload;
+    if (body !== undefined) {
+        headers['Content-Type'] = 'application/json';
+        payload = JSON.stringify(body);
+    }
+    const res = await fetch(`${opts.apiUrl}${path}`, {
+        method,
+        headers,
+        ...(payload !== undefined ? { body: payload } : {}),
+    });
+    return parse(res);
+}
+export function listStacks(opts) {
+    return request(opts, 'GET', '/api/stacks');
+}
+export function createStack(opts, input) {
+    return request(opts, 'POST', '/api/stacks', input);
+}
+export function getStack(opts, slug) {
+    return request(opts, 'GET', `/api/stacks/${encodeURIComponent(slug)}`);
+}
+export function updateStack(opts, slug, patch) {
+    return request(opts, 'PATCH', `/api/stacks/${encodeURIComponent(slug)}`, patch);
+}
+export function deleteStack(opts, slug) {
+    return request(opts, 'DELETE', `/api/stacks/${encodeURIComponent(slug)}`);
+}
+export function setStackModule(opts, slug, module, status) {
+    return request(opts, 'PATCH', `/api/stacks/${encodeURIComponent(slug)}/modules`, { module, status });
+}
+export function setStackResource(opts, slug, module, resourceId, action) {
+    return request(opts, 'PATCH', `/api/stacks/${encodeURIComponent(slug)}/resources`, {
+        module,
+        resource_id: resourceId,
+        action,
+    });
+}
+// ── Auth ────────────────────────────────────────────────────────────────────
+export async function login(opts, email, password, totp) {
+    const res = await fetch(`${opts.apiUrl}/api/auth/login`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'X-Token-In-Body': '1' },
+        body: JSON.stringify({ email, password, ...(totp ? { totp_token: totp } : {}) }),
+    });
+    const data = (await parse(res)) ?? {};
+    if (data.totp_required)
+        return { token: '', org: data.org ?? '', totpRequired: true };
+    if (!data.access_token)
+        throw new ApiError(500, 'login: server did not return access_token');
+    return {
+        token: data.access_token,
+        ...(data.refresh_token ? { refresh: data.refresh_token } : {}),
+        org: data.org ?? '',
+    };
+}
+export function getMe(opts) {
+    return request(opts, 'GET', '/api/me');
+}
+export function listProjects(opts) {
+    return request(opts, 'GET', '/api/projects');
+}
+export function createProject(opts, name, platform) {
+    return request(opts, 'POST', '/api/projects', { name, platform });
+}
+export function getProject(opts, projectId) {
+    return request(opts, 'GET', `/api/projects/${encodeURIComponent(projectId)}`);
+}
+export function rotateDsn(opts, projectId) {
+    return request(opts, 'POST', `/api/projects/${encodeURIComponent(projectId)}/rotate-dsn`, {});
+}
+export function listIssues(opts, params = {}) {
+    const q = new URLSearchParams();
+    // snake_case is the canonical query-param spelling across the API.
+    if (params.projectId)
+        q.set('project_id', params.projectId);
+    if (params.limit)
+        q.set('limit', String(params.limit));
+    const qs = q.toString();
+    return request(opts, 'GET', `/api/issues${qs ? `?${qs}` : ''}`);
+}
+export function getIssue(opts, issueId) {
+    return request(opts, 'GET', `/api/issues/${encodeURIComponent(issueId)}`);
+}
+// ── TillPulse: metrics / performance / alerts ────────────────────────────────
+export function getMetrics(opts, projectId) {
+    const qs = projectId ? `?project_id=${encodeURIComponent(projectId)}` : '';
+    return request(opts, 'GET', `/api/metrics${qs}`);
+}
+export function listAlerts(opts, limit) {
+    const qs = limit ? `?limit=${limit}` : '';
+    return request(opts, 'GET', `/api/alerts/recent${qs}`);
+}
+export function listAlertRules(opts, projectId) {
+    const qs = projectId ? `?project_id=${encodeURIComponent(projectId)}` : '';
+    return request(opts, 'GET', `/api/alerts${qs}`);
+}
+// ── TillPulse: releases ──────────────────────────────────────────────────────
+export function createRelease(opts, projectId, body) {
+    return request(opts, 'POST', `/api/projects/${encodeURIComponent(projectId)}/releases`, body);
+}
+// ── TillPulse: symbol uploads ────────────────────────────────────────────────
+async function uploadForm(opts, path, fields, filePath) {
+    const buf = readFileSync(filePath);
+    const fd = new FormData();
+    for (const [k, v] of Object.entries(fields))
+        fd.append(k, v);
+    fd.append('file', new Blob([buf]), basename(filePath));
+    const res = await fetch(`${opts.apiUrl}${path}`, { method: 'POST', headers: authHeaders(opts), body: fd });
+    return parse(res);
+}
+export function uploadSourceMap(opts, projectId, p) {
+    return uploadForm(opts, `/api/projects/${encodeURIComponent(projectId)}/source-maps`, { release: p.release, symbolication_type: 'js_source_map' }, p.filePath);
+}
+export function uploadProguardMapping(opts, projectId, p) {
+    return uploadForm(opts, `/api/projects/${encodeURIComponent(projectId)}/source-maps`, { release: p.release, symbolication_type: 'proguard' }, p.filePath);
+}
+export function uploadDsym(opts, projectId, p) {
+    return uploadForm(opts, `/api/projects/${encodeURIComponent(projectId)}/dsyms`, { release: p.release }, p.filePath);
+}
+export function listApiKeys(opts) {
+    return request(opts, 'GET', '/api/api-keys');
+}
+export function createApiKey(opts, name, scopes) {
+    return request(opts, 'POST', '/api/api-keys', { name, scopes });
+}
+export function listAuthApps(opts) {
+    return request(opts, 'GET', '/api/auth/admin/apps');
+}
+export function createAuthApp(opts, name) {
+    return request(opts, 'POST', '/api/auth/admin/apps', { name });
+}
+export function getAuthApp(opts, appId) {
+    return request(opts, 'GET', `/api/auth/admin/apps/${encodeURIComponent(appId)}`);
+}
+export function listTeam(opts) {
+    return request(opts, 'GET', '/api/team');
+}
+export function listEdgeRules(opts) {
+    return request(opts, 'GET', '/api/shield/edge-rules');
+}
+export function createEdgeRule(opts, body) {
+    return request(opts, 'POST', '/api/shield/edge-rules', body);
+}
+export function updateEdgeRule(opts, id, body) {
+    return request(opts, 'PATCH', `/api/shield/edge-rules/${encodeURIComponent(id)}`, body);
+}
+export function deleteEdgeRule(opts, id) {
+    return request(opts, 'DELETE', `/api/shield/edge-rules/${encodeURIComponent(id)}`);
+}
+export function listEdgeKeys(opts) {
+    return request(opts, 'GET', '/api/shield/edge-keys');
+}
+export function createEdgeKey(opts, projectId, name) {
+    return request(opts, 'POST', '/api/shield/edge-keys', { project_id: projectId, name });
+}
+export function revokeEdgeKey(opts, id) {
+    return request(opts, 'DELETE', `/api/shield/edge-keys/${encodeURIComponent(id)}`);
+}
+export function getShieldSettings(opts) {
+    return request(opts, 'GET', '/api/shield/settings');
+}
+export function listIncidents(opts, status) {
+    const qs = status ? `?status=${encodeURIComponent(status)}` : '';
+    return request(opts, 'GET', `/api/shield/incidents${qs}`);
+}
+export function listGateSites(opts) {
+    return request(opts, 'GET', '/api/tillgate/sites');
+}
+export function createGateSite(opts, body) {
+    return request(opts, 'POST', '/api/tillgate/sites', body);
+}
+export function updateGateSite(opts, id, body) {
+    return request(opts, 'PATCH', `/api/tillgate/sites/${encodeURIComponent(id)}`, body);
+}
+export function deleteGateSite(opts, id) {
+    return request(opts, 'DELETE', `/api/tillgate/sites/${encodeURIComponent(id)}`);
+}
+export function listTracker(opts, projectId) {
+    return request(opts, 'GET', `/api/projects/${encodeURIComponent(projectId)}/integrations/tracker`);
+}
+export function connectTracker(opts, projectId, body) {
+    return request(opts, 'PUT', `/api/projects/${encodeURIComponent(projectId)}/integrations/tracker`, body);
+}
+export function disconnectTracker(opts, projectId, provider) {
+    return request(opts, 'DELETE', `/api/projects/${encodeURIComponent(projectId)}/integrations/tracker?provider=${provider}`);
+}
+export function getTrackerWebhook(opts, projectId, provider) {
+    return request(opts, 'GET', `/api/projects/${encodeURIComponent(projectId)}/integrations/tracker/webhook-secret?provider=${provider}`);
+}
+export function setTrackerWebhook(opts, projectId, body) {
+    return request(opts, 'POST', `/api/projects/${encodeURIComponent(projectId)}/integrations/tracker/webhook-secret`, body);
+}
+// ── Ask (NLQ assistant over your telemetry) ──────────────────────────────────
+// The /api/ask route proxies an LLM and streams the answer back. We read the
+// stream and print assistant text as it arrives, tolerating either a raw text
+// stream or SSE `data:` lines carrying OpenAI-style chat deltas.
+export async function askStream(opts, orgSlug, question, onChunk) {
+    const res = await fetch(`${opts.apiUrl}/api/ask`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...authHeaders(opts) },
+        body: JSON.stringify({ orgSlug, messages: [{ role: 'user', content: question }] }),
+    });
+    if (!res.ok || !res.body) {
+        const text = await res.text().catch(() => '');
+        throw new ApiError(res.status, text.slice(0, 300) || `ask failed: ${res.status}`);
+    }
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() ?? '';
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            if (trimmed.startsWith('data:')) {
+                const data = trimmed.slice(5).trim();
+                if (data === '[DONE]')
+                    return;
+                try {
+                    const j = JSON.parse(data);
+                    const piece = j.choices?.[0]?.delta?.content;
+                    if (piece)
+                        onChunk(piece);
+                }
+                catch {
+                    onChunk(data);
+                }
+            }
+            else {
+                onChunk(line + '\n');
+            }
+        }
+    }
+    if (buffer.trim())
+        onChunk(buffer);
+}
+export function listNamespaces(opts) {
+    return request(opts, 'GET', '/api/cache/namespaces');
+}
+export function createNamespace(opts, input) {
+    return request(opts, 'POST', '/api/cache/namespaces', input);
+}
+export function getNamespace(opts, id) {
+    return request(opts, 'GET', `/api/cache/namespaces/${encodeURIComponent(id)}`);
+}
+export function updateNamespace(opts, id, patch) {
+    return request(opts, 'PATCH', `/api/cache/namespaces/${encodeURIComponent(id)}`, patch);
+}
+export function deleteNamespace(opts, id) {
+    return request(opts, 'DELETE', `/api/cache/namespaces/${encodeURIComponent(id)}`);
+}
+export function listCacheTokens(opts, nsId) {
+    return request(opts, 'GET', `/api/cache/namespaces/${encodeURIComponent(nsId)}/tokens`);
+}
+export function createCacheToken(opts, nsId, name, scope) {
+    return request(opts, 'POST', `/api/cache/namespaces/${encodeURIComponent(nsId)}/tokens`, { name, scope });
+}
+export function revokeCacheToken(opts, nsId, tokenId) {
+    return request(opts, 'DELETE', `/api/cache/namespaces/${encodeURIComponent(nsId)}/tokens/${encodeURIComponent(tokenId)}`);
+}
+export function listCacheQueues(opts, nsId) {
+    return request(opts, 'GET', `/api/cache/namespaces/${encodeURIComponent(nsId)}/queues`);
+}
+export function listCacheKeys(opts, nsId) {
+    return request(opts, 'GET', `/api/cache/namespaces/${encodeURIComponent(nsId)}/keys`);
+}
+export function getCacheUsage(opts, nsId) {
+    return request(opts, 'GET', `/api/cache/namespaces/${encodeURIComponent(nsId)}/usage`);
+}
+export function listSecretsProjects(opts) {
+    return request(opts, 'GET', '/api/secrets/projects');
+}
+export function createSecretsProject(opts, name, slug, description = '') {
+    return request(opts, 'POST', '/api/secrets/projects', { name, slug, description });
+}
+export function listSecretsEnvironments(opts, projectId) {
+    return request(opts, 'GET', `/api/secrets/projects/${encodeURIComponent(projectId)}/environments`);
+}
+export function createSecretsEnvironment(opts, projectId, name, slug) {
+    return request(opts, 'POST', `/api/secrets/projects/${encodeURIComponent(projectId)}/environments`, { name, slug });
+}
+export function listSecrets(opts, envId) {
+    return request(opts, 'GET', `/api/secrets/environments/${encodeURIComponent(envId)}/secrets`);
+}
+export function setSecret(opts, envId, key, value, comment = '') {
+    return request(opts, 'POST', `/api/secrets/environments/${encodeURIComponent(envId)}/secrets`, { key, value, comment });
+}
+export function revealSecret(opts, secretId, version) {
+    const qs = version ? `?version=${version}` : '';
+    return request(opts, 'POST', `/api/secrets/secrets/${encodeURIComponent(secretId)}/reveal${qs}`);
+}
+export function listSecretVersions(opts, secretId) {
+    return request(opts, 'GET', `/api/secrets/secrets/${encodeURIComponent(secretId)}/versions`);
+}
+export function rollbackSecret(opts, secretId, version) {
+    return request(opts, 'POST', `/api/secrets/secrets/${encodeURIComponent(secretId)}/rollback`, { version });
+}
+export function deleteSecret(opts, secretId) {
+    return request(opts, 'DELETE', `/api/secrets/secrets/${encodeURIComponent(secretId)}`);
+}
+export function listSecretsTokens(opts, projectId) {
+    return request(opts, 'GET', `/api/secrets/projects/${encodeURIComponent(projectId)}/tokens`);
+}
+export function createSecretsToken(opts, projectId, body) {
+    return request(opts, 'POST', `/api/secrets/projects/${encodeURIComponent(projectId)}/tokens`, body);
+}
+export function revokeSecretsToken(opts, projectId, tokenId) {
+    return request(opts, 'DELETE', `/api/secrets/projects/${encodeURIComponent(projectId)}/tokens/${encodeURIComponent(tokenId)}`);
+}
+export function listSyncTargets(opts, projectId) {
+    return request(opts, 'GET', `/api/secrets/projects/${encodeURIComponent(projectId)}/sync-targets`);
+}
+export function createSyncTarget(opts, projectId, input) {
+    return request(opts, 'POST', `/api/secrets/projects/${encodeURIComponent(projectId)}/sync-targets`, input);
+}
+export function setSyncTargetStatus(opts, projectId, targetId, status) {
+    return request(opts, 'PATCH', `/api/secrets/projects/${encodeURIComponent(projectId)}/sync-targets/${encodeURIComponent(targetId)}`, { status });
+}
+export function deleteSyncTarget(opts, projectId, targetId) {
+    return request(opts, 'DELETE', `/api/secrets/projects/${encodeURIComponent(projectId)}/sync-targets/${encodeURIComponent(targetId)}`);
+}
+export function pushSyncTarget(opts, projectId, targetId) {
+    return request(opts, 'POST', `/api/secrets/projects/${encodeURIComponent(projectId)}/sync-targets/${encodeURIComponent(targetId)}/push`);
+}
+export function pullSecrets(opts, environmentId) {
+    return request(opts, 'POST', '/api/secrets/pull', environmentId ? { environment_id: environmentId } : {});
+}
+export function leaseSecret(opts, body) {
+    // `opts.apiUrl` here is the lease service base (e.g. https://secrets.tilldev.dev).
+    return request(opts, 'POST', '/v1/lease', body);
+}
+export function revokeLease(opts, leaseId) {
+    return request(opts, 'POST', `/v1/lease/${encodeURIComponent(leaseId)}/revoke`);
+}
+export function listArkSources(opts) {
+    return request(opts, 'GET', '/api/ark/sources');
+}
+export function createArkSource(opts, body) {
+    return request(opts, 'POST', '/api/ark/sources', body);
+}
+export function getArkSource(opts, id) {
+    return request(opts, 'GET', `/api/ark/sources/${encodeURIComponent(id)}`);
+}
+export function deleteArkSource(opts, id) {
+    return request(opts, 'DELETE', `/api/ark/sources/${encodeURIComponent(id)}`);
+}
+export function listArkTargets(opts) {
+    return request(opts, 'GET', '/api/ark/targets');
+}
+export function createArkTarget(opts, body) {
+    return request(opts, 'POST', '/api/ark/targets', body);
+}
+export function getArkTarget(opts, id) {
+    return request(opts, 'GET', `/api/ark/targets/${encodeURIComponent(id)}`);
+}
+export function deleteArkTarget(opts, id) {
+    return request(opts, 'DELETE', `/api/ark/targets/${encodeURIComponent(id)}`);
+}
+export function listArkPolicies(opts, sourceId) {
+    const qs = sourceId ? `?source_id=${encodeURIComponent(sourceId)}` : '';
+    return request(opts, 'GET', `/api/ark/policies${qs}`);
+}
+export function createArkPolicy(opts, body) {
+    return request(opts, 'POST', '/api/ark/policies', body);
+}
+export function listArkBackups(opts, sourceId) {
+    const qs = sourceId ? `?source_id=${encodeURIComponent(sourceId)}` : '';
+    return request(opts, 'GET', `/api/ark/backups${qs}`);
+}
+export function runArkBackup(opts, sourceId, policyId) {
+    return request(opts, 'POST', '/api/ark/backups/run', { source_id: sourceId, ...(policyId ? { policy_id: policyId } : {}) });
+}
+export function listArkRestores(opts, backupId) {
+    const qs = backupId ? `?backup_id=${encodeURIComponent(backupId)}` : '';
+    return request(opts, 'GET', `/api/ark/restores${qs}`);
+}
+export function startArkRestore(opts, body) {
+    return request(opts, 'POST', '/api/ark/restores', body);
+}
+export function getArkFailover(opts, sourceId) {
+    return request(opts, 'GET', `/api/ark/failover?source_id=${encodeURIComponent(sourceId)}`);
+}
+export function promoteArkFailover(opts, body) {
+    return request(opts, 'POST', '/api/ark/failover/promote', body);
+}
+export function failbackArkFailover(opts, body) {
+    return request(opts, 'POST', '/api/ark/failover/failback', body);
+}
+export function listArkReplicas(opts) {
+    return request(opts, 'GET', '/api/ark/replicas');
+}
+export function listArkTokens(opts) {
+    return request(opts, 'GET', '/api/ark/tokens');
+}
+export function createArkToken(opts, body) {
+    return request(opts, 'POST', '/api/ark/tokens', body);
+}
+export function revokeArkToken(opts, id) {
+    return request(opts, 'DELETE', `/api/ark/tokens/${encodeURIComponent(id)}`);
+}
+export function listArkAudit(opts, limit) {
+    const qs = limit ? `?limit=${limit}` : '';
+    return request(opts, 'GET', `/api/ark/audit${qs}`);
+}
+export function listArkCanary(opts) {
+    return request(opts, 'GET', '/api/ark/canary');
+}
+export function ackArkCanary(opts, id, status) {
+    return request(opts, 'POST', `/api/ark/canary/${encodeURIComponent(id)}/ack`, { status });
+}
+export function listArkClones(opts) {
+    return request(opts, 'GET', '/api/ark/clones');
+}
+export function createArkClone(opts, body) {
+    return request(opts, 'POST', '/api/ark/clones', body);
+}
+export function expireArkClone(opts, id) {
+    return request(opts, 'POST', `/api/ark/clones/${encodeURIComponent(id)}/expire`);
+}
+const enc = encodeURIComponent;
+export function forgeDeviceCode(opts, scope) {
+    return request(opts, 'POST', '/api/forge/device/code', { scope });
+}
+/** One poll of the device-token endpoint. `authorization_pending` (and a 429
+ *  slow_down) are normal mid-flow answers, not errors — so this speaks fetch
+ *  directly instead of request(), which throws on any non-2xx. */
+export async function forgeDeviceToken(opts, deviceCode) {
+    const res = await fetch(`${opts.apiUrl}/api/forge/device/token`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ device_code: deviceCode }),
+    });
+    const body = (await res.json().catch(() => null));
+    if (res.ok && typeof body?.access_token === 'string') {
+        return { status: 'ok', token: body.access_token, scope: body.scope ?? 'read' };
+    }
+    if (res.status === 429)
+        return { status: 'slow_down' };
+    if (body?.error === 'authorization_pending')
+        return { status: 'pending' };
+    return { status: 'expired' };
+}
+export function listForgeRepos(opts) {
+    return request(opts, 'GET', '/api/forge/repos');
+}
+export function createForgeRepo(opts, body) {
+    return request(opts, 'POST', '/api/forge/repos', body);
+}
+export function getForgeRepo(opts, repo) {
+    return request(opts, 'GET', `/api/forge/repos/${enc(repo)}`);
+}
+export function deleteForgeRepo(opts, repo) {
+    return request(opts, 'DELETE', `/api/forge/repos/${enc(repo)}`);
+}
+export function forgeTree(opts, repo, rev, path) {
+    const q = new URLSearchParams();
+    if (rev)
+        q.set('rev', rev);
+    if (path)
+        q.set('path', path);
+    const qs = q.toString() ? `?${q}` : '';
+    return request(opts, 'GET', `/api/forge/repos/${enc(repo)}/tree${qs}`);
+}
+export function forgeBlob(opts, repo, path, rev) {
+    const q = new URLSearchParams({ path });
+    if (rev)
+        q.set('rev', rev);
+    return request(opts, 'GET', `/api/forge/repos/${enc(repo)}/blob?${q}`);
+}
+export function forgeCommits(opts, repo, rev, limit) {
+    const q = new URLSearchParams();
+    if (rev)
+        q.set('rev', rev);
+    if (limit)
+        q.set('limit', String(limit));
+    const qs = q.toString() ? `?${q}` : '';
+    return request(opts, 'GET', `/api/forge/repos/${enc(repo)}/commits${qs}`);
+}
+export function forgeRefs(opts, repo) {
+    return request(opts, 'GET', `/api/forge/repos/${enc(repo)}/refs`);
+}
+export function forgeBlame(opts, repo, path, rev) {
+    const q = new URLSearchParams({ path });
+    if (rev)
+        q.set('rev', rev);
+    return request(opts, 'GET', `/api/forge/repos/${enc(repo)}/blame?${q}`);
+}
+export function listForgePolicies(opts, repo) {
+    return request(opts, 'GET', `/api/forge/repos/${enc(repo)}/policies`);
+}
+export function putForgePolicy(opts, repo, body) {
+    return request(opts, 'PUT', `/api/forge/repos/${enc(repo)}/policies`, body);
+}
+export function listForgeReflog(opts, repo, limit) {
+    const qs = limit ? `?limit=${limit}` : '';
+    return request(opts, 'GET', `/api/forge/repos/${enc(repo)}/reflog${qs}`);
+}
+export function recoverForgeRef(opts, repo, id) {
+    return request(opts, 'POST', `/api/forge/repos/${enc(repo)}/reflog/${enc(id)}/recover`, {});
+}
+export function listForgeFindings(opts, repo, limit) {
+    const qs = limit ? `?limit=${limit}` : '';
+    return request(opts, 'GET', `/api/forge/repos/${enc(repo)}/findings${qs}`);
+}
+export function allowlistForgeFinding(opts, repo, id, reason) {
+    return request(opts, 'POST', `/api/forge/repos/${enc(repo)}/findings/${enc(id)}/allowlist`, { reason });
+}
+export function listForgePulls(opts, repo, state) {
+    const qs = state ? `?state=${enc(state)}` : '';
+    return request(opts, 'GET', `/api/forge/repos/${enc(repo)}/pulls${qs}`);
+}
+export function createForgePull(opts, repo, body) {
+    return request(opts, 'POST', `/api/forge/repos/${enc(repo)}/pulls`, body);
+}
+export function getForgePull(opts, repo, number) {
+    return request(opts, 'GET', `/api/forge/repos/${enc(repo)}/pulls/${number}`);
+}
+export function mergeForgePull(opts, repo, number, body) {
+    return request(opts, 'POST', `/api/forge/repos/${enc(repo)}/pulls/${number}/merge`, body);
+}
+export function reviewForgePull(opts, repo, number, body) {
+    return request(opts, 'POST', `/api/forge/repos/${enc(repo)}/pulls/${number}/reviews`, body);
+}
+export function listForgeChecks(opts, repo, sha) {
+    const qs = sha ? `?sha=${enc(sha)}` : '';
+    return request(opts, 'GET', `/api/forge/repos/${enc(repo)}/checks${qs}`);
+}
+export function reportForgeCheck(opts, repo, body) {
+    return request(opts, 'POST', `/api/forge/repos/${enc(repo)}/checks`, body);
+}
+export function listForgeCiJobs(opts, repo, status, workflow, limit) {
+    const q = new URLSearchParams();
+    if (status)
+        q.set('status', status);
+    if (workflow)
+        q.set('workflow', workflow);
+    if (limit)
+        q.set('limit', String(limit));
+    const qs = q.toString() ? `?${q}` : '';
+    return request(opts, 'GET', `/api/forge/repos/${enc(repo)}/ci/jobs${qs}`);
+}
+export function getForgeCiJob(opts, repo, id) {
+    return request(opts, 'GET', `/api/forge/repos/${enc(repo)}/ci/jobs/${enc(id)}`);
+}
+export function runForgeCi(opts, repo, sha, ref) {
+    return request(opts, 'POST', `/api/forge/repos/${enc(repo)}/ci/run`, {
+        ...(sha ? { sha } : {}),
+        ...(ref ? { ref } : {}),
+    });
+}
+export function forgeCorrelation(opts, repo, rev) {
+    const qs = rev ? `?rev=${enc(rev)}` : '';
+    return request(opts, 'GET', `/api/forge/repos/${enc(repo)}/correlation${qs}`);
+}
+export function listForgeTokens(opts) {
+    return request(opts, 'GET', '/api/forge/tokens');
+}
+export function createForgeToken(opts, body) {
+    return request(opts, 'POST', '/api/forge/tokens', body);
+}
+export function revokeForgeToken(opts, id) {
+    return request(opts, 'DELETE', `/api/forge/tokens/${enc(id)}`);
+}
+export function listForgeAudit(opts, limit) {
+    const qs = limit ? `?limit=${limit}` : '';
+    return request(opts, 'GET', `/api/forge/audit${qs}`);
+}
+export function getForgeAiPolicy(opts, repo) {
+    return request(opts, 'GET', `/api/forge/repos/${enc(repo)}/ai-policy`);
+}
+export function putForgeAiPolicy(opts, repo, body) {
+    return request(opts, 'PUT', `/api/forge/repos/${enc(repo)}/ai-policy`, body);
+}
+export function listForgeEgress(opts, limit) {
+    const qs = limit ? `?limit=${limit}` : '';
+    return request(opts, 'GET', `/api/forge/ai-egress${qs}`);
+}
+export function setForgeMirror(opts, repo, body) {
+    return request(opts, 'PUT', `/api/forge/repos/${enc(repo)}/mirror`, body);
+}
+export function removeForgeMirror(opts, repo) {
+    return request(opts, 'DELETE', `/api/forge/repos/${enc(repo)}/mirror`);
+}
+export function listForgeKeys(opts, repo) {
+    return request(opts, 'GET', `/api/forge/repos/${enc(repo)}/keys`);
+}
+export function addForgeKey(opts, repo, body) {
+    return request(opts, 'POST', `/api/forge/repos/${enc(repo)}/keys`, body);
+}
+export function revokeForgeKey(opts, repo, keyId) {
+    return request(opts, 'DELETE', `/api/forge/repos/${enc(repo)}/keys/${enc(keyId)}`);
+}
+export function getForgeCodeowners(opts, repo, rev) {
+    const qs = rev ? `?rev=${enc(rev)}` : '';
+    return request(opts, 'GET', `/api/forge/repos/${enc(repo)}/codeowners${qs}`);
+}
+export function listForgeIssues(opts, repo, params) {
+    const q = new URLSearchParams();
+    if (params?.state)
+        q.set('state', params.state);
+    if (params?.label)
+        q.set('label', params.label);
+    const qs = q.toString() ? `?${q.toString()}` : '';
+    return request(opts, 'GET', `/api/forge/repos/${enc(repo)}/issues${qs}`);
+}
+export function createForgeIssue(opts, repo, body) {
+    return request(opts, 'POST', `/api/forge/repos/${enc(repo)}/issues`, body);
+}
+export function getForgeIssue(opts, repo, number) {
+    return request(opts, 'GET', `/api/forge/repos/${enc(repo)}/issues/${number}`);
+}
+export function updateForgeIssue(opts, repo, number, body) {
+    return request(opts, 'PATCH', `/api/forge/repos/${enc(repo)}/issues/${number}`, body);
+}
+export function commentForgeIssue(opts, repo, number, body) {
+    return request(opts, 'POST', `/api/forge/repos/${enc(repo)}/issues/${number}/comments`, { body });
+}
+export function listForgeLabels(opts, repo) {
+    return request(opts, 'GET', `/api/forge/repos/${enc(repo)}/labels`);
+}
+export function createForgeLabel(opts, repo, body) {
+    return request(opts, 'POST', `/api/forge/repos/${enc(repo)}/labels`, body);
+}
+export function listForgeCollaborators(opts, repo) {
+    return request(opts, 'GET', `/api/forge/repos/${enc(repo)}/collaborators`);
+}
+export function addForgeCollaborator(opts, repo, body) {
+    return request(opts, 'POST', `/api/forge/repos/${enc(repo)}/collaborators`, body);
+}
+export function removeForgeCollaborator(opts, repo, id) {
+    return request(opts, 'DELETE', `/api/forge/repos/${enc(repo)}/collaborators/${enc(id)}`);
+}
+export function updateForgePull(opts, repo, number, body) {
+    return request(opts, 'PATCH', `/api/forge/repos/${enc(repo)}/pulls/${number}`, body);
+}
+export function listForgePullComments(opts, repo, number) {
+    return request(opts, 'GET', `/api/forge/repos/${enc(repo)}/pulls/${number}/comments`);
+}
+export function commentForgePull(opts, repo, number, body) {
+    return request(opts, 'POST', `/api/forge/repos/${enc(repo)}/pulls/${number}/comments`, body);
+}
+export function forgePullDiff(opts, repo, number) {
+    return request(opts, 'GET', `/api/forge/repos/${enc(repo)}/pulls/${number}/diff`);
+}
+export function forgeCompare(opts, repo, base, head) {
+    return request(opts, 'GET', `/api/forge/repos/${enc(repo)}/compare?base=${enc(base)}&head=${enc(head)}`);
+}
+export function forgeSearch(opts, repo, q, rev, limit) {
+    const qp = new URLSearchParams({ q });
+    if (rev)
+        qp.set('rev', rev);
+    if (limit)
+        qp.set('limit', String(limit));
+    return request(opts, 'GET', `/api/forge/repos/${enc(repo)}/search?${qp}`);
+}
+export function forgeEnvironments(opts, repo) {
+    return request(opts, 'GET', `/api/forge/repos/${enc(repo)}/environments`);
+}
+export function forgeSetEnvironment(opts, repo, body) {
+    return request(opts, 'POST', `/api/forge/repos/${enc(repo)}/environments`, body);
+}
+export function forgeDeployments(opts, repo, environment) {
+    const q = new URLSearchParams();
+    if (environment)
+        q.set('environment', environment);
+    const qs = q.toString() ? `?${q}` : '';
+    return request(opts, 'GET', `/api/forge/repos/${enc(repo)}/deployments${qs}`);
+}
+export function forgeCreateDeployment(opts, repo, body) {
+    return request(opts, 'POST', `/api/forge/repos/${enc(repo)}/deployments`, body);
+}
+export function forgeUpdateDeployment(opts, repo, id, body) {
+    return request(opts, 'PATCH', `/api/forge/repos/${enc(repo)}/deployments/${enc(id)}`, body);
+}
+export function forgeReleases(opts, repo) {
+    return request(opts, 'GET', `/api/forge/repos/${enc(repo)}/releases`);
+}
+export function forgeGetRelease(opts, repo, tag) {
+    return request(opts, 'GET', `/api/forge/repos/${enc(repo)}/releases/${enc(tag)}`);
+}
+export function forgeCreateRelease(opts, repo, body) {
+    return request(opts, 'POST', `/api/forge/repos/${enc(repo)}/releases`, body);
+}
+export function forgeDeleteRelease(opts, repo, tag) {
+    return request(opts, 'DELETE', `/api/forge/repos/${enc(repo)}/releases/${enc(tag)}`);
+}
+export function forgeAddAsset(opts, repo, tag, body) {
+    return request(opts, 'POST', `/api/forge/repos/${enc(repo)}/releases/${enc(tag)}/assets`, body);
+}
+export function forgeRemoveAsset(opts, repo, tag, id) {
+    return request(opts, 'DELETE', `/api/forge/repos/${enc(repo)}/releases/${enc(tag)}/assets/${enc(id)}`);
+}
+export function forgeWebhooks(opts) {
+    return request(opts, 'GET', '/api/forge/webhooks');
+}
+export function forgeCreateWebhook(opts, body) {
+    return request(opts, 'POST', '/api/forge/webhooks', body);
+}
+export function forgeDeleteWebhook(opts, id) {
+    return request(opts, 'DELETE', `/api/forge/webhooks/${enc(id)}`);
+}
+export function forgePingWebhook(opts, id) {
+    return request(opts, 'POST', `/api/forge/webhooks/${enc(id)}/ping`, {});
+}
+export function forgeWebhookDeliveries(opts, id) {
+    return request(opts, 'GET', `/api/forge/webhooks/${enc(id)}/deliveries`);
+}
+export function listForgeAccountKeys(opts) {
+    return request(opts, 'GET', '/api/forge/keys');
+}
+export function addForgeAccountKey(opts, body) {
+    return request(opts, 'POST', '/api/forge/keys', body);
+}
+export function revokeForgeAccountKey(opts, id) {
+    return request(opts, 'DELETE', `/api/forge/keys/${enc(id)}`);
+}
+//# sourceMappingURL=api.js.map