@mnemom/mnemom 0.10.0 → 0.12.0

package/dist/lib/api.d.ts

@@ -18,7 +18,7 @@ export interface Agent {
     created_at: string;
 }
 /**
- * Per docs.mnemom.ai/api-reference/openapi.json#components/schemas/IntegrityScore:
+ * Per api.mnemom.ai/openapi.json#components/schemas/IntegrityScore:
  *
  *   { agent_id, total_traces, verified_traces, violation_count, integrity_score }
  *
@@ -344,7 +344,7 @@ export declare function testPolicyHistorical(agentId: string, policyJson: Record
     agent_id: string;
     policy_name: string;
     total_traces: number;
-    results: any[];
+    results: unknown[];
     summary: {
         pass: number;
         warn: number;
@@ -645,4 +645,201 @@ export declare function getSafeHouseHarnessState(): Promise<{
     full: HarnessRunSummary | null;
     fast: HarnessRunSummary | null;
 }>;
+export type GovernanceSignalScope = "platform" | "org" | "team" | "agent";
+export type GovernanceSignalSource = "sideband.drift" | "sideband.coherence" | "sideband.fault_line" | "sideband.fleet";
+export type GovernanceSignalSeverity = "info" | "warn" | "high" | "critical";
+export type GovernanceSignalStatus = "open" | "acknowledged" | "resolved" | "dismissed" | "expired";
+export type GovernanceResolutionStatus = "action_taken" | "wont_fix" | "duplicate" | "false_positive" | "self_resolved";
+export type GovernanceNotificationChannel = "webhook" | "slack" | "email" | "pagerduty";
+export interface GovernanceSignal {
+    id: string;
+    scope: GovernanceSignalScope;
+    scope_id: string;
+    source: GovernanceSignalSource;
+    pattern_type: string;
+    severity: GovernanceSignalSeverity;
+    detected_at: string;
+    detected_by: string;
+    org_id: string;
+    team_id: string | null;
+    agent_ids: string[];
+    detail: Record<string, unknown>;
+    source_ref: Record<string, unknown>;
+    status: GovernanceSignalStatus;
+    acknowledged_by: string | null;
+    acknowledged_at: string | null;
+    acknowledged_actor_role: string | null;
+    resolution_status: GovernanceResolutionStatus | null;
+    action_taken: string | null;
+    resolved_by: string | null;
+    resolved_at: string | null;
+    expires_at: string | null;
+    notification_state: Record<string, unknown>;
+    created_at: string;
+    updated_at: string;
+}
+export interface GovernanceDestination {
+    id: string;
+    org_id: string;
+    channel: GovernanceNotificationChannel;
+    config: Record<string, unknown>;
+    filter: Record<string, unknown>;
+    enabled: boolean;
+    display_name: string | null;
+    last_tested_at: string | null;
+    last_test_status: "ok" | "failed" | null;
+    last_test_error: string | null;
+    created_at: string;
+    updated_at: string;
+}
+export interface GovernanceRule {
+    id: string;
+    org_id: string;
+    name: string;
+    predicate: Record<string, unknown>;
+    destination_ids: string[];
+    enabled: boolean;
+    last_fired_at: string | null;
+    fire_count: number;
+    created_at: string;
+    updated_at: string;
+}
+interface SignalListFilters {
+    source?: string;
+    severity?: string;
+    status?: string;
+    scope?: string;
+    pattern_type?: string;
+    since?: string;
+    limit?: number;
+}
+export declare function listGovernanceSignalsForOrg(orgId: string, opts?: SignalListFilters): Promise<{
+    org_id: string;
+    signals: GovernanceSignal[];
+}>;
+export declare function listGovernanceSignalsForTeam(teamId: string, opts?: SignalListFilters): Promise<{
+    team_id: string;
+    signals: GovernanceSignal[];
+}>;
+export declare function listGovernanceSignalsForAgent(agentId: string, opts?: SignalListFilters): Promise<{
+    agent_id: string;
+    signals: GovernanceSignal[];
+}>;
+export declare function getGovernanceSignal(id: string): Promise<GovernanceSignal>;
+export declare function acknowledgeGovernanceSignal(id: string, body?: {
+    action_taken?: string;
+}): Promise<GovernanceSignal>;
+export declare function resolveGovernanceSignal(id: string, body: {
+    resolution_status: GovernanceResolutionStatus;
+    action_taken?: string;
+}): Promise<GovernanceSignal>;
+export declare function dismissGovernanceSignal(id: string, body?: {
+    reason?: string;
+}): Promise<GovernanceSignal>;
+export declare function listGovernanceDestinations(orgId: string): Promise<{
+    org_id: string;
+    destinations: GovernanceDestination[];
+}>;
+export declare function createGovernanceDestination(orgId: string, body: {
+    channel: GovernanceNotificationChannel;
+    config: Record<string, unknown>;
+    filter?: Record<string, unknown>;
+    display_name?: string;
+    enabled?: boolean;
+}): Promise<GovernanceDestination>;
+export declare function deleteGovernanceDestination(orgId: string, destinationId: string): Promise<{
+    ok: true;
+}>;
+export declare function testGovernanceDestination(orgId: string, destinationId: string): Promise<{
+    destination_id: string;
+    channel: GovernanceNotificationChannel;
+    result: {
+        ok: boolean;
+        attempts: number;
+        delivered_at?: string;
+        last_error?: string;
+    };
+}>;
+export declare function listGovernanceRules(orgId: string): Promise<{
+    org_id: string;
+    rules: GovernanceRule[];
+}>;
+export declare function createGovernanceRule(orgId: string, body: {
+    name: string;
+    predicate: Record<string, unknown>;
+    destination_ids: string[];
+    enabled?: boolean;
+}): Promise<GovernanceRule>;
+export declare function deleteGovernanceRule(orgId: string, ruleId: string): Promise<{
+    ok: true;
+}>;
+/**
+ * Capability-based scope vocabulary (ADR-049). Mirrors the API's
+ * VALID_SCOPES exactly. Update both surfaces together when the
+ * vocabulary changes.
+ */
+export declare const API_KEY_SCOPES: readonly ["gateway", "api:read", "api:write", "admin:org", "admin:platform"];
+export type ApiKeyScope = (typeof API_KEY_SCOPES)[number];
+export declare const DEFAULT_API_KEY_SCOPES: ApiKeyScope[];
+/**
+ * Recognize legacy two-scope sets so the CLI can annotate pre-ADR-049
+ * keys appropriately. Mirror of mnemom-api `expandLegacyScopes` logic
+ * for display purposes; the auth gate handles the actual aliasing.
+ */
+export declare function isLegacyScopeSet(scopes: string[] | undefined): boolean;
+export interface ApiKeyListItem {
+    key_id: string;
+    key_prefix: string;
+    name: string;
+    scopes: string[];
+    created_at: string;
+    last_used_at: string | null;
+    org_id?: string | null;
+}
+export interface ApiKeyCreated {
+    key_id: string;
+    key: string;
+    key_prefix: string;
+    name: string;
+    scopes: string[];
+    created_at: string;
+}
+/**
+ * GET /v1/api-keys — list the caller's active personal API keys.
+ */
+export declare function listApiKeys(): Promise<ApiKeyListItem[]>;
+/**
+ * POST /v1/api-keys — mint a new personal API key with explicit scopes.
+ *
+ * Returns the full secret only on this call. The mint-time ceiling
+ * rejects admin scopes the caller is not eligible for (admin:platform
+ * for non-staff, admin:org for users not in any org-admin role).
+ */
+export declare function createApiKey(name: string, scopes: ApiKeyScope[]): Promise<ApiKeyCreated>;
+/**
+ * POST /v1/api-keys/{key_id}/rotate — atomic mint-new + revoke-old.
+ * Returns the full new secret only on this call. The new key inherits
+ * the old key's name and scopes verbatim; the old key is revoked the
+ * moment this returns.
+ */
+export declare function rotateApiKey(keyId: string): Promise<ApiKeyCreated>;
+/**
+ * DELETE /v1/api-keys/{key_id} — soft-revoke. The key row stays for
+ * audit; `is_active` flips to false and `revoked_at` is timestamped.
+ */
+export declare function revokeApiKey(keyId: string): Promise<void>;
+export interface RecipeReportInput {
+    type: "fn" | "fp";
+    summary: string;
+    evidence?: string;
+    agent_id?: string;
+    checkpoint_id?: string;
+}
+export interface RecipeReportResult {
+    ok: true;
+    candidate_id: string;
+    type: "fn" | "fp";
+    related_recipe_id: string;
+}
+export declare function reportRecipeFnFp(recipeId: string, input: RecipeReportInput): Promise<RecipeReportResult>;
 export {};

