voidforge-build 23.9.1

package/dist/wizard/lib/financial/campaign/google-campaign.js

@@ -0,0 +1,186 @@
+/**
+ * Google Ads Campaign Adapter — orchestration layer.
+ *
+ * Implements AdPlatformAdapter for Google Ads API v17.
+ * Raw API calls delegated to google-api.ts.
+ * Shared patterns from campaign-common.ts.
+ *
+ * PRD Reference: SS9.5, SS9.19.10, SS9.20.4
+ * No Stubs Doctrine: every method makes a real API call or returns documented empty.
+ */
+import { toCents, TokenBucketLimiter } from './base.js';
+import { safeParseJson, requireCompliance, aggregateSpend } from './campaign-common.js';
+import { googlePost, googleRefreshToken, extractSearchStreamRows, sanitizeGaqlParam, sanitizeDate, throwGoogleApiError, } from './google-api.js';
+// ── Adapter Implementation ──────────────────────────
+export class GoogleCampaignAdapter {
+    config;
+    rateLimiter;
+    constructor(config) {
+        this.config = config;
+        this.rateLimiter = new TokenBucketLimiter({ capacity: 100, refillRate: 15000 / 86400 });
+    }
+    async mutate(path, ops) {
+        await this.rateLimiter.acquire();
+        const { status, body } = await googlePost(`/customers/${this.config.customerId}/${path}`, this.config.accessToken, this.config.developerToken, ops);
+        if (status !== 200)
+            throwGoogleApiError(status, body);
+        return body;
+    }
+    async search(query) {
+        await this.rateLimiter.acquire();
+        const { status, body } = await googlePost(`/customers/${this.config.customerId}/googleAds:searchStream`, this.config.accessToken, this.config.developerToken, { query });
+        if (status !== 200)
+            throwGoogleApiError(status, body);
+        return extractSearchStreamRows(body);
+    }
+    campaignResource(id) {
+        return `customers/${this.config.customerId}/campaigns/${id}`;
+    }
+    async refreshToken(token) {
+        const result = await googleRefreshToken(token.refreshToken);
+        if (result.status !== 200)
+            throwGoogleApiError(result.status, result.body);
+        const parsed = safeParseJson(result.body);
+        return {
+            ...token,
+            accessToken: parsed.access_token,
+            expiresAt: new Date(Date.now() + (parsed.expires_in ?? 3600) * 1000).toISOString(),
+        };
+    }
+    async createCampaign(config) {
+        requireCompliance(config, 'google');
+        const body = await this.mutate('campaigns:mutate', {
+            operations: [{
+                    create: {
+                        name: config.name, advertisingChannelType: 'SEARCH', status: 'PAUSED',
+                        campaignBudget: `customers/${this.config.customerId}/campaignBudgets/-1`,
+                        biddingStrategyType: config.objective === 'conversions' ? 'MAXIMIZE_CONVERSIONS' : 'MAXIMIZE_CLICKS',
+                    },
+                }],
+            requestId: config.idempotencyKey,
+        });
+        const parsed = safeParseJson(body);
+        const results = parsed.results ?? [];
+        const resource = results[0]?.resourceName ?? '';
+        const externalId = resource.split('/').pop() ?? '';
+        return {
+            externalId, platform: 'google', status: 'created',
+            dashboardUrl: `https://ads.google.com/aw/campaigns?campaignId=${externalId}&ocid=${this.config.customerId}`,
+        };
+    }
+    async updateCampaign(id, changes) {
+        const update = { resourceName: this.campaignResource(id) };
+        const updateMask = [];
+        if (changes.name !== undefined) {
+            update.name = changes.name;
+            updateMask.push('name');
+        }
+        if (updateMask.length === 0)
+            return;
+        await this.mutate('campaigns:mutate', { operations: [{ update, updateMask: updateMask.join(',') }] });
+    }
+    async pauseCampaign(id) {
+        await this.mutate('campaigns:mutate', {
+            operations: [{ update: { resourceName: this.campaignResource(id), status: 'PAUSED' }, updateMask: 'status' }],
+        });
+    }
+    async resumeCampaign(id) {
+        await this.mutate('campaigns:mutate', {
+            operations: [{ update: { resourceName: this.campaignResource(id), status: 'ENABLED' }, updateMask: 'status' }],
+        });
+    }
+    async deleteCampaign(id) {
+        await this.mutate('campaigns:mutate', { operations: [{ remove: this.campaignResource(id) }] });
+    }
+    async updateBudget(id, dailyBudget) {
+        const budgetMicros = dailyBudget * 10000;
+        const rows = await this.search(`SELECT campaign_budget.resource_name FROM campaign WHERE campaign.id = ${sanitizeGaqlParam(id)} LIMIT 1`);
+        const budgetResource = rows[0]?.campaignBudget?.resourceName;
+        if (!budgetResource) {
+            throwGoogleApiError(404, JSON.stringify({ error: { message: `Budget resource not found for campaign ${id}` } }));
+        }
+        await this.mutate('campaignBudgets:mutate', {
+            operations: [{ update: { resourceName: budgetResource, amountMicros: budgetMicros }, updateMask: 'amount_micros' }],
+        });
+    }
+    async updateCreative(id, creative) {
+        const rows = await this.search(`SELECT ad_group_ad.ad.resource_name, ad_group_ad.ad.id FROM ad_group_ad WHERE campaign.id = ${sanitizeGaqlParam(id)} LIMIT 1`);
+        const adResource = rows[0]?.adGroupAd;
+        if (!adResource?.ad?.resourceName) {
+            throwGoogleApiError(404, JSON.stringify({ error: { message: `No ad found for campaign ${id}` } }));
+        }
+        const update = { resourceName: adResource.ad.resourceName };
+        const updateMask = [];
+        if (creative.headlines) {
+            update.responsiveSearchAd = {
+                ...(update.responsiveSearchAd ?? {}),
+                headlines: creative.headlines.map(h => ({ text: h })),
+            };
+            updateMask.push('responsive_search_ad.headlines');
+        }
+        if (creative.descriptions) {
+            update.responsiveSearchAd = {
+                ...(update.responsiveSearchAd ?? {}),
+                descriptions: creative.descriptions.map(d => ({ text: d })),
+            };
+            updateMask.push('responsive_search_ad.descriptions');
+        }
+        if (creative.landingUrl) {
+            update.finalUrls = [creative.landingUrl];
+            updateMask.push('final_urls');
+        }
+        if (updateMask.length === 0)
+            return;
+        await this.mutate('ads:mutate', { operations: [{ update, updateMask: updateMask.join(',') }] });
+    }
+    async getSpend(dateRange) {
+        const rows = await this.search([
+            'SELECT campaign.id, metrics.cost_micros, metrics.impressions, metrics.clicks, metrics.conversions',
+            'FROM campaign',
+            `WHERE segments.date BETWEEN '${sanitizeDate(dateRange.start)}' AND '${sanitizeDate(dateRange.end)}'`,
+        ].join(' '));
+        const campaigns = rows.map(row => {
+            const m = row.metrics ?? {};
+            const c = row.campaign ?? {};
+            return {
+                externalId: c.id ?? '',
+                spend: toCents(parseInt(m.costMicros ?? '0') / 1_000_000),
+                impressions: parseInt(m.impressions ?? '0'),
+                clicks: parseInt(m.clicks ?? '0'),
+                conversions: Math.round(parseFloat(m.conversions ?? '0')),
+            };
+        });
+        return { platform: 'google', dateRange, totalSpend: aggregateSpend(campaigns), campaigns };
+    }
+    async getPerformance(campaignId) {
+        const today = new Date().toISOString().slice(0, 10);
+        const rows = await this.search([
+            'SELECT metrics.cost_micros, metrics.impressions, metrics.clicks,',
+            'metrics.conversions, metrics.ctr, metrics.average_cpc FROM campaign',
+            `WHERE campaign.id = ${sanitizeGaqlParam(campaignId)} AND segments.date = '${today}'`,
+        ].join(' '));
+        const m = rows[0]?.metrics ?? {};
+        const spend = toCents(parseInt(m.costMicros ?? '0') / 1_000_000);
+        return {
+            campaignId,
+            impressions: parseInt(m.impressions ?? '0'),
+            clicks: parseInt(m.clicks ?? '0'),
+            conversions: Math.round(parseFloat(m.conversions ?? '0')),
+            spend,
+            ctr: parseFloat(m.ctr ?? '0'),
+            cpc: toCents(parseInt(m.averageCpc ?? '0') / 1_000_000),
+            roas: (spend > 0 ? 0 : 0),
+        };
+    }
+    async getInsights(campaignId, metrics) {
+        const metricsQuery = metrics.map(m => `metrics.${sanitizeGaqlParam(m)}`).join(', ');
+        const today = new Date().toISOString().slice(0, 10);
+        const rows = await this.search(`SELECT ${metricsQuery} FROM campaign WHERE campaign.id = ${sanitizeGaqlParam(campaignId)} AND segments.date = '${today}'`);
+        const row = rows[0]?.metrics ?? {};
+        const result = {};
+        for (const metric of metrics) {
+            result[metric] = parseFloat(row[metric] ?? '0');
+        }
+        return { campaignId, metrics: result };
+    }
+}

