@graph8/sdk 0.4.0 → 0.5.0

package/dist/react.d.ts

@@ -2,6 +2,1027 @@ import * as _jitsu_js from '@jitsu/js';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { ReactNode } from 'react';
 
+interface MeetingAttendee {
+    name: string | null;
+    email: string;
+    role: "host" | "prospect" | "guest" | string;
+    contact_id?: number | null;
+}
+interface MeetingTranscriptLine {
+    speaker: string;
+    text: string;
+    timestamp: number;
+}
+interface MeetingAnalysis {
+    sentiment: "positive" | "neutral" | "negative";
+    summary: string;
+    next_steps: string[];
+    objections: string[];
+    talk_listen_ratio: number | null;
+}
+interface MeetingSummary {
+    id: string;
+    status: "scheduled" | "completed" | "cancelled" | "no_show";
+    event_type: string | null;
+    scheduled_at: string;
+    duration_minutes: number;
+    attendees: MeetingAttendee[];
+    contact_id: number | null;
+    conferencing_provider: string | null;
+    conferencing_url: string | null;
+    recording_url: string | null;
+    created_at: string;
+}
+interface MeetingDetail extends MeetingSummary {
+    transcript: MeetingTranscriptLine[] | null;
+    analysis: MeetingAnalysis | null;
+}
+interface MeetingListParams {
+    status?: "scheduled" | "completed" | "cancelled" | "no_show";
+    date_from?: string;
+    date_to?: string;
+    attendee_id?: string;
+    event_type?: string;
+    contact_id?: number;
+    page?: number;
+    limit?: number;
+}
+/**
+ * Meetings API - read-only access to scheduled, completed, and cancelled meetings.
+ * Booking happens via `g8.calendar.*` (write-key safe, browser only) — this surface
+ * is for reading meeting records, transcripts, and AI analysis.
+ *
+ * Requires API key (server-side).
+ *
+ * Backed by:
+ *   GET /api/v1/inbox/meetings
+ *   GET /api/v1/inbox/meetings/{meeting_id}
+ */
+declare const createMeetingsClient: (apiKey: string, apiUrl?: string) => {
+    /** List meetings with optional filters. Returns summary rows without transcript / analysis. */
+    list(params?: MeetingListParams): Promise<{
+        data: MeetingSummary[];
+        pagination?: {
+            page: number;
+            limit: number;
+            total: number;
+            has_next: boolean;
+        };
+    }>;
+    /** Get full meeting detail including transcript + AI analysis (transcript available 1-5 min after meeting ends). */
+    get(meetingId: string): Promise<MeetingDetail>;
+};
+
+interface GlobalContextDocument {
+    id: string;
+    category: string;
+    title: string;
+    content: string;
+    metadata: Record<string, unknown> | null;
+    created_at: string | null;
+    updated_at: string | null;
+}
+interface Persona {
+    id: string;
+    name: string;
+    description: string | null;
+    status: string;
+    pain_points: string[];
+    goals: string[];
+    channels: string[];
+    created_at: string | null;
+}
+interface ICP {
+    id: string;
+    name: string;
+    description: string | null;
+    status: string;
+    industry: string[] | null;
+    employee_count_min: number | null;
+    employee_count_max: number | null;
+    revenue_min: number | null;
+    revenue_max: number | null;
+    countries: string[] | null;
+    created_at: string | null;
+}
+interface IntelligenceData {
+    id: string;
+    source_type: string;
+    url: string | null;
+    title: string | null;
+    content_summary: string | null;
+    collected_at: string | null;
+}
+interface ResearchReport {
+    id: string;
+    category: "buyer_psychology" | "competitive_teardown" | "gtm_channel" | "industry_analyst" | "review_sentiment" | "voice_of_customer";
+    title: string;
+    summary: string | null;
+    created_at: string | null;
+}
+/**
+ * Studio context — org-level intelligence documents. The 44-doc engine that
+ * powers campaign ideation: brand brief, value props, messaging house, ICPs,
+ * personas, intelligence (scrapes + enrichment), and AI research reports.
+ *
+ * Requires API key (server-side).
+ *
+ * Backed by:
+ *   GET /api/v1/global-context/documents
+ *   GET /api/v1/icps
+ *   GET /api/v1/personas
+ *   GET /api/v1/intelligence-data
+ *   GET /api/v1/research-reports
+ */
+declare const createStudioClient: (apiKey: string, apiUrl?: string) => {
+    /** Org-level Studio documents (brand_brief, value_props, messaging_house, etc.). */
+    globalContext(params?: {
+        category?: string;
+        limit?: number;
+    }): Promise<{
+        data: GlobalContextDocument[];
+    }>;
+    /** ICP definitions. */
+    icps(params?: {
+        status?: string;
+        limit?: number;
+    }): Promise<{
+        data: ICP[];
+    }>;
+    /** Buyer persona definitions. */
+    personas(params?: {
+        status?: string;
+        limit?: number;
+    }): Promise<{
+        data: Persona[];
+    }>;
+    /** Intelligence data (website scrapes, enrichment, competitor research). */
+    intelligenceData(params?: {
+        source_type?: string;
+        limit?: number;
+    }): Promise<{
+        data: IntelligenceData[];
+    }>;
+    /** AI research reports (buyer psychology, competitive teardown, GTM channel, etc.). */
+    researchReports(params?: {
+        category?: string;
+        limit?: number;
+    }): Promise<{
+        data: ResearchReport[];
+    }>;
+};
+
+interface IntentKeyword {
+    id: string;
+    keyword: string;
+    domain: string | null;
+    include_patterns: string[];
+    exclude_patterns: string[];
+    page_count: number;
+    visitor_count: number;
+    company_count: number;
+    contact_count: number;
+    created_at: string | null;
+}
+interface IntentPage {
+    url: string;
+    title: string | null;
+    keyword: string | null;
+    domain: string;
+    visitor_count: number;
+    last_seen: string | null;
+}
+interface IntentVisitor {
+    visitor_id: string;
+    company_domain: string | null;
+    company_name: string | null;
+    page_url: string;
+    first_seen: string | null;
+    last_seen: string | null;
+    visit_count: number;
+}
+interface IntentCompany {
+    domain: string;
+    name: string | null;
+    industry: string | null;
+    employee_count: string | null;
+    visit_count: number;
+    last_seen: string | null;
+}
+interface IntentContact {
+    contact_id: number | null;
+    email: string | null;
+    full_name: string | null;
+    company: string | null;
+    job_title: string | null;
+    last_seen: string | null;
+}
+interface IntentStats {
+    total_keywords: number;
+    total_pages: number;
+    total_visitors_30d: number;
+    total_companies_30d: number;
+}
+/**
+ * Intent + visitor tracking. Distinct from `g8.signals` (which is summary scoring) —
+ * this module exposes keyword tracking, page-level visitor data, and account-level
+ * intent signals from your own site (or from competitor URLs you've added).
+ *
+ * Requires API key (server-side).
+ *
+ * Backed by:
+ *   GET    /api/v1/intent/stats
+ *   POST   /api/v1/intent/keywords/list
+ *   POST   /api/v1/intent/keywords/create-from-domain
+ *   DELETE /api/v1/intent/keywords/{keyword_id}
+ *   POST   /api/v1/intent/keywords/{keyword_id}/companies
+ *   POST   /api/v1/intent/keywords/{keyword_id}/contacts
+ *   POST   /api/v1/intent/keywords/{keyword_id}/urls
+ *   POST   /api/v1/intent/pages-by-domain
+ *   POST   /api/v1/intent/pages/search
+ *   POST   /api/v1/intent/pages/visitors
+ *   POST   /api/v1/intent/pages/contacts
+ *   POST   /api/v1/intent/pages/visitor-counts
+ *   POST   /intent-search/url-companies          (note: bare host, no /api/v1 prefix)
+ */
+declare const createIntentClient: (apiKey: string, apiUrl?: string) => {
+    /** Org-level intent stats (totals over the last 30 days). */
+    stats(): Promise<{
+        data: IntentStats;
+    }>;
+    /** List tracked keywords with optional pagination. */
+    listKeywords(params?: {
+        page?: number;
+        limit?: number;
+        search?: string;
+    }): Promise<{
+        data: IntentKeyword[];
+    }>;
+    /** Create a keyword group from a domain (auto-tracks all pages). */
+    createFromDomain(domain: string): Promise<{
+        data: IntentKeyword;
+    }>;
+    /** Stop tracking a keyword (irreversible — historical data is retained). */
+    deleteKeyword(keywordId: string): Promise<{
+        data: {
+            deleted: boolean;
+        };
+    }>;
+    /** Companies showing interest in a tracked keyword. */
+    keywordCompanies(keywordId: string, params?: {
+        limit?: number;
+        date_from?: string;
+        date_to?: string;
+    }): Promise<{
+        data: IntentCompany[];
+    }>;
+    /** Contacts showing interest in a tracked keyword. */
+    keywordContacts(keywordId: string, params?: {
+        limit?: number;
+        date_from?: string;
+        date_to?: string;
+    }): Promise<{
+        data: IntentContact[];
+    }>;
+    /** URLs associated with a keyword (pages visitors landed on while interested). */
+    keywordUrls(keywordId: string, params?: {
+        limit?: number;
+    }): Promise<{
+        data: IntentPage[];
+    }>;
+    /** Pages tracked on a specific domain. */
+    pagesByDomain(domain: string, params?: {
+        limit?: number;
+    }): Promise<{
+        data: IntentPage[];
+    }>;
+    /** Search tracked pages by URL fragment or keyword. */
+    searchPages(query: string, params?: {
+        limit?: number;
+    }): Promise<{
+        data: IntentPage[];
+    }>;
+    /** Get visitor records for a specific page URL. */
+    pageVisitors(pageUrl: string, params?: {
+        limit?: number;
+        date_from?: string;
+        date_to?: string;
+    }): Promise<{
+        data: IntentVisitor[];
+    }>;
+    /** Get contacts who visited a specific page URL. */
+    pageContacts(pageUrl: string, params?: {
+        limit?: number;
+    }): Promise<{
+        data: IntentContact[];
+    }>;
+    /** Visitor count aggregates by page (pass an array of URLs). */
+    pageVisitorCounts(urls: string[]): Promise<{
+        data: Array<{
+            url: string;
+            visitor_count: number;
+        }>;
+    }>;
+    /**
+     * Find companies whose users visited a specific URL (intent search).
+     *
+     * Note: this endpoint lives at the bare host (no `/api/v1` prefix), unlike the rest
+     * of the intent surface — we call it directly here instead of through the shared `post()` helper.
+     */
+    urlCompanies(url: string, params?: {
+        limit?: number;
+        date_from?: string;
+        date_to?: string;
+    }): Promise<{
+        data: IntentCompany[];
+    }>;
+};
+
+type SkillType = "llm" | "api";
+interface SkillInputField {
+    name: string;
+    type: string;
+    required: boolean;
+    description?: string;
+}
+interface Skill {
+    id: string;
+    title: string;
+    description: string | null;
+    type: SkillType;
+    /** Only present on `type=llm`. */
+    prompt?: string;
+    /** Only present on `type=llm`. */
+    model?: string;
+    /** Only present on `type=api`. */
+    method?: "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
+    /** Only present on `type=api`. */
+    url?: string;
+    /** Only present on `type=api`. */
+    headers?: Record<string, string>;
+    /** Only present on `type=api`. */
+    body_template?: string;
+    input_schema: {
+        fields: SkillInputField[];
+    };
+    output_schema: Record<string, unknown> | null;
+    created_at: string | null;
+    updated_at: string | null;
+}
+interface SkillCreateLLMParams {
+    title: string;
+    description?: string;
+    prompt: string;
+    model: string;
+    input_schema: {
+        fields: SkillInputField[];
+    };
+    output_schema?: Record<string, unknown>;
+}
+interface SkillCreateAPIParams {
+    title: string;
+    description?: string;
+    method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
+    url: string;
+    headers?: Record<string, string>;
+    body_template?: string;
+    response_mapping?: Record<string, string>;
+    input_schema: {
+        fields: SkillInputField[];
+    };
+}
+interface SkillUpdateLLMParams {
+    title?: string;
+    description?: string;
+    prompt?: string;
+    model?: string;
+    input_schema?: {
+        fields: SkillInputField[];
+    };
+    output_schema?: Record<string, unknown>;
+}
+interface SkillUpdateAPIParams {
+    title?: string;
+    description?: string;
+    method?: "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
+    url?: string;
+    headers?: Record<string, string>;
+    body_template?: string;
+    response_mapping?: Record<string, string>;
+    input_schema?: {
+        fields: SkillInputField[];
+    };
+}
+interface SkillTemplate {
+    id: string;
+    title: string;
+    description: string;
+    type: SkillType;
+    use_cases: string[];
+}
+interface SkillListParams {
+    page?: number;
+    limit?: number;
+    type?: SkillType;
+    search?: string;
+}
+/**
+ * Skills API - LLM and API building blocks that workflows compose into runs.
+ * Requires API key (server-side).
+ *
+ * Backed by:
+ *   GET    /api/v1/skills
+ *   GET    /api/v1/skills/{id}
+ *   GET    /api/v1/skills/{id}/variables
+ *   GET    /api/v1/skills/models
+ *   GET    /api/v1/skills/templates
+ *   POST   /api/v1/skills              (both llm + api types via `type` field)
+ *   POST   /api/v1/skills/from-template
+ *   POST   /api/v1/skills/from-node
+ *   PUT    /api/v1/skills/{id}
+ *   DELETE /api/v1/skills/{id}
+ *   POST   /api/v1/skills/validate
+ *   POST   /api/v1/skills/{id}/execute
+ */
+declare const createSkillsClient: (apiKey: string, apiUrl?: string) => {
+    /** List skills. */
+    list(params?: SkillListParams): Promise<{
+        data: Skill[];
+    }>;
+    /** Get a skill by ID. */
+    get(skillId: string): Promise<Skill>;
+    /** Get the variables required by a skill (extracted from prompt or body template). */
+    getVariables(skillId: string): Promise<{
+        data: SkillInputField[];
+    }>;
+    /** List available LLM models. */
+    listModels(): Promise<{
+        data: Array<{
+            id: string;
+            label: string;
+            provider: string;
+        }>;
+    }>;
+    /** List skill templates. */
+    listTemplates(params?: {
+        type?: SkillType;
+    }): Promise<{
+        data: SkillTemplate[];
+    }>;
+    /** Create an LLM skill (prompt + model + schemas). */
+    createLLM(params: SkillCreateLLMParams): Promise<Skill>;
+    /** Create an API skill (HTTP request wrapper). */
+    createAPI(params: SkillCreateAPIParams): Promise<Skill>;
+    /** Create a skill from a built-in template. */
+    createFromTemplate(params: {
+        title: string;
+        template_id: string;
+        overrides?: Record<string, unknown>;
+    }): Promise<Skill>;
+    /** Lift a workflow node into a reusable skill. */
+    createFromNode(params: {
+        title: string;
+        description?: string;
+        node_id: string;
+        input_mapping?: Record<string, string>;
+        output_mapping?: Record<string, string>;
+    }): Promise<Skill>;
+    /** Update an LLM skill. */
+    updateLLM(skillId: string, fields: SkillUpdateLLMParams): Promise<Skill>;
+    /** Update an API skill. */
+    updateAPI(skillId: string, fields: SkillUpdateAPIParams): Promise<Skill>;
+    /** Delete a skill (irreversible if in-use workflows exist). */
+    delete(skillId: string): Promise<{
+        data: {
+            deleted: boolean;
+        };
+    }>;
+    /** Validate a skill definition (without saving). */
+    validate(skill: Partial<Skill>): Promise<{
+        data: {
+            valid: boolean;
+            errors: string[];
+        };
+    }>;
+    /** Execute a skill immediately with an input payload (test / preview). */
+    execute(skillId: string, inputPayload: Record<string, unknown>): Promise<{
+        data: {
+            output: Record<string, unknown>;
+            latency_ms: number;
+            tokens?: number;
+            error: string | null;
+        };
+    }>;
+};
+
+interface WorkflowNode {
+    id: string;
+    type: string;
+    config: Record<string, unknown>;
+    position?: {
+        x: number;
+        y: number;
+    };
+    /** Mapping from this node's output to the next node's input. */
+    input_mappings?: Record<string, string>;
+}
+interface WorkflowConnection {
+    from_node_id: string;
+    to_node_id: string;
+    condition?: string | null;
+}
+interface WorkflowConfig {
+    nodes: WorkflowNode[];
+    connections: WorkflowConnection[];
+    trigger?: Record<string, unknown> | null;
+}
+interface Workflow {
+    id: string;
+    name: string;
+    description: string | null;
+    config: WorkflowConfig;
+    trigger_config: Record<string, unknown> | null;
+    is_active: boolean;
+    created_at: string | null;
+    updated_at: string | null;
+}
+interface WorkflowCreateParams {
+    name: string;
+    description?: string;
+    config?: WorkflowConfig;
+    trigger_config?: Record<string, unknown>;
+}
+interface WorkflowUpdateParams {
+    name?: string;
+    description?: string;
+    config?: WorkflowConfig;
+    trigger_config?: Record<string, unknown>;
+    is_active?: boolean;
+}
+interface WorkflowExecution {
+    id: string;
+    workflow_id: string;
+    status: "pending" | "running" | "paused" | "completed" | "failed" | "stopped";
+    trigger_payload: Record<string, unknown>;
+    outputs: Record<string, unknown>;
+    error: string | null;
+    started_at: string | null;
+    ended_at: string | null;
+}
+interface NodeTypeSchema {
+    type: string;
+    label: string;
+    description: string;
+    config_schema: Record<string, unknown>;
+    output_schema: Record<string, unknown>;
+}
+interface WorkflowListParams {
+    page?: number;
+    limit?: number;
+    is_active?: boolean;
+    search?: string;
+}
+/**
+ * Workflows API - automation workflows with nodes, connections, and execution lifecycle.
+ * Requires API key (server-side).
+ *
+ * The graph8 workflow surface treats the whole workflow definition as a single
+ * record updated via `update()` — there are no per-node CRUD endpoints. To edit
+ * nodes or connections, fetch the workflow, mutate `config.nodes` / `config.connections`,
+ * and PUT it back.
+ *
+ * Backed by:
+ *   GET    /api/v1/workflows
+ *   GET    /api/v1/workflows/{id}
+ *   POST   /api/v1/workflows
+ *   PUT    /api/v1/workflows/{id}
+ *   DELETE /api/v1/workflows/{id}
+ *   POST   /api/v1/workflows/validate
+ *   POST   /api/v1/workflows/{id}/execute
+ *   GET    /api/v1/workflows/executions/{exec_id}
+ *   POST   /api/v1/workflows/executions/{exec_id}/pause
+ *   POST   /api/v1/workflows/executions/{exec_id}/resume
+ *   POST   /api/v1/workflows/executions/{exec_id}/stop
+ *   GET    /api/v1/workflows/{id}/trigger-status
+ *   POST   /api/v1/workflows/{id}/trigger-reset
+ *   GET    /api/v1/workflows/node-types/schema
+ *   GET    /api/v1/workflows/integrations/slack/users|channels
+ *   GET    /api/v1/workflows/integrations/roam/users|groups
+ *   GET    /api/v1/workflows/mcp-servers
+ *   GET    /api/v1/workflows/dispositions
+ *   GET    /api/v1/workflows/forms/{form_id}/fields
+ */
+declare const createWorkflowsClient: (apiKey: string, apiUrl?: string) => {
+    /** List workflows org-wide. */
+    list(params?: WorkflowListParams): Promise<{
+        data: Workflow[];
+    }>;
+    /** Get full workflow definition (nodes, connections, trigger, execution state). */
+    get(workflowId: string): Promise<Workflow>;
+    /** Create a new workflow. */
+    create(params: WorkflowCreateParams): Promise<Workflow>;
+    /**
+     * Update a workflow. Pass the full `config` (nodes + connections) to edit
+     * the graph — node-level CRUD is performed client-side by mutating the
+     * config and submitting the updated record.
+     */
+    update(workflowId: string, fields: WorkflowUpdateParams): Promise<Workflow>;
+    /** Delete a workflow. */
+    delete(workflowId: string): Promise<{
+        data: {
+            deleted: boolean;
+        };
+    }>;
+    /** Validate a workflow definition (orphans, dangling connections, required fields). */
+    validate(workflow: {
+        config: WorkflowConfig;
+        trigger_config?: Record<string, unknown>;
+    }): Promise<{
+        data: {
+            valid: boolean;
+            errors: Array<{
+                node_id?: string;
+                field?: string;
+                message: string;
+            }>;
+        };
+    }>;
+    /** Execute a workflow immediately with a trigger payload. */
+    execute(workflowId: string, triggerPayload?: Record<string, unknown>): Promise<WorkflowExecution>;
+    /** Get the status + output of a workflow execution. */
+    getExecution(executionId: string): Promise<WorkflowExecution>;
+    /** Pause an in-flight execution. */
+    pauseExecution(executionId: string): Promise<{
+        data: {
+            paused: boolean;
+        };
+    }>;
+    /** Resume a paused execution. */
+    resumeExecution(executionId: string): Promise<{
+        data: {
+            resumed: boolean;
+        };
+    }>;
+    /** Stop an execution (terminal state — cannot resume). */
+    stopExecution(executionId: string): Promise<{
+        data: {
+            stopped: boolean;
+        };
+    }>;
+    /** Get the status of a workflow's external trigger (e.g. "waiting for webhook"). */
+    getTriggerStatus(workflowId: string): Promise<{
+        data: {
+            status: string;
+            details: Record<string, unknown>;
+        };
+    }>;
+    /** Reset the trigger cursor (e.g. for event-stream triggers — resume from beginning). */
+    resetTrigger(workflowId: string): Promise<{
+        data: {
+            reset: boolean;
+        };
+    }>;
+    /**
+     * List available node types with schemas. Pass a `type` param to fetch one type's full schema.
+     */
+    nodeTypes(params?: {
+        type?: string;
+    }): Promise<{
+        data: NodeTypeSchema[];
+    }>;
+    /** Slack workspace users (for Slack action recipients). */
+    listSlackUsers(): Promise<{
+        data: Array<{
+            id: string;
+            name: string;
+            email: string | null;
+        }>;
+    }>;
+    /** Slack channels. */
+    listSlackChannels(): Promise<{
+        data: Array<{
+            id: string;
+            name: string;
+            is_private: boolean;
+        }>;
+    }>;
+    /** Roam (Copilot chat) users. */
+    listRoamUsers(): Promise<{
+        data: Array<{
+            id: string;
+            name: string;
+            email: string | null;
+        }>;
+    }>;
+    /** Roam (Copilot chat) groups. */
+    listRoamGroups(): Promise<{
+        data: Array<{
+            id: string;
+            name: string;
+        }>;
+    }>;
+    /** Available MCP servers (for Agent-node integrations). */
+    listMcpServers(): Promise<{
+        data: Array<{
+            id: string;
+            name: string;
+            url: string;
+        }>;
+    }>;
+    /** Available call dispositions (voice workflow nodes). */
+    listDispositions(): Promise<{
+        data: Array<{
+            id: string;
+            label: string;
+        }>;
+    }>;
+    /** Form field schema for form-trigger nodes. */
+    listFormFields(formId: string): Promise<{
+        data: Array<{
+            name: string;
+            type: string;
+            required: boolean;
+        }>;
+    }>;
+};
+
+/**
+ * Stage Checklist v2 pipelines. A "pipeline" here is a multi-stage workflow
+ * (with evidence requirements and per-channel scripts) that lives parallel
+ * to deal pipelines. Use `g8.deals.pipelines()` for deal-pipeline reads.
+ */
+interface StagePipelineStage {
+    id: string;
+    name: string;
+    position: number;
+    /** Evidence keys that must be collected before the stage can be marked done. */
+    required_elements: string[];
+    /** Evidence keys that are recommended but not enforced. */
+    recommended_elements: string[];
+    /** Channel-specific scripts (call, email, linkedin, etc.). */
+    channel_scripts: Record<string, string>;
+    color: string | null;
+    stage_type: string | null;
+}
+interface StagePipeline {
+    id: string;
+    name: string;
+    target: string | null;
+    is_default: boolean;
+    stages: StagePipelineStage[];
+    created_at: string | null;
+    updated_at: string | null;
+}
+interface StagePipelineCreateParams {
+    name: string;
+    target?: string;
+    /** If true, creates an empty pipeline (no default stages). */
+    blank?: boolean;
+}
+interface StagePipelineUpdateParams {
+    name?: string;
+    target?: string;
+}
+interface StageCreateParams {
+    name: string;
+    position?: number;
+    required_elements?: string[];
+    recommended_elements?: string[];
+    channel_scripts?: Record<string, string>;
+    color?: string;
+    stage_type?: string;
+}
+interface StageUpdateParams {
+    name?: string;
+    position?: number;
+    required_elements?: string[];
+    recommended_elements?: string[];
+    channel_scripts?: Record<string, string>;
+    color?: string;
+}
+interface EvidenceKey {
+    key: string;
+    label: string;
+    description: string;
+    category: string;
+}
+interface PipelineSuggestion {
+    suggestion_id: string;
+    name: string;
+    target: string;
+    stages: Array<{
+        name: string;
+        required_elements: string[];
+        channel_scripts: Record<string, string>;
+    }>;
+    rationale: string;
+}
+/**
+ * Stage Checklist Pipelines API - workflow pipelines with evidence + scripts.
+ * Requires API key (server-side).
+ *
+ * Backed by:
+ *   GET    /api/v1/pipelines
+ *   GET    /api/v1/pipelines/{id}
+ *   GET    /api/v1/pipelines/evidence-library
+ *   POST   /api/v1/pipelines
+ *   PUT    /api/v1/pipelines/{id}
+ *   DELETE /api/v1/pipelines/{id}
+ *   POST   /api/v1/pipelines/{id}/stages
+ *   PUT    /api/v1/pipelines/{id}/stages/{stage_id}
+ *   DELETE /api/v1/pipelines/{id}/stages/{stage_id}
+ *   PUT    /api/v1/pipelines/{id}/stages/reorder
+ *   POST   /api/v1/pipelines/suggest
+ *   POST   /api/v1/pipelines/from-suggestion
+ */
+declare const createPipelinesClient: (apiKey: string, apiUrl?: string) => {
+    /** List all stage-checklist pipelines with stages, evidence, scripts. */
+    list(): Promise<{
+        data: StagePipeline[];
+    }>;
+    /** Get a single pipeline by ID. */
+    get(pipelineId: string): Promise<StagePipeline>;
+    /** Get the canonical evidence-key library (used when defining stages). */
+    evidenceLibrary(): Promise<{
+        data: EvidenceKey[];
+    }>;
+    /** Create a new pipeline. Defaults to a templated set of stages; pass blank=true for empty. */
+    create(params: StagePipelineCreateParams): Promise<StagePipeline>;
+    /** Update pipeline metadata (name, target). */
+    update(pipelineId: string, fields: StagePipelineUpdateParams): Promise<StagePipeline>;
+    /** Delete a pipeline. Only allowed when no deals reference it. */
+    delete(pipelineId: string): Promise<{
+        data: {
+            deleted: boolean;
+        };
+    }>;
+    /** Add a new stage to a pipeline. */
+    createStage(pipelineId: string, stage: StageCreateParams): Promise<StagePipelineStage>;
+    /** Update a stage (evidence, scripts, position). */
+    updateStage(pipelineId: string, stageId: string, fields: StageUpdateParams): Promise<StagePipelineStage>;
+    /** Reorder stages within a pipeline (pass full ordered list of stage IDs). */
+    reorderStages(pipelineId: string, stageIds: string[]): Promise<{
+        data: StagePipelineStage[];
+    }>;
+    /** Delete a stage from a pipeline. */
+    deleteStage(pipelineId: string, stageId: string): Promise<{
+        data: {
+            deleted: boolean;
+        };
+    }>;
+    /** Get an AI-suggested pipeline based on org context (brand, ICP, messaging). */
+    suggest(): Promise<{
+        data: PipelineSuggestion;
+    }>;
+    /** Create a real pipeline from an AI suggestion (optionally with overrides). */
+    fromSuggestion(suggestionId: string, overrides?: Partial<{
+        name: string;
+        target: string;
+    }>): Promise<StagePipeline>;
+};
+
+interface QuoteLineItem {
+    product_id?: string | null;
+    name?: string | null;
+    description?: string | null;
+    quantity: number;
+    unit_price: number;
+    currency?: string | null;
+    recurring?: boolean | null;
+}
+type QuoteStatus = "draft" | "sent" | "signed" | "declined" | "expired" | "void";
+interface QuoteSummary {
+    id: string;
+    name: string | null;
+    status: QuoteStatus;
+    total: number | null;
+    currency: string | null;
+    contact_id: number | null;
+    company_id: number | null;
+    expires_at: string | null;
+    created_at: string | null;
+    updated_at: string | null;
+    signing_url: string | null;
+    payment_link_url: string | null;
+}
+interface QuoteDetail extends QuoteSummary {
+    line_items: QuoteLineItem[];
+    notes: string | null;
+    recipient_email: string | null;
+    signed_at: string | null;
+    sent_at: string | null;
+}
+interface QuoteCreateParams {
+    contact_id?: number;
+    company_id?: number;
+    line_items: QuoteLineItem[];
+    currency?: string;
+    notes?: string;
+    /** ISO 8601 timestamp. */
+    expires_at?: string;
+    name?: string;
+}
+interface QuoteUpdateParams {
+    line_items?: QuoteLineItem[];
+    notes?: string;
+    expires_at?: string;
+    name?: string;
+}
+interface QuoteSendParams {
+    recipient_email: string;
+    /** Whether to attach the signing link. Defaults to true. */
+    send_signing_link?: boolean;
+}
+interface QuoteListParams {
+    status?: QuoteStatus;
+    contact_id?: number;
+    company_id?: number;
+    page?: number;
+    limit?: number;
+}
+interface QuotableProduct {
+    id: string;
+    name: string;
+    description: string | null;
+    unit_price: number;
+    currency: string;
+    recurring: boolean;
+}
+interface QuoteSettings {
+    default_currency: string;
+    default_tax_rate: number | null;
+    payment_providers: string[];
+    logo_url: string | null;
+    signature_required: boolean;
+}
+interface PaginationMeta$2 {
+    page: number;
+    limit: number;
+    total: number;
+    has_next: boolean;
+}
+/**
+ * Quotes API - quote-to-cash lifecycle. Requires API key (server-side).
+ *
+ * Backed by:
+ *   GET    /api/v1/quotes
+ *   GET    /api/v1/quotes/{id}
+ *   POST   /api/v1/quotes
+ *   PUT    /api/v1/quotes/{id}
+ *   DELETE /api/v1/quotes/{id}
+ *   POST   /api/v1/quotes/{id}/duplicate
+ *   POST   /api/v1/quotes/{id}/edit-as-draft
+ *   POST   /api/v1/quotes/{id}/send
+ *   GET    /api/v1/quotable-products
+ *   GET    /api/v1/quote-settings
+ *   GET    /api/v1/contacts/{contact_id}/quotes
+ *   GET    /api/v1/companies/{company_id}/quotes
+ */
+declare const createQuotesClient: (apiKey: string, apiUrl?: string) => {
+    /** List quotes org-wide with optional filters and pagination. */
+    list(params?: QuoteListParams): Promise<{
+        data: QuoteSummary[];
+        pagination?: PaginationMeta$2;
+    }>;
+    /** Get full details for a single quote. */
+    get(quoteId: string): Promise<QuoteDetail>;
+    /** Create a new quote from line items. */
+    create(quote: QuoteCreateParams): Promise<QuoteDetail>;
+    /** Update a draft quote (line items, expiry, notes). */
+    update(quoteId: string, fields: QuoteUpdateParams): Promise<QuoteDetail>;
+    /** Delete a draft quote (irreversible). */
+    delete(quoteId: string): Promise<{
+        data: {
+            deleted: boolean;
+        };
+    }>;
+    /** Duplicate an existing quote (all line items copied into a new draft). */
+    duplicate(quoteId: string): Promise<QuoteDetail>;
+    /** Convert a signed / sent quote back to editable draft state. */
+    editAsDraft(quoteId: string): Promise<{
+        data: {
+            id: string;
+            status: string;
+        };
+    }>;
+    /** Send a quote to its recipient via email (with signature + optional payment link). */
+    send(quoteId: string, params: QuoteSendParams): Promise<QuoteDetail>;
+    /** List products available for line items. */
+    products(): Promise<{
+        data: QuotableProduct[];
+    }>;
+    /** Get org-level quote settings (currency, tax rate, payment providers, logo). */
+    settings(): Promise<QuoteSettings>;
+    /** Get all quotes associated with a contact. */
+    forContact(contactId: number): Promise<{
+        data: QuoteSummary[];
+    }>;
+    /** Get all quotes associated with a company. */
+    forCompany(companyId: number): Promise<{
+        data: QuoteSummary[];
+    }>;
+};
+
 /**
  * Inbox channel — `email`, `sms`, or `linkedin` (HeyReach internally).
  * Defaults to `email` on routes that accept this as a query param.
@@ -1015,6 +2036,44 @@ declare const createVoiceClient: (apiKey: string, apiUrl?: string) => {
         callGrading(roomName: string): Promise<CallGradingResult>;
         /** List voice agents available for dialer sessions (capped at 100; no pagination). */
         agents(params?: DialerAgentsListParams): Promise<DialerAgentsListResult>;
