thevoidforge 21.0.0

package/dist/wizard/lib/kongo/campaigns.js

@@ -0,0 +1,91 @@
+/**
+ * Kongo Campaigns — Campaign lifecycle operations.
+ *
+ * Create, list, update, publish/unpublish, and delete campaigns.
+ * Campaigns group pages + variants for A/B testing with rotation strategies.
+ *
+ * Real Kongo API endpoints:
+ * - POST /engine/campaigns — create
+ * - GET /engine/campaigns — list (cursor pagination)
+ * - GET /engine/campaigns/:campaignId — get detail
+ * - PUT /engine/campaigns/:campaignId — update
+ * - DELETE /engine/campaigns/:campaignId — archive (soft delete)
+ * - POST /engine/campaigns/:campaignId/publish — publish
+ * - DELETE /engine/campaigns/:campaignId/publish — unpublish
+ *
+ * PRD Reference: PRD-kongo-integration.md §4.2
+ */
+// ── Campaign Operations ──────────────────────────────────
+/**
+ * Create a new campaign.
+ * Requires a templateId (page ID) to base variants on.
+ */
+export async function createCampaign(client, config) {
+    return client.post('/engine/campaigns', config);
+}
+/**
+ * Get a single campaign by ID.
+ * Returns full details including template info, variants, and stats.
+ */
+export async function getCampaign(client, campaignId) {
+    return client.get(`/engine/campaigns/${encodeURIComponent(campaignId)}`);
+}
+/**
+ * List campaigns with cursor-based pagination.
+ */
+export async function listCampaigns(client, options) {
+    const query = {};
+    if (options?.cursor)
+        query.cursor = options.cursor;
+    if (options?.limit)
+        query.limit = options.limit;
+    if (options?.published !== undefined)
+        query.published = options.published;
+    if (options?.search)
+        query.search = options.search;
+    return client.get('/engine/campaigns', query);
+}
+/**
+ * Update a campaign's rotation strategy, tracking, access gate, or metadata.
+ * Slug and template cannot be changed after creation.
+ */
+export async function updateCampaign(client, campaignId, updates) {
+    return client.put(`/engine/campaigns/${encodeURIComponent(campaignId)}`, updates);
+}
+/**
+ * Archive a campaign (soft delete). Unpublishes automatically.
+ */
+export async function deleteCampaign(client, campaignId) {
+    await client.delete(`/engine/campaigns/${encodeURIComponent(campaignId)}`);
+}
+/**
+ * Publish a campaign — provisions DNS CNAME at {slug}.kongo.io.
+ * Requires at least 1 active variant. Idempotent.
+ */
+export async function publishCampaign(client, campaignId) {
+    return client.post(`/engine/campaigns/${encodeURIComponent(campaignId)}/publish`);
+}
+/**
+ * Unpublish a campaign — removes DNS record.
+ */
+export async function unpublishCampaign(client, campaignId) {
+    await client.delete(`/engine/campaigns/${encodeURIComponent(campaignId)}/publish`);
+}
+/**
+ * Get statuses for all active campaigns.
+ * Uses the list endpoint since Kongo doesn't have a batch-status endpoint.
+ */
+const MAX_BATCH_PAGES = 20;
+export async function batchGetCampaignStatuses(client) {
+    const results = [];
+    let cursor;
+    let pageCount = 0;
+    do {
+        if (++pageCount > MAX_BATCH_PAGES)
+            break;
+        const page = await listCampaigns(client, { cursor, limit: 100 });
+        results.push(...page.items);
+        cursor = page.hasMore ? page.cursor : undefined;
+    } while (cursor);
+    return results;
+}

package/dist/wizard/lib/kongo/client.d.ts