package/dist/wizard/lib/financial/campaign/meta-api.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Meta Marketing API layer — raw HTTP calls via node:https (zero new dependencies).
+ *
+ * Meta Marketing API v19.0:
+ *   Base URL: https://graph.facebook.com/v19.0
+ *   Auth: access_token query parameter
+ *   Rate limit: 200 calls/hr/ad account (sliding window)
+ *
+ * PRD Reference: SS9.5, SS9.19.10, SS9.20.4
+ */
+export declare const META_HOST = "graph.facebook.com";
+export interface MetaCampaignConfig {
+    adAccountId: string;
+    accessToken: string;
+}
+export declare function metaGet(path: string, accessToken: string, params?: Record<string, string>): Promise<{
+    status: number;
+    body: string;
+}>;
+export declare function metaPost(path: string, accessToken: string, params: Record<string, string>): Promise<{
+    status: number;
+    body: string;
+}>;
+export declare function metaDelete(path: string, accessToken: string): Promise<{
+    status: number;
+    body: string;
+}>;
+export declare function throwMetaApiError(status: number, body: string): never;

package/dist/wizard/lib/financial/campaign/meta-api.js

@@ -0,0 +1,93 @@
+/**
+ * Meta Marketing API layer — raw HTTP calls via node:https (zero new dependencies).
+ *
+ * Meta Marketing API v19.0:
+ *   Base URL: https://graph.facebook.com/v19.0
+ *   Auth: access_token query parameter
+ *   Rate limit: 200 calls/hr/ad account (sliding window)
+ *
+ * PRD Reference: SS9.5, SS9.19.10, SS9.20.4
+ */
+import { request as httpsRequest } from 'node:https';
+import { safeParseJson, makePlatformError } from './campaign-common.js';
+export const META_HOST = 'graph.facebook.com';
+// ── HTTP helpers ─────────────────────────────────────
+export async function metaGet(path, accessToken, params) {
+    const queryParams = new URLSearchParams({ access_token: accessToken, ...params });
+    const query = '?' + queryParams.toString();
+    return new Promise((resolve, reject) => {
+        const req = httpsRequest({
+            hostname: META_HOST,
+            path: `/v19.0${path}${query}`,
+            method: 'GET',
+            headers: { 'Accept': 'application/json' },
+            timeout: 15000,
+        }, (res) => {
+            let data = '';
+            res.on('data', (chunk) => { data += chunk.toString(); });
+            res.on('end', () => resolve({ status: res.statusCode ?? 500, body: data }));
+        });
+        req.on('error', reject);
+        req.on('timeout', () => { req.destroy(); reject(new Error('Meta API timeout')); });
+        req.end();
+    });
+}
+export async function metaPost(path, accessToken, params) {
+    const payload = new URLSearchParams({ access_token: accessToken, ...params }).toString();
+    return new Promise((resolve, reject) => {
+        const req = httpsRequest({
+            hostname: META_HOST,
+            path: `/v19.0${path}`,
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                'Accept': 'application/json',
+            },
+            timeout: 15000,
+        }, (res) => {
+            let data = '';
+            res.on('data', (chunk) => { data += chunk.toString(); });
+            res.on('end', () => resolve({ status: res.statusCode ?? 500, body: data }));
+        });
+        req.on('error', reject);
+        req.on('timeout', () => { req.destroy(); reject(new Error('Meta API timeout')); });
+        req.write(payload);
+        req.end();
+    });
+}
+export async function metaDelete(path, accessToken) {
+    const query = `?access_token=${encodeURIComponent(accessToken)}`;
+    return new Promise((resolve, reject) => {
+        const req = httpsRequest({
+            hostname: META_HOST,
+            path: `/v19.0${path}${query}`,
+            method: 'DELETE',
+            headers: { 'Accept': 'application/json' },
+            timeout: 15000,
+        }, (res) => {
+            let data = '';
+            res.on('data', (chunk) => { data += chunk.toString(); });
+            res.on('end', () => resolve({ status: res.statusCode ?? 500, body: data }));
+        });
+        req.on('error', reject);
+        req.on('timeout', () => { req.destroy(); reject(new Error('Meta API timeout')); });
+        req.end();
+    });
+}
+// ── Error classification ─────────────────────────────
+export function throwMetaApiError(status, body) {
+    const parsed = safeParseJson(body);
+    const errObj = parsed.error;
+    const errMsg = errObj?.message ?? `HTTP ${status}`;
+    const errCode = errObj?.code;
+    if (status === 429 || errCode === 32 || errCode === 4) {
+        throw makePlatformError('meta', 'RATE_LIMITED', status, errMsg, true, 60);
+    }
+    if (status === 401 || status === 403 || errCode === 190) {
+        throw makePlatformError('meta', 'AUTH_EXPIRED', status, errMsg);
+    }
+    if (errCode === 2635005 || errMsg.toLowerCase().includes('budget')) {
+        throw makePlatformError('meta', 'BUDGET_EXCEEDED', status, errMsg);
+    }
+    throw makePlatformError('meta', 'UNKNOWN', status, errMsg);
+}