+        /** Fetch the full transcript for a single dialer call. */
+        callTranscript(roomName: string): Promise<{
+            data: {
+                status: string;
+                transcript: Array<{
+                    speaker: string;
+                    text: string;
+                    timestamp: number;
+                }>;
+            };
+        }>;
+        /** List dialer calls — pass `contact_id` or `user_email` to scope. */
+        listCalls(params?: {
+            contact_id?: number;
+            user_email?: string;
+            campaign_id?: string;
+            date_from?: string;
+            date_to?: string;
+            limit?: number;
+            page?: number;
+        }): Promise<{
+            data: Array<Record<string, unknown>>;
+            pagination?: VoicePagination;
+        }>;
+        /** Convenience: list calls for a single contact. */
+        listCallsForContact(contactId: number, extra?: {
+            limit?: number;
+        }): Promise<{
+            data: Array<Record<string, unknown>>;
+        }>;
+        /** Convenience: list calls placed by a specific SDR. */
+        listCallsForSdr(userEmail: string, extra?: {
+            limit?: number;
+            date_from?: string;
+            date_to?: string;
+        }): Promise<{
+            data: Array<Record<string, unknown>>;
+        }>;
     };
 };
 
@@ -1641,6 +2700,13 @@ declare const useG8: () => {
         _fields: ReturnType<typeof createFieldsClient> | null;
         _deals: ReturnType<typeof createDealsClient> | null;
         _inbox: ReturnType<typeof createInboxClient> | null;
+        _quotes: ReturnType<typeof createQuotesClient> | null;
+        _pipelines: ReturnType<typeof createPipelinesClient> | null;
+        _workflows: ReturnType<typeof createWorkflowsClient> | null;
+        _skills: ReturnType<typeof createSkillsClient> | null;
+        _intent: ReturnType<typeof createIntentClient> | null;
+        _studio: ReturnType<typeof createStudioClient> | null;
+        _meetings: ReturnType<typeof createMeetingsClient> | null;
         init(config: G8Config): void;
         track(event: string, properties?: TrackProperties): void;
         identify(userId: string, properties?: IdentifyProperties): void;
@@ -1757,6 +2823,40 @@ declare const useG8: () => {
                 missedCallbacks(limit?: number): Promise<MissedCallbacksResult>;
                 callGrading(roomName: string): Promise<CallGradingResult>;
                 agents(params?: DialerAgentsListParams): Promise<DialerAgentsListResult>;
+                callTranscript(roomName: string): Promise<{
+                    data: {
+                        status: string;
+                        transcript: Array<{
+                            speaker: string;
+                            text: string;
+                            timestamp: number;
+                        }>;
+                    };
+                }>;
+                listCalls(params?: {
+                    contact_id?: number;
+                    user_email?: string;
+                    campaign_id?: string;
+                    date_from?: string;
+                    date_to?: string;
+                    limit?: number;
+                    page?: number;
+                }): Promise<{
+                    data: Array<Record<string, unknown>>;
+                    pagination?: VoicePagination;
+                }>;
+                listCallsForContact(contactId: number, extra?: {
+                    limit?: number;
+                }): Promise<{
+                    data: Array<Record<string, unknown>>;
+                }>;
+                listCallsForSdr(userEmail: string, extra?: {
+                    limit?: number;
+                    date_from?: string;
+                    date_to?: string;
+                }): Promise<{
+                    data: Array<Record<string, unknown>>;
+                }>;
             };
         };
         get pages(): {
@@ -1915,6 +3015,351 @@ declare const useG8: () => {
             draft(replyId: string, channel?: InboxChannel): Promise<InboxDraft>;
             send(replyId: string, payload: InboxSendParams): Promise<InboxSendResult>;
         };
+        get quotes(): {
+            list(params?: QuoteListParams): Promise<{
+                data: QuoteSummary[];
+                pagination?: PaginationMeta$2;
+            }>;
+            get(quoteId: string): Promise<QuoteDetail>;
+            create(quote: QuoteCreateParams): Promise<QuoteDetail>;
+            update(quoteId: string, fields: QuoteUpdateParams): Promise<QuoteDetail>;
+            delete(quoteId: string): Promise<{
+                data: {
+                    deleted: boolean;
+                };
+            }>;
+            duplicate(quoteId: string): Promise<QuoteDetail>;
+            editAsDraft(quoteId: string): Promise<{
+                data: {
+                    id: string;
+                    status: string;
+                };
+            }>;
+            send(quoteId: string, params: QuoteSendParams): Promise<QuoteDetail>;
+            products(): Promise<{
+                data: QuotableProduct[];
+            }>;
+            settings(): Promise<QuoteSettings>;
+            forContact(contactId: number): Promise<{
+                data: QuoteSummary[];
+            }>;
+            forCompany(companyId: number): Promise<{
+                data: QuoteSummary[];
+            }>;
+        };
+        get pipelines(): {
+            list(): Promise<{
+                data: StagePipeline[];
+            }>;
+            get(pipelineId: string): Promise<StagePipeline>;
+            evidenceLibrary(): Promise<{
+                data: EvidenceKey[];
+            }>;
+            create(params: StagePipelineCreateParams): Promise<StagePipeline>;
+            update(pipelineId: string, fields: StagePipelineUpdateParams): Promise<StagePipeline>;
+            delete(pipelineId: string): Promise<{
+                data: {
+                    deleted: boolean;
+                };
+            }>;
+            createStage(pipelineId: string, stage: StageCreateParams): Promise<StagePipelineStage>;
+            updateStage(pipelineId: string, stageId: string, fields: StageUpdateParams): Promise<StagePipelineStage>;
+            reorderStages(pipelineId: string, stageIds: string[]): Promise<{
+                data: StagePipelineStage[];
+            }>;
+            deleteStage(pipelineId: string, stageId: string): Promise<{
+                data: {
+                    deleted: boolean;
+                };
+            }>;
+            suggest(): Promise<{
+                data: PipelineSuggestion;
+            }>;
+            fromSuggestion(suggestionId: string, overrides?: Partial<{
+                name: string;
+                target: string;
+            }>): Promise<StagePipeline>;
+        };
+        get workflows(): {
+            list(params?: WorkflowListParams): Promise<{
+                data: Workflow[];
+            }>;
+            get(workflowId: string): Promise<Workflow>;
+            create(params: WorkflowCreateParams): Promise<Workflow>;
+            update(workflowId: string, fields: WorkflowUpdateParams): Promise<Workflow>;
+            delete(workflowId: string): Promise<{
+                data: {
+                    deleted: boolean;
+                };
+            }>;
+            validate(workflow: {
+                config: WorkflowConfig;
+                trigger_config?: Record<string, unknown>;
+            }): Promise<{
+                data: {
+                    valid: boolean;
+                    errors: Array<{
+                        node_id?: string;
+                        field?: string;
+                        message: string;
+                    }>;
+                };
+            }>;
+            execute(workflowId: string, triggerPayload?: Record<string, unknown>): Promise<WorkflowExecution>;
+            getExecution(executionId: string): Promise<WorkflowExecution>;
+            pauseExecution(executionId: string): Promise<{
+                data: {
+                    paused: boolean;
+                };
+            }>;
+            resumeExecution(executionId: string): Promise<{
+                data: {
+                    resumed: boolean;
+                };
+            }>;
+            stopExecution(executionId: string): Promise<{
+                data: {
+                    stopped: boolean;
+                };
+            }>;
+            getTriggerStatus(workflowId: string): Promise<{
+                data: {
+                    status: string;
+                    details: Record<string, unknown>;
+                };
+            }>;
+            resetTrigger(workflowId: string): Promise<{
+                data: {
+                    reset: boolean;
+                };
+            }>;
+            nodeTypes(params?: {
+                type?: string;
+            }): Promise<{
+                data: NodeTypeSchema[];
+            }>;
+            listSlackUsers(): Promise<{
+                data: Array<{
+                    id: string;
+                    name: string;
+                    email: string | null;
+                }>;
+            }>;
+            listSlackChannels(): Promise<{
+                data: Array<{
+                    id: string;
+                    name: string;
+                    is_private: boolean;
+                }>;
+            }>;
+            listRoamUsers(): Promise<{
+                data: Array<{
+                    id: string;
+                    name: string;
+                    email: string | null;
+                }>;
+            }>;
+            listRoamGroups(): Promise<{
+                data: Array<{
+                    id: string;
+                    name: string;
+                }>;
+            }>;
+            listMcpServers(): Promise<{
+                data: Array<{
+                    id: string;
+                    name: string;
+                    url: string;
+                }>;
+            }>;
+            listDispositions(): Promise<{
+                data: Array<{
+                    id: string;
+                    label: string;
+                }>;
+            }>;
+            listFormFields(formId: string): Promise<{
+                data: Array<{
+                    name: string;
+                    type: string;
+                    required: boolean;
+                }>;
+            }>;
+        };
+        get skills(): {
+            list(params?: SkillListParams): Promise<{
+                data: Skill[];
+            }>;
+            get(skillId: string): Promise<Skill>;
+            getVariables(skillId: string): Promise<{
+                data: SkillInputField[];
+            }>;
+            listModels(): Promise<{
+                data: Array<{
+                    id: string;
+                    label: string;
+                    provider: string;
+                }>;
+            }>;
+            listTemplates(params?: {
+                type?: SkillType;
+            }): Promise<{
+                data: SkillTemplate[];
+            }>;
+            createLLM(params: SkillCreateLLMParams): Promise<Skill>;
+            createAPI(params: SkillCreateAPIParams): Promise<Skill>;
+            createFromTemplate(params: {
+                title: string;
+                template_id: string;
+                overrides?: Record<string, unknown>;
+            }): Promise<Skill>;
+            createFromNode(params: {
+                title: string;
+                description?: string;
+                node_id: string;
+                input_mapping?: Record<string, string>;
+                output_mapping?: Record<string, string>;
+            }): Promise<Skill>;
+            updateLLM(skillId: string, fields: SkillUpdateLLMParams): Promise<Skill>;
+            updateAPI(skillId: string, fields: SkillUpdateAPIParams): Promise<Skill>;
+            delete(skillId: string): Promise<{
+                data: {
+                    deleted: boolean;
+                };
+            }>;
+            validate(skill: Partial<Skill>): Promise<{
+                data: {
+                    valid: boolean;
+                    errors: string[];
+                };
+            }>;
+            execute(skillId: string, inputPayload: Record<string, unknown>): Promise<{
+                data: {
+                    output: Record<string, unknown>;
+                    latency_ms: number;
+                    tokens?: number;
+                    error: string | null;
+                };
+            }>;
+        };
+        get intent(): {
+            stats(): Promise<{
+                data: IntentStats;
+            }>;
+            listKeywords(params?: {
+                page?: number;
+                limit?: number;
+                search?: string;
+            }): Promise<{
+                data: IntentKeyword[];
+            }>;
+            createFromDomain(domain: string): Promise<{
+                data: IntentKeyword;
+            }>;
+            deleteKeyword(keywordId: string): Promise<{
+                data: {
+                    deleted: boolean;
+                };
+            }>;
+            keywordCompanies(keywordId: string, params?: {
+                limit?: number;
+                date_from?: string;
+                date_to?: string;
+            }): Promise<{
+                data: IntentCompany[];
+            }>;
+            keywordContacts(keywordId: string, params?: {
+                limit?: number;
+                date_from?: string;
+                date_to?: string;
+            }): Promise<{
+                data: IntentContact[];
+            }>;
+            keywordUrls(keywordId: string, params?: {
+                limit?: number;
+            }): Promise<{
+                data: IntentPage[];
+            }>;
+            pagesByDomain(domain: string, params?: {
+                limit?: number;
+            }): Promise<{
+                data: IntentPage[];
+            }>;
+            searchPages(query: string, params?: {
+                limit?: number;
+            }): Promise<{
+                data: IntentPage[];
+            }>;
+            pageVisitors(pageUrl: string, params?: {
+                limit?: number;
+                date_from?: string;
+                date_to?: string;
+            }): Promise<{
+                data: IntentVisitor[];
+            }>;
+            pageContacts(pageUrl: string, params?: {
+                limit?: number;
+            }): Promise<{
+                data: IntentContact[];
+            }>;
+            pageVisitorCounts(urls: string[]): Promise<{
+                data: Array<{
+                    url: string;
+                    visitor_count: number;
+                }>;
+            }>;
+            urlCompanies(url: string, params?: {
+                limit?: number;
+                date_from?: string;
+                date_to?: string;
+            }): Promise<{
+                data: IntentCompany[];
+            }>;
+        };
+        get studio(): {
+            globalContext(params?: {
+                category?: string;
+                limit?: number;
+            }): Promise<{
+                data: GlobalContextDocument[];
+            }>;
+            icps(params?: {
+                status?: string;
+                limit?: number;
+            }): Promise<{
+                data: ICP[];
+            }>;
+            personas(params?: {
+                status?: string;
+                limit?: number;
+            }): Promise<{
+                data: Persona[];
+            }>;
+            intelligenceData(params?: {
+                source_type?: string;
+                limit?: number;
+            }): Promise<{
+                data: IntelligenceData[];
+            }>;
+            researchReports(params?: {
+                category?: string;
+                limit?: number;
+            }): Promise<{
+                data: ResearchReport[];
+            }>;
+        };
+        get meetings(): {
+            list(params?: MeetingListParams): Promise<{
+                data: MeetingSummary[];
+                pagination?: {
+                    page: number;
+                    limit: number;
+                    total: number;
+                    has_next: boolean;
+                };
+            }>;
+            get(meetingId: string): Promise<MeetingDetail>;
+        };
         get initialized(): boolean;
         _assertInit(): void;
         _assertKey(module: string): void;