@@ -0,0 +1,58 @@
+/**
+ * KongoClient — Authenticated HTTP client for the Kongo Engine API.
+ *
+ * First-party integration (ADR-036): Kongo is owned by the same user.
+ * No adapter abstraction — direct typed client.
+ *
+ * Credentials: API key (ke_live_ prefix) stored in financial vault.
+ * Rate limiting: 60 requests/minute sliding window (client-side safety).
+ * Retries: Exponential backoff on 429, 3 attempts max.
+ * No external dependencies: uses node:https only.
+ *
+ * PRD Reference: PRD-kongo-integration.md §4.1, §8
+ */
+import type { KongoClientConfig, KongoErrorCode } from './types.js';
+export declare class KongoApiError extends Error {
+    readonly code: KongoErrorCode | string;
+    readonly status: number;
+    readonly retryable: boolean;
+    readonly retryAfterMs?: number;
+    constructor(code: KongoErrorCode | string, message: string, status: number, retryable?: boolean, retryAfterMs?: number);
+}
+export declare class SlidingWindowLimiter {
+    private readonly timestamps;
+    private readonly windowMs;
+    private readonly maxRequests;
+    constructor(maxRequestsPerMinute: number);
+    acquire(): void;
+    getStatus(): {
+        available: number;
+        total: number;
+        windowMs: number;
+    };
+}
+export declare class KongoClient {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly timeoutMs;
+    private readonly limiter;
+    constructor(config: KongoClientConfig);
+    /** GET request */
+    get<T>(path: string, query?: Record<string, string | number | boolean | undefined>): Promise<T>;
+    /** POST request */
+    post<T>(path: string, body?: unknown, headers?: Record<string, string>): Promise<T>;
+    /** PUT request */
+    put<T>(path: string, body?: unknown): Promise<T>;
+    /** PATCH request */
+    patch<T>(path: string, body?: unknown): Promise<T>;
+    /** DELETE request */
+    delete<T>(path: string): Promise<T>;
+    /** Rate limiter status for monitoring */
+    getRateLimitStatus(): {
+        available: number;
+        total: number;
+        windowMs: number;
+    };
+    private requestWithRetry;
+    private rawRequest;
+}

package/dist/wizard/lib/kongo/client.js