package/dist/wizard/lib/financial/campaign/meta-campaign.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Meta Marketing Campaign Adapter — orchestration layer.
+ *
+ * Implements AdPlatformAdapter for Meta Marketing API v19.0.
+ * Raw API calls delegated to meta-api.ts.
+ * Shared patterns from campaign-common.ts.
+ *
+ * PRD Reference: SS9.5, SS9.19.10, SS9.20.4
+ * No Stubs Doctrine: every method makes a real API call or returns documented empty.
+ */
+import type { AdPlatformAdapter, CampaignConfig, CampaignResult, CampaignUpdate, CreativeConfig, SpendReport, PerformanceMetrics, InsightData, OAuthTokens, Cents } from './base.js';
+import type { MetaCampaignConfig } from './meta-api.js';
+export type { MetaCampaignConfig } from './meta-api.js';
+export declare class MetaCampaignAdapter implements AdPlatformAdapter {
+    private readonly config;
+    private readonly rateLimiter;
+    constructor(config: MetaCampaignConfig);
+    refreshToken(token: OAuthTokens): Promise<OAuthTokens>;
+    createCampaign(config: CampaignConfig): Promise<CampaignResult>;
+    updateCampaign(id: string, changes: CampaignUpdate): Promise<void>;
+    pauseCampaign(id: string): Promise<void>;
+    resumeCampaign(id: string): Promise<void>;
+    deleteCampaign(id: string): Promise<void>;
+    updateBudget(id: string, dailyBudget: Cents): Promise<void>;
+    updateCreative(id: string, creative: CreativeConfig): Promise<void>;
+    getSpend(dateRange: {
+        start: string;
+        end: string;
+    }): Promise<SpendReport>;
+    getPerformance(campaignId: string): Promise<PerformanceMetrics>;
+    getInsights(campaignId: string, metrics: string[]): Promise<InsightData>;
+}