package/dist/lib/api.js

@@ -1162,3 +1162,210 @@ export async function getSafeHouseHarnessState() {
     }
     return (await response.json());
 }
+function buildSignalListQuery(opts = {}) {
+    const params = new URLSearchParams();
+    if (opts.source)
+        params.set("source", opts.source);
+    if (opts.severity)
+        params.set("severity", opts.severity);
+    if (opts.status)
+        params.set("status", opts.status);
+    if (opts.scope)
+        params.set("scope", opts.scope);
+    if (opts.pattern_type)
+        params.set("pattern_type", opts.pattern_type);
+    if (opts.since)
+        params.set("since", opts.since);
+    if (opts.limit)
+        params.set("limit", String(opts.limit));
+    const qs = params.toString();
+    return qs ? `?${qs}` : "";
+}
+async function gFetch(path, init = {}, notFoundLabel) {
+    const url = validateUrl(`${API_BASE}${path}`);
+    const response = await fetchWithAuthRetry(url, async () => ({
+        method: init.method ?? "GET",
+        headers: {
+            ...(await authHeaders()),
+            Accept: "application/json",
+            ...(init.body ? { "Content-Type": "application/json" } : {}),
+            ...(init.headers ?? {}),
+        },
+        body: init.body,
+    }));
+    if (!response.ok) {
+        if (response.status === 401)
+            throw new Error("Not authenticated.");
+        if (response.status === 403)
+            throw new Error("Permission denied (need org admin / membership).");
+        if (response.status === 404 && notFoundLabel)
+            throw new Error(`${notFoundLabel} not found.`);
+        const err = (await response.json().catch(() => ({ error: "unknown" })));
+        throw new Error(err.message || `Request failed: ${response.status}`);
+    }
+    return (await response.json());
+}
+export async function listGovernanceSignalsForOrg(orgId, opts = {}) {
+    return gFetch(`/v1/orgs/${encodeURIComponent(orgId)}/governance/signals${buildSignalListQuery(opts)}`, {}, "Org");
+}
+export async function listGovernanceSignalsForTeam(teamId, opts = {}) {
+    return gFetch(`/v1/teams/${encodeURIComponent(teamId)}/governance/signals${buildSignalListQuery(opts)}`, {}, "Team");
+}
+export async function listGovernanceSignalsForAgent(agentId, opts = {}) {
+    return gFetch(`/v1/agents/${encodeURIComponent(agentId)}/governance/signals${buildSignalListQuery(opts)}`, {}, "Agent");
+}
+export async function getGovernanceSignal(id) {
+    return gFetch(`/v1/governance/signals/${encodeURIComponent(id)}`, {}, "Signal");
+}
+export async function acknowledgeGovernanceSignal(id, body = {}) {
+    return gFetch(`/v1/governance/signals/${encodeURIComponent(id)}/acknowledge`, { method: "POST", body: JSON.stringify(body) }, "Signal");
+}
+export async function resolveGovernanceSignal(id, body) {
+    return gFetch(`/v1/governance/signals/${encodeURIComponent(id)}/resolve`, { method: "POST", body: JSON.stringify(body) }, "Signal");
+}
+export async function dismissGovernanceSignal(id, body = {}) {
+    return gFetch(`/v1/governance/signals/${encodeURIComponent(id)}/dismiss`, { method: "POST", body: JSON.stringify(body) }, "Signal");
+}
+export async function listGovernanceDestinations(orgId) {
+    return gFetch(`/v1/orgs/${encodeURIComponent(orgId)}/governance/notification-destinations`, {}, "Org");
+}
+export async function createGovernanceDestination(orgId, body) {
+    return gFetch(`/v1/orgs/${encodeURIComponent(orgId)}/governance/notification-destinations`, { method: "POST", body: JSON.stringify(body) }, "Org");
+}
+export async function deleteGovernanceDestination(orgId, destinationId) {
+    return gFetch(`/v1/orgs/${encodeURIComponent(orgId)}/governance/notification-destinations/${encodeURIComponent(destinationId)}`, { method: "DELETE" }, "Destination");
+}
+export async function testGovernanceDestination(orgId, destinationId) {
+    return gFetch(`/v1/orgs/${encodeURIComponent(orgId)}/governance/notification-destinations/${encodeURIComponent(destinationId)}/test`, { method: "POST", body: JSON.stringify({}) }, "Destination");
+}
+export async function listGovernanceRules(orgId) {
+    return gFetch(`/v1/orgs/${encodeURIComponent(orgId)}/governance/escalation-rules`, {}, "Org");
+}
+export async function createGovernanceRule(orgId, body) {
+    return gFetch(`/v1/orgs/${encodeURIComponent(orgId)}/governance/escalation-rules`, { method: "POST", body: JSON.stringify(body) }, "Org");
+}
+export async function deleteGovernanceRule(orgId, ruleId) {
+    return gFetch(`/v1/orgs/${encodeURIComponent(orgId)}/governance/escalation-rules/${encodeURIComponent(ruleId)}`, { method: "DELETE" }, "Rule");
+}
+// ─── api-keys (ADR-049) ─────────────────────────────────────────────────
+/**
+ * Capability-based scope vocabulary (ADR-049). Mirrors the API's
+ * VALID_SCOPES exactly. Update both surfaces together when the
+ * vocabulary changes.
+ */
+export const API_KEY_SCOPES = [
+    "gateway",
+    "api:read",
+    "api:write",
+    "admin:org",
+    "admin:platform",
+];
+export const DEFAULT_API_KEY_SCOPES = ["gateway", "api:read", "api:write"];
+/**
+ * Recognize legacy two-scope sets so the CLI can annotate pre-ADR-049
+ * keys appropriately. Mirror of mnemom-api `expandLegacyScopes` logic
+ * for display purposes; the auth gate handles the actual aliasing.
+ */
+export function isLegacyScopeSet(scopes) {
+    if (!scopes || scopes.length === 0)
+        return false;
+    if (scopes.length === 2 && scopes.includes("gateway") && scopes.includes("api")) {
+        return true;
+    }
+    if (scopes.length === 1 && scopes[0] === "api")
+        return true;
+    return false;
+}
+/**
+ * GET /v1/api-keys — list the caller's active personal API keys.
+ */
+export async function listApiKeys() {
+    const url = validateUrl(`${API_BASE}/v1/api-keys`);
+    const response = await fetchWithAuthRetry(url, async () => ({
+        headers: await authHeaders(),
+    }));
+    if (!response.ok) {
+        if (response.status === 401) {
+            throw new Error("Not authenticated. Run `mnemom login` or set MNEMOM_API_KEY.");
+        }
+        const err = (await response.json().catch(() => ({ error: "unknown" })));
+        throw new Error(err.message || `Failed to list api keys: ${response.status}`);
+    }
+    const data = (await response.json());
+    return data.keys ?? [];
+}
+/**
+ * POST /v1/api-keys — mint a new personal API key with explicit scopes.
+ *
+ * Returns the full secret only on this call. The mint-time ceiling
+ * rejects admin scopes the caller is not eligible for (admin:platform
+ * for non-staff, admin:org for users not in any org-admin role).
+ */
+export async function createApiKey(name, scopes) {
+    const url = validateUrl(`${API_BASE}/v1/api-keys`);
+    const response = await fetchWithAuthRetry(url, async () => ({
+        method: "POST",
+        headers: { ...(await authHeaders()), "Content-Type": "application/json" },
+        body: JSON.stringify({ name, scopes }),
+    }));
+    if (!response.ok) {
+        if (response.status === 401) {
+            throw new Error("Not authenticated. Run `mnemom login` or set MNEMOM_API_KEY.");
+        }
+        const body = await response.text().catch(() => "");
+        if (response.status === 403) {
+            throw new Error(`Mint-time ceiling rejected scope: ${body}`);
+        }
+        if (response.status === 400) {
+            throw new Error(`Invalid scope(s): ${body}`);
+        }
+        throw new Error(`Failed to create api key: ${response.status} ${body}`);
+    }
+    return (await response.json());
+}
+/**
+ * POST /v1/api-keys/{key_id}/rotate — atomic mint-new + revoke-old.
+ * Returns the full new secret only on this call. The new key inherits
+ * the old key's name and scopes verbatim; the old key is revoked the
+ * moment this returns.
+ */
+export async function rotateApiKey(keyId) {
+    const url = validateUrl(`${API_BASE}/v1/api-keys/${encodeURIComponent(keyId)}/rotate`);
+    const response = await fetchWithAuthRetry(url, async () => ({
+        method: "POST",
+        headers: { ...(await authHeaders()), "Content-Type": "application/json" },
+    }));
+    if (!response.ok) {
+        if (response.status === 401) {
+            throw new Error("Not authenticated. Run `mnemom login` or set MNEMOM_API_KEY.");
+        }
+        if (response.status === 404)
+            throw new Error(`Key not found: ${keyId}`);
+        const body = await response.text().catch(() => "");
+        throw new Error(`Failed to rotate api key: ${response.status} ${body}`);
+    }
+    return (await response.json());
+}
+/**
+ * DELETE /v1/api-keys/{key_id} — soft-revoke. The key row stays for
+ * audit; `is_active` flips to false and `revoked_at` is timestamped.
+ */
+export async function revokeApiKey(keyId) {
+    const url = validateUrl(`${API_BASE}/v1/api-keys/${encodeURIComponent(keyId)}`);
+    const response = await fetchWithAuthRetry(url, async () => ({
+        method: "DELETE",
+        headers: await authHeaders(),
+    }));
+    if (!response.ok) {
+        if (response.status === 401) {
+            throw new Error("Not authenticated. Run `mnemom login` or set MNEMOM_API_KEY.");
+        }
+        if (response.status === 404)
+            throw new Error(`Key not found: ${keyId}`);
+        const body = await response.text().catch(() => "");
+        throw new Error(`Failed to revoke api key: ${response.status} ${body}`);
+    }
+}
+export async function reportRecipeFnFp(recipeId, input) {
+    return postApi(`/v1/recipes/${encodeURIComponent(recipeId)}/report`, input);
+}