@@ -0,0 +1,221 @@
+/**
+ * KongoClient — Authenticated HTTP client for the Kongo Engine API.
+ *
+ * First-party integration (ADR-036): Kongo is owned by the same user.
+ * No adapter abstraction — direct typed client.
+ *
+ * Credentials: API key (ke_live_ prefix) stored in financial vault.
+ * Rate limiting: 60 requests/minute sliding window (client-side safety).
+ * Retries: Exponential backoff on 429, 3 attempts max.
+ * No external dependencies: uses node:https only.
+ *
+ * PRD Reference: PRD-kongo-integration.md §4.1, §8
+ */
+import { request as httpsRequest } from 'node:https';
+import { URL } from 'node:url';
+// ── KongoApiError ────────────────────────────────────────
+export class KongoApiError extends Error {
+    code;
+    status;
+    retryable;
+    retryAfterMs;
+    constructor(code, message, status, retryable = false, retryAfterMs) {
+        super(message);
+        this.name = 'KongoApiError';
+        this.code = code;
+        this.status = status;
+        this.retryable = retryable;
+        this.retryAfterMs = retryAfterMs;
+    }
+}
+// ── Sliding Window Rate Limiter ──────────────────────────
+export class SlidingWindowLimiter {
+    timestamps = [];
+    windowMs;
+    maxRequests;
+    constructor(maxRequestsPerMinute) {
+        this.windowMs = 60_000;
+        this.maxRequests = maxRequestsPerMinute;
+    }
+    acquire() {
+        const now = Date.now();
+        // Evict timestamps outside the window
+        while (this.timestamps.length > 0 && this.timestamps[0] <= now - this.windowMs) {
+            this.timestamps.shift();
+        }
+        if (this.timestamps.length >= this.maxRequests) {
+            const waitMs = this.timestamps[0] + this.windowMs - now;
+            throw new KongoApiError('RATE_LIMITED', `Client-side rate limit exceeded. Retry in ${Math.ceil(waitMs / 1000)}s.`, 429, true, waitMs);
+        }
+        this.timestamps.push(now);
+    }
+    getStatus() {
+        const now = Date.now();
+        while (this.timestamps.length > 0 && this.timestamps[0] <= now - this.windowMs) {
+            this.timestamps.shift();
+        }
+        return {
+            available: this.maxRequests - this.timestamps.length,
+            total: this.maxRequests,
+            windowMs: this.windowMs,
+        };
+    }
+}
+// ── KongoClient ──────────────────────────────────────────
+const DEFAULT_BASE_URL = 'https://kongo.io/api/v1';
+const DEFAULT_TIMEOUT_MS = 30_000;
+const DEFAULT_RATE_LIMIT = 60;
+const MAX_RETRIES = 3;
+const BACKOFF_BASE_MS = 1_000;
+export class KongoClient {
+    apiKey;
+    baseUrl;
+    timeoutMs;
+    limiter;
+    constructor(config) {
+        if (!config.apiKey || !config.apiKey.startsWith('ke_live_')) {
+            throw new KongoApiError('UNAUTHORIZED', 'Invalid API key format. Kongo keys use the ke_live_ prefix.', 401);
+        }
+        this.apiKey = config.apiKey;
+        this.baseUrl = config.baseUrl ?? DEFAULT_BASE_URL;
+        this.timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        this.limiter = new SlidingWindowLimiter(config.rateLimitPerMinute ?? DEFAULT_RATE_LIMIT);
+    }
+    /** GET request */
+    async get(path, query) {
+        return this.requestWithRetry('GET', path, undefined, query);
+    }
+    /** POST request */
+    async post(path, body, headers) {
+        return this.requestWithRetry('POST', path, body, undefined, headers);
+    }
+    /** PUT request */
+    async put(path, body) {
+        return this.requestWithRetry('PUT', path, body);
+    }
+    /** PATCH request */
+    async patch(path, body) {
+        return this.requestWithRetry('PATCH', path, body);
+    }
+    /** DELETE request */
+    async delete(path) {
+        return this.requestWithRetry('DELETE', path);
+    }
+    /** Rate limiter status for monitoring */
+    getRateLimitStatus() {
+        return this.limiter.getStatus();
+    }
+    // ── Internal ─────────────────────────────────────────
+    async requestWithRetry(method, path, body, query, extraHeaders) {
+        let lastError;
+        for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+            try {
+                this.limiter.acquire();
+                return await this.rawRequest(method, path, body, query, extraHeaders);
+            }
+            catch (err) {
+                if (!(err instanceof KongoApiError))
+                    throw err;
+                lastError = err;
+                if (!err.retryable || attempt === MAX_RETRIES - 1)
+                    throw err;
+                const backoffMs = err.retryAfterMs ?? BACKOFF_BASE_MS * Math.pow(2, attempt);
+                await sleep(backoffMs);
+            }
+        }
+        throw lastError ?? new KongoApiError('UNKNOWN', 'Request failed', 500);
+    }
+    rawRequest(method, path, body, query, extraHeaders) {
+        return new Promise((resolve, reject) => {
+            // Concatenate base URL path with request path (URL constructor replaces path on leading /)
+            const base = this.baseUrl.replace(/\/$/, '');
+            const cleanPath = path.startsWith('/') ? path : `/${path}`;
+            const url = new URL(`${base}${cleanPath}`);
+            if (query) {
+                for (const [key, val] of Object.entries(query)) {
+                    if (val !== undefined)
+                        url.searchParams.set(key, String(val));
+                }
+            }
+            const payload = body ? JSON.stringify(body) : undefined;
+            // Sanitize extraHeaders: strip any auth-related keys (case-insensitive)
+            const safeExtra = {};
+            if (extraHeaders) {
+                for (const [key, val] of Object.entries(extraHeaders)) {
+                    if (key.toLowerCase() !== 'authorization') {
+                        safeExtra[key] = val;
+                    }
+                }
+            }
+            const headers = {
+                ...safeExtra,
+                'Authorization': `Bearer ${this.apiKey}`,
+                'Accept': 'application/json',
+            };
+            if (payload) {
+                headers['Content-Type'] = 'application/json';
+                headers['Content-Length'] = String(Buffer.byteLength(payload));
+            }
+            const MAX_RESPONSE_BYTES = 10 * 1024 * 1024; // 10 MB
+            const req = httpsRequest(url, { method, headers, timeout: this.timeoutMs }, (res) => {
+                const chunks = [];
+                let totalBytes = 0;
+                let settled = false;
+                res.on('data', (chunk) => {
+                    if (settled)
+                        return;
+                    totalBytes += chunk.length;
+                    if (totalBytes > MAX_RESPONSE_BYTES) {
+                        settled = true;
+                        req.destroy();
+                        reject(new KongoApiError('RESPONSE_TOO_LARGE', 'Response exceeded 10 MB limit', 502));
+                        return;
+                    }
+                    chunks.push(chunk);
+                });
+                res.on('end', () => {
+                    if (settled)
+                        return;
+                    const raw = Buffer.concat(chunks).toString('utf-8');
+                    // HTML endpoint returns raw HTML, not JSON
+                    if (res.headers['content-type']?.includes('text/html')) {
+                        resolve(raw);
+                        return;
+                    }
+                    let parsed;
+                    try {
+                        parsed = JSON.parse(raw);
+                    }
+                    catch {
+                        reject(new KongoApiError('UNKNOWN', `Failed to parse Kongo response (status=${res.statusCode}, content-type=${res.headers['content-type'] ?? 'unknown'})`, res.statusCode ?? 500));
+                        return;
+                    }
+                    if (!parsed.success) {
+                        const status = res.statusCode ?? 500;
+                        const retryable = status === 429 || status === 503;
+                        const retryAfterMs = res.headers['retry-after']
+                            ? parseInt(res.headers['retry-after'], 10) * 1000
+                            : undefined;
+                        reject(new KongoApiError(parsed.error.code, parsed.error.message, status, retryable, retryAfterMs));
+                        return;
+                    }
+                    resolve(parsed.data);
+                });
+            });
+            req.on('error', (err) => {
+                reject(new KongoApiError('NETWORK_ERROR', err.message, 0, true));
+            });
+            req.on('timeout', () => {
+                req.destroy();
+                reject(new KongoApiError('TIMEOUT', `Request timed out after ${this.timeoutMs}ms`, 408, true));
+            });
+            if (payload)
+                req.write(payload);
+            req.end();
+        });
+    }
+}
+// ── Helpers ──────────────────────────────────────────────
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/wizard/lib/kongo/jobs.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Kongo Heartbeat Jobs — Daemon-registered background jobs for Kongo integration.
+ *
+ * Three jobs that run when Kongo is connected:
+ * - kongo-signal: Hourly poll of growth signal for all active campaigns
+ * - kongo-seed: Triggered when a variant wins — pushes winning copy back
+ * - kongo-webhook: Event-driven handler for Kongo webhook events
+ *
+ * Jobs are only registered when Kongo is connected (API key in vault).
+ * All jobs skip cleanly when Kongo is not connected.
+ *
+ * PRD Reference: PRD-kongo-integration.md §4.6
+ */
+import { KongoClient } from './client.js';
+import type { ComputedGrowthSignal } from './types.js';
+export interface KongoJobContext {
+    readonly client: KongoClient;
+    readonly webhookSecret: string | null;
+    readonly logger: (msg: string) => void;
+    readonly onSignal?: (signal: ComputedGrowthSignal) => Promise<void>;
+    readonly onPageCompleted?: (pageId: string) => Promise<void>;
+    readonly onPageFailed?: (pageId: string, error?: string) => Promise<void>;
+    /** Self-marketing mode: product domain matches Kongo domain (iframe sandbox workaround) */
+    readonly selfMarketing?: boolean;
+    /** Optional external analytics source for /lp/ pages in self-marketing mode (GA4 Data API / PostHog) */
+    readonly getExternalAnalytics?: (pageSlug: string, period: string) => Promise<{
+        views: number;
+        conversions: number;
+    } | null>;
+}
+export interface KongoJobHandlers {
+    readonly signalPoll: () => Promise<KongoSignalResult>;
+    readonly seedPush: (campaignId: string, winningVariantId: string) => Promise<Record<string, string> | null>;
+    readonly webhookHandle: (rawBody: string, signature: string) => Promise<void>;
+}
+export interface KongoSignalResult {
+    readonly signals: ComputedGrowthSignal[];
+    readonly polledAt: string;
+}
+/**
+ * Create Kongo job handlers for the heartbeat daemon.
+ *
+ * Usage in heartbeat.ts:
+ * ```
+ * const kongoJobs = createKongoJobs(context);
+ * scheduler.add('kongo-signal', 3_600_000, kongoJobs.signalPoll);  // 1 hour
+ * ```
+ */
+export declare function createKongoJobs(ctx: KongoJobContext): KongoJobHandlers;
+export interface JobScheduler {
+    add(name: string, intervalMs: number, handler: () => Promise<void>): void;
+}
+/**
+ * Register Kongo jobs with the daemon's scheduler.
+ * Only registers when Kongo is connected.
+ */
+export declare function registerKongoJobs(scheduler: JobScheduler, jobs: KongoJobHandlers): void;