package/dist/wizard/lib/financial/campaign/meta-campaign.js

@@ -0,0 +1,189 @@
+/**
+ * Meta Marketing Campaign Adapter — orchestration layer.
+ *
+ * Implements AdPlatformAdapter for Meta Marketing API v19.0.
+ * Raw API calls delegated to meta-api.ts.
+ * Shared patterns from campaign-common.ts.
+ *
+ * PRD Reference: SS9.5, SS9.19.10, SS9.20.4
+ * No Stubs Doctrine: every method makes a real API call or returns documented empty.
+ */
+import { toCents, TokenBucketLimiter } from './base.js';
+import { safeParseJson, mapObjective, requireCompliance, aggregateSpend, makePlatformError } from './campaign-common.js';
+import { metaGet, metaPost, metaDelete, throwMetaApiError } from './meta-api.js';
+// ── Adapter Implementation ──────────────────────────
+export class MetaCampaignAdapter {
+    config;
+    rateLimiter;
+    constructor(config) {
+        this.config = config;
+        // Meta: 200 calls/hr/ad account
+        this.rateLimiter = new TokenBucketLimiter({ capacity: 200, refillRate: 200 / 3600 });
+    }
+    async refreshToken(token) {
+        // Meta long-lived tokens: exchange at 80% of 60-day TTL
+        await this.rateLimiter.acquire();
+        const { status, body } = await metaGet('/oauth/access_token', token.accessToken, {
+            grant_type: 'fb_exchange_token',
+            fb_exchange_token: token.accessToken,
+        });
+        if (status !== 200) {
+            throwMetaApiError(status, body);
+        }
+        const parsed = safeParseJson(body);
+        return {
+            ...token,
+            accessToken: parsed.access_token,
+            expiresAt: new Date(Date.now() + 60 * 24 * 60 * 60 * 1000).toISOString(),
+        };
+    }
+    async createCampaign(config) {
+        requireCompliance(config, 'meta');
+        await this.rateLimiter.acquire();
+        const { status, body } = await metaPost(`/act_${this.config.adAccountId}/campaigns`, this.config.accessToken, {
+            name: config.name,
+            objective: mapObjective('meta', config.objective),
+            status: 'PAUSED',
+            special_ad_categories: '[]',
+            idempotency_key: config.idempotencyKey,
+        });
+        if (status !== 200)
+            throwMetaApiError(status, body);
+        const parsed = safeParseJson(body);
+        const externalId = parsed.id;
+        return {
+            externalId,
+            platform: 'meta',
+            status: 'created',
+            dashboardUrl: `https://www.facebook.com/adsmanager/manage/campaigns?act=${this.config.adAccountId}&campaign_ids=${externalId}`,
+        };
+    }
+    async updateCampaign(id, changes) {
+        await this.rateLimiter.acquire();
+        const params = {};
+        if (changes.name !== undefined)
+            params.name = changes.name;
+        if (Object.keys(params).length === 0)
+            return;
+        const { status, body } = await metaPost(`/${id}`, this.config.accessToken, params);
+        if (status !== 200)
+            throwMetaApiError(status, body);
+    }
+    async pauseCampaign(id) {
+        await this.rateLimiter.acquire();
+        const { status, body } = await metaPost(`/${id}`, this.config.accessToken, {
+            status: 'PAUSED',
+        });
+        if (status !== 200)
+            throwMetaApiError(status, body);
+    }
+    async resumeCampaign(id) {
+        await this.rateLimiter.acquire();
+        const { status, body } = await metaPost(`/${id}`, this.config.accessToken, {
+            status: 'ACTIVE',
+        });
+        if (status !== 200)
+            throwMetaApiError(status, body);
+    }
+    async deleteCampaign(id) {
+        await this.rateLimiter.acquire();
+        const { status, body } = await metaDelete(`/${id}`, this.config.accessToken);
+        if (status !== 200)
+            throwMetaApiError(status, body);
+    }
+    async updateBudget(id, dailyBudget) {
+        await this.rateLimiter.acquire();
+        // Meta budgets are in the account's currency smallest unit (cents for USD)
+        const { status, body } = await metaPost(`/${id}`, this.config.accessToken, {
+            daily_budget: String(dailyBudget),
+        });
+        if (status !== 200)
+            throwMetaApiError(status, body);
+    }
+    async updateCreative(id, creative) {
+        await this.rateLimiter.acquire();
+        const { status: queryStatus, body: queryBody } = await metaGet(`/${id}/ads`, this.config.accessToken, { fields: 'id', limit: '1' });
+        if (queryStatus !== 200)
+            throwMetaApiError(queryStatus, queryBody);
+        const queryParsed = safeParseJson(queryBody);
+        const ads = queryParsed.data ?? [];
+        if (ads.length === 0) {
+            throw makePlatformError('meta', 'CREATIVE_REJECTED', 404, `No ads found for campaign ${id}`);
+        }
+        const adId = ads[0].id;
+        const params = {};
+        if (creative.landingUrl) {
+            params.creative = JSON.stringify({
+                object_story_spec: {
+                    link_data: {
+                        link: creative.landingUrl,
+                        message: creative.descriptions?.[0] ?? '',
+                        name: creative.headlines?.[0] ?? '',
+                        call_to_action: creative.callToAction
+                            ? { type: creative.callToAction }
+                            : undefined,
+                    },
+                },
+            });
+        }
+        if (Object.keys(params).length === 0)
+            return;
+        const { status, body } = await metaPost(`/${adId}`, this.config.accessToken, params);
+        if (status !== 200)
+            throwMetaApiError(status, body);
+    }
+    async getSpend(dateRange) {
+        await this.rateLimiter.acquire();
+        const { status, body } = await metaGet(`/act_${this.config.adAccountId}/insights`, this.config.accessToken, {
+            fields: 'campaign_id,spend,impressions,clicks,conversions',
+            time_range: JSON.stringify({ since: dateRange.start, until: dateRange.end }),
+            level: 'campaign',
+        });
+        if (status !== 200)
+            throwMetaApiError(status, body);
+        const parsed = safeParseJson(body);
+        const dataArray = parsed.data ?? [];
+        const campaigns = dataArray.map(r => ({
+            externalId: r.campaign_id,
+            spend: toCents(parseFloat(r.spend)),
+            impressions: parseInt(r.impressions),
+            clicks: parseInt(r.clicks),
+            conversions: parseInt(r.conversions || '0'),
+        }));
+        return { platform: 'meta', dateRange, totalSpend: aggregateSpend(campaigns), campaigns };
+    }
+    async getPerformance(campaignId) {
+        await this.rateLimiter.acquire();
+        const { status, body } = await metaGet(`/${campaignId}/insights`, this.config.accessToken, { fields: 'impressions,clicks,conversions,spend,ctr,cpc' });
+        if (status !== 200)
+            throwMetaApiError(status, body);
+        const parsed = safeParseJson(body);
+        const dataArray = parsed.data ?? [];
+        const d = dataArray[0] ?? {};
+        const spend = toCents(parseFloat(d.spend ?? '0'));
+        return {
+            campaignId,
+            impressions: parseInt(d.impressions ?? '0'),
+            clicks: parseInt(d.clicks ?? '0'),
+            conversions: parseInt(d.conversions || '0'),
+            spend,
+            ctr: parseFloat(d.ctr ?? '0'),
+            cpc: toCents(parseFloat(d.cpc ?? '0')),
+            roas: (spend > 0 ? 0 : 0),
+        };
+    }
+    async getInsights(campaignId, metrics) {
+        await this.rateLimiter.acquire();
+        const { status, body } = await metaGet(`/${campaignId}/insights`, this.config.accessToken, { fields: metrics.join(',') });
+        if (status !== 200)
+            throwMetaApiError(status, body);
+        const parsed = safeParseJson(body);
+        const dataArray = parsed.data ?? [];
+        const row = dataArray[0] ?? {};
+        const result = {};
+        for (const metric of metrics) {
+            result[metric] = parseFloat(row[metric] ?? '0');
+        }
+        return { campaignId, metrics: result };
+    }
+}

