thevoidforge 21.0.0

package/dist/wizard/lib/http-helpers.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Shared HTTP helpers — used across all API modules.
+ * Extracted to eliminate 13 duplicate sendJson() implementations.
+ */
+import type { ServerResponse } from 'node:http';
+/** Send a JSON response with the given status code. */
+export declare function sendJson(res: ServerResponse, status: number, data: unknown, noCache?: boolean): void;
+/** Read a file, returning null if it doesn't exist or fails. */
+export declare function readFileOrNull(path: string): Promise<string | null>;

package/dist/wizard/lib/http-helpers.js

@@ -0,0 +1,24 @@
+/**
+ * Shared HTTP helpers — used across all API modules.
+ * Extracted to eliminate 13 duplicate sendJson() implementations.
+ */
+import { readFile } from 'node:fs/promises';
+/** Send a JSON response with the given status code. */
+export function sendJson(res, status, data, noCache = false) {
+    const headers = { 'Content-Type': 'application/json; charset=utf-8' };
+    if (noCache) {
+        headers['Cache-Control'] = 'no-store';
+        headers['Pragma'] = 'no-cache';
+    }
+    res.writeHead(status, headers);
+    res.end(JSON.stringify(data));
+}
+/** Read a file, returning null if it doesn't exist or fails. */
+export async function readFileOrNull(path) {
+    try {
+        return await readFile(path, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}

package/dist/wizard/lib/image-gen.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Image generation provider abstraction — Celebrimbor's forge tools.
+ * Default: OpenAI (gpt-image-1). Extensible to other providers.
+ * Uses the same vault system as other VoidForge credentials.
+ */
+import type { ProvisionEmitter } from './provisioners/types.js';
+export interface ImageGenerationOptions {
+    prompt: string;
+    width: number;
+    height: number;
+    model?: string;
+    quality?: 'low' | 'medium' | 'high';
+}
+export interface GeneratedAsset {
+    name: string;
+    filename: string;
+    prompt: string;
+    size: string;
+    generatedAt: string;
+    hash: string;
+}
+export interface AssetManifest {
+    generated: string;
+    model: string;
+    style: string;
+    assets: GeneratedAsset[];
+}
+/**
+ * Generate an image via OpenAI's API.
+ * Returns the raw image bytes as a Buffer.
+ */
+export declare function generateImage(apiKey: string, options: ImageGenerationOptions, emit: ProvisionEmitter): Promise<Buffer | null>;
+/**
+ * Validate an OpenAI API key by making a lightweight models list request.
+ */
+export declare function validateOpenAIKey(apiKey: string): Promise<boolean>;
+/**
+ * Estimate the cost of generating N images.
+ */
+export declare function estimateImageCost(count: number, model?: string): number;
+/**
+ * Read the asset manifest from disk.
+ */
+export declare function readManifest(imagesDir: string): Promise<AssetManifest | null>;
+/**
+ * Write the asset manifest to disk.
+ */
+export declare function writeManifest(imagesDir: string, manifest: AssetManifest): Promise<void>;
+/**
+ * Save a generated image to disk and update the manifest.
+ */
+export declare function saveGeneratedImage(imagesDir: string, category: string, name: string, imageBuffer: Buffer, prompt: string, size: string, manifest: AssetManifest): Promise<string>;
+/**
+ * Check if an asset already exists on disk.
+ */
+export declare function assetExists(imagesDir: string, category: string, name: string): boolean;

package/dist/wizard/lib/image-gen.js

@@ -0,0 +1,159 @@
+/**
+ * Image generation provider abstraction — Celebrimbor's forge tools.
+ * Default: OpenAI (gpt-image-1). Extensible to other providers.
+ * Uses the same vault system as other VoidForge credentials.
+ */
+import { writeFile, readFile, mkdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { createHash } from 'node:crypto';
+import { httpsPost, httpsGet, safeJsonParse } from './provisioners/http-client.js';
+// ── OpenAI Provider ──────────────────────────────────────
+const OPENAI_API = 'api.openai.com';
+/**
+ * Generate an image via OpenAI's API.
+ * Returns the raw image bytes as a Buffer.
+ */
+export async function generateImage(apiKey, options, emit) {
+    const model = options.model || 'gpt-image-1';
+    const size = `${options.width}x${options.height}`;
+    // OpenAI only supports specific sizes — map to nearest and warn
+    const validSizes = ['1024x1024', '1792x1024', '1024x1792'];
+    const actualSize = validSizes.includes(size) ? size : '1024x1024';
+    if (actualSize !== size) {
+        emit({ step: 'image-gen', status: 'started', message: `Requested ${size} → using ${actualSize} (API constraint)` });
+    }
+    const body = JSON.stringify({
+        model,
+        prompt: options.prompt,
+        n: 1,
+        size: actualSize,
+        quality: options.quality || 'medium',
+        response_format: 'b64_json',
+    });
+    // Retry logic: 3 attempts with exponential backoff (1s, 3s, 9s)
+    // DALL-E 3 returns 500 errors on ~15% of requests (field report #1)
+    const MAX_RETRIES = 3;
+    const BACKOFF_BASE_MS = 1000;
+    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+        try {
+            const res = await httpsPost(OPENAI_API, '/v1/images/generations', {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json',
+            }, body, 120_000); // 2 min timeout for image generation
+            if (res.status === 500 || res.status === 502 || res.status === 503) {
+                // Server error — retry with backoff
+                if (attempt < MAX_RETRIES) {
+                    const delay = BACKOFF_BASE_MS * Math.pow(3, attempt - 1);
+                    emit({ step: 'image-gen', status: 'started', message: `Server error (${res.status}), retrying in ${delay / 1000}s (attempt ${attempt}/${MAX_RETRIES})` });
+                    await new Promise((resolve) => setTimeout(resolve, delay));
+                    continue;
+                }
+                emit({ step: 'image-gen', status: 'error', message: `Server error (${res.status}) after ${MAX_RETRIES} attempts` });
+                return null;
+            }
+            if (res.status !== 200) {
+                const errData = safeJsonParse(res.body);
+                const errMsg = errData?.error?.message || `API returned ${res.status}`;
+                emit({ step: 'image-gen', status: 'error', message: `Generation failed: ${errMsg}` });
+                return null;
+            }
+            const data = safeJsonParse(res.body);
+            const b64 = data?.data?.[0]?.b64_json;
+            if (!b64) {
+                emit({ step: 'image-gen', status: 'error', message: 'No image data in API response' });
+                return null;
+            }
+            if (attempt > 1) {
+                emit({ step: 'image-gen', status: 'done', message: `Succeeded on attempt ${attempt}` });
+            }
+            return Buffer.from(b64, 'base64');
+        }
+        catch (err) {
+            if (attempt < MAX_RETRIES) {
+                const delay = BACKOFF_BASE_MS * Math.pow(3, attempt - 1);
+                emit({ step: 'image-gen', status: 'started', message: `Request failed, retrying in ${delay / 1000}s (attempt ${attempt}/${MAX_RETRIES})`, detail: err.message });
+                await new Promise((resolve) => setTimeout(resolve, delay));
+                continue;
+            }
+            emit({ step: 'image-gen', status: 'error', message: `Image generation failed after ${MAX_RETRIES} attempts`, detail: err.message });
+            return null;
+        }
+    }
+    return null;
+}
+/**
+ * Validate an OpenAI API key by making a lightweight models list request.
+ */
+export async function validateOpenAIKey(apiKey) {
+    try {
+        const res = await httpsGet(OPENAI_API, '/v1/models', {
+            'Authorization': `Bearer ${apiKey}`,
+        }, 10_000);
+        return res.status === 200;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Estimate the cost of generating N images.
+ */
+export function estimateImageCost(count, model = 'gpt-image-1') {
+    const costPerImage = {
+        'gpt-image-1': 0.04,
+        'dall-e-3': 0.08,
+    };
+    return count * (costPerImage[model] || 0.04);
+}
+// ── Asset Manifest ──────────────────────────────────────
+const MANIFEST_FILENAME = 'manifest.json';
+/**
+ * Read the asset manifest from disk.
+ */
+export async function readManifest(imagesDir) {
+    const manifestPath = join(imagesDir, MANIFEST_FILENAME);
+    try {
+        const content = await readFile(manifestPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Write the asset manifest to disk.
+ */
+export async function writeManifest(imagesDir, manifest) {
+    await mkdir(imagesDir, { recursive: true });
+    await writeFile(join(imagesDir, MANIFEST_FILENAME), JSON.stringify(manifest, null, 2) + '\n', 'utf-8');
+}
+/**
+ * Save a generated image to disk and update the manifest.
+ */
+export async function saveGeneratedImage(imagesDir, category, name, imageBuffer, prompt, size, manifest) {
+    const categoryDir = join(imagesDir, category);
+    await mkdir(categoryDir, { recursive: true });
+    const filename = `${category}/${name}.png`;
+    const filepath = join(imagesDir, filename);
+    await writeFile(filepath, imageBuffer);
+    const hash = createHash('sha256').update(imageBuffer).digest('hex');
+    // Remove any existing entry with the same filename (dedup for --regen)
+    manifest.assets = manifest.assets.filter(a => a.filename !== filename);
+    manifest.assets.push({
+        name,
+        filename,
+        prompt,
+        size,
+        generatedAt: new Date().toISOString(),
+        hash: `sha256:${hash}`,
+    });
+    await writeManifest(imagesDir, manifest);
+    return filepath;
+}
+/**
+ * Check if an asset already exists on disk.
+ */
+export function assetExists(imagesDir, category, name) {
+    return existsSync(join(imagesDir, category, `${name}.png`));
+}

package/dist/wizard/lib/instance-sizing.d.ts

@@ -0,0 +1,26 @@
+/**
+ * EC2 instance type recommendation based on PRD scope signals.
+ * Pure function — no side effects, no AWS calls.
+ */
+export declare const VALID_INSTANCE_TYPES: readonly ["t3.micro", "t3.small", "t3.medium", "t3.large"];
+export type InstanceType = typeof VALID_INSTANCE_TYPES[number];
+export interface SizingInput {
+    type?: string;
+    framework?: string;
+    database?: string;
+    cache?: string;
+    workers?: string;
+    payments?: string;
+}
+/**
+ * Recommend an EC2 instance type based on PRD signals.
+ * Never auto-recommends above t3.medium (cost protection).
+ */
+export declare function recommendInstanceType(input: SizingInput): InstanceType;
+/** Map EC2 instance type to matching RDS instance class. */
+export declare function rdsInstanceClass(instanceType: InstanceType): string;
+/** Map EC2 instance type to matching ElastiCache node type. */
+export declare function cacheNodeType(instanceType: InstanceType): string;
+/** Recommended swap size in GB based on instance memory. */
+export declare function swapSizeGb(instanceType: InstanceType): number;
+export declare function isValidInstanceType(value: string): value is InstanceType;

package/dist/wizard/lib/instance-sizing.js

@@ -0,0 +1,51 @@
+/**
+ * EC2 instance type recommendation based on PRD scope signals.
+ * Pure function — no side effects, no AWS calls.
+ */
+export const VALID_INSTANCE_TYPES = ['t3.micro', 't3.small', 't3.medium', 't3.large'];
+/**
+ * Recommend an EC2 instance type based on PRD signals.
+ * Never auto-recommends above t3.medium (cost protection).
+ */
+export function recommendInstanceType(input) {
+    // Static sites and prototypes always get micro
+    if (input.type === 'static-site' || input.type === 'prototype') {
+        return 't3.micro';
+    }
+    let score = 0;
+    if (input.database === 'postgres' || input.database === 'mysql')
+        score++;
+    if (input.cache === 'redis')
+        score++;
+    if (input.workers === 'yes')
+        score++;
+    if (input.payments === 'stripe' || input.payments === 'lemonsqueezy')
+        score++;
+    if (input.framework === 'next.js')
+        score++; // SSR is memory-hungry
+    if (score >= 4)
+        return 't3.medium';
+    if (score >= 2)
+        return 't3.small';
+    return 't3.micro';
+}
+/** Map EC2 instance type to matching RDS instance class. */
+export function rdsInstanceClass(instanceType) {
+    return `db.${instanceType}`;
+}
+/** Map EC2 instance type to matching ElastiCache node type. */
+export function cacheNodeType(instanceType) {
+    return `cache.${instanceType}`;
+}
+/** Recommended swap size in GB based on instance memory. */
+export function swapSizeGb(instanceType) {
+    switch (instanceType) {
+        case 't3.micro': return 2;
+        case 't3.small': return 2;
+        case 't3.medium': return 1;
+        case 't3.large': return 0;
+    }
+}
+export function isValidInstanceType(value) {
+    return VALID_INSTANCE_TYPES.includes(value);
+}

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

@@ -0,0 +1,29 @@
+/**
+ * Kongo Analytics — Campaign analytics and computed growth signal.
+ *
+ * Kongo doesn't have a dedicated growth-signal endpoint, so we compute it
+ * client-side from the campaign analytics data using statistical analysis.
+ *
+ * Real Kongo API endpoint:
+ * - GET /engine/campaigns/:campaignId/analytics — per-variant breakdown
+ *
+ * PRD Reference: PRD-kongo-integration.md §4.3
+ */
+import { KongoClient } from './client.js';
+import type { CampaignAnalytics, AnalyticsPeriod, ComputedGrowthSignal } from './types.js';
+/**
+ * Get campaign analytics with per-variant, per-source, and daily breakdown.
+ */
+export declare function getCampaignAnalytics(client: KongoClient, campaignId: string, period?: AnalyticsPeriod): Promise<CampaignAnalytics>;
+/**
+ * Compute a growth signal from campaign analytics.
+ *
+ * This replaces the hypothetical /growth-signal endpoint from the PRD.
+ * Uses two-proportion z-test to determine if any variant significantly
+ * outperforms the control (first variant by order).
+ */
+export declare function computeGrowthSignal(campaignId: string, analytics: CampaignAnalytics): ComputedGrowthSignal;
+/**
+ * Fetch analytics and compute growth signal in one call.
+ */
+export declare function getGrowthSignal(client: KongoClient, campaignId: string, period?: AnalyticsPeriod): Promise<ComputedGrowthSignal>;

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

@@ -0,0 +1,179 @@
+/**
+ * Kongo Analytics — Campaign analytics and computed growth signal.
+ *
+ * Kongo doesn't have a dedicated growth-signal endpoint, so we compute it
+ * client-side from the campaign analytics data using statistical analysis.
+ *
+ * Real Kongo API endpoint:
+ * - GET /engine/campaigns/:campaignId/analytics — per-variant breakdown
+ *
+ * PRD Reference: PRD-kongo-integration.md §4.3
+ */
+// ── Analytics Operations ─────────────────────────────────
+/**
+ * Get campaign analytics with per-variant, per-source, and daily breakdown.
+ */
+export async function getCampaignAnalytics(client, campaignId, period) {
+    const query = {};
+    if (period)
+        query.period = period;
+    return client.get(`/engine/campaigns/${encodeURIComponent(campaignId)}/analytics`, query);
+}
+// ── Computed Growth Signal ───────────────────────────────
+// Minimum sample size per variant before making recommendations
+const MIN_SAMPLE_SIZE = 100;
+// Minimum total views before any signal is meaningful
+const MIN_TOTAL_VIEWS = 200;
+// Z-score threshold for 95% confidence
+const Z_95 = 1.96;
+/**
+ * Compute a growth signal from campaign analytics.
+ *
+ * This replaces the hypothetical /growth-signal endpoint from the PRD.
+ * Uses two-proportion z-test to determine if any variant significantly
+ * outperforms the control (first variant by order).
+ */
+export function computeGrowthSignal(campaignId, analytics) {
+    const timestamp = new Date().toISOString();
+    const variants = analytics.byVariant;
+    // Not enough data yet
+    if (analytics.summary.totalViews < MIN_TOTAL_VIEWS || variants.length < 2) {
+        return {
+            campaignId,
+            timestamp,
+            winningVariantId: null,
+            confidence: 0,
+            conversionRateDelta: 0,
+            recommendation: 'wait',
+            reasoning: variants.length < 2
+                ? 'Need at least 2 variants to evaluate'
+                : `Insufficient data: ${analytics.summary.totalViews} views (need ${MIN_TOTAL_VIEWS})`,
+            sampleSize: { control: variants[0]?.views ?? 0, variant: 0 },
+        };
+    }
+    // Control = first variant by creation order (the original, pre-variation baseline).
+    // NOT the worst performer — using worst inflates z-scores and causes false positives.
+    // Tiebreaker by variantId for deterministic selection across JS engines.
+    const control = [...variants].sort((a, b) => a.order - b.order || a.variantId.localeCompare(b.variantId))[0];
+    const challengers = variants.filter(v => v.variantId !== control.variantId);
+    if (challengers.length === 0) {
+        return {
+            campaignId,
+            timestamp,
+            winningVariantId: null,
+            confidence: 0,
+            conversionRateDelta: 0,
+            recommendation: 'wait',
+            reasoning: 'Only the control variant exists — need at least one challenger',
+            sampleSize: { control: control.views, variant: 0 },
+        };
+    }
+    // Find best challenger by CVR (guard against NaN from 0-view variants)
+    const best = challengers
+        .filter(v => v.views > 0)
+        .sort((a, b) => b.cvr - a.cvr)[0];
+    if (!best) {
+        return {
+            campaignId,
+            timestamp,
+            winningVariantId: null,
+            confidence: 0,
+            conversionRateDelta: 0,
+            recommendation: 'wait',
+            reasoning: 'No challengers with traffic data yet',
+            sampleSize: { control: control.views, variant: 0 },
+        };
+    }
+    // Check minimum sample sizes
+    if (best.views < MIN_SAMPLE_SIZE || control.views < MIN_SAMPLE_SIZE) {
+        return {
+            campaignId,
+            timestamp,
+            winningVariantId: null,
+            confidence: 0,
+            conversionRateDelta: 0,
+            recommendation: 'wait',
+            reasoning: `Insufficient per-variant data: best=${best.views}, control=${control.views} views (need ${MIN_SAMPLE_SIZE} each)`,
+            sampleSize: { control: control.views, variant: best.views },
+        };
+    }
+    // Two-proportion z-test (one-tailed: is best better than control?)
+    const { zScore, pValue } = twoProportionZTest(best.conversions, best.views, control.conversions, control.views);
+    // Confidence = 1 - p_value (one-tailed). For two-tailed 95%, need p < 0.025.
+    // We use one-tailed because we have a directional hypothesis (best > control).
+    const confidence = 1 - pValue;
+    const conversionRateDelta = best.cvr - control.cvr;
+    const recommendation = computeRecommendation(confidence, conversionRateDelta, analytics.summary.totalViews);
+    return {
+        campaignId,
+        timestamp,
+        winningVariantId: confidence >= 0.95 ? best.variantId : null,
+        confidence,
+        conversionRateDelta,
+        recommendation,
+        reasoning: formatReasoning(best, control, confidence, recommendation),
+        sampleSize: { control: control.views, variant: best.views },
+    };
+}
+/**
+ * Fetch analytics and compute growth signal in one call.
+ */
+export async function getGrowthSignal(client, campaignId, period) {
+    const analytics = await getCampaignAnalytics(client, campaignId, period);
+    return computeGrowthSignal(campaignId, analytics);
+}
+// ── Statistical Helpers ──────────────────────────────────
+function twoProportionZTest(successA, nA, successB, nB) {
+    const pA = successA / nA;
+    const pB = successB / nB;
+    const pPooled = (successA + successB) / (nA + nB);
+    const se = Math.sqrt(pPooled * (1 - pPooled) * (1 / nA + 1 / nB));
+    if (nA === 0 || nB === 0 || !(se > 0))
+        return { zScore: 0, pValue: 1 };
+    const zScore = (pA - pB) / se;
+    // One-tailed p-value: P(Z >= z) = 1 - CDF(z)
+    const pValue = 1 - normalCdf(zScore);
+    return { zScore, pValue };
+}
+/**
+ * Approximate normal CDF using Abramowitz and Stegun formula.
+ * Returns P(Z <= z) for standard normal distribution.
+ */
+function normalCdf(z) {
+    if (z < -6)
+        return 0;
+    if (z > 6)
+        return 1;
+    const absZ = Math.abs(z);
+    const t = 1 / (1 + 0.2316419 * absZ);
+    const d = 0.3989422804014327; // 1/sqrt(2*PI)
+    const p = d * Math.exp(-absZ * absZ / 2) *
+        (t * (0.3193815 + t * (-0.3565638 + t * (1.781478 + t * (-1.8212560 + t * 1.3302744)))));
+    return z > 0 ? 1 - p : p;
+}
+function computeRecommendation(confidence, conversionRateDelta, totalViews) {
+    // High confidence winner
+    if (confidence >= 0.95 && conversionRateDelta > 0)
+        return 'scale';
+    // Moderate confidence, positive trend — keep iterating
+    if (confidence >= 0.80 && conversionRateDelta > 0)
+        return 'iterate';
+    // High confidence that all challengers underperform the control
+    if (confidence >= 0.95 && conversionRateDelta < 0 && totalViews > 500)
+        return 'kill';
+    // Not enough signal yet
+    return 'wait';
+}
+function formatReasoning(best, control, confidence, recommendation) {
+    const delta = (best.cvr - control.cvr).toFixed(2);
+    switch (recommendation) {
+        case 'scale':
+            return `Variant "${best.label}" outperforms control by ${delta}pp CVR with ${(confidence * 100).toFixed(1)}% confidence. Scale this variant.`;
+        case 'iterate':
+            return `Variant "${best.label}" shows +${delta}pp CVR lift at ${(confidence * 100).toFixed(1)}% confidence. Continue testing for stronger signal.`;
+        case 'kill':
+            return `No variant shows significant improvement. Consider killing this campaign.`;
+        case 'wait':
+            return `Insufficient data for recommendation. Current best: "${best.label}" at ${best.cvr.toFixed(2)}% CVR.`;
+    }
+}

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

@@ -0,0 +1,52 @@
+/**
+ * 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
+ */
+import { KongoClient } from './client.js';
+import type { CreateCampaignRequest, CampaignDetail, UpdateCampaignRequest, PublishResult, ListCampaignsOptions, PaginatedResponse } from './types.js';
+/**
+ * Create a new campaign.
+ * Requires a templateId (page ID) to base variants on.
+ */
+export declare function createCampaign(client: KongoClient, config: CreateCampaignRequest): Promise<CampaignDetail>;
+/**
+ * Get a single campaign by ID.
+ * Returns full details including template info, variants, and stats.
+ */
+export declare function getCampaign(client: KongoClient, campaignId: string): Promise<CampaignDetail>;
+/**
+ * List campaigns with cursor-based pagination.
+ */
+export declare function listCampaigns(client: KongoClient, options?: ListCampaignsOptions): Promise<PaginatedResponse<CampaignDetail>>;
+/**
+ * Update a campaign's rotation strategy, tracking, access gate, or metadata.
+ * Slug and template cannot be changed after creation.
+ */
+export declare function updateCampaign(client: KongoClient, campaignId: string, updates: UpdateCampaignRequest): Promise<CampaignDetail>;
+/**
+ * Archive a campaign (soft delete). Unpublishes automatically.
+ */
+export declare function deleteCampaign(client: KongoClient, campaignId: string): Promise<void>;
+/**
+ * Publish a campaign — provisions DNS CNAME at {slug}.kongo.io.
+ * Requires at least 1 active variant. Idempotent.
+ */
+export declare function publishCampaign(client: KongoClient, campaignId: string): Promise<PublishResult>;
+/**
+ * Unpublish a campaign — removes DNS record.
+ */
+export declare function unpublishCampaign(client: KongoClient, campaignId: string): Promise<void>;
+export declare function batchGetCampaignStatuses(client: KongoClient): Promise<CampaignDetail[]>;