@signaliz/sdk 1.0.1 → 1.0.3

package/dist/index.d.ts

@@ -45,6 +45,19 @@ interface VerifyEmailResult {
     confidenceScore: number;
     verificationSource?: string;
 }
+interface FindAndVerifyEmailContact extends FindEmailParams {
+}
+interface EmailBatchJobResult {
+    jobId: string;
+    status: string;
+    capability: string;
+    itemsTotal: number;
+    message: string;
+    estimatedTimeSeconds?: number;
+    skippedCount?: number;
+    queuePosition?: number;
+    estimatedStartTime?: string;
+}
 interface EnrichSignalsParams {
     companyName: string;
     domain?: string;
@@ -181,6 +194,14 @@ interface RunResult {
     totalRows?: number;
     completedRows?: number;
     creditsUsed?: number;
+    completed?: boolean;
+    retryEligible?: boolean;
+    triggerStatus?: string;
+    output?: unknown;
+    error?: string;
+    message?: string;
+    recoveryGuidance?: string;
+    raw?: unknown;
 }
 interface HttpRequestParams {
     url: string;
@@ -193,12 +214,90 @@ interface HttpRequestResult {
     headers: Record<string, string>;
     body: unknown;
 }
+interface CustomAiOutputField {
+    name: string;
+    type?: 'text' | 'string' | 'number' | 'boolean' | 'array' | 'json';
+    description?: string;
+}
+interface CustomAiAttachment {
+    type?: 'text' | 'image' | 'pdf' | 'file' | 'audio' | 'video';
+    url?: string;
+    data_url?: string;
+    base64?: string;
+    mime_type?: string;
+    filename?: string;
+    text?: string;
+    detail?: 'auto' | 'low' | 'high';
+    format?: string;
+}
+interface CustomAiFusionConfig {
+    required?: boolean;
+    analysis_models?: string[];
+    judge_model?: string;
+    include_raw_analysis?: boolean;
+}
+interface CustomAiMultiModelParams {
+    /** Simple prompt template. Equivalent to userTemplate. */
+    prompt?: string;
+    /** One record to enrich. */
+    input?: Record<string, unknown>;
+    /** Multiple records to enrich. Max 25 per request. */
+    inputs?: Record<string, unknown>[];
+    /** Alias for inputs. */
+    records?: Record<string, unknown>[];
+    /** OpenRouter model id, e.g. anthropic/claude-sonnet-4. */
+    model: string;
+    systemPrompt?: string;
+    system_prompt?: string;
+    userTemplate?: string;
+    user_template?: string;
+    temperature?: number;
+    maxConcurrency?: number;
+    max_concurrency?: number;
+    maxTokens?: number;
+    max_tokens?: number;
+    outputFields?: CustomAiOutputField[];
+    output_fields?: CustomAiOutputField[];
+    attachments?: CustomAiAttachment[];
+    attachmentFields?: string[];
+    attachment_fields?: string[];
+    pdfEngine?: 'cloudflare-ai' | 'mistral-ocr' | 'native';
+    pdf_engine?: 'cloudflare-ai' | 'mistral-ocr' | 'native';
+    fusion?: CustomAiFusionConfig;
+}
+interface CustomAiMultiModelResult {
+    success: boolean;
+    capability: string;
+    displayName: string;
+    results: Record<string, unknown>[];
+    creditsUsed: number;
+    model?: string;
+    fusion?: Record<string, unknown>;
+    multimodalCount: number;
+    tokensUsed: number;
+    costUsd: number;
+    billingMetadata?: Record<string, unknown>;
+    raw: Record<string, unknown>;
+}
 interface WorkspaceInfo {
     id: string;
     name: string;
     creditsRemaining: number;
     plan: string;
 }
+interface PlatformHealth {
+    status: string;
+    period?: string;
+    totalRequests: number;
+    errorRate: string;
+    latency: {
+        p50: number;
+        p95: number;
+        p99: number;
+        sampleCount?: number;
+        source?: string;
+    };
+}
 interface RunProgressEvent {
     runId: string;
     status: string;
@@ -212,6 +311,89 @@ interface MCPToolInfo {
     description: string;
     category?: string;
     costCredits?: number;
+    contractVersion?: string;
+    permissionLevel?: string;
+    authScopes?: string[];
+    idempotent?: boolean;
+    destructive?: boolean;
+    retryable?: boolean;
+    rateLimitKey?: string;
+    observability?: Record<string, unknown>;
+    inputSchema?: {
+        required?: string[];
+        properties?: Record<string, unknown>;
+        [key: string]: unknown;
+    };
+    outputSchema?: {
+        required?: string[];
+        properties?: Record<string, unknown>;
+        [key: string]: unknown;
+    };
+    annotations?: Record<string, unknown>;
+}
+interface GenerateLeadsParams {
+    prompt: string;
+    maxLeads?: number;
+    verifyEmails?: boolean;
+    fileName?: string;
+    model?: string;
+    companyDomains?: string[];
+    completenessMode?: 'fast' | 'complete';
+    /** Net-new expansion mode for lookalike prompts. Bypasses recent lead cache and suppresses existing workspace leads. */
+    lookalikeExpansion?: boolean;
+    /** Required for spendful lead generation. Omit to receive an approval-required error with retry arguments. */
+    confirmSpend?: boolean;
+}
+interface GenerateLocalLeadsParams {
+    prompt: string;
+    /** Number of verified leads to return (auto-continues until target met). */
+    targetVerified?: number;
+    /** @deprecated Use targetVerified. */
+    maxLeads?: number;
+    verifyEmails?: boolean;
+    fileName?: string;
+    /** Required for spendful local lead generation. Omit to receive an approval-required error with retry arguments. */
+    confirmSpend?: boolean;
+}
+interface NativeGtmCapabilityInfo {
+    id: string;
+    label: string;
+    category: string;
+    description: string;
+    best_for: string[];
+    required_input: string;
+    default_results: number;
+    max_results: number;
+    credits_per_result: number;
+    quality: Record<string, unknown>;
+    api_call: Record<string, unknown>;
+    profitability_guardrail: Record<string, unknown>;
+}
+interface RunNativeGtmCapabilityParams {
+    capability: string;
+    query?: string;
+    urls?: string[];
+    placeIds?: string[];
+    maxResults?: number;
+    mode?: string;
+    since?: string;
+    location?: string;
+    countryCode?: string;
+    /** Required for spendful native GTM runs. Omit to receive an approval-required result with retry arguments. */
+    confirmSpend?: boolean;
+}
+interface LeadGenJobResult {
+    jobId: string;
+    status: string;
+    capability: string;
+    prompt: string;
+    source: string;
+    targetVerified?: number;
+    /** @deprecated */
+    maxLeads?: number;
+    verifyEmails: boolean;
+    message: string;
+    estimatedTimeSeconds: number;
 }
 
 declare class HttpClient {
@@ -226,6 +408,8 @@ declare class HttpClient {
     request<T = any>(functionName: string, body: Record<string, unknown>, method?: 'POST' | 'GET'): Promise<T>;
     /** Convenience wrapper for POST-based edge function calls */
     post<T = any>(functionName: string, body: Record<string, unknown>): Promise<T>;
+    /** Convenience wrapper for GET-based edge function calls with query params */
+    get<T = any>(functionName: string, query?: Record<string, unknown>): Promise<T>;
     /** JSON-RPC call to the MCP server */
     mcp<T = any>(method: string, params?: Record<string, unknown>): Promise<T>;
     private getToken;
@@ -238,6 +422,18 @@ declare class Emails {
     find(params: FindEmailParams): Promise<FindEmailResult>;
     /** Verify a single email address */
     verify(email: string): Promise<VerifyEmailResult>;
+    /** Submit up to 5,000 contacts for async find + verify processing. */
+    findBatch(contacts: FindAndVerifyEmailContact[]): Promise<EmailBatchJobResult>;
+    /** Submit up to 5,000 email addresses for async verification. */
+    verifyBatch(emails: Array<string | {
+        email: string;
+    }>): Promise<EmailBatchJobResult>;
+    /** Poll a batch email job returned by findBatch or verifyBatch. */
+    checkStatus(jobId: string, opts?: {
+        page?: number;
+        pageSize?: number;
+        includePartialResults?: boolean;
+    }): Promise<Record<string, unknown>>;
 }
 
 declare class Signals {
@@ -265,7 +461,7 @@ declare class Systems {
 declare class Runs {
     private client;
     constructor(client: HttpClient);
-    /** Get run status */
+    /** Get run status across Trigger, batch, and dataplane runs. */
     get(runId: string): Promise<RunResult>;
     /** Poll until a run completes. Returns final result. */
     waitForCompletion(runId: string, pollIntervalMs?: number): Promise<RunResult>;
@@ -283,6 +479,2383 @@ declare class Http {
     request(params: HttpRequestParams): Promise<HttpRequestResult>;
 }
 
+/** Allowed delivery output modes. */
+type CampaignDeliveryMode = 'json' | 'csv' | 'webhook';
+interface CampaignBuildRequest {
+    name: string;
+    prompt: string;
+    /** Existing GTM Kernel campaign object to link this build to. */
+    gtmCampaignId?: string;
+    description?: string;
+    icp?: {
+        personas?: string[];
+        industries?: string[];
+        companySizes?: string[];
+        geographies?: string[];
+        keywords?: string[];
+        exclusions?: string[];
+        requireVerifiedEmail?: boolean;
+    };
+    targetCount?: number;
+    /** Return a validated plan without launching spendful work. */
+    dryRun?: boolean;
+    /** Allow Signaliz to clamp oversized target counts to the supported max. */
+    allowDownscale?: boolean;
+    /** Explicitly acknowledge spendful campaign generation when the API asks for approval. */
+    confirmSpend?: boolean;
+    dedupKeys?: ('email' | 'linkedin_url' | 'company_domain')[];
+    policy?: {
+        maxCredits?: number;
+        verifyEmails?: boolean;
+        model?: string;
+    };
+    signals?: {
+        enabled?: boolean;
+        types?: string[];
+        customPrompt?: string;
+        confidenceThreshold?: number;
+        lookbackDays?: number;
+    };
+    qualification?: {
+        enabled?: boolean;
+        model?: string;
+    };
+    copy?: {
+        enabled?: boolean;
+        tone?: string;
+        maxBodyWords?: number;
+        senderContext?: string;
+        offerContext?: string;
+        model?: string;
+    };
+    delivery?: {
+        enabled?: boolean;
+        destinationType?: CampaignDeliveryMode;
+        approvalRequired?: boolean;
+        includeDisqualified?: boolean;
+        destinationConfig?: Record<string, unknown>;
+    };
+    enhancers?: {
+        clay?: {
+            enabled?: boolean;
+            mode?: 'if_available' | 'required';
+            tableId?: string;
+            enrichmentFields?: string[];
+            apiKeyEnv?: string;
+        };
+        octave?: {
+            enabled?: boolean;
+            mode?: 'if_available' | 'required';
+            copyAgentId?: string;
+            qualificationAgentId?: string;
+            apiKeyEnv?: string;
+        };
+    };
+    /** Brain preflight context returned by scope_campaign. */
+    brainPreflight?: Record<string, unknown>;
+    /** Optional output from gtm_brain_seed_defaults. */
+    brainDefaults?: Record<string, unknown>;
+    /** Optional output from gtm_brain_delivery_risk. */
+    deliveryRisk?: Record<string, unknown>;
+}
+type CampaignApproach = 'account_first_qualified_outbound' | 'lookalike_expansion' | 'local_services_verified_email' | 'named_account_signal_monitor' | 'list_enrichment_and_route';
+interface CampaignScopeRequest {
+    prompt: string;
+    clientName?: string;
+    clientContext?: string;
+    campaignGoal?: string;
+    targetCount?: number;
+    destinations?: Array<{
+        type?: string;
+        config?: Record<string, unknown>;
+        [key: string]: unknown;
+    }>;
+    knownAccounts?: string[];
+    offers?: string[];
+    proofPoints?: string[];
+    sourceDocs?: string[];
+    approvalPolicy?: string;
+}
+interface CampaignScopeResult {
+    campaignScopeId: string;
+    clientName: string;
+    campaignName: string;
+    approach: CampaignApproach;
+    approachLabel: string;
+    goal: string;
+    targetCount: number;
+    icp: Record<string, unknown>;
+    personas: Array<Record<string, unknown>>;
+    sourceStrategy: Array<Record<string, unknown>>;
+    qualificationPlan: Array<Record<string, unknown>>;
+    signalPlan: Array<Record<string, unknown>>;
+    copyPlan: Record<string, unknown>;
+    deliveryPlan: Record<string, unknown>;
+    brainPreflight: Record<string, unknown>;
+    recommendedSignalizTools: string[];
+    buildCampaignArgs: Record<string, unknown>;
+    mcpFlow: Array<{
+        tool: string;
+        arguments: Record<string, unknown>;
+    }>;
+    missingInputs: string[];
+    estimatedCredits: number;
+    campaignMarkdown: string;
+}
+interface CampaignProviderRouteReadback {
+    plan?: Record<string, unknown> | null;
+    summary?: Record<string, unknown> | null;
+    ready: boolean | null;
+    label: string;
+    blockers: string[];
+    warnings: string[];
+}
+interface CampaignBuildResult {
+    campaignBuildId: string | null;
+    campaignId?: string | null;
+    campaignObject?: Record<string, unknown> | null;
+    status: string;
+    currentPhase: string | null;
+    nextPollAfterSeconds: number;
+    message: string;
+    dryRun?: boolean;
+    requestedTargetCount?: number;
+    plannedTargetCount?: number;
+    estimatedCredits?: number;
+    estimatedDurationSeconds?: number;
+    targetLimitApplied?: boolean;
+    targetLimitReason?: string | null;
+    maxSupportedTargetCount?: number;
+    brainContext?: Record<string, unknown>;
+    providerRoute?: CampaignProviderRouteReadback | null;
+}
+interface CampaignBuildStatus {
+    campaignBuildId: string;
+    campaignId?: string | null;
+    campaignObject?: Record<string, unknown> | null;
+    name: string;
+    status: string;
+    currentPhase: string | null;
+    currentPhaseStatus: string | null;
+    phases: {
+        phase: string;
+        status: string;
+    }[];
+    recordsTotal: number;
+    recordsProcessed: number;
+    recordsSucceeded: number;
+    recordsFailed: number;
+    warnings: string[];
+    errors: string[];
+    artifactCount: number;
+    providerRoute?: CampaignProviderRouteReadback | null;
+    nextAction: string;
+    createdAt: string;
+    updatedAt: string;
+    completedAt: string | null;
+}
+interface CampaignBuildRow {
+    /** Row index within the build */
+    index: number;
+    /** Row status: succeeded, failed, disqualified, etc. */
+    status: string;
+    /** Whether the row passed qualification */
+    qualified: boolean;
+    /** Row segment: signal, standard, disqualified */
+    segment: string | null;
+    /** Enriched row data */
+    data: Record<string, unknown>;
+}
+interface CampaignArtifact {
+    id: string;
+    campaignBuildId: string;
+    artifactType: string;
+    destination: string;
+    storagePath: string;
+    signedUrl: string | null;
+    rowCount: number;
+    checksum: string | null;
+    metadata: Record<string, unknown>;
+    createdAt: string;
+}
+interface CampaignRowsOptions {
+    /** Max rows per page (default: 50) */
+    limit?: number;
+    /** Pagination cursor from a previous response */
+    cursor?: string;
+    /** Filter by segment */
+    segment?: 'signal' | 'standard' | 'disqualified';
+    /** Filter by qualification status */
+    qualified?: boolean;
+    /** Filter by row processing status */
+    rowStatus?: string;
+}
+interface CampaignRowsResult {
+    campaignBuildId: string;
+    rows: CampaignBuildRow[];
+    count: number;
+    pageSize: number;
+    nextCursor: string | null;
+    hasMore: boolean;
+}
+interface ApproveDeliveryResult {
+    campaignBuildId: string;
+    destinationType: string;
+    status: string;
+    message: string;
+    deliveryId?: string;
+    deliveryIds?: string[];
+    approvedCount?: number;
+}
+interface CancelBuildResult {
+    campaignBuildId: string;
+    status: string;
+    reason: string;
+    message: string;
+}
+interface BuildOptions {
+    /** Idempotency key to prevent duplicate builds */
+    idempotencyKey?: string;
+}
+interface WaitOptions {
+    /** Polling interval in ms (default: 5000) */
+    intervalMs?: number;
+    /** Max wait time in ms (default: 600000 = 10 min) */
+    timeoutMs?: number;
+    /** Called on each poll with the latest status */
+    onProgress?: (status: CampaignBuildStatus) => void;
+}
+declare class Campaigns {
+    private client;
+    constructor(client: HttpClient);
+    /**
+     * Start an async Campaign Build.
+     * Returns immediately with a pollable campaign_build_id.
+     *
+     * ```ts
+     * const result = await signaliz.campaigns.build({ name: 'Q3 SaaS', prompt: '...' });
+     * console.log(result.campaignBuildId);
+     * ```
+     */
+    build(request: CampaignBuildRequest, options?: BuildOptions): Promise<CampaignBuildResult>;
+    /** Scope an agency/client campaign into a markdown brief plus build_campaign dry-run args. */
+    scope(request: CampaignScopeRequest): Promise<CampaignScopeResult>;
+    /** Get a concise status snapshot — ideal for polling loops. */
+    status(campaignBuildId: string): Promise<CampaignBuildStatus>;
+    /** Get the full campaign build record including delivery details. */
+    get(campaignBuildId: string): Promise<CampaignBuildStatus>;
+    /** Retrieve paginated rows from a completed build. */
+    rows(campaignBuildId: string, options?: CampaignRowsOptions): Promise<CampaignRowsResult>;
+    /** List all artifacts (CSV exports, etc.) for a build. */
+    artifacts(campaignBuildId: string): Promise<CampaignArtifact[]>;
+    /** Cancel a queued or running build. */
+    cancel(campaignBuildId: string, reason?: string): Promise<CancelBuildResult>;
+    /**
+     * Poll until a campaign build reaches a terminal status.
+     *
+     * ```ts
+     * const final = await signaliz.campaigns.wait(buildId, {
+     *   onProgress: (s) => console.log(`${s.recordsProcessed}/${s.recordsTotal}`),
+     * });
+     * ```
+     */
+    wait(campaignBuildId: string, options?: WaitOptions): Promise<CampaignBuildStatus>;
+    scopeCampaign(request: CampaignScopeRequest): Promise<CampaignScopeResult>;
+    buildCampaign(request: CampaignBuildRequest, options?: BuildOptions): Promise<CampaignBuildResult>;
+    getCampaignBuildStatus(campaignBuildId: string): Promise<CampaignBuildStatus>;
+    listCampaignBuildArtifacts(campaignBuildId: string): Promise<CampaignArtifact[]>;
+    getCampaignBuildRows(campaignBuildId: string, options?: CampaignRowsOptions): Promise<CampaignRowsResult>;
+    approveCampaignDelivery(campaignBuildId: string, destinationType: CampaignDeliveryMode, options?: {
+        destinationId?: string;
+        destinationConfig?: Record<string, unknown>;
+    }): Promise<ApproveDeliveryResult>;
+    cancelCampaignBuild(campaignBuildId: string, reason?: string): Promise<CancelBuildResult>;
+    waitForCompletion(campaignBuildId: string, options?: {
+        intervalMs?: number;
+        timeoutMs?: number;
+        onStatus?: (status: CampaignBuildStatus) => void;
+    }): Promise<CampaignBuildStatus>;
+    private callMcp;
+}
+
+type UnknownRecord$1 = Record<string, unknown>;
+type CampaignBuilderLayer = 'workspace_context' | 'memory' | 'source' | 'enrichment' | 'qualification' | 'copy' | 'delivery' | 'feedback' | 'approval';
+type CampaignBuilderGtmLayer = 'icp' | 'find_company' | 'find_people' | 'lead_generation' | 'local_leads' | 'email_finding' | 'email_verification' | 'company_enrichment' | 'copy_enrichment' | 'qualification' | 'sender' | 'feedback' | 'approval' | 'source_import' | 'destination_export' | 'customer_data' | 'custom';
+type CampaignBuilderProvider = 'signaliz' | 'octave' | 'apollo' | 'ai_ark' | 'clay_webhook' | 'airbyte' | 'nango' | 'instantly' | 'smartlead' | 'heyreach' | 'custom_mcp' | 'custom_api' | 'custom_webhook' | 'webhook' | 'csv';
+type CampaignBuilderAgentProvider = CampaignBuilderProvider;
+type CampaignBuilderRouteMode = 'required' | 'if_available' | 'fallback' | 'disabled';
+type CampaignBuilderProviderRoutingMode = 'preferred' | 'fallback' | 'disabled';
+type CampaignBuilderProviderInvocationType = 'signaliz_native' | 'mcp' | 'mcp_tool' | 'webhook' | 'api' | 'airbyte' | 'manual' | 'managed_integration';
+type CampaignBuilderMemoryScope = 'workspace' | 'network_patterns' | 'customer_private' | 'operator_notes';
+type CampaignBuilderApprovalType = 'memory_retrieval' | 'spend' | 'customer_tool' | 'external_write' | 'delivery' | 'launch';
+interface CampaignBuilderWorkspaceContext {
+    workspaceId?: string;
+    workspaceName?: string;
+    plan?: string;
+    creditsRemaining?: number;
+    connectedTools?: string[];
+    defaultSender?: string;
+    brandVoice?: string;
+    suppressionRules?: string[];
+    operatorNotes?: string[];
+    [key: string]: unknown;
+}
+interface CampaignBuilderMemoryQuery {
+    query: string;
+    scopes?: CampaignBuilderMemoryScope[];
+    topK?: number;
+    required?: boolean;
+    rationale?: string;
+}
+interface CampaignBuilderMemoryPlan {
+    enabled?: boolean;
+    queries?: CampaignBuilderMemoryQuery[];
+    useWorkspaceHistory?: boolean;
+    useNetworkPatterns?: boolean;
+    privacyMode?: 'workspace_only' | 'anonymized_patterns' | 'opt_in_network';
+    summary?: string;
+}
+interface CampaignBuilderIntegrationRoute {
+    id?: string;
+    layer: CampaignBuilderLayer;
+    gtmLayer?: CampaignBuilderGtmLayer;
+    gtmLayers?: CampaignBuilderGtmLayer[];
+    provider: CampaignBuilderProvider;
+    mode?: CampaignBuilderRouteMode;
+    routingPolicy?: CampaignBuilderProviderRoutingPolicy;
+    toolName?: string;
+    mcpServerName?: string;
+    label?: string;
+    rationale?: string;
+    approvalRequired?: boolean;
+    config?: UnknownRecord$1;
+    fallbackProvider?: CampaignBuilderProvider;
+    providerCapability?: CampaignBuilderProviderCapabilityContract;
+}
+interface CampaignBuilderCustomerTool {
+    provider: CampaignBuilderProvider;
+    label?: string;
+    mcpServerName?: string;
+    availableTools?: string[];
+    useForLayers: CampaignBuilderLayer[];
+    gtmLayerCapabilities?: CampaignBuilderGtmLayer[];
+    mode?: CampaignBuilderRouteMode;
+    routingPolicy?: CampaignBuilderProviderRoutingPolicy;
+    approvalRequired?: boolean;
+    config?: UnknownRecord$1;
+    providerCapability?: CampaignBuilderProviderCapabilityContract;
+}
+interface CampaignBuilderProviderRoutingPolicy {
+    mode: CampaignBuilderProviderRoutingMode;
+    useSignalizFallback?: boolean;
+    workspaceScoped?: boolean;
+    dryRunRequired?: boolean;
+    confirmRequired?: boolean;
+}
+interface CampaignBuilderProviderCapabilityContract {
+    providerId?: CampaignBuilderProvider | string;
+    layerCapabilities: CampaignBuilderGtmLayer[];
+    invocationType?: CampaignBuilderProviderInvocationType;
+    setupRequirements?: Array<{
+        kind: string;
+        label: string;
+        required?: boolean;
+        guidance?: string;
+    }>;
+    exampleInputSchema?: UnknownRecord$1;
+    exampleOutputSchema?: UnknownRecord$1;
+    routingPolicy?: CampaignBuilderProviderRoutingPolicy;
+    workspaceConfiguration?: {
+        scope?: 'workspace';
+        storesSecretsByReferenceOnly?: boolean;
+        fields?: UnknownRecord$1[];
+    };
+}
+interface SignalizCampaignBuilderDefaults {
+    requireVerifiedEmail?: boolean;
+    dedupKeys?: Array<'email' | 'linkedin_url' | 'company_domain'>;
+    maxCredits?: number;
+    allowDownscale?: boolean;
+    signals?: {
+        enabled?: boolean;
+        types?: string[];
+        confidenceThreshold?: number;
+        lookbackDays?: number;
+    };
+    qualification?: {
+        enabled?: boolean;
+        model?: string;
+    };
+    copy?: {
+        enabled?: boolean;
+        tone?: string;
+        maxBodyWords?: number;
+        senderContext?: string;
+        offerContext?: string;
+        model?: string;
+    };
+    delivery?: {
+        enabled?: boolean;
+        destinationType?: CampaignDeliveryMode;
+        approvalRequired?: boolean;
+        destinationConfig?: UnknownRecord$1;
+    };
+}
+interface CampaignBuilderApprovalPolicy {
+    requireHumanApproval?: boolean;
+    maxCreditsWithoutApproval?: number;
+    requireApprovalFor?: CampaignBuilderApprovalType[];
+    approvedByDefault?: CampaignBuilderApprovalType[];
+}
+interface CampaignBuilderAgentRequest {
+    goal: string;
+    /** Existing committed GTM campaign object to execute through gtm_campaign_build_execution_prepare. */
+    gtmCampaignId?: string;
+    campaignName?: string;
+    clientName?: string;
+    clientContext?: string;
+    targetCount?: number;
+    icp?: CampaignBuildRequest['icp'];
+    /** Optional output from gtm_brain_seed_defaults to attach to build_campaign. */
+    brainDefaults?: UnknownRecord$1;
+    /** Optional output from gtm_brain_delivery_risk. Required before committed-campaign launch handoff. */
+    deliveryRisk?: UnknownRecord$1;
+    workspaceContext?: CampaignBuilderWorkspaceContext;
+    memory?: CampaignBuilderMemoryPlan;
+    integrations?: CampaignBuilderIntegrationRoute[];
+    customerTools?: CampaignBuilderCustomerTool[];
+    signalizDefaults?: SignalizCampaignBuilderDefaults;
+    approvalPolicy?: CampaignBuilderApprovalPolicy;
+    constraints?: {
+        geographies?: string[];
+        exclusions?: string[];
+        maxDailySends?: number;
+        deliverabilityNotes?: string[];
+    };
+}
+interface CampaignBuilderRequiredApproval {
+    id: string;
+    type: CampaignBuilderApprovalType;
+    label: string;
+    reason: string;
+    blocking: boolean;
+    routeId?: string;
+    provider?: CampaignBuilderProvider;
+    estimatedCredits?: number;
+}
+interface CampaignBuilderApproval {
+    planId: string;
+    approvedBy: string;
+    approvedAt?: string;
+    approvedTypes: CampaignBuilderApprovalType[];
+    spendLimitCredits?: number;
+    approvedRouteIds?: string[];
+    notes?: string;
+}
+interface CampaignBuilderMcpStep {
+    id: string;
+    phase: CampaignBuilderLayer | 'plan' | 'launch';
+    tool: string;
+    arguments: UnknownRecord$1;
+    readOnly: boolean;
+    approvalRequired: boolean;
+}
+interface CampaignBuilderAgentPlan {
+    planId: string;
+    campaignName: string;
+    goal: string;
+    targetCount: number;
+    workspaceContext: CampaignBuilderWorkspaceContext;
+    memory: Required<Pick<CampaignBuilderMemoryPlan, 'enabled' | 'queries' | 'useWorkspaceHistory' | 'useNetworkPatterns' | 'privacyMode'>>;
+    defaults: Required<Pick<SignalizCampaignBuilderDefaults, 'requireVerifiedEmail' | 'dedupKeys' | 'allowDownscale'>>;
+    routes: CampaignBuilderIntegrationRoute[];
+    approvals: CampaignBuilderRequiredApproval[];
+    buildRequest: CampaignBuildRequest;
+    brainPreflight: UnknownRecord$1;
+    mcpFlow: CampaignBuilderMcpStep[];
+    estimatedCredits: number;
+    warnings: string[];
+}
+interface CampaignBuilderPlanOptions {
+    discoverCapabilities?: boolean;
+    scopeCampaign?: boolean;
+}
+declare const DEFAULT_SIGNALIZ_CAMPAIGN_BUILDER_DEFAULTS: Required<Pick<SignalizCampaignBuilderDefaults, 'requireVerifiedEmail' | 'dedupKeys' | 'allowDownscale'>> & SignalizCampaignBuilderDefaults;
+declare class CampaignBuilderAgent {
+    private client;
+    constructor(client: HttpClient);
+    createPlan(request: CampaignBuilderAgentRequest, options?: CampaignBuilderPlanOptions): Promise<CampaignBuilderAgentPlan>;
+    dryRunPlan(plan: CampaignBuilderAgentPlan, options?: BuildOptions): Promise<CampaignBuildResult>;
+    buildApprovedPlan(plan: CampaignBuilderAgentPlan, approval: CampaignBuilderApproval, options?: BuildOptions): Promise<CampaignBuildResult>;
+    private getWorkspaceContext;
+    private scopeCampaign;
+    private discoverPlannedRoutes;
+    private callMcp;
+}
+declare function createCampaignBuilderAgentPlan(request: CampaignBuilderAgentRequest, context?: {
+    workspaceContext?: CampaignBuilderWorkspaceContext;
+    scopeBuildArgs?: UnknownRecord$1;
+    scopeBrainPreflight?: UnknownRecord$1;
+    warnings?: string[];
+}): CampaignBuilderAgentPlan;
+declare function getMissingCampaignBuilderApprovals(plan: CampaignBuilderAgentPlan, approval: CampaignBuilderApproval): CampaignBuilderRequiredApproval[];
+declare function createCampaignBuilderApproval(plan: CampaignBuilderAgentPlan, input: Omit<CampaignBuilderApproval, 'planId' | 'approvedAt'>): CampaignBuilderApproval;
+
+interface IcpSummary {
+    id: string;
+    name: string;
+    description?: string;
+    industry_focus?: string[];
+    target_job_titles?: string[];
+    target_departments?: string[];
+    geography?: string[];
+    has_source_playbook_data: boolean;
+    /** @deprecated Use has_source_playbook_data. */
+    has_octave_data?: boolean;
+    created_at: string;
+}
+interface IcpDetail extends IcpSummary {
+    pain_points?: string[];
+    buying_triggers?: string[];
+    tech_stack?: string[];
+    revenue_range?: string;
+    employee_count_range?: string[];
+    deep_analysis?: Record<string, unknown>;
+    source_playbook_data?: Record<string, unknown>;
+    /** @deprecated Use source_playbook_data. */
+    octave_playbook_data?: Record<string, unknown>;
+    updated_at: string;
+}
+interface ImportPlaybooksResult {
+    imported: number;
+    skipped: number;
+    icps: Array<{
+        id: string;
+        name: string;
+    }>;
+}
+/** @deprecated Use ImportPlaybooksResult. */
+type ImportOctaveResult = ImportPlaybooksResult;
+declare class Icps {
+    private client;
+    constructor(client: HttpClient);
+    /** List all ICPs in the workspace */
+    list(opts?: {
+        includeSourcePlaybookData?: boolean;
+        includeOctaveData?: boolean;
+    }): Promise<IcpSummary[]>;
+    /** Get full ICP details by ID */
+    get(icpId: string): Promise<IcpDetail>;
+    /** Import connected source playbooks as ICPs */
+    importFromPlaybooks(playbookIds?: string[]): Promise<ImportPlaybooksResult>;
+    /** @deprecated Use importFromPlaybooks. */
+    importFromOctave(playbookIds?: string[]): Promise<ImportPlaybooksResult>;
+}
+
+declare class Leads {
+    private client;
+    constructor(client: HttpClient);
+    /**
+     * Generate B2B leads from a natural-language prompt.
+     * Returns a job_id — poll with `runs.get(jobId)` or `check_job_status`.
+     */
+    generate(params: GenerateLeadsParams): Promise<LeadGenJobResult>;
+    /**
+     * Generate local business leads via Google Maps + email scraping.
+     * Returns a job_id — poll with `runs.get(jobId)` or `check_job_status`.
+     */
+    generateLocal(params: GenerateLocalLeadsParams): Promise<LeadGenJobResult>;
+    /**
+     * List curated native GTM data sources with data-cost guardrails.
+     */
+    listNativeGtmCapabilities(category?: string): Promise<NativeGtmCapabilityInfo[]>;
+    /**
+     * Run a curated native GTM capability. Returns a job_id; poll with `runs.get(jobId)`
+     * or `checkStatus(jobId)`.
+     */
+    runNativeGtmCapability(params: RunNativeGtmCapabilityParams): Promise<LeadGenJobResult>;
+    /**
+     * Free-text router: pass an intent like "pull youtube subscribers of @joshwhitfieldai"
+     * and get back the top GTM capability matches with suggested args ready to run.
+     */
+    findGtmCapability(intent: string): Promise<{
+        matches: Array<{
+            capability_id: string;
+            label: string;
+            category: string;
+            score: number;
+            why_it_matched: string[];
+            required_input: string;
+            suggested_args: Record<string, unknown>;
+        }>;
+        intent: string;
+    }>;
+    /**
+     * Check the status of a lead generation job.
+     */
+    checkStatus(jobId: string): Promise<Record<string, unknown>>;
+}
+
+type ExecutionReferenceKind = 'op' | 'routine' | 'routine_tick' | 'trigger_run' | 'dataplane_run' | 'queue_job' | 'execution_event' | 'replay_run' | 'unknown';
+interface ExecutionReference {
+    kind: ExecutionReferenceKind;
+    id: string;
+    original: string;
+    label: string;
+    query_field: string;
+    status_command?: string;
+    replay_command?: string;
+}
+interface ExecutionReferenceInput {
+    id: string;
+    kind?: ExecutionReferenceKind;
+    source_field?: string;
+}
+declare function normalizeExecutionReference(input: string | ExecutionReferenceInput): ExecutionReference;
+declare function collectExecutionReferences(payload: Record<string, unknown>): ExecutionReference[];
+
+type OpsCadence = 'hourly' | 'daily' | 'weekly' | 'manual';
+type OpsRoutineStatus = 'draft' | 'active' | 'paused' | 'archived' | 'failed';
+type OpsSinkType = 'csv' | 'webhook' | 'airbyte' | 'nango' | 'slack' | 'google_sheets' | 'notion' | 'instantly' | 'routine';
+type OpsBlueprint = 'monitor_companies' | 'build_leads' | 'enrich_list' | 'route_signals' | 'launch_campaign';
+type SimpleOpStatus = 'draft' | 'ready' | 'running' | 'blocked' | 'needs_approval' | 'completed' | 'failed';
+type OpsPrimitivePermissionLevel = 'read' | 'write' | 'spend' | 'admin';
+type OpsPrimitiveWorkspaceScope = 'required';
+interface OpsPrimitiveRetryPolicy {
+    max_retries: number;
+    maxRetries?: number;
+    initial_delay_ms: number;
+    initialDelayMs?: number;
+    max_delay_ms: number;
+    maxDelayMs?: number;
+    backoff_multiplier: number;
+    backoffMultiplier?: number;
+    jitter: boolean;
+    retryable_errors: string[];
+    retryableErrors?: string[];
+    respect_retry_after: boolean;
+    respectRetryAfter?: boolean;
+}
+interface OpsPrimitiveConcurrencyPolicy {
+    workspace_key: string;
+    workspaceKey?: string;
+    provider_key?: string;
+    providerKey?: string;
+    max_concurrency: number;
+    maxConcurrency?: number;
+}
+interface OpsPrimitiveDeadLetterPolicy {
+    enabled: boolean;
+    queue: string;
+    include_input_hash: boolean;
+    includeInputHash?: boolean;
+    include_execution_refs: boolean;
+    includeExecutionRefs?: boolean;
+}
+interface OpsPrimitiveObservabilityPolicy {
+    emits_execution_refs: boolean;
+    emitsExecutionRefs?: boolean;
+    emits_progress_events: boolean;
+    emitsProgressEvents?: boolean;
+    event_fields: string[];
+    eventFields?: string[];
+}
+interface OpsPrimitive {
+    id: string;
+    version: string;
+    capability: string;
+    permission_level: OpsPrimitivePermissionLevel;
+    permissionLevel?: OpsPrimitivePermissionLevel;
+    workspace_scope: OpsPrimitiveWorkspaceScope;
+    workspaceScope?: OpsPrimitiveWorkspaceScope;
+    input_schema: Record<string, unknown>;
+    inputSchema?: Record<string, unknown>;
+    output_schema: Record<string, unknown>;
+    outputSchema?: Record<string, unknown>;
+    retry_policy: OpsPrimitiveRetryPolicy;
+    retryPolicy?: OpsPrimitiveRetryPolicy;
+    concurrency_policy: OpsPrimitiveConcurrencyPolicy;
+    concurrencyPolicy?: OpsPrimitiveConcurrencyPolicy;
+    rate_limit_key?: string;
+    rateLimitKey?: string;
+    idempotency_key_fields: string[];
+    idempotencyKeyFields?: string[];
+    dead_letter_policy: OpsPrimitiveDeadLetterPolicy;
+    deadLetterPolicy?: OpsPrimitiveDeadLetterPolicy;
+    observability: OpsPrimitiveObservabilityPolicy;
+}
+interface OpsSink {
+    id?: string;
+    sinkId?: string;
+    sink_id?: string;
+    connectionId?: string;
+    connection_id?: string;
+    type: OpsSinkType;
+    name?: string;
+    connectorId?: string;
+    connector_id?: string;
+    category?: string;
+    status?: string;
+    syncStatus?: string | null;
+    sync_status?: string | null;
+    lastSyncedAt?: string | null;
+    last_synced_at?: string | null;
+    config?: Record<string, unknown>;
+    enabled?: boolean;
+}
+interface OpsRoutine {
+    id?: string;
+    routine_id?: string;
+    routineId?: string;
+    name?: string;
+    goal?: string;
+    cadence?: OpsCadence | string;
+    status?: OpsRoutineStatus | string;
+    lastTickAt?: string | null;
+    last_tick_at?: string | null;
+    nextTickAt?: string | null;
+    next_tick_at?: string | null;
+    outputSinks?: OpsSink[];
+    output_sinks?: OpsSink[];
+    execution_refs?: ExecutionReference[];
+    [key: string]: unknown;
+}
+interface OpsRoutinesResult {
+    routines: OpsRoutine[];
+    total?: number;
+    next_cursor?: string | null;
+    nextCursor?: string | null;
+    has_more?: boolean;
+    hasMore?: boolean;
+}
+interface OpsRoutineTick {
+    id?: string;
+    tick_id?: string;
+    tickId?: string;
+    routine_id?: string;
+    routineId?: string;
+    status?: string;
+    state?: string;
+    started_at?: string | null;
+    startedAt?: string | null;
+    completed_at?: string | null;
+    completedAt?: string | null;
+    error_message?: string | null;
+    errorMessage?: string | null;
+    execution_refs?: ExecutionReference[];
+    [key: string]: unknown;
+}
+interface OpsRoutineTicksResult {
+    ticks: OpsRoutineTick[];
+    items?: OpsRoutineTick[];
+    next_cursor?: string | null;
+    nextCursor?: string | null;
+    has_more?: boolean;
+    hasMore?: boolean;
+    [key: string]: unknown;
+}
+interface OpsRoutineTickItem {
+    id?: string;
+    item_id?: string;
+    itemId?: string;
+    tick_id?: string;
+    tickId?: string;
+    routine_id?: string;
+    routineId?: string;
+    state?: string;
+    status?: string;
+    error_message?: string | null;
+    errorMessage?: string | null;
+    payload?: Record<string, unknown>;
+    row?: Record<string, unknown>;
+    execution_refs?: ExecutionReference[];
+    [key: string]: unknown;
+}
+interface OpsRoutineTickItemsResult {
+    items: OpsRoutineTickItem[];
+    rows?: OpsRoutineTickItem[];
+    next_cursor?: string | null;
+    nextCursor?: string | null;
+    has_more?: boolean;
+    hasMore?: boolean;
+    [key: string]: unknown;
+}
+interface OpsReadinessOptions {
+    windowHours?: number;
+    includeDetails?: boolean;
+    runAcquisitionProbe?: boolean;
+}
+interface OpsReadinessCheck {
+    id: string;
+    label: string;
+    status: 'pass' | 'warn' | 'fail';
+    detail: string;
+    next_action?: string;
+    nextAction?: string;
+}
+interface OpsReadinessResult {
+    status: 'ready' | 'degraded' | 'blocked';
+    checked_at?: string;
+    checkedAt: string;
+    credits_used?: 0;
+    creditsUsed: 0;
+    credits_charged?: 0;
+    creditsCharged: 0;
+    summary: {
+        active_connections?: number;
+        activeConnections: number;
+        failing_connections?: number;
+        failingConnections: number;
+        active_routines?: number;
+        activeRoutines: number;
+        recent_failed_ticks?: number;
+        recentFailedTicks: number;
+        queued_deliveries?: number;
+        queuedDeliveries: number;
+        pending_approvals?: number;
+        pendingApprovals: number;
+        lead_records?: number;
+        leadRecords: number;
+        recent_acquisition_failures?: number;
+        recentAcquisitionFailures: number;
+        acquisition_probe_status?: string;
+        acquisitionProbeStatus?: string;
+    };
+    checks: OpsReadinessCheck[];
+    next_actions?: string[];
+    nextActions: string[];
+    raw?: Record<string, unknown>;
+}
+interface OpsProofOptions {
+    windowHours?: number;
+}
+interface OpsProofDestination {
+    type: string;
+    label: string;
+    connected: boolean;
+    healthy: boolean;
+    delivered: number;
+    failed: number;
+    proof: 'verified' | 'connected' | 'needs_attention' | 'not_connected' | string;
+}
+interface OpsProofResult {
+    success?: boolean;
+    status: 'ready' | 'partial' | 'unproven' | 'blocked' | string;
+    proof_state?: string;
+    proofState?: string;
+    phase?: string;
+    checked_at?: string;
+    checkedAt?: string;
+    window_hours?: number;
+    windowHours?: number;
+    label: string;
+    ui_summary?: string;
+    uiSummary?: string;
+    founder_verdict?: string;
+    founderVerdict?: string;
+    description?: string;
+    summary: {
+        connected_destinations?: number;
+        connectedDestinations: number;
+        healthy_destinations?: number;
+        healthyDestinations: number;
+        failing_destinations?: number;
+        failingDestinations: number;
+        deliveries_30d?: number;
+        deliveries30d: number;
+        delivered_30d?: number;
+        delivered30d: number;
+        failed_30d?: number;
+        failed30d: number;
+        external_delivered_30d?: number;
+        externalDelivered30d: number;
+        airbyte_configured?: number;
+        airbyteConfigured: number;
+        airbyte_proofs_30d?: number;
+        airbyteProofs30d: number;
+        airbyte_failures_30d?: number;
+        airbyteFailures30d: number;
+    };
+    destinations: OpsProofDestination[];
+    blockers?: string[];
+    next_action?: string;
+    nextAction?: string;
+    next_actions?: string[];
+    nextActions?: string[];
+    estimated_credits?: number;
+    estimatedCredits?: number;
+    approval_required?: boolean;
+    approvalRequired?: boolean;
+    credits_charged?: 0;
+    creditsCharged?: 0;
+    proof_mode?: boolean;
+    proofMode?: boolean;
+    query_errors?: string[];
+    queryErrors?: string[];
+    raw?: Record<string, unknown>;
+}
+interface OpsAutopilotOptions {
+    windowHours?: number;
+}
+interface OpsAutopilotStep {
+    tool: string;
+    purpose?: string;
+    arguments?: Record<string, unknown>;
+}
+interface OpsAutopilotMotion {
+    id: string;
+    blueprint: OpsBlueprint;
+    title: string;
+    outcome: string;
+    prompt: string;
+    target_count: number;
+    targetCount?: number;
+    cadence: OpsCadence | string;
+    destinations: OpsSinkType[];
+    estimated_credits: number;
+    estimatedCredits?: number;
+    proof_gate?: string;
+    proofGate?: string;
+    why_now?: string;
+    whyNow?: string;
+    agent_prompt?: string;
+    agentPrompt?: string;
+    cli_command?: string;
+    cliCommand?: string;
+    mcp_sequence?: OpsAutopilotStep[];
+    mcpSequence?: OpsAutopilotStep[];
+}
+interface OpsAutopilotResult {
+    success?: boolean;
+    status?: string;
+    phase?: string;
+    stage: string;
+    headline: string;
+    verdict: string;
+    next_action: string;
+    nextAction?: string;
+    primary_motion: OpsAutopilotMotion;
+    primaryMotion?: OpsAutopilotMotion;
+    motions: OpsAutopilotMotion[];
+    scale_rule?: string;
+    scaleRule?: string;
+    agent_handoff?: string;
+    agentHandoff?: string;
+    proof_state?: string;
+    proofState?: string;
+    proof_summary?: Record<string, unknown>;
+    proofSummary?: Record<string, unknown>;
+    next_step?: Record<string, unknown>;
+    nextStep?: Record<string, unknown>;
+    query_errors?: string[];
+    queryErrors?: string[];
+    credits_charged?: 0;
+    creditsCharged?: 0;
+}
+interface CreateRoutineRequest {
+    name: string;
+    goal: string;
+    description?: string;
+    cadence?: OpsCadence;
+    timezone?: string;
+    status?: Extract<OpsRoutineStatus, 'draft' | 'active' | 'paused'>;
+    policy?: Record<string, unknown>;
+    output_sinks?: OpsSink[];
+    outputSinks?: OpsSink[];
+    wake_on_events?: string[];
+    wakeOnEvents?: string[];
+}
+interface UpdateRoutineRequest extends Partial<CreateRoutineRequest> {
+    routine_id?: string;
+    routineId?: string;
+}
+interface RunRoutineRequest {
+    routine_id?: string;
+    routineId?: string;
+    instruction?: string;
+    force?: boolean;
+}
+interface OpsRoutineRunResult {
+    success?: boolean;
+    routine_id?: string;
+    routineId?: string;
+    tick_id?: string;
+    tickId?: string;
+    run_id?: string | null;
+    runId?: string | null;
+    status?: string;
+    state?: string;
+    next_action?: string;
+    nextAction?: string;
+    execution_refs?: ExecutionReference[];
+    [key: string]: unknown;
+}
+interface OpsRoutineDeleteResult {
+    success?: boolean;
+    routine_id?: string;
+    routineId?: string;
+    deleted?: boolean;
+    permanent?: boolean;
+    status?: string;
+    next_action?: string;
+    nextAction?: string;
+    execution_refs?: ExecutionReference[];
+    [key: string]: unknown;
+}
+interface OpsRoutineSinkResult {
+    success?: boolean;
+    routine_id?: string;
+    routineId?: string;
+    sink_id?: string;
+    sinkId?: string;
+    status?: string;
+    next_action?: string;
+    nextAction?: string;
+    routine?: OpsRoutine;
+    sink?: OpsSink;
+    execution_refs?: ExecutionReference[];
+    [key: string]: unknown;
+}
+interface ListOutputSinksOptions {
+    status?: string;
+    category?: string;
+    include_inactive?: boolean;
+    includeInactive?: boolean;
+}
+interface CreateOutputSinkRequest {
+    type: Exclude<OpsSinkType, 'routine'>;
+    name?: string;
+    connection_id?: string;
+    connectionId?: string;
+    config?: Record<string, unknown>;
+    webhook_url?: string;
+    webhookUrl?: string;
+}
+interface OpsApproveRequest {
+    token_id?: string;
+    tokenId?: string;
+    token_ids?: string[];
+    tokenIds?: string[];
+    decision?: 'approved' | 'rejected';
+    reviewer_notes?: string;
+    reviewerNotes?: string;
+}
+interface OpsApproveResult {
+    success: boolean;
+    decision?: 'approved' | 'rejected' | string;
+    token_id?: string;
+    tokenId?: string;
+    token_ids?: string[];
+    tokenIds?: string[];
+    reviewer_notes?: string;
+    reviewerNotes?: string;
+    [key: string]: unknown;
+}
+interface OpsPlanRequest {
+    prompt: string;
+    blueprint?: OpsBlueprint;
+    target_count?: number;
+    targetCount?: number;
+    cadence?: OpsCadence;
+    destinations?: Array<Record<string, unknown>>;
+    company_domains?: string[];
+    companyDomains?: string[];
+    custom_ai_prompt?: string;
+    customAiPrompt?: string;
+    signal_prompt?: string;
+    signalPrompt?: string;
+    output_prompt?: string;
+    outputPrompt?: string;
+}
+interface OpsPlanResult {
+    plan_id: string;
+    planId?: string;
+    blueprint: OpsBlueprint;
+    title: string;
+    goal: string;
+    target_count: number;
+    targetCount?: number;
+    cadence: OpsCadence;
+    status: SimpleOpStatus | string;
+    estimated_credits: number;
+    estimatedCredits?: number;
+    approval_required: boolean;
+    approvalRequired?: boolean;
+    destinations: Array<Record<string, unknown>>;
+    blockers: string[];
+    expected_output?: string;
+    expectedOutput?: string;
+    next_action: string;
+    nextAction?: string;
+    ui_summary?: string;
+    uiSummary?: string;
+    review_steps?: Array<{
+        label: string;
+        value: string;
+        status?: string;
+    }>;
+    reviewSteps?: Array<{
+        label: string;
+        value: string;
+        status?: string;
+    }>;
+    fix_actions?: string[];
+    fixActions?: string[];
+    destination_status?: string;
+    destinationStatus?: string;
+    customization?: {
+        custom_ai_prompt?: string;
+        signal_prompt?: string;
+        output_prompt?: string;
+        [key: string]: unknown;
+    };
+    primitive_graph?: OpsPrimitive[];
+    primitiveGraph?: OpsPrimitive[];
+    advanced?: Record<string, unknown>;
+}
+interface OpsCreateRequest extends OpsPlanRequest {
+    name?: string;
+    description?: string;
+    policy?: Record<string, unknown>;
+    activate?: boolean;
+    confirm_spend?: boolean;
+    confirmSpend?: boolean;
+}
+interface OpsExecuteRequest extends OpsCreateRequest {
+    auto_run?: boolean;
+    autoRun?: boolean;
+    dry_run?: boolean;
+    dryRun?: boolean;
+    output_format?: 'markdown' | 'json';
+    outputFormat?: 'markdown' | 'json';
+}
+interface OpsCreateResult {
+    success: boolean;
+    op_id: string;
+    opId?: string;
+    routine_id?: string;
+    routineId?: string;
+    run_id?: string | null;
+    runId?: string | null;
+    status: SimpleOpStatus | string;
+    phase: string;
+    next_action: string;
+    nextAction?: string;
+    results_count: number;
+    resultsCount?: number;
+    results_url?: string;
+    resultsUrl?: string;
+    delivery_status?: string;
+    deliveryStatus?: string;
+    estimated_credits?: number;
+    estimatedCredits?: number;
+    plan?: OpsPlanResult;
+    execution_refs?: ExecutionReference[];
+}
+interface OpsExecuteResult extends OpsCreateResult {
+    error_code?: string;
+    errorCode?: string;
+    approval?: Record<string, unknown>;
+    approval_required?: boolean;
+    approvalRequired?: boolean;
+    retry_arguments?: Record<string, unknown>;
+    retryArguments?: Record<string, unknown>;
+    next_step?: Record<string, unknown>;
+    nextStep?: Record<string, unknown>;
+    next_steps?: string[];
+    nextSteps?: string[];
+    blockers?: string[];
+}
+interface OpsRunOptions {
+    op_id?: string;
+    opId?: string;
+    instruction?: string;
+    force?: boolean;
+}
+interface OpsRunResult {
+    success: boolean;
+    op_id: string;
+    opId?: string;
+    routine_id?: string;
+    routineId?: string;
+    run_id?: string | null;
+    runId?: string | null;
+    status: SimpleOpStatus | string;
+    phase: string;
+    next_action: string;
+    nextAction?: string;
+    results_count?: number;
+    resultsCount?: number;
+    results_url?: string;
+    resultsUrl?: string;
+    delivery_status?: string;
+    deliveryStatus?: string;
+    execution_refs?: ExecutionReference[];
+}
+interface OpsStatusOptions {
+    op_id?: string;
+    opId?: string;
+}
+interface OpsStatusResult extends OpsRunResult {
+    estimated_credits?: number | null;
+    estimatedCredits?: number | null;
+    latest_run?: Record<string, unknown> | null;
+    latestRun?: Record<string, unknown> | null;
+    diagnosis?: OpsDebugDiagnosis;
+}
+interface OpsResultsOptions {
+    op_id?: string;
+    opId?: string;
+    limit?: number;
+    cursor?: string;
+    nextCursor?: string;
+    state?: string;
+    include_failed_runs?: boolean;
+    includeFailedRuns?: boolean;
+}
+interface OpsResultsResult {
+    success: boolean;
+    op_id: string;
+    opId?: string;
+    routine_id?: string;
+    routineId?: string;
+    run_id?: string | null;
+    runId?: string | null;
+    status: SimpleOpStatus | string;
+    phase: string;
+    results_count: number;
+    resultsCount?: number;
+    results_total?: number | null;
+    resultsTotal?: number | null;
+    results: Array<Record<string, unknown>>;
+    next_cursor?: string | null;
+    nextCursor?: string | null;
+    has_more: boolean;
+    hasMore?: boolean;
+    next_action: string;
+    nextAction?: string;
+    results_url?: string;
+    resultsUrl?: string;
+    delivery_status?: string;
+    deliveryStatus?: string;
+    execution_refs?: ExecutionReference[];
+}
+interface OpsTriggerRunStatus {
+    success: boolean;
+    run_id: string;
+    runId?: string;
+    status: string;
+    output?: unknown;
+    error?: unknown;
+    costInCents?: number;
+    baseCostInCents?: number;
+    durationMs?: number;
+    _note?: string;
+    diagnosis?: OpsDebugDiagnosis;
+    execution_refs?: ExecutionReference[];
+}
+interface OpsTriggerBatchRunStatus {
+    success: boolean;
+    runs: OpsTriggerRunStatus[];
+}
+type OpsTriggerRunStatusOptions = {
+    run_id: string;
+    runId?: never;
+    run_ids?: never;
+    runIds?: never;
+} | {
+    runId: string;
+    run_id?: never;
+    run_ids?: never;
+    runIds?: never;
+} | {
+    run_ids: string[];
+    run_id?: never;
+    runId?: never;
+    runIds?: never;
+} | {
+    runIds: string[];
+    run_id?: never;
+    runId?: never;
+    run_ids?: never;
+};
+interface OpsQueueStatusOptions {
+    job_id?: string;
+    jobId?: string;
+    idempotency_key?: string;
+    idempotencyKey?: string;
+    summary?: boolean;
+}
+interface OpsQueueStatus {
+    success: boolean;
+    producer_envelope?: OpsQueueProducerEnvelope;
+    producerEnvelope?: OpsQueueProducerEnvelope;
+    queue?: {
+        pending?: number;
+        processing?: number;
+    };
+    summary?: {
+        queue?: {
+            pending?: number;
+            processing?: number;
+            completed_last_hour?: number;
+            completedLastHour?: number;
+            failed_last_hour?: number;
+            failedLastHour?: number;
+            pending_by_function?: Record<string, number>;
+            pendingByFunction?: Record<string, number>;
+        };
+        providers?: Record<string, unknown>;
+        provider_stats?: Record<string, unknown>;
+        providerStats?: Record<string, unknown>;
+        redis_status?: Record<string, unknown>;
+        redisStatus?: Record<string, unknown>;
+        recent_events?: Array<Record<string, unknown>>;
+        recentEvents?: Array<Record<string, unknown>>;
+    };
+    job?: {
+        id?: string;
+        jobId?: string;
+        status?: string;
+        function_name?: string;
+        functionName?: string;
+        estimated_wait_ms?: number;
+        estimatedWaitMs?: number;
+        error_message?: string;
+        errorMessage?: string;
+        [key: string]: unknown;
+    };
+    error?: string;
+    diagnosis?: OpsDebugDiagnosis;
+    execution_refs?: ExecutionReference[];
+}
+interface OpsQueueProducerEnvelope {
+    schema_version?: string;
+    schemaVersion?: string;
+    producer?: string;
+    queue_name?: string;
+    queueName?: string;
+    status_source?: string;
+    statusSource?: string;
+    idempotency_key?: string | null;
+    idempotencyKey?: string | null;
+    job_id?: string | null;
+    jobId?: string | null;
+    summary_requested?: boolean;
+    summaryRequested?: boolean;
+    retry_after_ms?: number;
+    retryAfterMs?: number;
+    poll_after_seconds?: number;
+    pollAfterSeconds?: number;
+    emitted_at?: string;
+    emittedAt?: string;
+    [key: string]: unknown;
+}
+interface OpsReplayResult {
+    success: boolean;
+    replay_run_id: string;
+    replayRunId?: string;
+    original_run_id: string;
+    originalRunId?: string;
+    start_from_node: number;
+    startFromNode?: number;
+    total_nodes: number;
+    totalNodes?: number;
+    diagnosis?: OpsDebugDiagnosis;
+    execution_refs?: ExecutionReference[];
+}
+interface OpsDashboardOptions {
+    section?: 'summary' | 'functions' | 'workspaces' | 'timeseries' | 'sources' | 'recent';
+    timeRangeDays?: number;
+    granularity?: 'hour' | 'day' | 'week' | 'month';
+    limit?: number;
+}
+interface OpsDashboardResult {
+    today_executions?: number;
+    todayExecutions?: number;
+    today_credits?: number;
+    todayCredits?: number;
+    month_executions?: number;
+    monthExecutions?: number;
+    month_credits?: number;
+    monthCredits?: number;
+    avg_execution_time_ms?: number;
+    avgExecutionTimeMs?: number;
+    [key: string]: unknown;
+}
+interface OpsDebugOptions {
+    op_id?: string;
+    opId?: string;
+    include_results?: boolean;
+    includeResults?: boolean;
+    results_limit?: number;
+    resultsLimit?: number;
+    include_queue?: boolean;
+    includeQueue?: boolean;
+    include_dashboard?: boolean;
+    includeDashboard?: boolean;
+    dashboard_limit?: number;
+    dashboardLimit?: number;
+    time_range_days?: number;
+    timeRangeDays?: number;
+}
+interface OpsDebugDiagnosticError {
+    step: string;
+    message: string;
+}
+interface OpsDebugDiagnosis {
+    state: 'healthy' | 'running' | 'failed' | 'degraded' | 'unknown';
+    retryable: boolean;
+    queue_pending: number;
+    queuePending?: number;
+    queue_processing: number;
+    queueProcessing?: number;
+    queue_failed_last_hour: number;
+    queueFailedLastHour?: number;
+    provider_pressure: 'none' | 'low' | 'medium' | 'high';
+    providerPressure?: 'none' | 'low' | 'medium' | 'high';
+    failed_run_count: number;
+    failedRunCount?: number;
+    primary_error?: string;
+    primaryError?: string;
+    summary: string;
+}
+interface OpsDebugResult {
+    success: boolean;
+    op_id: string;
+    opId?: string;
+    checked_at: string;
+    checkedAt?: string;
+    diagnosis: OpsDebugDiagnosis;
+    status: OpsStatusResult;
+    execution_refs: ExecutionReference[];
+    executionRefs?: ExecutionReference[];
+    run_statuses: OpsTriggerRunStatus[];
+    runStatuses?: OpsTriggerRunStatus[];
+    queue?: OpsQueueStatus;
+    dashboard_recent?: unknown;
+    dashboardRecent?: unknown;
+    results?: OpsResultsResult;
+    replay_candidates: ExecutionReference[];
+    replayCandidates?: ExecutionReference[];
+    next_actions: string[];
+    nextActions?: string[];
+    diagnostic_errors: OpsDebugDiagnosticError[];
+    diagnosticErrors?: OpsDebugDiagnosticError[];
+}
+interface OpsQuickstartStep {
+    step: number;
+    tool?: string;
+    action?: string;
+    arguments?: Record<string, unknown>;
+    description: string;
+    primitive_id?: string;
+    primitiveId?: string;
+    primitive_version?: string;
+    primitiveVersion?: string;
+}
+interface OpsQuickstartWorkflow {
+    workflow_type: string;
+    workflowType?: string;
+    requested_workflow_type?: string;
+    requestedWorkflowType?: string;
+    name: string;
+    description: string;
+    credits_required: number;
+    creditsRequired?: number;
+    steps: OpsQuickstartStep[];
+    primitive_graph?: OpsPrimitive[];
+    primitiveGraph?: OpsPrimitive[];
+    available_types: string[];
+    availableTypes?: string[];
+}
+declare class Ops {
+    private client;
+    constructor(client: HttpClient);
+    plan(params: OpsPlanRequest | string): Promise<OpsPlanResult>;
+    autopilot(params?: OpsAutopilotOptions): Promise<OpsAutopilotResult>;
+    create(params: OpsCreateRequest | string): Promise<OpsCreateResult>;
+    execute(params: OpsExecuteRequest | string): Promise<OpsExecuteResult>;
+    run(params: OpsRunOptions | string): Promise<OpsRunResult>;
+    status(params: OpsStatusOptions | string): Promise<OpsStatusResult>;
+    results(params: OpsResultsOptions | string): Promise<OpsResultsResult>;
+    proof(params?: OpsProofOptions): Promise<OpsProofResult>;
+    debug(params: OpsDebugOptions | string): Promise<OpsDebugResult>;
+    quickstartWorkflow(workflowType?: string): Promise<OpsQuickstartWorkflow>;
+    approve(params: OpsApproveRequest): Promise<OpsApproveResult>;
+    createRoutine(params: CreateRoutineRequest): Promise<OpsRoutine>;
+    listRoutines(params?: {
+        status?: OpsRoutineStatus;
+        limit?: number;
+        cursor?: string;
+    }): Promise<OpsRoutinesResult>;
+    getRoutine(routineId: string): Promise<OpsRoutine>;
+    updateRoutine(params: UpdateRoutineRequest): Promise<OpsRoutine>;
+    runRoutineNow(params: RunRoutineRequest | string): Promise<OpsRoutineRunResult>;
+    deleteRoutine(routineId: string, permanent?: boolean): Promise<OpsRoutineDeleteResult>;
+    listOutputSinks(params?: ListOutputSinksOptions): Promise<OpsSink[]>;
+    getReadiness(params?: OpsReadinessOptions): Promise<OpsReadinessResult>;
+    doctor(params?: OpsReadinessOptions): Promise<OpsReadinessResult>;
+    createOutputSink(params: CreateOutputSinkRequest): Promise<OpsSink>;
+    attachSinkToRoutine(params: {
+        routine_id?: string;
+        routineId?: string;
+        sink_id?: string;
+        sinkId?: string;
+    }): Promise<OpsRoutineSinkResult>;
+    getRoutineTicks(params: {
+        routine_id?: string;
+        routineId?: string;
+        limit?: number;
+        cursor?: string;
+    }): Promise<OpsRoutineTicksResult>;
+    getLastTickItems(params: {
+        routine_id?: string;
+        routineId?: string;
+        limit?: number;
+        cursor?: string;
+        state?: string;
+    }): Promise<OpsRoutineTickItemsResult>;
+    getTriggerRunStatus(params: OpsTriggerRunStatusOptions | string): Promise<OpsTriggerRunStatus | OpsTriggerBatchRunStatus>;
+    getQueueStatus(params?: OpsQueueStatusOptions): Promise<OpsQueueStatus>;
+    replayFromCheckpoint(executionEventId: string): Promise<OpsReplayResult>;
+    normalizeExecutionReference(input: string | ExecutionReferenceInput): ExecutionReference;
+    collectExecutionReferences(payload: Record<string, unknown>): ExecutionReference[];
+    getDashboard(params?: OpsDashboardOptions): Promise<OpsDashboardResult>;
+    private call;
+}
+
+declare class Ai {
+    private client;
+    constructor(client: HttpClient);
+    /**
+     * Run Custom AI Enrichment - Multi Model.
+     *
+     * Uses OpenRouter Fusion for multi-model analysis with web search/fetch enabled
+     * inside Fusion, then synthesizes the requested structured output fields.
+     */
+    multiModel(params: CustomAiMultiModelParams): Promise<CustomAiMultiModelResult>;
+}
+
+type UnknownRecord = Record<string, unknown>;
+type GtmCampaignStatus = 'draft' | 'building' | 'ready' | 'active' | 'paused' | 'completed' | 'archived' | 'failed';
+type GtmCampaignSource = 'mcp' | 'campaign_builder' | 'routine' | 'manual' | 'import' | 'api' | 'webhook';
+type GtmActorType = 'human' | 'agent' | 'system' | 'provider';
+type GtmPatternType = 'angle' | 'subject_line' | 'opener' | 'sequence_structure' | 'icp' | 'lead_source' | 'provider_chain' | 'verification' | 'failure' | 'default' | 'calibration' | 'other';
+type GtmMemoryType = 'subject_line' | 'opener' | 'sequence_step' | 'icp' | 'lead_source' | 'provider_chain' | 'verification' | 'reply' | 'objection' | 'meeting' | 'failure' | 'campaign_summary' | 'agent_note' | 'other';
+type GtmLayer = 'icp' | 'find_company' | 'find_people' | 'lead_generation' | 'local_leads' | 'email_finding' | 'email_verification' | 'company_enrichment' | 'copy_enrichment' | 'qualification' | 'sender' | 'feedback' | 'approval' | 'source_import' | 'destination_export' | 'customer_data' | 'custom';
+type GtmInvocationType = 'signaliz_native' | 'webhook' | 'mcp_tool' | 'airbyte' | 'api' | 'managed_integration' | 'manual';
+type GtmAuthStrategy = 'none' | 'integration_key' | 'mcp_auth' | 'webhook_secret' | 'session_vault' | 'byo_runtime';
+interface GtmWorkspaceContextOptions {
+    includeCampaigns?: boolean;
+    includeMemory?: boolean;
+    includeBrain?: boolean;
+    includeConnections?: boolean;
+    limit?: number;
+}
+interface GtmWorkspaceBootstrapStatusOptions {
+    campaignId?: string;
+    days?: number;
+    minSampleSize?: number;
+    includeConnections?: boolean;
+    includeSamples?: boolean;
+    limit?: number;
+}
+interface GtmProviderLinkInput {
+    provider: string;
+    providerCampaignId: string;
+    integrationId?: string;
+    providerWorkspaceId?: string;
+    providerAccountId?: string;
+    status?: string;
+    metadata?: UnknownRecord;
+}
+interface GtmCampaignCreateInput {
+    name: string;
+    description?: string;
+    source?: GtmCampaignSource;
+    status?: GtmCampaignStatus;
+    campaignBuildId?: string;
+    campaignBuilderJobId?: string;
+    routineId?: string;
+    targetIcp?: UnknownRecord;
+    sequences?: UnknownRecord[];
+    leadListRefs?: UnknownRecord[];
+    sendConfig?: UnknownRecord;
+    providerLinks?: GtmProviderLinkInput[];
+    brainConfig?: UnknownRecord;
+    metadata?: UnknownRecord;
+    log?: GtmCampaignLogInput;
+}
+interface GtmCampaignHistoryMemoryInput {
+    idempotencyKey?: string;
+    memoryType?: GtmMemoryType;
+    title: string;
+    content: string;
+    keywords?: string[];
+    dimensions?: UnknownRecord;
+    outcomeType?: string;
+    outcomeValue?: number;
+    sampleSize?: number;
+    confidence?: number;
+    shareable?: boolean;
+    redactionState?: 'raw' | 'redacted' | 'abstracted';
+    metadata?: UnknownRecord;
+    recencyAt?: string;
+}
+interface GtmCampaignHistoryCampaignInput {
+    campaignId?: string;
+    idempotencyKey?: string;
+    name?: string;
+    description?: string;
+    source?: GtmCampaignSource;
+    status?: GtmCampaignStatus;
+    campaignBuildId?: string;
+    campaignBuilderJobId?: string;
+    routineId?: string;
+    targetIcp?: UnknownRecord;
+    sequences?: UnknownRecord[];
+    leadListRefs?: UnknownRecord[];
+    sendConfig?: UnknownRecord;
+    performanceMetrics?: UnknownRecord;
+    brainConfig?: UnknownRecord;
+    memorySummary?: UnknownRecord;
+    metadata?: UnknownRecord;
+    providerLinks?: GtmProviderLinkInput[];
+    feedbackEvents?: UnknownRecord[];
+    memoryItems?: GtmCampaignHistoryMemoryInput[];
+    startedAt?: string;
+    completedAt?: string;
+    summary?: string;
+    memorySummaryText?: string;
+}
+interface GtmCampaignHistoryImportInput {
+    source?: GtmCampaignSource;
+    dryRun?: boolean;
+    createMemory?: boolean;
+    campaigns: GtmCampaignHistoryCampaignInput[];
+}
+interface GtmCampaignHistoryImportBatchInput {
+    batchId?: string;
+    campaigns: GtmCampaignHistoryCampaignInput[];
+}
+interface GtmCampaignHistoryImportRunInput {
+    source?: GtmCampaignSource;
+    dryRun?: boolean;
+    createMemory?: boolean;
+    campaigns?: GtmCampaignHistoryCampaignInput[];
+    batches?: GtmCampaignHistoryImportBatchInput[];
+    batchSize?: number;
+    continueOnError?: boolean;
+    runBrainCycle?: boolean;
+    brainCycleWriteMode?: 'dry_run' | 'write';
+    brainCyclePhases?: GtmBrainLearningCyclePhase[];
+    brainCycleDays?: number;
+    brainCycleNetworkDays?: number;
+    brainCycleMinSampleSize?: number;
+    brainCycleLimit?: number;
+}
+interface GtmCampaignBuildBackfillPreviewOptions {
+    campaignBuildId: string;
+    includeSampleRows?: boolean;
+    includeCopySamples?: boolean;
+    sampleRowLimit?: number;
+    createMemory?: boolean;
+    includePayload?: boolean;
+}
+interface GtmCampaignBuildBackfillRunInput {
+    campaignBuildIds: string[];
+    source?: GtmCampaignSource;
+    dryRun?: boolean;
+    createMemory?: boolean;
+    includeSampleRows?: boolean;
+    includeCopySamples?: boolean;
+    includePayload?: boolean;
+    sampleRowLimit?: number;
+    batchSize?: number;
+    continueOnError?: boolean;
+    runBrainCycle?: boolean;
+    brainCycleWriteMode?: 'dry_run' | 'write';
+    brainCyclePhases?: GtmBrainLearningCyclePhase[];
+    brainCycleDays?: number;
+    brainCycleNetworkDays?: number;
+    brainCycleMinSampleSize?: number;
+    brainCycleLimit?: number;
+}
+interface GtmCampaignBuildBackfillStatusOptions {
+    campaignBuildId: string;
+    includePhases?: boolean;
+    includeLinkedCampaign?: boolean;
+}
+interface GtmCampaignListOptions {
+    status?: GtmCampaignStatus;
+    provider?: string;
+    search?: string;
+    limit?: number;
+    includeArchived?: boolean;
+}
+interface GtmCampaignGetOptions {
+    logLimit?: number;
+    memoryLimit?: number;
+}
+interface GtmCampaignExecutionStatusOptions {
+    campaignId?: string;
+    campaignBuildId?: string;
+    includeProviderReadiness?: boolean;
+    includeFeedback?: boolean;
+    includeMemory?: boolean;
+    includeRecentLog?: boolean;
+    logLimit?: number;
+    memoryLimit?: number;
+}
+interface GtmCampaignLearningStatusOptions {
+    campaignId?: string;
+    campaignBuildId?: string;
+    days?: number;
+    networkDays?: number;
+    minSampleSize?: number;
+    minWorkspaceCount?: number;
+    minPrivacyK?: number;
+    includeMemory?: boolean;
+    includeNetwork?: boolean;
+    writeMode?: 'dry_run' | 'write';
+    limit?: number;
+}
+interface GtmCampaignUpdateInput {
+    campaignId: string;
+    name?: string;
+    description?: string;
+    status?: GtmCampaignStatus;
+    targetIcp?: UnknownRecord;
+    sequences?: UnknownRecord[];
+    leadListRefs?: UnknownRecord[];
+    sendConfig?: UnknownRecord;
+    performanceMetrics?: UnknownRecord;
+    brainConfig?: UnknownRecord;
+    memorySummary?: UnknownRecord;
+    metadata?: UnknownRecord;
+    providerLinks?: GtmProviderLinkInput[];
+    log?: GtmCampaignLogInput;
+}
+interface GtmCampaignLogInput {
+    campaignId?: string;
+    actorType?: GtmActorType;
+    actorId?: string;
+    action?: string;
+    rationale?: string;
+    payload?: UnknownRecord;
+    idempotencyKey?: string;
+}
+interface GtmFeedbackIngestInput {
+    source: string;
+    campaignId?: string;
+    campaignBuildId?: string;
+    providerCampaignId?: string;
+    events?: UnknownRecord[];
+    providerPayload?: UnknownRecord;
+    createMemory?: boolean;
+    writeRoutineOutcomes?: boolean;
+}
+interface GtmInstantlyFeedbackSyncInput {
+    campaignId?: string;
+    campaignBuildId?: string;
+    providerCampaignId?: string;
+    instantlyCampaignId?: string;
+    syncMode?: 'webhook' | 'pull' | 'manual';
+    events?: UnknownRecord[];
+    providerPayload?: UnknownRecord;
+    cursor?: string;
+    since?: string;
+    until?: string;
+    aggregateSnapshot?: UnknownRecord;
+    createMemory?: boolean;
+    writeRoutineOutcomes?: boolean;
+}
+interface GtmInstantlyFeedbackPullInput {
+    campaignId?: string;
+    campaignBuildId?: string;
+    providerLinkId?: string;
+    providerCampaignId?: string;
+    instantlyCampaignId?: string;
+    integrationId?: string;
+    cursor?: string;
+    from?: string;
+    to?: string;
+    limit?: number;
+    maxPages?: number;
+    createMemory?: boolean;
+    writeRoutineOutcomes?: boolean;
+    dryRun?: boolean;
+    runBrainCycle?: boolean;
+    brainCycleWriteMode?: 'dry_run' | 'write';
+    brainCyclePhases?: GtmBrainLearningCyclePhase[];
+    brainCycleMinIngested?: number;
+    brainCycleMinIntervalMinutes?: number;
+}
+interface GtmInstantlyFeedbackWebhookPrepareInput {
+    campaignId?: string;
+    campaignBuildId?: string;
+    providerLinkId?: string;
+    providerCampaignId?: string;
+    instantlyCampaignId?: string;
+    integrationId?: string;
+    providerWorkspaceId?: string;
+    providerAccountId?: string;
+    rotateSecret?: boolean;
+    runBrainCycle?: boolean;
+    brainCycleWriteMode?: 'dry_run' | 'write';
+    brainCyclePhases?: GtmBrainLearningCyclePhase[];
+    brainCycleMinIngested?: number;
+    brainCycleMinIntervalMinutes?: number;
+}
+interface GtmFeedbackWebhookPrepareInput {
+    provider: string;
+    campaignId?: string;
+    campaignBuildId?: string;
+    providerLinkId?: string;
+    providerCampaignId?: string;
+    integrationId?: string;
+    providerWorkspaceId?: string;
+    providerAccountId?: string;
+    rotateSecret?: boolean;
+    runBrainCycle?: boolean;
+    brainCycleWriteMode?: 'dry_run' | 'write';
+    brainCyclePhases?: GtmBrainLearningCyclePhase[];
+    brainCycleMinIngested?: number;
+    brainCycleMinIntervalMinutes?: number;
+}
+interface GtmMemorySearchOptions {
+    query?: string;
+    campaignId?: string;
+    memoryType?: GtmMemoryType;
+    keywords?: string[];
+    outcomeType?: string;
+    targetIcp?: UnknownRecord;
+    layers?: GtmLayer[];
+    providerChain?: string[];
+    dimensionFilters?: UnknownRecord;
+    requireDimensionMatch?: boolean;
+    days?: number;
+    limit?: number;
+}
+interface GtmBrainPatternsOptions {
+    campaignId?: string;
+    patternType?: GtmPatternType;
+    segmentKey?: string;
+    includeGlobal?: boolean;
+    minConfidence?: number;
+    limit?: number;
+}
+interface GtmBrainSeedDefaultsInput {
+    campaignId?: string;
+    campaignBrief?: string;
+    targetIcp?: UnknownRecord;
+    layers?: GtmLayer[];
+    includeGlobal?: boolean;
+    includeMemory?: boolean;
+    minConfidence?: number;
+    writeCampaign?: boolean;
+    limit?: number;
+}
+interface GtmBrainLearningCyclePlanInput {
+    campaignId?: string;
+    campaignBrief?: string;
+    targetIcp?: UnknownRecord;
+    layers?: GtmLayer[];
+    providerChain?: string[];
+    leadSource?: string;
+    days?: number;
+    networkDays?: number;
+    minSampleSize?: number;
+    minWorkspaceCount?: number;
+    minPrivacyK?: number;
+    includeMemory?: boolean;
+    includeNetwork?: boolean;
+    writeMode?: 'dry_run' | 'write';
+    limit?: number;
+}
+type GtmBrainLearningCyclePhase = 'workspace_pattern_extraction' | 'deliverability_calibration' | 'failure_pattern_detection' | 'aggregate_patterns' | 'aggregate_calibrations' | 'defaults_seed' | 'delivery_risk';
+type GtmBrainLearningLaneId = 'workspace_patterns' | 'network_patterns' | 'defaults_learning' | 'failure_detection' | 'deliverability_calibration';
+type GtmBrainLearningLaneState = 'ready' | 'attention' | 'blocked' | 'unknown';
+interface GtmBrainLearningLane {
+    id: GtmBrainLearningLaneId;
+    label: string;
+    state: GtmBrainLearningLaneState;
+    metric: string;
+    detail: string;
+    blockers: string[];
+    warnings: string[];
+    next_mcp_action: string;
+    raw_data_policy?: string;
+}
+interface GtmBrainLearningLaneSummary {
+    total_lanes: number;
+    ready_lanes: number;
+    blocked_lanes: number;
+    attention_lanes: number;
+    unknown_lanes: number;
+}
+interface GtmBrainLearningEvidenceCounts {
+    feedback_events?: number;
+    deliverability_events?: number;
+    failure_events?: number;
+    positive_events?: number;
+    event_type_counts?: UnknownRecord;
+    classification_counts?: UnknownRecord;
+    memory_items?: number;
+    memory_sample_size?: number;
+    workspace_patterns?: number;
+    workspace_calibrations?: number;
+    global_patterns?: number;
+    global_calibrations?: number;
+    opted_in_workspaces?: number;
+}
+interface GtmBrainLearningPhaseStatus {
+    phase: GtmBrainLearningCyclePhase | string;
+    ready: boolean;
+    blocked_by?: string[];
+}
+interface GtmBrainLearningPhaseReadiness {
+    ready: boolean;
+    blocked_by: string[];
+}
+interface GtmBrainLearningAction {
+    tool: string;
+    arguments?: UnknownRecord;
+    reason?: string;
+}
+interface GtmBrainLearningRecommendedToolCall extends GtmBrainLearningAction {
+    step?: number;
+    phase?: GtmBrainLearningCyclePhase | string;
+    ready?: boolean;
+    blocked_by?: string[];
+}
+interface GtmCampaignLearningStatusResult {
+    workspace_id?: string;
+    learning_stage?: string;
+    ready?: boolean;
+    outcome_learning_ready?: boolean;
+    campaign?: {
+        id?: string;
+        name?: string;
+        status?: string;
+        source?: string;
+        campaign_build_id?: string | null;
+        updated_at?: string;
+    } | null;
+    campaign_build?: {
+        id?: string;
+        name?: string;
+        status?: string;
+        requested_target_count?: number;
+        planned_target_count?: number;
+        completed_at?: string | null;
+        updated_at?: string | null;
+    } | null;
+    evidence_counts?: GtmBrainLearningEvidenceCounts;
+    learning_lanes?: GtmBrainLearningLane[];
+    lane_summary?: GtmBrainLearningLaneSummary;
+    feedback_brain_cycle?: UnknownRecord;
+    thresholds?: UnknownRecord;
+    phases?: GtmBrainLearningPhaseStatus[];
+    ready_phases?: Array<GtmBrainLearningCyclePhase | string>;
+    learning_cycle_plan_args?: UnknownRecord;
+    learning_cycle_run_args?: UnknownRecord | null;
+    last_learning_cycle_receipt?: UnknownRecord | null;
+    recent_brain_log?: UnknownRecord[];
+    blockers?: string[];
+    warnings?: string[];
+    next_actions?: GtmBrainLearningAction[];
+    execution_policy?: string;
+    privacy_policy?: string;
+}
+interface GtmBrainLearningCyclePlanResult {
+    cycle?: UnknownRecord;
+    evidence_counts?: GtmBrainLearningEvidenceCounts;
+    readiness?: Record<string, GtmBrainLearningPhaseReadiness>;
+    learning_lanes?: GtmBrainLearningLane[];
+    lane_summary?: GtmBrainLearningLaneSummary;
+    recommended_tool_calls?: GtmBrainLearningRecommendedToolCall[];
+    next_ready_tools?: string[];
+    queued_runner_tool?: string;
+    execution_policy?: string;
+    privacy_policy?: string;
+}
+interface GtmBrainLearningCycleRunInput extends GtmBrainLearningCyclePlanInput {
+    phases?: GtmBrainLearningCyclePhase[];
+    continueOnError?: boolean;
+}
+interface GtmBrainExtractPatternsInput {
+    campaignId?: string;
+    days?: number;
+    patternTypes?: GtmPatternType[];
+    minSampleSize?: number;
+    includeMemory?: boolean;
+    writePatterns?: boolean;
+    dryRun?: boolean;
+    replaceExisting?: boolean;
+    limit?: number;
+}
+interface GtmBrainAggregatePatternsInput {
+    days?: number;
+    patternTypes?: GtmPatternType[];
+    minWorkspaceCount?: number;
+    minPrivacyK?: number;
+    minConfidence?: number;
+    includeLowConfidence?: boolean;
+    writePatterns?: boolean;
+    dryRun?: boolean;
+    replaceExisting?: boolean;
+    limit?: number;
+}
+interface GtmBrainAggregateCalibrationsInput {
+    days?: number;
+    dimensionTypes?: GtmCalibrationDimensionType[];
+    minWorkspaceCount?: number;
+    minPrivacyK?: number;
+    minConfidence?: number;
+    includeLowConfidence?: boolean;
+    writeCalibrations?: boolean;
+    dryRun?: boolean;
+    replaceExisting?: boolean;
+    limit?: number;
+}
+interface GtmBrainCalibrateDeliverabilityInput {
+    campaignId?: string;
+    days?: number;
+    dimensionTypes?: GtmCalibrationDimensionType[];
+    minSampleSize?: number;
+    dryRun?: boolean;
+    writeCalibrations?: boolean;
+    writePatterns?: boolean;
+    replaceExisting?: boolean;
+    limit?: number;
+}
+interface GtmBrainDeliveryRiskInput {
+    campaignId?: string;
+    providerChain?: string[];
+    leadSource?: string;
+    targetIcp?: UnknownRecord;
+    leadSamples?: UnknownRecord[];
+    includeGlobal?: boolean;
+    minConfidence?: number;
+    limit?: number;
+}
+type GtmCalibrationDimensionType = 'email_domain' | 'email_provider' | 'verification_source' | 'lead_source' | 'provider_chain' | 'icp_shape' | 'copy_pattern' | 'other';
+type GtmFailurePatternDimension = 'provider_chain' | 'provider' | 'icp_shape' | 'lead_source' | 'copy_pattern' | 'sequence_step' | 'email_domain';
+interface GtmBrainFailurePatternsOptions {
+    campaignId?: string;
+    days?: number;
+    minSampleSize?: number;
+    dimensions?: GtmFailurePatternDimension[];
+    includeExistingPatterns?: boolean;
+    includeGlobal?: boolean;
+    limit?: number;
+}
+interface GtmConnectionsListOptions {
+    kind?: 'all' | 'integrations' | 'mcp_servers';
+    includeDisconnected?: boolean;
+}
+interface GtmProviderCatalogOptions {
+    providerId?: string;
+    layer?: GtmLayer;
+    includePlanned?: boolean;
+    includeLayerCatalog?: boolean;
+}
+interface GtmIntegrationsActivationStatusOptions {
+    campaignId?: string;
+    layer?: GtmLayer;
+    includePlanned?: boolean;
+    includeConnections?: boolean;
+}
+interface GtmCampaignBuildPlanInput {
+    campaignId?: string;
+    campaignBuildId?: string;
+    campaignBrief?: string;
+    targetIcp?: UnknownRecord;
+    leadCount?: number;
+    layers?: GtmLayer[];
+    preferredProviders?: string[];
+    memoryDimensionFilters?: UnknownRecord;
+    requireMemoryDimensionMatch?: boolean;
+    includeMemory?: boolean;
+    includeBrain?: boolean;
+    includeProviderRoutes?: boolean;
+    includeFailurePatterns?: boolean;
+    includePlannedProviders?: boolean;
+    days?: number;
+    limit?: number;
+}
+interface GtmCampaignBuildPlanCommitInput {
+    campaignId?: string;
+    campaignBuildId?: string;
+    name?: string;
+    campaignBrief?: string;
+    targetIcp?: UnknownRecord;
+    leadCount?: number;
+    layers?: GtmLayer[];
+    preferredProviders?: string[];
+    planSnapshot?: UnknownRecord;
+    sequences?: UnknownRecord[];
+    leadListRefs?: UnknownRecord[];
+    sendConfig?: UnknownRecord;
+    brainConfig?: UnknownRecord;
+    metadata?: UnknownRecord;
+    status?: Extract<GtmCampaignStatus, 'draft' | 'building' | 'ready'>;
+    approvalRequired?: boolean;
+    actorType?: GtmActorType;
+    actorId?: string;
+    rationale?: string;
+    idempotencyKey?: string;
+    dryRun?: boolean;
+    confirm?: boolean;
+}
+interface GtmCampaignBuildExecutionPrepareInput {
+    campaignId: string;
+    targetCount?: number;
+    allowDownscale?: boolean;
+    dryRun?: boolean;
+    confirmSpend?: boolean;
+    includeBrainContext?: boolean;
+    requireDeliveryRiskClearance?: boolean;
+    /** Output from gtm_brain_delivery_risk. When omitted, the MCP tool returns exact risk-check next-action args unless a stored campaign snapshot is available. */
+    deliveryRisk?: UnknownRecord;
+    dedupKeys?: ('email' | 'linkedin_url' | 'company_domain')[];
+    policy?: UnknownRecord;
+    signals?: UnknownRecord;
+    qualification?: UnknownRecord;
+    copy?: UnknownRecord;
+    delivery?: UnknownRecord;
+    enhancers?: UnknownRecord;
+}
+interface GtmProviderRecipePrepareInput {
+    providerId: string;
+    providerName?: string;
+    description?: string;
+    layerCapabilities?: GtmLayer[];
+    invocationType?: GtmInvocationType;
+    authStrategy?: GtmAuthStrategy;
+    endpointUrl?: string;
+    httpMethod?: string;
+    secretRef?: string;
+    workspaceIntegrationId?: string;
+    workspaceMcpServerId?: string;
+    workspaceConnectionId?: string;
+    requestTemplate?: UnknownRecord;
+    responseMapping?: UnknownRecord;
+    inputSchema?: UnknownRecord;
+    outputSchema?: UnknownRecord;
+    readiness?: UnknownRecord;
+    metadata?: UnknownRecord;
+    layer?: GtmLayer;
+    campaignId?: string;
+    useSignalizFallback?: boolean;
+    priority?: number;
+    status?: 'draft' | 'active' | 'needs_setup';
+    sampleRecords?: UnknownRecord[];
+    context?: UnknownRecord;
+}
+interface GtmClayWebhookPrepareInput {
+    endpointUrl?: string;
+    secretRef?: string;
+    layer?: Extract<GtmLayer, 'find_company' | 'find_people' | 'lead_generation' | 'company_enrichment' | 'copy_enrichment' | 'approval' | 'destination_export' | 'custom'>;
+    campaignId?: string;
+    useSignalizFallback?: boolean;
+    priority?: number;
+    status?: 'draft' | 'active' | 'needs_setup';
+    sampleRecords?: UnknownRecord[];
+    context?: UnknownRecord;
+}
+interface GtmProviderRouteActivateInput {
+    providerId: string;
+    providerName?: string;
+    description?: string;
+    layer?: GtmLayer;
+    layers?: GtmLayer[];
+    campaignId?: string;
+    invocationType?: GtmInvocationType;
+    authStrategy?: GtmAuthStrategy;
+    endpointUrl?: string;
+    httpMethod?: string;
+    secretRef?: string;
+    workspaceIntegrationId?: string;
+    workspaceMcpServerId?: string;
+    workspaceConnectionId?: string;
+    useSignalizFallback?: boolean;
+    priority?: number;
+    routeConfig?: UnknownRecord;
+    requestTemplate?: UnknownRecord;
+    responseMapping?: UnknownRecord;
+    inputSchema?: UnknownRecord;
+    outputSchema?: UnknownRecord;
+    readiness?: UnknownRecord;
+    metadata?: UnknownRecord;
+    status?: 'draft' | 'active' | 'needs_setup' | 'paused' | 'archived' | 'failed';
+    routeStatus?: 'active' | 'paused' | 'archived' | 'failed';
+    replaceExistingRoutes?: boolean;
+    dryRun?: boolean;
+    confirm?: boolean;
+    sampleRecords?: UnknownRecord[];
+    context?: UnknownRecord;
+}
+interface GtmConnectionRegisterInput {
+    connectionKind: 'mcp_server' | 'integration';
+    name: string;
+    serverUrl?: string;
+    authType?: 'none' | 'api_key' | 'bearer' | 'oauth';
+    authConfig?: UnknownRecord;
+    enabledTools?: string[];
+    presetId?: string;
+    vendorId?: string;
+    serviceCategory?: string;
+    connectionType?: string;
+    status?: string;
+    metadata?: UnknownRecord;
+}
+interface GtmIntegrationRecipeCreateInput {
+    providerId: string;
+    providerName: string;
+    description?: string;
+    layerCapabilities?: GtmLayer[];
+    invocationType: GtmInvocationType;
+    authStrategy?: GtmAuthStrategy;
+    workspaceIntegrationId?: string;
+    workspaceMcpServerId?: string;
+    workspaceConnectionId?: string;
+    endpointUrl?: string;
+    httpMethod?: string;
+    requestTemplate?: UnknownRecord;
+    responseMapping?: UnknownRecord;
+    inputSchema?: UnknownRecord;
+    outputSchema?: UnknownRecord;
+    readiness?: UnknownRecord;
+    metadata?: UnknownRecord;
+    status?: 'draft' | 'active' | 'needs_setup' | 'paused' | 'archived' | 'failed';
+}
+interface GtmLayerRouteSetInput {
+    layer: GtmLayer;
+    providerId: string;
+    campaignId?: string;
+    recipeId?: string;
+    priority?: number;
+    useSignalizFallback?: boolean;
+    routeConfig?: UnknownRecord;
+    status?: 'active' | 'paused' | 'archived' | 'failed';
+}
+interface GtmLayerRoutesGetOptions {
+    campaignId?: string;
+    layer?: GtmLayer;
+}
+interface GtmLayerRoutePreviewInput {
+    layer: GtmLayer;
+    campaignId?: string;
+    sampleRecords?: UnknownRecord[];
+    context?: UnknownRecord;
+}
+interface GtmWebhookDeliverInput {
+    recipeId: string;
+    campaignId?: string;
+    layer?: GtmLayer;
+    records: UnknownRecord[];
+    context?: UnknownRecord;
+    idempotencyKey?: string;
+}
+declare class GtmKernel {
+    private client;
+    constructor(client: HttpClient);
+    /** Load workspace context for an agent session: campaigns, memory, Brain, connections, and Signaliz primitives. */
+    context(options?: GtmWorkspaceContextOptions): Promise<any>;
+    /** Inspect whether the workspace has the Kernel + Brain substrate pieces needed to build, run, and improve campaigns. */
+    bootstrapStatus(options?: GtmWorkspaceBootstrapStatusOptions): Promise<any>;
+    /** Create a first-class GTM campaign object in the current workspace. */
+    createCampaign(input: GtmCampaignCreateInput): Promise<any>;
+    /** Backfill historical campaigns, provider links, feedback, and memory into the GTM Kernel substrate. */
+    importCampaignHistory(input: GtmCampaignHistoryImportInput): Promise<any>;
+    /** Queue a Trigger-backed campaign history import for larger CMM/client backfills. */
+    importCampaignHistoryRun(input: GtmCampaignHistoryImportRunInput): Promise<any>;
+    /** Preview a provider-neutral history import payload derived from an existing campaign build. */
+    previewCampaignBuildBackfill(options: GtmCampaignBuildBackfillPreviewOptions): Promise<any>;
+    /** Queue campaign-build history backfills through the Trigger-backed history import runner. */
+    runCampaignBuildBackfill(input: GtmCampaignBuildBackfillRunInput): Promise<any>;
+    /** Inspect Campaign Builder to Kernel backfill status for one build. */
+    campaignBuildBackfillStatus(options: GtmCampaignBuildBackfillStatusOptions): Promise<any>;
+    /** List first-class GTM campaign objects in the current workspace. */
+    listCampaigns(options?: GtmCampaignListOptions): Promise<any>;
+    /** Get one campaign with provider links, logs, feedback summary, memory, and Brain patterns. */
+    getCampaign(campaignId: string, options?: GtmCampaignGetOptions): Promise<any>;
+    /** Inspect campaign execution state, linked build progress, provider readiness, feedback, memory, and next actions. */
+    campaignExecutionStatus(options: GtmCampaignExecutionStatusOptions): Promise<any>;
+    /** Inspect whether a campaign/build is ready for Brain learning and return exact learning-cycle args. */
+    campaignLearningStatus(options: GtmCampaignLearningStatusOptions): Promise<GtmCampaignLearningStatusResult>;
+    /** Update a first-class GTM campaign and append the associated campaign log entry. */
+    updateCampaign(input: GtmCampaignUpdateInput): Promise<any>;
+    /** Append an auditable campaign action with actor, rationale, payload, and optional idempotency key. */
+    logCampaign(campaignId: string, input: Omit<GtmCampaignLogInput, 'campaignId'>): Promise<any>;
+    /** Ingest provider-neutral feedback from Instantly, Smartlead, HeyReach, webhook, or a custom MCP. */
+    ingestFeedback(input: GtmFeedbackIngestInput): Promise<any>;
+    /** Normalize Instantly webhook/pull payloads and ingest row-level feedback through the GTM Kernel. */
+    syncInstantlyFeedback(input: GtmInstantlyFeedbackSyncInput): Promise<any>;
+    /** Start a background Instantly webhook-events pull and route results into the GTM feedback loop. */
+    pullInstantlyFeedback(input: GtmInstantlyFeedbackPullInput): Promise<any>;
+    /** Prepare a secure Instantly feedback webhook URL for a campaign provider link. */
+    prepareInstantlyFeedbackWebhook(input: GtmInstantlyFeedbackWebhookPrepareInput): Promise<any>;
+    /** Prepare a provider-agnostic feedback webhook URL for Smartlead, HeyReach, Airbyte, or custom sender events. */
+    prepareFeedbackWebhook(input: GtmFeedbackWebhookPrepareInput): Promise<any>;
+    /** Search ranked workspace campaign memory instead of dumping raw history. */
+    searchMemory(options?: GtmMemorySearchOptions): Promise<any>;
+    /** Retrieve evidence-backed workspace and privacy-safe aggregate Brain patterns. */
+    brainPatterns(options?: GtmBrainPatternsOptions): Promise<any>;
+    /** Plan the closed-loop Brain learning sequence without recursively executing Edge Functions. */
+    learningCyclePlan(input?: GtmBrainLearningCyclePlanInput): Promise<GtmBrainLearningCyclePlanResult>;
+    /** Queue the closed-loop Brain learning sequence in Trigger. */
+    learningCycleRun(input?: GtmBrainLearningCycleRunInput): Promise<any>;
+    /** Seed campaign defaults from active Brain patterns and ranked workspace memory. */
+    seedBrainDefaults(input?: GtmBrainSeedDefaultsInput): Promise<any>;
+    /** Extract within-workspace Brain V1 patterns from feedback, provider links, campaigns, and memory. */
+    extractBrainPatterns(input?: GtmBrainExtractPatternsInput): Promise<any>;
+    /** Aggregate opted-in workspace Brain patterns into privacy-safe global defaults. */
+    aggregateBrainPatterns(input?: GtmBrainAggregatePatternsInput): Promise<any>;
+    /** Aggregate opted-in workspace deliverability calibrations into privacy-safe global calibration rows. */
+    aggregateBrainCalibrations(input?: GtmBrainAggregateCalibrationsInput): Promise<any>;
+    /** Calibrate workspace deliverability predictions against actual bounce feedback. */
+    calibrateDeliverability(input?: GtmBrainCalibrateDeliverabilityInput): Promise<any>;
+    /** Estimate pre-send delivery risk from campaign context, lead samples, and Brain calibrations. */
+    deliveryRisk(input?: GtmBrainDeliveryRiskInput): Promise<any>;
+    /** Rank provider-chain, ICP, source, copy, and sequence failure patterns without writing raw lead data. */
+    failurePatterns(options?: GtmBrainFailurePatternsOptions): Promise<any>;
+    /** List provider presets agents can wire into GTM campaign layers, including BYO and Signaliz fallback options. */
+    providerCatalog(options?: GtmProviderCatalogOptions): Promise<any>;
+    /** Inspect GTM integration activation cards for UI and agent routing without writing state. */
+    integrationsActivationStatus(options?: GtmIntegrationsActivationStatusOptions): Promise<any>;
+    /** Compose Memory, Brain defaults, failure intelligence, and provider routes into a read-only campaign build plan. */
+    campaignBuildPlan(input?: GtmCampaignBuildPlanInput): Promise<any>;
+    /** Persist a reviewed campaign build plan into a campaign object and audit log. Dry-run first by default. */
+    commitCampaignBuildPlan(input?: GtmCampaignBuildPlanCommitInput): Promise<any>;
+    /** Derive exact build_campaign arguments from a committed campaign object without creating a build. */
+    prepareCampaignBuildExecution(input: GtmCampaignBuildExecutionPrepareInput): Promise<any>;
+    /** Prepare exact recipe, route, preview, and delivery arguments for a provider without writing state. */
+    prepareProviderRecipe(input: GtmProviderRecipePrepareInput): Promise<any>;
+    /** Prepare exact Clay webhook recipe, route, preview, and delivery arguments without writing state. */
+    prepareClayWebhook(input?: GtmClayWebhookPrepareInput): Promise<any>;
+    /** Dry-run or confirm a one-call provider route activation across one or more GTM layers. */
+    activateProviderRoute(input: GtmProviderRouteActivateInput): Promise<any>;
+    /** List Signaliz-managed integrations, external MCP servers, app connections, recipes, and layer routes. */
+    listConnections(options?: GtmConnectionsListOptions): Promise<any>;
+    /** Register a workspace connection for the Kernel connection layer. */
+    registerConnection(input: GtmConnectionRegisterInput): Promise<any>;
+    /** Create a reusable integration recipe for BYO providers such as Clay webhooks, Apollo, AI Ark, Octave, or Airbyte. */
+    createIntegrationRecipe(input: GtmIntegrationRecipeCreateInput): Promise<any>;
+    /** Set a workspace or campaign provider route for one GTM layer. */
+    setLayerRoute(input: GtmLayerRouteSetInput): Promise<any>;
+    /** Get effective layer routes, including Signaliz fallback availability. */
+    getLayerRoutes(options?: GtmLayerRoutesGetOptions): Promise<any>;
+    /** Preview one effective layer route before external delivery or provider execution. */
+    previewLayerRoute(input: GtmLayerRoutePreviewInput): Promise<any>;
+    /** Deliver approved campaign-layer records to a webhook recipe, starting with Clay-style webhooks. */
+    deliverWebhook(input: GtmWebhookDeliverInput): Promise<any>;
+    private callMcp;
+}
+
 declare class SignalizError extends Error {
     readonly code: string;
     readonly errorType: ErrorType;
@@ -298,14 +2871,25 @@ declare class Signaliz {
     readonly systems: Systems;
     readonly runs: Runs;
     readonly http: Http;
+    readonly campaigns: Campaigns;
+    readonly campaignBuilderAgent: CampaignBuilderAgent;
+    readonly icps: Icps;
+    readonly leads: Leads;
+    readonly ops: Ops;
+    readonly ai: Ai;
+    readonly gtm: GtmKernel;
     private client;
     constructor(config: SignalizConfig);
     /** Get current workspace info including credits */
     getWorkspace(): Promise<WorkspaceInfo>;
+    /** Get MCP platform health and recent latency/error-rate signals */
+    getPlatformHealth(): Promise<PlatformHealth>;
+    /** Alias for getPlatformHealth, useful in health-check scripts */
+    health(): Promise<PlatformHealth>;
     /** List all available MCP tools */
     listTools(): Promise<MCPToolInfo[]>;
     /** Discover tools by natural language query */
     discover(query: string, category?: string): Promise<MCPToolInfo[]>;
 }
 
-export { type CompanyIntelligenceParams, type CompanyIntelligenceResult, type CreateSystemParams, type EnrichSignalsParams, type EnrichSignalsResult, type ErrorType, type FindEmailParams, type FindEmailResult, type HttpRequestParams, type HttpRequestResult, type MCPToolInfo, type RunProgressEvent, type RunResult, type RunSystemParams, type Signal, Signaliz, type SignalizConfig, SignalizError, type SignalizErrorData, type SystemResult, type VerifyEmailResult, type WorkspaceInfo };
+export { Ai, type ApproveDeliveryResult, type BuildOptions, type CampaignArtifact, type CampaignBuildRequest, type CampaignBuildResult, type CampaignBuildRow, type CampaignBuildStatus, CampaignBuilderAgent, type CampaignBuilderAgentPlan, type CampaignBuilderAgentProvider, type CampaignBuilderAgentRequest, type CampaignBuilderApproval, type CampaignBuilderApprovalPolicy, type CampaignBuilderApprovalType, type CampaignBuilderCustomerTool, type CampaignBuilderIntegrationRoute, type CampaignBuilderLayer, type CampaignBuilderMcpStep, type CampaignBuilderMemoryPlan, type CampaignBuilderMemoryQuery, type CampaignBuilderMemoryScope, type CampaignBuilderProvider, type CampaignBuilderRequiredApproval, type CampaignBuilderRouteMode, type CampaignBuilderWorkspaceContext, type CampaignDeliveryMode, type CampaignProviderRouteReadback, type CampaignRowsOptions, type CampaignRowsResult, Campaigns, type CancelBuildResult, type CompanyIntelligenceParams, type CompanyIntelligenceResult, type CreateOutputSinkRequest, type CreateRoutineRequest, type CreateSystemParams, type CustomAiAttachment, type CustomAiFusionConfig, type CustomAiMultiModelParams, type CustomAiMultiModelResult, type CustomAiOutputField, DEFAULT_SIGNALIZ_CAMPAIGN_BUILDER_DEFAULTS, type EmailBatchJobResult, type EnrichSignalsParams, type EnrichSignalsResult, type ErrorType, type ExecutionReference, type ExecutionReferenceInput, type ExecutionReferenceKind, type FindAndVerifyEmailContact, type FindEmailParams, type FindEmailResult, type GenerateLeadsParams, type GenerateLocalLeadsParams, type GtmActorType, type GtmAuthStrategy, type GtmBrainAggregateCalibrationsInput, type GtmBrainAggregatePatternsInput, type GtmBrainCalibrateDeliverabilityInput, type GtmBrainDeliveryRiskInput, type GtmBrainExtractPatternsInput, type GtmBrainFailurePatternsOptions, type GtmBrainLearningAction, type GtmBrainLearningCyclePhase, type GtmBrainLearningCyclePlanInput, type GtmBrainLearningCyclePlanResult, type GtmBrainLearningCycleRunInput, type GtmBrainLearningEvidenceCounts, type GtmBrainLearningLane, type GtmBrainLearningLaneId, type GtmBrainLearningLaneState, type GtmBrainLearningLaneSummary, type GtmBrainLearningPhaseReadiness, type GtmBrainLearningPhaseStatus, type GtmBrainLearningRecommendedToolCall, type GtmBrainPatternsOptions, type GtmBrainSeedDefaultsInput, type GtmCalibrationDimensionType, type GtmCampaignBuildPlanInput, type GtmCampaignCreateInput, type GtmCampaignGetOptions, type GtmCampaignHistoryCampaignInput, type GtmCampaignHistoryImportBatchInput, type GtmCampaignHistoryImportInput, type GtmCampaignHistoryImportRunInput, type GtmCampaignHistoryMemoryInput, type GtmCampaignLearningStatusResult, type GtmCampaignListOptions, type GtmCampaignLogInput, type GtmCampaignSource, type GtmCampaignStatus, type GtmCampaignUpdateInput, type GtmConnectionRegisterInput, type GtmConnectionsListOptions, type GtmFeedbackIngestInput, type GtmIntegrationRecipeCreateInput, type GtmInvocationType, GtmKernel, type GtmLayer, type GtmLayerRouteSetInput, type GtmLayerRoutesGetOptions, type GtmMemorySearchOptions, type GtmMemoryType, type GtmPatternType, type GtmProviderLinkInput, type GtmWebhookDeliverInput, type GtmWorkspaceBootstrapStatusOptions, type GtmWorkspaceContextOptions, type HttpRequestParams, type HttpRequestResult, type IcpDetail, type IcpSummary, Icps, type ImportOctaveResult, type LeadGenJobResult, type ListOutputSinksOptions, type MCPToolInfo, type NativeGtmCapabilityInfo, Ops, type OpsApproveRequest, type OpsApproveResult, type OpsBlueprint, type OpsCadence, type OpsCreateRequest, type OpsCreateResult, type OpsDashboardOptions, type OpsDashboardResult, type OpsDebugDiagnosticError, type OpsDebugOptions, type OpsDebugResult, type OpsPlanRequest, type OpsPlanResult, type OpsPrimitive, type OpsPrimitiveConcurrencyPolicy, type OpsPrimitiveDeadLetterPolicy, type OpsPrimitiveObservabilityPolicy, type OpsPrimitivePermissionLevel, type OpsPrimitiveRetryPolicy, type OpsPrimitiveWorkspaceScope, type OpsQueueStatus, type OpsQueueStatusOptions, type OpsQuickstartStep, type OpsQuickstartWorkflow, type OpsReadinessCheck, type OpsReadinessOptions, type OpsReadinessResult, type OpsReplayResult, type OpsResultsOptions, type OpsResultsResult, type OpsRoutine, type OpsRoutineDeleteResult, type OpsRoutineRunResult, type OpsRoutineSinkResult, type OpsRoutineStatus, type OpsRoutineTick, type OpsRoutineTickItem, type OpsRoutineTickItemsResult, type OpsRoutineTicksResult, type OpsRoutinesResult, type OpsRunOptions, type OpsRunResult, type OpsSink, type OpsSinkType, type OpsStatusOptions, type OpsStatusResult, type OpsTriggerBatchRunStatus, type OpsTriggerRunStatus, type OpsTriggerRunStatusOptions, type PlatformHealth, type RunNativeGtmCapabilityParams, type RunProgressEvent, type RunResult, type RunRoutineRequest, type RunSystemParams, type Signal, Signaliz, type SignalizCampaignBuilderDefaults, type SignalizConfig, SignalizError, type SignalizErrorData, type SimpleOpStatus, type SystemResult, type UpdateRoutineRequest, type VerifyEmailResult, type WaitOptions, type WorkspaceInfo, collectExecutionReferences, createCampaignBuilderAgentPlan, createCampaignBuilderApproval, getMissingCampaignBuilderApprovals, normalizeExecutionReference };