@tillstack/cli 0.2.0

package/dist/api.d.ts

@@ -0,0 +1,1579 @@
+export declare class ApiError extends Error {
+    status: number;
+    constructor(status: number, message: string);
+}
+export interface ApiOptions {
+    apiUrl: string;
+    token?: string;
+}
+/** Generic JSON request against the dashboard API. */
+export declare function request<T>(opts: ApiOptions, method: string, path: string, body?: unknown): Promise<T>;
+export interface StackModuleRef {
+    module: string;
+    status: 'active' | 'paused';
+}
+export interface Stack {
+    id: string;
+    name: string;
+    slug: string;
+    description: string;
+    accent: string;
+    status: 'active' | 'archived';
+    created_at: string;
+    updated_at: string;
+    modules?: StackModuleRef[];
+}
+export interface StackDetail {
+    stack: Stack;
+    modules: Array<{
+        module: string;
+        status: string;
+        enabled_at?: string;
+    }>;
+    counts: Record<string, number>;
+}
+export interface CreateStackInput {
+    name: string;
+    slug?: string;
+    description?: string;
+    accent?: string;
+    modules?: string[];
+}
+export declare function listStacks(opts: ApiOptions): Promise<{
+    stacks: Stack[];
+}>;
+export declare function createStack(opts: ApiOptions, input: CreateStackInput): Promise<{
+    stack: Stack;
+}>;
+export declare function getStack(opts: ApiOptions, slug: string): Promise<StackDetail>;
+export declare function updateStack(opts: ApiOptions, slug: string, patch: {
+    name?: string;
+    description?: string;
+    accent?: string;
+    status?: 'active' | 'archived';
+}): Promise<{
+    stack: Stack;
+}>;
+export declare function deleteStack(opts: ApiOptions, slug: string): Promise<{
+    ok: boolean;
+}>;
+export declare function setStackModule(opts: ApiOptions, slug: string, module: string, status: 'active' | 'paused'): Promise<{
+    module: string;
+    status: string;
+}>;
+export declare function setStackResource(opts: ApiOptions, slug: string, module: string, resourceId: string, action: 'attach' | 'detach'): Promise<{
+    ok: boolean;
+    in_stack: boolean;
+}>;
+export declare function login(opts: ApiOptions, email: string, password: string, totp?: string): Promise<{
+    token: string;
+    refresh?: string;
+    org: string;
+    totpRequired?: boolean;
+}>;
+export interface Me {
+    user?: {
+        id?: string;
+        email?: string;
+        name?: string | null;
+    };
+    org?: {
+        slug?: string;
+        name?: string;
+        role?: string;
+    };
+    role?: string;
+}
+export declare function getMe(opts: ApiOptions): Promise<Me>;
+export interface Project {
+    id: string;
+    name: string;
+    slug?: string;
+    platform?: string;
+    dsn?: string;
+    created_at?: string;
+}
+export declare function listProjects(opts: ApiOptions): Promise<{
+    projects: Project[];
+}>;
+export declare function createProject(opts: ApiOptions, name: string, platform: string): Promise<{
+    project: Project;
+}>;
+export declare function getProject(opts: ApiOptions, projectId: string): Promise<{
+    project: Project;
+}>;
+export declare function rotateDsn(opts: ApiOptions, projectId: string): Promise<unknown>;
+export interface Issue {
+    id: string;
+    title?: string;
+    culprit?: string | null;
+    level?: string;
+    status?: string;
+    events_count?: number;
+    last_seen?: string;
+    first_seen?: string;
+}
+export declare function listIssues(opts: ApiOptions, params?: {
+    projectId?: string;
+    limit?: number;
+}): Promise<{
+    issues: Issue[];
+    total?: number;
+}>;
+export declare function getIssue(opts: ApiOptions, issueId: string): Promise<unknown>;
+export declare function getMetrics(opts: ApiOptions, projectId?: string): Promise<unknown>;
+export interface Alert {
+    id: string;
+    title?: string;
+    source?: string;
+    project?: string;
+    severity?: string;
+    acknowledged?: boolean;
+    created_at?: string;
+}
+export declare function listAlerts(opts: ApiOptions, limit?: number): Promise<{
+    alerts: Alert[];
+    unread?: number;
+}>;
+export interface AlertRule {
+    id: string;
+    name?: string;
+    trigger_type?: string;
+    enabled?: boolean;
+    project_id?: string;
+    quiet_period_minutes?: number;
+}
+export declare function listAlertRules(opts: ApiOptions, projectId?: string): Promise<{
+    rules: AlertRule[];
+    total?: number;
+}>;
+export declare function createRelease(opts: ApiOptions, projectId: string, body: {
+    version: string;
+    build?: string;
+    environment?: string;
+    commit_sha?: string;
+}): Promise<unknown>;
+export declare function uploadSourceMap(opts: ApiOptions, projectId: string, p: {
+    release: string;
+    filePath: string;
+}): Promise<unknown>;
+export declare function uploadProguardMapping(opts: ApiOptions, projectId: string, p: {
+    release: string;
+    filePath: string;
+}): Promise<unknown>;
+export declare function uploadDsym(opts: ApiOptions, projectId: string, p: {
+    release: string;
+    filePath: string;
+}): Promise<unknown>;
+export interface ApiKey {
+    id: string;
+    name: string;
+    scopes?: string[];
+    last_used_at?: string | null;
+    expires_at?: string | null;
+    created_at?: string;
+}
+export declare function listApiKeys(opts: ApiOptions): Promise<{
+    keys: ApiKey[];
+}>;
+export declare function createApiKey(opts: ApiOptions, name: string, scopes: string[]): Promise<{
+    key?: string;
+    api_key?: string;
+    id?: string;
+}>;
+export interface TillAuthApp {
+    id: string;
+    public_id?: string;
+    name: string;
+    slug?: string;
+    created_at?: string;
+}
+export declare function listAuthApps(opts: ApiOptions): Promise<{
+    apps: TillAuthApp[];
+}>;
+export declare function createAuthApp(opts: ApiOptions, name: string): Promise<{
+    app: TillAuthApp;
+}>;
+export declare function getAuthApp(opts: ApiOptions, appId: string): Promise<unknown>;
+export interface TeamMember {
+    user_id?: string;
+    id?: string;
+    email?: string;
+    name?: string | null;
+    role?: string;
+}
+export declare function listTeam(opts: ApiOptions): Promise<{
+    members?: TeamMember[];
+    team?: TeamMember[];
+}>;
+export interface EdgeRuleMatch {
+    ip_cidrs?: string[];
+    paths?: string[];
+    methods?: string[];
+    countries?: string[];
+    user_agent_regex?: string;
+    threat_intel?: boolean;
+}
+export interface EdgeRuleRateLimit {
+    requests: number;
+    window_seconds: number;
+    by?: 'ip' | 'ip_path';
+}
+export interface EdgeRule {
+    id: string;
+    name: string;
+    description?: string | null;
+    project_id?: string | null;
+    enabled: boolean;
+    priority: number;
+    mode: 'block' | 'challenge' | 'log';
+    match: EdgeRuleMatch;
+    rate_limit?: EdgeRuleRateLimit | null;
+    response_status: number;
+    response_body?: string | null;
+    escalate_to_incident: boolean;
+    created_at?: string;
+    updated_at?: string;
+}
+/** The authored shape — everything except server-managed identity/timestamps. */
+export type EdgeRuleInput = Omit<EdgeRule, 'id' | 'created_at' | 'updated_at'>;
+export declare function listEdgeRules(opts: ApiOptions): Promise<{
+    rules: EdgeRule[];
+}>;
+export declare function createEdgeRule(opts: ApiOptions, body: Partial<EdgeRuleInput>): Promise<{
+    rule: EdgeRule;
+}>;
+export declare function updateEdgeRule(opts: ApiOptions, id: string, body: Partial<EdgeRuleInput>): Promise<{
+    rule: EdgeRule;
+}>;
+export declare function deleteEdgeRule(opts: ApiOptions, id: string): Promise<{
+    ok: boolean;
+}>;
+export interface EdgeKey {
+    id: string;
+    name: string;
+    project_id: string;
+    key_prefix: string;
+    last_used_at?: string | null;
+    revoked_at?: string | null;
+    created_at?: string;
+    secret?: string;
+}
+export declare function listEdgeKeys(opts: ApiOptions): Promise<{
+    keys: EdgeKey[];
+}>;
+export declare function createEdgeKey(opts: ApiOptions, projectId: string, name: string): Promise<{
+    key: EdgeKey;
+}>;
+export declare function revokeEdgeKey(opts: ApiOptions, id: string): Promise<{
+    ok: boolean;
+}>;
+export interface ShieldSettings {
+    auto_quarantine_compromised?: boolean;
+    auto_incident_on_confirmed_indicator?: boolean;
+    panic_mode?: boolean;
+    contribute_threat_intel?: boolean;
+}
+export declare function getShieldSettings(opts: ApiOptions): Promise<{
+    settings: ShieldSettings;
+}>;
+export interface Incident {
+    id: string;
+    title: string;
+    severity?: string;
+    status?: string;
+    security_type?: string | null;
+    created_at?: string;
+}
+export declare function listIncidents(opts: ApiOptions, status?: string): Promise<{
+    incidents: Incident[];
+}>;
+export interface GateSite {
+    id: string;
+    project_id: string;
+    name: string;
+    site_key: string;
+    secret_prefix?: string;
+    mode: string;
+    difficulty: number;
+    token_ttl_seconds: number;
+    hostname_allowlist: string[];
+    last_verified_at?: string | null;
+    created_at?: string;
+    secret?: string;
+}
+export interface GateSiteInput {
+    project_id: string;
+    name?: string;
+    mode?: string;
+    difficulty?: number;
+    token_ttl_seconds?: number;
+    hostname_allowlist?: string[];
+}
+export declare function listGateSites(opts: ApiOptions): Promise<{
+    sites: GateSite[];
+}>;
+export declare function createGateSite(opts: ApiOptions, body: GateSiteInput): Promise<{
+    site: GateSite;
+}>;
+export declare function updateGateSite(opts: ApiOptions, id: string, body: Partial<Omit<GateSiteInput, 'project_id'>>): Promise<{
+    site: GateSite;
+}>;
+export declare function deleteGateSite(opts: ApiOptions, id: string): Promise<{
+    ok: boolean;
+}>;
+export type TrackerProvider = 'jira' | 'linear';
+export interface TrackerIntegration {
+    id: string;
+    provider: TrackerProvider;
+    site_url?: string | null;
+    auth_email?: string | null;
+    default_target: string;
+    default_issue_type?: string | null;
+    has_webhook_secret?: boolean;
+    created_at?: string;
+}
+export interface TrackerConnectInput {
+    provider: TrackerProvider;
+    api_token?: string;
+    site_url?: string;
+    auth_email?: string;
+    default_target: string;
+    default_issue_type?: string;
+}
+export declare function listTracker(opts: ApiOptions, projectId: string): Promise<{
+    integrations: TrackerIntegration[];
+}>;
+export declare function connectTracker(opts: ApiOptions, projectId: string, body: TrackerConnectInput): Promise<{
+    ok: boolean;
+}>;
+export declare function disconnectTracker(opts: ApiOptions, projectId: string, provider: TrackerProvider): Promise<{
+    ok: boolean;
+}>;
+export interface TrackerWebhookStatus {
+    provider: TrackerProvider;
+    configured: boolean;
+    webhook_url: string;
+    header?: string;
+}
+export declare function getTrackerWebhook(opts: ApiOptions, projectId: string, provider: TrackerProvider): Promise<TrackerWebhookStatus>;
+export interface TrackerWebhookResult {
+    ok: boolean;
+    secret?: string;
+    webhook_url: string;
+    header?: string;
+    hint?: string;
+}
+export declare function setTrackerWebhook(opts: ApiOptions, projectId: string, body: {
+    provider: TrackerProvider;
+    secret?: string;
+}): Promise<TrackerWebhookResult>;
+export declare function askStream(opts: ApiOptions, orgSlug: string, question: string, onChunk: (text: string) => void): Promise<void>;
+export interface CacheNamespace {
+    id: string;
+    name: string;
+    slug: string;
+    backend: 'upstash' | 'durable' | 'byo' | 'auto';
+    consistency: 'strong' | 'eventual';
+    region: string;
+    status: 'active' | 'paused' | 'archived';
+    default_ttl_sec: number;
+    max_commands_per_day: number;
+    project_id?: string | null;
+    byo_configured?: boolean;
+    created_at?: string;
+}
+export interface CacheNamespaceInput {
+    name: string;
+    slug: string;
+    backend?: CacheNamespace['backend'];
+    consistency?: CacheNamespace['consistency'];
+    region?: string;
+    default_ttl_sec?: number;
+    project_id?: string | null;
+    byo?: {
+        url: string;
+        token: string;
+    };
+}
+export interface CacheToken {
+    id: string;
+    name: string;
+    scope: 'rw' | 'ro';
+    token_prefix: string;
+    last_used_at?: string | null;
+    revoked_at?: string | null;
+    created_at?: string;
+    secret?: string;
+}
+export interface CacheQueue {
+    name: string;
+    depth: number;
+    in_flight: number;
+    dead_lettered: number;
+    delivered_total: number;
+    max_retries: number;
+    visibility_timeout_sec: number;
+}
+export interface CacheKeyMeta {
+    key: string;
+    kind: string;
+    bytes: number;
+    hits: number;
+    hot: boolean;
+    ttl_alert_sec?: number | null;
+    last_access_at?: string | null;
+}
+export declare function listNamespaces(opts: ApiOptions): Promise<{
+    namespaces: CacheNamespace[];
+}>;
+export declare function createNamespace(opts: ApiOptions, input: CacheNamespaceInput): Promise<{
+    namespace: CacheNamespace;
+}>;
+export declare function getNamespace(opts: ApiOptions, id: string): Promise<{
+    namespace: CacheNamespace;
+}>;
+export declare function updateNamespace(opts: ApiOptions, id: string, patch: Partial<CacheNamespaceInput> & {
+    status?: string;
+    max_commands_per_day?: number;
+}): Promise<{
+    namespace: CacheNamespace;
+}>;
+export declare function deleteNamespace(opts: ApiOptions, id: string): Promise<{
+    ok: boolean;
+}>;
+export declare function listCacheTokens(opts: ApiOptions, nsId: string): Promise<{
+    tokens: CacheToken[];
+}>;
+export declare function createCacheToken(opts: ApiOptions, nsId: string, name: string, scope: 'rw' | 'ro'): Promise<{
+    token: CacheToken;
+}>;
+export declare function revokeCacheToken(opts: ApiOptions, nsId: string, tokenId: string): Promise<{
+    ok: boolean;
+}>;
+export declare function listCacheQueues(opts: ApiOptions, nsId: string): Promise<{
+    queues: CacheQueue[];
+}>;
+export declare function listCacheKeys(opts: ApiOptions, nsId: string): Promise<{
+    keys: CacheKeyMeta[];
+}>;
+export declare function getCacheUsage(opts: ApiOptions, nsId: string): Promise<{
+    usage: unknown[];
+    totals: {
+        commands: number;
+        queue_messages: number;
+        publishes: number;
+        storage_bytes: number;
+    };
+}>;
+export interface SecretsProject {
+    id: string;
+    name: string;
+    slug: string;
+    description?: string;
+    created_at?: string;
+}
+export interface SecretsEnvironment {
+    id: string;
+    project_id: string;
+    name: string;
+    slug: string;
+    sensitivity?: number;
+    created_at?: string;
+}
+export interface SecretMeta {
+    id: string;
+    key: string;
+    kind: 'static' | 'dynamic';
+    current_version: number;
+    updated_at?: string;
+}
+export interface SecretsServiceToken {
+    id: string;
+    name: string;
+    scope: 'read' | 'read_write';
+    environment_id?: string | null;
+    token_prefix: string;
+    last_used_at?: string | null;
+    expires_at?: string | null;
+    revoked_at?: string | null;
+    created_at?: string;
+    secret?: string;
+}
+export interface SecretVersion {
+    version: number;
+    value_hash: string;
+    comment?: string;
+    created_at?: string;
+}
+export declare function listSecretsProjects(opts: ApiOptions): Promise<{
+    projects: SecretsProject[];
+}>;
+export declare function createSecretsProject(opts: ApiOptions, name: string, slug: string, description?: string): Promise<{
+    project: SecretsProject;
+}>;
+export declare function listSecretsEnvironments(opts: ApiOptions, projectId: string): Promise<{
+    environments: SecretsEnvironment[];
+}>;
+export declare function createSecretsEnvironment(opts: ApiOptions, projectId: string, name: string, slug: string): Promise<{
+    environment: SecretsEnvironment;
+}>;
+export declare function listSecrets(opts: ApiOptions, envId: string): Promise<{
+    secrets: SecretMeta[];
+}>;
+export declare function setSecret(opts: ApiOptions, envId: string, key: string, value: string, comment?: string): Promise<{
+    secret: {
+        id: string;
+        key: string;
+        version: number;
+    };
+}>;
+export declare function revealSecret(opts: ApiOptions, secretId: string, version?: number): Promise<{
+    key: string;
+    version: number;
+    value: string;
+}>;
+export declare function listSecretVersions(opts: ApiOptions, secretId: string): Promise<{
+    current_version: number;
+    versions: SecretVersion[];
+}>;
+export declare function rollbackSecret(opts: ApiOptions, secretId: string, version: number): Promise<{
+    ok: boolean;
+    current_version: number;
+}>;
+export declare function deleteSecret(opts: ApiOptions, secretId: string): Promise<{
+    ok: boolean;
+}>;
+export declare function listSecretsTokens(opts: ApiOptions, projectId: string): Promise<{
+    tokens: SecretsServiceToken[];
+}>;
+export declare function createSecretsToken(opts: ApiOptions, projectId: string, body: {
+    name?: string;
+    scope?: 'read' | 'read_write';
+    environment_id?: string | null;
+    expires_in_days?: number | null;
+}): Promise<{
+    token: SecretsServiceToken;
+}>;
+export declare function revokeSecretsToken(opts: ApiOptions, projectId: string, tokenId: string): Promise<{
+    ok: boolean;
+}>;
+export type SyncProviderName = 'cloudflare' | 'vercel' | 'railway' | 'github' | 'aws_ssm' | 'dotenv' | 'custom';
+export interface SyncTarget {
+    id: string;
+    environment_id: string;
+    provider: SyncProviderName;
+    status: 'active' | 'paused' | 'error';
+    last_synced_at: string | null;
+    last_error: string | null;
+    created_at: string;
+}
+export declare function listSyncTargets(opts: ApiOptions, projectId: string): Promise<{
+    targets: SyncTarget[];
+}>;
+export declare function createSyncTarget(opts: ApiOptions, projectId: string, input: {
+    environment_id: string;
+    provider: SyncProviderName;
+    config: unknown;
+}): Promise<{
+    target: SyncTarget;
+}>;
+export declare function setSyncTargetStatus(opts: ApiOptions, projectId: string, targetId: string, status: 'active' | 'paused'): Promise<{
+    ok: boolean;
+    status: string;
+}>;
+export declare function deleteSyncTarget(opts: ApiOptions, projectId: string, targetId: string): Promise<{
+    ok: boolean;
+}>;
+export declare function pushSyncTarget(opts: ApiOptions, projectId: string, targetId: string): Promise<unknown>;
+export interface SecretPullResult {
+    /** Decrypted key → value map (static secrets only). */
+    secrets: Record<string, string>;
+    /** Keys declared dynamic — not resolved here; lease them separately. */
+    dynamic: string[];
+}
+export declare function pullSecrets(opts: ApiOptions, environmentId?: string): Promise<SecretPullResult>;
+export interface LeaseResult {
+    lease_id: string;
+    credential: Record<string, string>;
+    expires_at: string;
+    ttl_seconds: number;
+}
+export declare function leaseSecret(opts: ApiOptions, body: {
+    secret_key?: string;
+    backend_id?: string;
+    ttl_seconds?: number;
+}): Promise<LeaseResult>;
+export declare function revokeLease(opts: ApiOptions, leaseId: string): Promise<{
+    ok: boolean;
+    already?: string;
+}>;
+export interface ArkSource {
+    id: string;
+    name: string;
+    type: 'postgres' | 'mysql' | 'mongo' | 'clickhouse' | 'meili' | 'redis' | 'object';
+    provider: string;
+    region: string;
+    residency_zone: string;
+    managed: boolean;
+    status: 'active' | 'paused' | 'error';
+    has_dsn: boolean;
+    created_at?: string;
+}
+export interface ArkSourceInput {
+    name: string;
+    type: ArkSource['type'];
+    provider: string;
+    region?: string;
+    residency_zone?: string;
+    managed?: boolean;
+    dsn?: string;
+}
+export interface ArkTarget {
+    id: string;
+    name: string;
+    provider: 's3' | 'r2' | 'b2' | 'wasabi' | 'gcs' | 'azure' | 'minio' | 'sftp';
+    bucket: string;
+    region: string;
+    residency_zone: string;
+    immutable: boolean;
+    object_lock_days: number;
+    credential_domain: string;
+    status: 'active' | 'paused' | 'error';
+    has_creds: boolean;
+    created_at?: string;
+}
+export interface ArkTargetInput {
+    name: string;
+    provider: ArkTarget['provider'];
+    bucket?: string;
+    region?: string;
+    residency_zone?: string;
+    endpoint?: string;
+    immutable?: boolean;
+    object_lock_days?: number;
+    credential_domain?: string;
+    creds?: Record<string, unknown>;
+}
+export interface ArkRetention {
+    keepLast: number;
+    keepHourly: number;
+    keepDaily: number;
+    keepWeekly: number;
+    keepMonthly: number;
+    keepYearly: number;
+}
+export interface ArkPolicy {
+    id: string;
+    source_id: string;
+    name: string;
+    schedule_cron: string;
+    retention: ArkRetention;
+    rpo_slo_sec: number;
+    rto_slo_sec: number;
+    verify_cadence: string;
+    byok: boolean;
+    enabled: boolean;
+    created_at?: string;
+}
+export interface ArkPolicyInput {
+    source_id: string;
+    name?: string;
+    schedule_cron?: string;
+    retention?: ArkRetention;
+    rpo_slo_sec?: number;
+    rto_slo_sec?: number;
+    verify_cadence?: string;
+    byok?: boolean;
+}
+export interface ArkBackup {
+    id: string;
+    source_id: string;
+    policy_id?: string | null;
+    target_id?: string | null;
+    engine: 'restic' | 'kopia' | 'walg' | 'pgbackrest' | 'chbackup';
+    status: 'pending' | 'running' | 'succeeded' | 'failed' | 'verifying' | 'verified' | 'pruning' | 'pruned';
+    size_bytes: number;
+    dedup_ratio: number;
+    /** Server re-verified the signed manifest at report time (F4). */
+    manifest_verified?: boolean;
+    /** Barred as a restore/clone source by a ransomware-canary alarm. */
+    quarantined?: boolean;
+    snapshot_ref?: string | null;
+    consistency_epoch: number;
+    started_at?: string | null;
+    finished_at?: string | null;
+    created_at?: string;
+}
+export interface ArkRestore {
+    id: string;
+    backup_id: string;
+    kind: 'real' | 'verification';
+    target_ref?: string | null;
+    status: 'pending' | 'running' | 'passed' | 'failed';
+    authorized_by?: string | null;
+    approval_ref?: string | null;
+    rto_observed_sec?: number | null;
+    created_at?: string;
+}
+export interface ArkReplica {
+    id: string;
+    source_id: string;
+    provider: string;
+    region: string;
+    residency_zone: string;
+    mode: 'sync' | 'async' | 'logical';
+    role: 'primary' | 'replica';
+    promotable: boolean;
+    lag_bytes: number;
+    lag_sec: number;
+    health: 'healthy' | 'lagging' | 'down' | 'unknown';
+    last_heartbeat?: string | null;
+}
+export interface ArkFailover {
+    id: string;
+    source_id: string;
+    from_node?: string | null;
+    to_node?: string | null;
+    trigger: 'auto' | 'manual';
+    state: 'healthy' | 'suspect' | 'fencing' | 'promoted' | 'reverse_sync' | 'failback' | 'failed';
+    fence_status: 'none' | 'pending' | 'fenced' | 'failed';
+    approved_by?: string | null;
+    reason?: string | null;
+    started_at?: string;
+    finished_at?: string | null;
+}
+export interface ArkToken {
+    id: string;
+    name: string;
+    scope: 'read' | 'operator' | 'admin';
+    can_approve: boolean;
+    token_prefix: string;
+    last_used_at?: string | null;
+    expires_at?: string | null;
+    revoked_at?: string | null;
+    created_at?: string;
+    secret?: string;
+}
+export interface ArkAuditEntry {
+    id: number;
+    actor_type: string;
+    actor_id?: string | null;
+    action: string;
+    source_id?: string | null;
+    target_id?: string | null;
+    backup_id?: string | null;
+    metadata?: Record<string, unknown>;
+    ip?: string | null;
+    created_at?: string;
+}
+/** A four-eyes approval envelope carried on dangerous actions. */
+export interface ArkApproval {
+    approved_by: string;
+    approval_ref: string;
+}
+export declare function listArkSources(opts: ApiOptions): Promise<{
+    sources: ArkSource[];
+}>;
+export declare function createArkSource(opts: ApiOptions, body: ArkSourceInput): Promise<{
+    source: ArkSource;
+}>;
+export declare function getArkSource(opts: ApiOptions, id: string): Promise<{
+    source: ArkSource;
+}>;
+export declare function deleteArkSource(opts: ApiOptions, id: string): Promise<{
+    deleted: string;
+}>;
+export declare function listArkTargets(opts: ApiOptions): Promise<{
+    targets: ArkTarget[];
+}>;
+export declare function createArkTarget(opts: ApiOptions, body: ArkTargetInput): Promise<{
+    target: ArkTarget;
+}>;
+export declare function getArkTarget(opts: ApiOptions, id: string): Promise<{
+    target: ArkTarget;
+}>;
+export declare function deleteArkTarget(opts: ApiOptions, id: string): Promise<{
+    deleted: string;
+}>;
+export declare function listArkPolicies(opts: ApiOptions, sourceId?: string): Promise<{
+    policies: ArkPolicy[];
+}>;
+export declare function createArkPolicy(opts: ApiOptions, body: ArkPolicyInput): Promise<{
+    policy: ArkPolicy;
+}>;
+export declare function listArkBackups(opts: ApiOptions, sourceId?: string): Promise<{
+    backups: ArkBackup[];
+}>;
+export declare function runArkBackup(opts: ApiOptions, sourceId: string, policyId?: string): Promise<{
+    backup: ArkBackup;
+}>;
+export declare function listArkRestores(opts: ApiOptions, backupId?: string): Promise<{
+    restores: ArkRestore[];
+}>;
+export declare function startArkRestore(opts: ApiOptions, body: {
+    backup_id: string;
+    kind: 'real' | 'verification';
+    target_source_id?: string;
+} & Partial<ArkApproval>): Promise<{
+    restore: ArkRestore;
+}>;
+export declare function getArkFailover(opts: ApiOptions, sourceId: string): Promise<{
+    failover: ArkFailover | null;
+    replicas: ArkReplica[];
+    config: unknown;
+}>;
+export declare function promoteArkFailover(opts: ApiOptions, body: {
+    source_id: string;
+    to_node?: string;
+} & ArkApproval): Promise<{
+    failover: ArkFailover;
+    next: unknown;
+    note: string;
+}>;
+export declare function failbackArkFailover(opts: ApiOptions, body: {
+    source_id: string;
+    replica_lag_sec?: number;
+} & ArkApproval): Promise<{
+    failover_id: string;
+    state: string;
+    effects: string[];
+}>;
+export declare function listArkReplicas(opts: ApiOptions): Promise<{
+    replicas: ArkReplica[];
+}>;
+export declare function listArkTokens(opts: ApiOptions): Promise<{
+    tokens: ArkToken[];
+}>;
+export declare function createArkToken(opts: ApiOptions, body: {
+    name?: string;
+    scope?: 'read' | 'operator' | 'admin';
+    can_approve?: boolean;
+    expires_in_days?: number | null;
+}): Promise<{
+    token: ArkToken;
+}>;
+export declare function revokeArkToken(opts: ApiOptions, id: string): Promise<{
+    revoked: string;
+}>;
+export declare function listArkAudit(opts: ApiOptions, limit?: number): Promise<{
+    audit: ArkAuditEntry[];
+}>;
+export interface ArkCanaryReason {
+    code: string;
+    detail: string;
+}
+export interface ArkCanaryEvent {
+    id: string;
+    source_id: string;
+    backup_id?: string | null;
+    verdict: 'watch' | 'alarm';
+    severity: 'critical' | 'high' | 'medium' | 'low' | 'info';
+    entropy_bpb: number;
+    dedup_ratio: number;
+    baseline_entropy_bpb: number;
+    baseline_dedup_ratio: number;
+    baseline_samples: number;
+    reasons: ArkCanaryReason[];
+    status: 'open' | 'acknowledged' | 'dismissed' | 'confirmed';
+    acknowledged_by?: string | null;
+    created_at?: string;
+}
+export declare function listArkCanary(opts: ApiOptions): Promise<{
+    events: ArkCanaryEvent[];
+}>;
+export declare function ackArkCanary(opts: ApiOptions, id: string, status: 'acknowledged' | 'confirmed' | 'dismissed'): Promise<{
+    ok: boolean;
+}>;
+export interface ArkCloneMaskEntry {
+    table: string;
+    column: string;
+    pii: string;
+    transform: string;
+}
+export interface ArkClone {
+    id: string;
+    backup_id: string;
+    source_id: string;
+    restore_id?: string | null;
+    name: string;
+    masking_profile: 'standard' | 'strict' | 'none';
+    status: 'pending' | 'restoring' | 'masking' | 'ready' | 'expired' | 'failed';
+    mask_plan: ArkCloneMaskEntry[];
+    columns_masked: number;
+    rows_masked: number;
+    scratch_ref?: string | null;
+    has_connection: boolean;
+    expires_at?: string | null;
+    requested_by?: string | null;
+    error?: string | null;
+    created_at?: string;
+}
+export interface ArkCloneInput {
+    backup_id: string;
+    name?: string;
+    masking_profile?: 'standard' | 'strict' | 'none';
+    ttl_minutes?: number;
+    approved_by?: string;
+    approval_ref?: string;
+}
+export declare function listArkClones(opts: ApiOptions): Promise<{
+    clones: ArkClone[];
+}>;
+export declare function createArkClone(opts: ApiOptions, body: ArkCloneInput): Promise<{
+    clone: ArkClone;
+}>;
+export declare function expireArkClone(opts: ApiOptions, id: string): Promise<{
+    ok: boolean;
+}>;
+export interface ForgeRepo {
+    id: string;
+    name: string;
+    slug: string;
+    description: string;
+    visibility: 'private' | 'internal' | 'public';
+    default_branch: string;
+    size_bytes: number;
+    is_empty: boolean;
+    is_mirror: boolean;
+    status: 'active' | 'archived' | 'disabled';
+    created_at: string;
+    updated_at: string;
+}
+export interface ForgeToken {
+    id: string;
+    name: string;
+    scope: 'read' | 'write' | 'admin';
+    repo_id: string | null;
+    mfa_verified: boolean;
+    token_prefix: string;
+    last_used_at: string | null;
+    expires_at: string | null;
+    revoked_at: string | null;
+    created_at: string;
+}
+export interface ForgePolicy {
+    id: string;
+    repo_id: string;
+    pattern: string;
+    protected: boolean;
+    require_signed: boolean;
+    require_linear: boolean;
+    required_approvals: number;
+    required_checks: string[];
+    allow_force_push: boolean;
+    allow_deletions: boolean;
+    require_mfa_to_push: boolean;
+    dismiss_stale_reviews: boolean;
+    updated_at: string;
+}
+export interface ForgePR {
+    id: string;
+    number: number;
+    title: string;
+    body: string;
+    source_ref: string;
+    target_ref: string;
+    source_sha: string | null;
+    state: 'open' | 'draft' | 'merged' | 'closed';
+    merge_strategy: 'merge' | 'squash' | 'rebase' | null;
+    merged_sha: string | null;
+    author_id: string | null;
+    merged_by: string | null;
+    created_at: string;
+    updated_at: string;
+    merged_at: string | null;
+    closed_at: string | null;
+}
+export interface ForgeReview {
+    id: string;
+    reviewer_id: string | null;
+    state: 'pending' | 'approved' | 'changes_requested' | 'commented' | 'dismissed';
+    commit_sha: string | null;
+    submitted_at: string | null;
+    created_at: string;
+}
+export interface ForgeCheck {
+    id: string;
+    commit_sha: string;
+    context: string;
+    state: 'pending' | 'success' | 'failure' | 'error' | 'cancelled';
+    target_url: string | null;
+    description: string;
+    updated_at: string;
+}
+export interface ForgeFinding {
+    id: string;
+    repo_id: string;
+    rule: string;
+    file_path: string | null;
+    line: number | null;
+    commit_sha: string | null;
+    ref: string | null;
+    action: 'rejected' | 'allowlisted';
+    allowlisted_by: string | null;
+    allowlist_reason: string | null;
+    created_at: string;
+}
+export interface ForgeRefLogEntry {
+    id: number;
+    ref: string;
+    old_oid: string;
+    new_oid: string;
+    operation: 'create' | 'update' | 'force_update' | 'delete';
+    actor_type: 'user' | 'token' | 'system';
+    actor_id: string | null;
+    recoverable_until: string | null;
+    created_at: string;
+}
+export interface ForgeCommit {
+    oid: string;
+    short: string;
+    author: string;
+    author_email: string;
+    date: string;
+    subject: string;
+    parents: number;
+}
+export interface ForgeRef {
+    name: string;
+    oid: string;
+    target: string;
+    kind: 'branch' | 'tag';
+}
+export interface ForgeTreeEntry {
+    name: string;
+    path: string;
+    type: 'blob' | 'tree' | 'commit';
+    mode: string;
+    oid: string;
+    size: number;
+}
+export interface ForgeBlob {
+    path: string;
+    oid: string;
+    size: number;
+    binary: boolean;
+    truncated: boolean;
+    content: string;
+}
+export interface ForgeCorrelationEntry {
+    commit_sha: string;
+    short: string;
+    subject: string;
+    author: string;
+    date: string;
+    release: {
+        version: string;
+        environment: string;
+        grade: 'A' | 'B' | 'C' | 'D' | 'F' | null;
+        crash_free_pct: number | null;
+        deployed_at: string;
+        project_id: string;
+    };
+}
+export interface ForgeAuditEntry {
+    id: number;
+    actor_type: string;
+    actor_id: string | null;
+    action: string;
+    repo_id: string | null;
+    target_ref: string | null;
+    metadata: Record<string, unknown>;
+    ip: string | null;
+    created_at: string;
+}
+export interface ForgeDeviceGrant {
+    device_code: string;
+    user_code: string;
+    verification_uri: string;
+    expires_in: number;
+    interval: number;
+}
+export declare function forgeDeviceCode(opts: ApiOptions, scope: 'read' | 'write'): Promise<ForgeDeviceGrant>;
+export type ForgeDevicePoll = {
+    status: 'pending';
+} | {
+    status: 'slow_down';
+} | {
+    status: 'expired';
+} | {
+    status: 'ok';
+    token: string;
+    scope: string;
+};
+/** 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 declare function forgeDeviceToken(opts: ApiOptions, deviceCode: string): Promise<ForgeDevicePoll>;
+export declare function listForgeRepos(opts: ApiOptions): Promise<{
+    repos: ForgeRepo[];
+}>;
+export declare function createForgeRepo(opts: ApiOptions, body: {
+    name: string;
+    slug?: string;
+    description?: string;
+    visibility?: ForgeRepo['visibility'];
+    default_branch?: string;
+}): Promise<{
+    repo: ForgeRepo;
+}>;
+export declare function getForgeRepo(opts: ApiOptions, repo: string): Promise<{
+    repo: ForgeRepo;
+}>;
+export declare function deleteForgeRepo(opts: ApiOptions, repo: string): Promise<{
+    deleted: string;
+}>;
+export declare function forgeTree(opts: ApiOptions, repo: string, rev?: string, path?: string): Promise<{
+    entries: ForgeTreeEntry[];
+}>;
+export declare function forgeBlob(opts: ApiOptions, repo: string, path: string, rev?: string): Promise<{
+    blob: ForgeBlob;
+}>;
+export declare function forgeCommits(opts: ApiOptions, repo: string, rev?: string, limit?: number): Promise<{
+    commits: ForgeCommit[];
+}>;
+export declare function forgeRefs(opts: ApiOptions, repo: string): Promise<{
+    refs: ForgeRef[];
+}>;
+export declare function forgeBlame(opts: ApiOptions, repo: string, path: string, rev?: string): Promise<{
+    blame: unknown[];
+}>;
+export declare function listForgePolicies(opts: ApiOptions, repo: string): Promise<{
+    policies: ForgePolicy[];
+}>;
+export declare function putForgePolicy(opts: ApiOptions, repo: string, body: Record<string, unknown>): Promise<{
+    policy: ForgePolicy;
+}>;
+export declare function listForgeReflog(opts: ApiOptions, repo: string, limit?: number): Promise<{
+    reflog: ForgeRefLogEntry[];
+}>;
+export declare function recoverForgeRef(opts: ApiOptions, repo: string, id: string): Promise<{
+    recovered: {
+        ref: string;
+        oid: string;
+    };
+}>;
+export declare function listForgeFindings(opts: ApiOptions, repo: string, limit?: number): Promise<{
+    findings: ForgeFinding[];
+}>;
+export declare function allowlistForgeFinding(opts: ApiOptions, repo: string, id: string, reason: string): Promise<{
+    finding: ForgeFinding;
+}>;
+export declare function listForgePulls(opts: ApiOptions, repo: string, state?: string): Promise<{
+    pulls: ForgePR[];
+}>;
+export declare function createForgePull(opts: ApiOptions, repo: string, body: {
+    title: string;
+    body?: string;
+    source_ref: string;
+    target_ref?: string;
+    draft?: boolean;
+}): Promise<{
+    pull: ForgePR;
+}>;
+export declare function getForgePull(opts: ApiOptions, repo: string, number: number): Promise<{
+    pull: ForgePR;
+    reviews: ForgeReview[];
+}>;
+export declare function mergeForgePull(opts: ApiOptions, repo: string, number: number, body: {
+    strategy?: 'merge' | 'squash' | 'rebase';
+    message?: string;
+}): Promise<{
+    pull: ForgePR;
+    merged_sha: string;
+}>;
+export declare function reviewForgePull(opts: ApiOptions, repo: string, number: number, body: {
+    state: 'approved' | 'changes_requested' | 'commented';
+    body?: string;
+}): Promise<{
+    review: ForgeReview;
+}>;
+export declare function listForgeChecks(opts: ApiOptions, repo: string, sha?: string): Promise<{
+    checks: ForgeCheck[];
+}>;
+export declare function reportForgeCheck(opts: ApiOptions, repo: string, body: {
+    commit_sha: string;
+    context: string;
+    state: string;
+    target_url?: string;
+    description?: string;
+}): Promise<{
+    check: ForgeCheck;
+}>;
+export interface ForgeCiJob {
+    id: string;
+    repo_id: string;
+    pr_id: string | null;
+    sha: string;
+    ref: string;
+    workflow: string;
+    trigger: 'push' | 'pull_request' | 'manual';
+    status: 'queued' | 'running' | 'success' | 'failure' | 'error' | 'cancelled' | 'timed_out';
+    runner_id: string | null;
+    runner_name?: string | null;
+    log_bytes: number;
+    log_truncated: boolean;
+    failure_reason: string | null;
+    created_by: string | null;
+    started_at: string | null;
+    finished_at: string | null;
+    created_at: string;
+}
+export interface ForgeCiJobDetail extends ForgeCiJob {
+    config: {
+        image?: string;
+        steps?: string[];
+        timeout?: number;
+        env?: Record<string, string>;
+    };
+    log: string;
+}
+export declare function listForgeCiJobs(opts: ApiOptions, repo: string, status?: string, workflow?: string, limit?: number): Promise<{
+    jobs: ForgeCiJob[];
+    next_cursor: string | null;
+}>;
+export declare function getForgeCiJob(opts: ApiOptions, repo: string, id: string): Promise<{
+    job: ForgeCiJobDetail;
+}>;
+export declare function runForgeCi(opts: ApiOptions, repo: string, sha?: string, ref?: string): Promise<{
+    enqueued: number;
+    sha: string;
+    ref: string;
+    config_missing?: boolean;
+    config_error?: string;
+}>;
+export declare function forgeCorrelation(opts: ApiOptions, repo: string, rev?: string): Promise<{
+    granularity: string;
+    shipped: number;
+    commits_scanned: number;
+    correlation: ForgeCorrelationEntry[];
+}>;
+export declare function listForgeTokens(opts: ApiOptions): Promise<{
+    tokens: ForgeToken[];
+}>;
+export declare function createForgeToken(opts: ApiOptions, body: {
+    name?: string;
+    scope?: 'read' | 'write' | 'admin';
+    repo?: string;
+    expires_in_days?: number | null;
+}): Promise<{
+    token: ForgeToken & {
+        secret: string;
+    };
+}>;
+export declare function revokeForgeToken(opts: ApiOptions, id: string): Promise<{
+    revoked: string;
+}>;
+export declare function listForgeAudit(opts: ApiOptions, limit?: number): Promise<{
+    audit: ForgeAuditEntry[];
+}>;
+export interface ForgeAiPolicy {
+    repo_id: string | null;
+    allow_egress: boolean;
+    sensitive: boolean;
+    redact_secrets: boolean;
+    allowed_providers: string[];
+    max_context_bytes: number;
+    default?: boolean;
+}
+export interface ForgeKey {
+    id: string;
+    name: string;
+    kind: 'ssh_public' | 'deploy_token';
+    scope: 'read' | 'write';
+    fingerprint: string | null;
+    expires_at: string | null;
+    last_used_at: string | null;
+    revoked_at: string | null;
+    created_at: string;
+    repo_id?: string | null;
+}
+export declare function getForgeAiPolicy(opts: ApiOptions, repo: string): Promise<{
+    policy: ForgeAiPolicy;
+}>;
+export declare function putForgeAiPolicy(opts: ApiOptions, repo: string, body: Record<string, unknown>): Promise<{
+    policy: ForgeAiPolicy;
+}>;
+export declare function listForgeEgress(opts: ApiOptions, limit?: number): Promise<{
+    egress: Array<Record<string, unknown>>;
+}>;
+export declare function setForgeMirror(opts: ApiOptions, repo: string, body: {
+    url: string;
+    direction?: 'pull' | 'push';
+}): Promise<{
+    ok: boolean;
+}>;
+export declare function removeForgeMirror(opts: ApiOptions, repo: string): Promise<{
+    ok: boolean;
+}>;
+export declare function listForgeKeys(opts: ApiOptions, repo: string): Promise<{
+    keys: ForgeKey[];
+}>;
+export declare function addForgeKey(opts: ApiOptions, repo: string, body: {
+    name: string;
+    public_key: string;
+    scope?: 'read' | 'write';
+    expires_in_days?: number;
+}): Promise<{
+    key: ForgeKey;
+}>;
+export declare function revokeForgeKey(opts: ApiOptions, repo: string, keyId: string): Promise<{
+    revoked: string;
+}>;
+export declare function getForgeCodeowners(opts: ApiOptions, repo: string, rev?: string): Promise<{
+    configured: boolean;
+    source?: string;
+    rules: Array<{
+        pattern: string;
+        owners: string[];
+    }>;
+}>;
+export interface ForgeIssue {
+    id: string;
+    number: number;
+    title: string;
+    body?: string;
+    state: 'open' | 'closed';
+    author_id: string | null;
+    assignee_id: string | null;
+    labels: string[];
+    comment_count: number;
+    created_at: string;
+    updated_at: string;
+    closed_at?: string | null;
+    closed_by?: string | null;
+}
+export interface ForgeIssueComment {
+    id: string;
+    author_id: string | null;
+    body: string;
+    created_at: string;
+}
+export interface ForgeLabel {
+    id: string;
+    name: string;
+    color: string;
+    description: string;
+}
+export interface ForgeCollaborator {
+    id: string;
+    user_id: string;
+    role: 'read' | 'triage' | 'write' | 'admin';
+    added_by: string | null;
+    created_at: string;
+}
+export interface ForgeReviewComment {
+    id: string;
+    author_id: string | null;
+    file_path: string | null;
+    line: number | null;
+    commit_sha: string | null;
+    body: string;
+    resolved: boolean;
+    outdated: boolean;
+    created_at: string;
+}
+export interface ForgeDiff {
+    base: string;
+    head: string;
+    files: Array<{
+        path: string;
+        status?: string;
+    }>;
+}
+export declare function listForgeIssues(opts: ApiOptions, repo: string, params?: {
+    state?: string;
+    label?: string;
+}): Promise<{
+    issues: ForgeIssue[];
+}>;
+export declare function createForgeIssue(opts: ApiOptions, repo: string, body: {
+    title: string;
+    body?: string;
+    labels?: string[];
+    assignee_id?: string;
+}): Promise<{
+    issue: ForgeIssue;
+}>;
+export declare function getForgeIssue(opts: ApiOptions, repo: string, number: number): Promise<{
+    issue: ForgeIssue;
+    comments: ForgeIssueComment[];
+}>;
+export declare function updateForgeIssue(opts: ApiOptions, repo: string, number: number, body: {
+    state?: 'open' | 'closed';
+    title?: string;
+    body?: string;
+    labels?: string[];
+    assignee_id?: string | null;
+}): Promise<{
+    issue: ForgeIssue;
+}>;
+export declare function commentForgeIssue(opts: ApiOptions, repo: string, number: number, body: string): Promise<{
+    comment: ForgeIssueComment;
+}>;
+export declare function listForgeLabels(opts: ApiOptions, repo: string): Promise<{
+    labels: ForgeLabel[];
+}>;
+export declare function createForgeLabel(opts: ApiOptions, repo: string, body: {
+    name: string;
+    color?: string;
+    description?: string;
+}): Promise<{
+    label: ForgeLabel;
+}>;
+export declare function listForgeCollaborators(opts: ApiOptions, repo: string): Promise<{
+    collaborators: ForgeCollaborator[];
+}>;
+export declare function addForgeCollaborator(opts: ApiOptions, repo: string, body: {
+    user_id: string;
+    role?: 'read' | 'triage' | 'write' | 'admin';
+}): Promise<{
+    collaborator: ForgeCollaborator;
+}>;
+export declare function removeForgeCollaborator(opts: ApiOptions, repo: string, id: string): Promise<{
+    removed: string;
+}>;
+export declare function updateForgePull(opts: ApiOptions, repo: string, number: number, body: {
+    state?: 'open' | 'closed';
+    title?: string;
+    body?: string;
+}): Promise<{
+    pull: ForgePR;
+}>;
+export declare function listForgePullComments(opts: ApiOptions, repo: string, number: number): Promise<{
+    comments: ForgeReviewComment[];
+}>;
+export declare function commentForgePull(opts: ApiOptions, repo: string, number: number, body: {
+    body: string;
+    file_path?: string;
+    line?: number;
+    commit_sha?: string;
+}): Promise<{
+    comment: ForgeReviewComment;
+}>;
+export declare function forgePullDiff(opts: ApiOptions, repo: string, number: number): Promise<ForgeDiff>;
+export declare function forgeCompare(opts: ApiOptions, repo: string, base: string, head: string): Promise<ForgeDiff>;
+export interface ForgeSearchMatch {
+    path: string;
+    line: number;
+    text: string;
+}
+export declare function forgeSearch(opts: ApiOptions, repo: string, q: string, rev?: string, limit?: number): Promise<{
+    query: string;
+    rev: string;
+    matches: ForgeSearchMatch[];
+}>;
+export interface ForgeEnvironment {
+    id: string;
+    name: string;
+    production: boolean;
+    url: string;
+    required_approvals: number;
+}
+export interface ForgeDeployment {
+    id: string;
+    environment: string;
+    ref: string;
+    sha: string | null;
+    state: string;
+    url: string;
+    description: string;
+    pr_number: number | null;
+    created_at: string;
+}
+export interface ForgeReleaseAsset {
+    id: string;
+    name: string;
+    platform: string;
+    arch: string;
+    size_bytes: number;
+    url: string | null;
+    sha256: string | null;
+}
+export interface ForgeRelease {
+    id: string;
+    tag: string;
+    name: string;
+    body: string;
+    prerelease: boolean;
+    draft: boolean;
+    published_at: string | null;
+    created_at: string;
+    assets: ForgeReleaseAsset[];
+}
+export interface ForgeWebhook {
+    id: string;
+    repo_id: string | null;
+    url: string;
+    events: string[];
+    active: boolean;
+    created_at: string;
+}
+export interface ForgeWebhookDelivery {
+    id: number;
+    event: string;
+    status_code: number;
+    success: boolean;
+    duration_ms: number;
+    error: string | null;
+    created_at: string;
+}
+export declare function forgeEnvironments(opts: ApiOptions, repo: string): Promise<{
+    environments: ForgeEnvironment[];
+}>;
+export declare function forgeSetEnvironment(opts: ApiOptions, repo: string, body: Record<string, unknown>): Promise<{
+    environment: ForgeEnvironment;
+}>;
+export declare function forgeDeployments(opts: ApiOptions, repo: string, environment?: string): Promise<{
+    deployments: ForgeDeployment[];
+}>;
+export declare function forgeCreateDeployment(opts: ApiOptions, repo: string, body: Record<string, unknown>): Promise<{
+    deployment: ForgeDeployment;
+}>;
+export declare function forgeUpdateDeployment(opts: ApiOptions, repo: string, id: string, body: Record<string, unknown>): Promise<{
+    deployment: ForgeDeployment;
+}>;
+export declare function forgeReleases(opts: ApiOptions, repo: string): Promise<{
+    releases: ForgeRelease[];
+}>;
+export declare function forgeGetRelease(opts: ApiOptions, repo: string, tag: string): Promise<{
+    release: ForgeRelease;
+    assets: ForgeReleaseAsset[];
+}>;
+export declare function forgeCreateRelease(opts: ApiOptions, repo: string, body: Record<string, unknown>): Promise<{
+    release: ForgeRelease;
+}>;
+export declare function forgeDeleteRelease(opts: ApiOptions, repo: string, tag: string): Promise<unknown>;
+export declare function forgeAddAsset(opts: ApiOptions, repo: string, tag: string, body: Record<string, unknown>): Promise<{
+    asset: ForgeReleaseAsset;
+}>;
+export declare function forgeRemoveAsset(opts: ApiOptions, repo: string, tag: string, id: string): Promise<unknown>;
+export declare function forgeWebhooks(opts: ApiOptions): Promise<{
+    webhooks: ForgeWebhook[];
+}>;
+export declare function forgeCreateWebhook(opts: ApiOptions, body: Record<string, unknown>): Promise<{
+    webhook: ForgeWebhook;
+}>;
+export declare function forgeDeleteWebhook(opts: ApiOptions, id: string): Promise<unknown>;
+export declare function forgePingWebhook(opts: ApiOptions, id: string): Promise<{
+    delivery: ForgeWebhookDelivery;
+}>;
+export declare function forgeWebhookDeliveries(opts: ApiOptions, id: string): Promise<{
+    deliveries: ForgeWebhookDelivery[];
+}>;
+export declare function listForgeAccountKeys(opts: ApiOptions): Promise<{
+    keys: ForgeKey[];
+}>;
+export declare function addForgeAccountKey(opts: ApiOptions, body: {
+    name: string;
+    public_key: string;
+    scope?: 'read' | 'write';
+    expires_in_days?: number;
+}): Promise<{
+    key: ForgeKey;
+}>;
+export declare function revokeForgeAccountKey(opts: ApiOptions, id: string): Promise<{
+    revoked: string;
+}>;
+//# sourceMappingURL=api.d.ts.map