package/dist/wizard/lib/financial/campaign/sandbox-campaign.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Sandbox Campaign Adapter — full implementation for development/demo.
+ *
+ * Returns realistic fake data matching the AdPlatformAdapter interface.
+ * Every method returns valid-shaped data. No throws (except invalid operations).
+ * This IS a full implementation for a sandbox provider (No Stubs Doctrine).
+ *
+ * Simulates campaign lifecycle: create → pending_review → (approveCampaign) →
+ * active → paused → resumed → completed. Realistic fake metrics: CTR 1.2-3.8%,
+ * CPC $0.45-$2.10, ROAS 1.5-4.2x. Idempotency key tracking prevents duplicate creates.
+ *
+ * PRD Reference: §9.5, §9.19.10, §9.20.4
+ */
+import type { AdPlatformAdapter, CampaignConfig, CampaignResult, CampaignUpdate, CreativeConfig, SpendReport, PerformanceMetrics, InsightData, OAuthTokens, AdPlatform, Cents } from './base.js';
+type SandboxCampaignStatus = 'pending_review' | 'active' | 'paused' | 'completed' | 'deleted';
+export declare class SandboxCampaignAdapter implements AdPlatformAdapter {
+    private readonly sandboxPlatform;
+    private campaigns;
+    private idempotencyKeys;
+    constructor(platform?: AdPlatform);
+    refreshToken(token: OAuthTokens): Promise<OAuthTokens>;
+    createCampaign(config: CampaignConfig): Promise<CampaignResult>;
+    updateCampaign(id: string, changes: CampaignUpdate): Promise<void>;
+    pauseCampaign(id: string): Promise<void>;
+    resumeCampaign(id: string): Promise<void>;
+    deleteCampaign(id: string): Promise<void>;
+    updateBudget(id: string, dailyBudget: Cents): Promise<void>;
+    updateCreative(id: string, creative: CreativeConfig): Promise<void>;
+    getSpend(dateRange: {
+        start: string;
+        end: string;
+    }): Promise<SpendReport>;
+    getPerformance(campaignId: string): Promise<PerformanceMetrics>;
+    getInsights(campaignId: string, metrics: string[]): Promise<InsightData>;
+    /** Manually advance campaign from pending_review to active (simulates platform approval). */
+    approveCampaign(id: string): void;
+    /** Get the current status of a sandbox campaign (for testing/integration). */
+    getCampaignStatus(id: string): SandboxCampaignStatus;
+    /** Get the count of tracked campaigns (for testing). */
+    getCampaignCount(): number;
+    private requireCampaign;
+    private requireNotDeleted;
+    private makePlatformError;
+}
+export {};