package/dist/lib/auth.js

@@ -311,11 +311,7 @@ async function startCallbackServer(expectedState) {
     };
 }
 function openBrowser(url) {
-    const cmd = process.platform === "darwin"
-        ? "open"
-        : process.platform === "win32"
-            ? "start"
-            : "xdg-open";
+    const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
     exec(`${cmd} ${JSON.stringify(url)}`);
 }
 // ============================================================================

package/dist/lib/format.d.ts

@@ -24,6 +24,10 @@ export declare const fmt: {
      * Dim label with value
      */
     label(key: string, val: string): string;
+    /**
+     * Dim text (for inline annotations and footnotes).
+     */
+    dim(text: string): string;
     /**
      * Syntax-highlighted JSON output
      */

package/dist/lib/format.js

@@ -38,6 +38,12 @@ export const fmt = {
     label(key, val) {
         return `${chalk.dim(key)} ${val}`;
     },
+    /**
+     * Dim text (for inline annotations and footnotes).
+     */
+    dim(text) {
+        return chalk.dim(text);
+    },
     /**
      * Syntax-highlighted JSON output
      */

package/dist/lib/listen-stream.d.ts

@@ -0,0 +1,40 @@
+/**
+ * SSE event-stream consumer for `mnemom listen` (Track 2 W3.4b).
+ *
+ * Parses `text/event-stream` framing into `SseFrame` objects per the
+ * W3C EventSource spec subset we need:
+ *
+ *   - Events delimited by `\n\n`.
+ *   - Lines starting with `:` are comments (heartbeats).
+ *   - `event: <name>` sets the frame's event name (default "message").
+ *   - `data: <json>` accumulates into a multi-line payload.
+ *   - `id: <cursor>` sets the frame's last-event-id.
+ *
+ * Exposed as a generator so callers can iterate with `for await`.
+ */
+export interface SseFrame {
+    event: string;
+    /** Multi-line `data:` payload joined with `\n`. */
+    data: string;
+    /** The `id:` cursor (for Last-Event-ID reconnect). */
+    id?: string;
+}
+/**
+ * Consume a fetch Response body and yield SSE frames.
+ *
+ * Buffers across chunk boundaries — SSE delimiters can land mid-chunk.
+ */
+export declare function parseSseStream(body: ReadableStream<Uint8Array>): AsyncGenerator<SseFrame, void, void>;
+/**
+ * Re-sign a webhook event body with a local-only secret. Mirrors the
+ * platform's HMAC-SHA256 over `${ts}.${rawBody}` convention so the
+ * receiver verifies cleanly with the same scheme.
+ *
+ * Used by `mnemom listen --forward-to <url> --secret <hex>` to make
+ * the local receiver behave identically to a production webhook
+ * subscriber.
+ */
+export declare function reSignDelivery(rawBody: string, signingSecret: string, nowSeconds?: number): {
+    timestamp: string;
+    signature: string;
+};

package/dist/lib/listen-stream.js

@@ -0,0 +1,101 @@
+/**
+ * SSE event-stream consumer for `mnemom listen` (Track 2 W3.4b).
+ *
+ * Parses `text/event-stream` framing into `SseFrame` objects per the
+ * W3C EventSource spec subset we need:
+ *
+ *   - Events delimited by `\n\n`.
+ *   - Lines starting with `:` are comments (heartbeats).
+ *   - `event: <name>` sets the frame's event name (default "message").
+ *   - `data: <json>` accumulates into a multi-line payload.
+ *   - `id: <cursor>` sets the frame's last-event-id.
+ *
+ * Exposed as a generator so callers can iterate with `for await`.
+ */
+import { createHmac } from "node:crypto";
+/**
+ * Consume a fetch Response body and yield SSE frames.
+ *
+ * Buffers across chunk boundaries — SSE delimiters can land mid-chunk.
+ */
+export async function* parseSseStream(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buf = "";
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buf += decoder.decode(value, { stream: true });
+            // Frames end at \n\n. Process all complete frames; keep the trailing partial.
+            let idx;
+            while ((idx = buf.indexOf("\n\n")) !== -1) {
+                const frameRaw = buf.slice(0, idx);
+                buf = buf.slice(idx + 2);
+                const frame = parseFrame(frameRaw);
+                if (frame)
+                    yield frame;
+            }
+        }
+        // Drain trailing partial — usually a comment line right before the
+        // server-side close. Process if it parses cleanly.
+        if (buf.length > 0) {
+            const frame = parseFrame(buf);
+            if (frame)
+                yield frame;
+        }
+    }
+    finally {
+        try {
+            await reader.cancel();
+        }
+        catch {
+            /* socket already torn down */
+        }
+    }
+}
+function parseFrame(raw) {
+    const lines = raw.split("\n");
+    let event = "message";
+    let id;
+    const dataLines = [];
+    let hadDataField = false;
+    for (const line of lines) {
+        if (line.length === 0)
+            continue;
+        if (line.startsWith(":"))
+            continue; // heartbeat comment
+        const colonIdx = line.indexOf(":");
+        if (colonIdx === -1)
+            continue;
+        const field = line.slice(0, colonIdx);
+        const value = line.slice(colonIdx + 1).replace(/^ /, ""); // strip optional leading space
+        if (field === "event")
+            event = value;
+        else if (field === "data") {
+            dataLines.push(value);
+            hadDataField = true;
+        }
+        else if (field === "id")
+            id = value;
+    }
+    if (!hadDataField)
+        return null;
+    return { event, data: dataLines.join("\n"), id };
+}
+// ─── HMAC re-signing for local forwarding ───────────────────────────────
+/**
+ * Re-sign a webhook event body with a local-only secret. Mirrors the
+ * platform's HMAC-SHA256 over `${ts}.${rawBody}` convention so the
+ * receiver verifies cleanly with the same scheme.
+ *
+ * Used by `mnemom listen --forward-to <url> --secret <hex>` to make
+ * the local receiver behave identically to a production webhook
+ * subscriber.
+ */
+export function reSignDelivery(rawBody, signingSecret, nowSeconds = Math.floor(Date.now() / 1000)) {
+    const timestamp = String(nowSeconds);
+    const signature = "v1=" + createHmac("sha256", signingSecret).update(`${timestamp}.${rawBody}`).digest("hex");
+    return { timestamp, signature };
+}