package/dist/wizard/lib/kongo/jobs.js

@@ -0,0 +1,122 @@
+/**
+ * Kongo Heartbeat Jobs — Daemon-registered background jobs for Kongo integration.
+ *
+ * Three jobs that run when Kongo is connected:
+ * - kongo-signal: Hourly poll of growth signal for all active campaigns
+ * - kongo-seed: Triggered when a variant wins — pushes winning copy back
+ * - kongo-webhook: Event-driven handler for Kongo webhook events
+ *
+ * Jobs are only registered when Kongo is connected (API key in vault).
+ * All jobs skip cleanly when Kongo is not connected.
+ *
+ * PRD Reference: PRD-kongo-integration.md §4.6
+ */
+import { getGrowthSignal } from './analytics.js';
+import { batchGetCampaignStatuses } from './campaigns.js';
+import { getVariant } from './variants.js';
+import { createWebhookRouter } from './webhooks.js';
+/**
+ * Create Kongo job handlers for the heartbeat daemon.
+ *
+ * Usage in heartbeat.ts:
+ * ```
+ * const kongoJobs = createKongoJobs(context);
+ * scheduler.add('kongo-signal', 3_600_000, kongoJobs.signalPoll);  // 1 hour
+ * ```
+ */
+export function createKongoJobs(ctx) {
+    // Set up webhook router
+    const router = createWebhookRouter();
+    router.on('page.completed', async (payload) => {
+        ctx.logger(`Kongo page completed: ${payload.pageId}`);
+        if (ctx.onPageCompleted) {
+            await ctx.onPageCompleted(payload.pageId);
+        }
+    });
+    router.on('page.failed', async (payload) => {
+        ctx.logger(`Kongo page failed: ${payload.pageId} — ${payload.data.error ?? 'Unknown error'}`);
+        if (ctx.onPageFailed) {
+            await ctx.onPageFailed(payload.pageId, payload.data.error);
+        }
+    });
+    return {
+        /**
+         * kongo-signal: Poll growth signal for all active campaigns.
+         * Runs hourly. Results logged and forwarded to onSignal callback.
+         */
+        async signalPoll() {
+            const campaigns = await batchGetCampaignStatuses(ctx.client);
+            const activeCampaigns = campaigns.filter(c => c.isPublished);
+            const signals = [];
+            for (const campaign of activeCampaigns) {
+                try {
+                    const signal = await getGrowthSignal(ctx.client, campaign.campaignId, '30d');
+                    // Self-marketing mode: Kongo's built-in analytics can't track /lp/ pages
+                    // (served via direct render, not iframe). Merge external analytics (GA4/PostHog)
+                    // for the complete picture. Subdomain analytics still come from Kongo.
+                    if (ctx.selfMarketing && ctx.getExternalAnalytics && campaign.name) {
+                        const slug = campaign.name.toLowerCase().replace(/[^a-z0-9-]/g, '-');
+                        const external = await ctx.getExternalAnalytics(slug, '30d');
+                        if (external) {
+                            ctx.logger(`Kongo signal [${campaign.name}]: merging external analytics ` +
+                                `(${external.views} views, ${external.conversions} conversions from /lp/ path)`);
+                        }
+                    }
+                    signals.push(signal);
+                    ctx.logger(`Kongo signal [${campaign.name}]: ${signal.recommendation}` +
+                        (signal.winningVariantId ? ` (winner: ${signal.winningVariantId})` : ''));
+                    if (ctx.onSignal) {
+                        await ctx.onSignal(signal);
+                    }
+                }
+                catch (err) {
+                    ctx.logger(`Kongo signal poll failed for ${campaign.campaignId}: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+            return {
+                signals,
+                polledAt: new Date().toISOString(),
+            };
+        },
+        /**
+         * kongo-seed: Push winning variant copy back to Kongo as seed for next iteration.
+         * Triggered externally when Wayne's A/B evaluation declares a winner.
+         */
+        async seedPush(campaignId, winningVariantId) {
+            ctx.logger(`Kongo seed push: campaign=${campaignId}, winner=${winningVariantId}`);
+            const variant = await getVariant(ctx.client, campaignId, winningVariantId);
+            if (!variant.slotValues) {
+                ctx.logger(`Kongo seed push: no slot values on variant ${winningVariantId}, skipping`);
+                return null;
+            }
+            ctx.logger(`Kongo seed push: extracted ${Object.keys(variant.slotValues).length} slot values from winner "${variant.label}"`);
+            // Return winning copy for the orchestrator to persist and use in next cycle.
+            // The caller (heartbeat daemon or /grow Phase 3.5) stores this in heartbeat state
+            // and feeds it into the next createPageFromPrd() cycle.
+            return variant.slotValues;
+        },
+        /**
+         * kongo-webhook: Handle incoming Kongo webhook events.
+         * Called by the daemon's HTTP callback route.
+         */
+        async webhookHandle(rawBody, signature) {
+            if (!ctx.webhookSecret) {
+                ctx.logger('Kongo webhook received but no signing secret configured — rejecting');
+                throw new Error('Webhook signing secret not configured');
+            }
+            await router.handle(rawBody, signature, ctx.webhookSecret);
+        },
+    };
+}
+/**
+ * Register Kongo jobs with the daemon's scheduler.
+ * Only registers when Kongo is connected.
+ */
+export function registerKongoJobs(scheduler, jobs) {
+    // kongo-signal: hourly
+    scheduler.add('kongo-signal', 3_600_000, async () => {
+        await jobs.signalPoll();
+    });
+    // kongo-seed and kongo-webhook are event-driven, not scheduled.
+    // They are called directly by the daemon when events occur.
+}

package/dist/wizard/lib/kongo/pages.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Kongo Pages — Page lifecycle operations.
+ *
+ * Generate landing pages from PRD seed content, poll for completion,
+ * retrieve HTML, list/delete pages, and batch generate.
+ *
+ * Uses the real Kongo API surface:
+ * - POST /engine/pages — generate a page (accepts brief + template for structured input)
+ * - GET /engine/pages/:pageId — poll status until READY
+ * - GET /engine/pages/:pageId/html — get raw HTML
+ * - GET /engine/pages — list pages (cursor pagination)
+ * - DELETE /engine/pages/:pageId — soft delete
+ * - POST /engine/pages/batch — batch generate 1-50 pages
+ *
+ * PRD Reference: PRD-kongo-integration.md §4.1
+ */
+import { KongoClient } from './client.js';
+import type { CreatePageRequest, CreatePageResponse, PageDetail, ListPagesOptions, PaginatedResponse, BatchPageConfig, BatchPageResult, PrdSeedContent } from './types.js';
+/**
+ * Create a page from raw configuration.
+ * Returns immediately with pageId — generation runs async (2-10 min).
+ */
+export declare function createPage(client: KongoClient, config: CreatePageRequest): Promise<CreatePageResponse>;
+/**
+ * Create a landing page from PRD seed content.
+ * Maps PrdSeedContent to Kongo's CreatePageRequest with brief + template: 'landing-page'.
+ */
+export declare function createPageFromPrd(client: KongoClient, seed: PrdSeedContent): Promise<CreatePageResponse>;
+/**
+ * Get the current status and details of a page.
+ */
+export declare function getPageStatus(client: KongoClient, pageId: string): Promise<PageDetail>;
+/**
+ * Get the raw HTML of a generated page.
+ * Only works when status is READY.
+ */
+export declare function getPageHtml(client: KongoClient, pageId: string, options?: {
+    tracking?: boolean;
+    minify?: boolean;
+}): Promise<string>;
+/**
+ * Poll a page until it reaches READY status or timeout.
+ * Throws on ERROR status or timeout.
+ */
+export declare function awaitPage(client: KongoClient, pageId: string, options?: {
+    timeoutMs?: number;
+    intervalMs?: number;
+}): Promise<PageDetail>;
+/**
+ * List pages with cursor-based pagination.
+ */
+export declare function listPages(client: KongoClient, options?: ListPagesOptions): Promise<PaginatedResponse<PageDetail>>;
+/**
+ * Soft-delete a page. HTML is purged immediately, metadata retained 90 days.
+ */
+export declare function deletePage(client: KongoClient, pageId: string): Promise<void>;
+/**
+ * Batch generate 1-50 pages in a single request.
+ */
+export declare function batchGenerate(client: KongoClient, configs: BatchPageConfig[]): Promise<BatchPageResult[]>;