package/dist/lib/webhooks-api.d.ts

@@ -0,0 +1,80 @@
+export interface WebhookEndpoint {
+    endpoint_id: string;
+    billing_account_id: string;
+    url: string;
+    description: string;
+    signing_secret?: string;
+    event_types: string[];
+    is_active: boolean;
+    consecutive_failures: number;
+    disabled_at: string | null;
+    disabled_reason: string | null;
+    created_at: string;
+    updated_at: string;
+}
+export interface WebhookDelivery {
+    delivery_id: string;
+    event_id: string;
+    endpoint_id: string;
+    status: string;
+    attempt_count?: number;
+    last_attempt_at?: string | null;
+    next_attempt_at?: string | null;
+    last_status_code?: number | null;
+    last_error?: string | null;
+    created_at?: string;
+}
+export interface WebhookReplayResponse {
+    event_id: string;
+    event_type: string;
+    deliveries: Array<{
+        delivery_id: string;
+        endpoint_id: string;
+    }>;
+    failed_endpoints?: Array<{
+        endpoint_id: string;
+        error: string;
+    }>;
+    message?: string;
+}
+export interface TestDeliveryResult {
+    success: boolean;
+    status: number | null;
+    latency_ms: number | null;
+    error: string | null;
+}
+export declare function listWebhookEndpoints(orgId: string): Promise<WebhookEndpoint[]>;
+export declare function getWebhookEndpoint(orgId: string, endpointId: string): Promise<WebhookEndpoint>;
+export declare function createWebhookEndpoint(orgId: string, body: {
+    url: string;
+    description?: string;
+    event_types?: string[];
+}): Promise<WebhookEndpoint>;
+export declare function updateWebhookEndpoint(orgId: string, endpointId: string, body: {
+    url?: string;
+    description?: string;
+    event_types?: string[];
+    is_active?: boolean;
+}): Promise<WebhookEndpoint>;
+export declare function deleteWebhookEndpoint(orgId: string, endpointId: string): Promise<{
+    deleted: true;
+    endpoint_id: string;
+}>;
+export declare function rotateWebhookSecret(orgId: string, endpointId: string): Promise<{
+    endpoint_id: string;
+    signing_secret: string;
+}>;
+export declare function testWebhookEndpoint(orgId: string, endpointId: string): Promise<TestDeliveryResult>;
+export declare function listWebhookDeliveries(orgId: string, opts?: {
+    endpointId?: string;
+    limit?: number;
+    offset?: number;
+}): Promise<WebhookDelivery[]>;
+export declare function redeliverWebhookEvent(orgId: string, deliveryId: string): Promise<{
+    delivery_id: string;
+    event_id: string;
+    status: string;
+}>;
+export declare function replayWebhookEvent(orgId: string, eventId: string, opts?: {
+    endpointIds?: string[];
+}): Promise<WebhookReplayResponse>;