@graph8/sdk 0.3.0 → 0.5.0

package/dist/react.d.ts

@@ -2,6 +2,1149 @@ 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.
+ */
+type InboxChannel = "email" | "sms" | "linkedin";
+interface InboxContact {
+    name?: string | null;
+    email?: string | null;
+    company?: string | null;
+    [key: string]: unknown;
+}
+interface InboxTag {
+    id: string;
+    name: string;
+}
+interface InboxAssignee {
+    email: string;
+    name?: string | null;
+    [key: string]: unknown;
+}
+interface InboxMessage {
+    message_id: string | null;
+    from_address: string | null;
+    to_addresses: string[];
+    content: string | null;
+    /** "USER", "AI", or "OTHER". */
+    responder: string | null;
+    date: string | null;
+    is_draft: boolean;
+}
+interface InboxThread {
+    id: string;
+    /** "email", "sms", or "linkedin". */
+    channel: string;
+    subject: string | null;
+    contact: InboxContact | null;
+    messages: InboxMessage[];
+    /** "open", "responded", "ai_responded", etc. */
+    status: string | null;
+    tags: InboxTag[];
+    assignees: InboxAssignee[];
+    created_at: string | null;
+    updated_at: string | null;
+}
+interface InboxListParams {
+    channel?: InboxChannel;
+    sequence_id?: string;
+    /** Filter by thread status (e.g. "open", "responded", "ai_responded"). */
+    status?: string;
+    /** Filter by assignee email. */
+    assignee?: string;
+    /** Filter by tag ID. */
+    tag?: string;
+    page?: number;
+    /** Default 50, max 100. */
+    page_size?: number;
+}
+interface InboxAssignResult {
+    assigned: boolean;
+    assignee: string;
+    count: number;
+    [key: string]: unknown;
+}
+interface InboxTagResult {
+    tagged: boolean;
+    tag_count: number;
+    [key: string]: unknown;
+}
+interface InboxDraft {
+    /** HTML body. */
+    content: string;
+    /** Plain-text alternative, if available. */
+    plain_content: string | null;
+    /** Credits charged for AI generation. */
+    credits_charged: number;
+}
+interface InboxSendParams {
+    body: string;
+    channel: InboxChannel;
+    subject?: string;
+    /** Recipient override — email, phone, or LinkedIn ID. */
+    to?: string;
+    /** Sender override — mailbox email, Twilio number, or LinkedIn account ID. */
+    from_address?: string;
+}
+interface InboxSendResult {
+    message_id: string | null;
+    status: string;
+    channel: string;
+}
+/**
+ * Inbox API — read + reply to multi-channel inbox threads (email, SMS, LinkedIn/HeyReach).
+ * Requires API key (server-side).
+ *
+ * Backed by:
+ *   GET   /api/v1/inbox
+ *   GET   /api/v1/inbox/{reply_id}
+ *   POST  /api/v1/inbox/{reply_id}/assign
+ *   POST  /api/v1/inbox/{reply_id}/tag
+ *   GET   /api/v1/inbox/{reply_id}/draft     (charges credits, 402 on insufficient balance)
+ *   POST  /api/v1/inbox/{reply_id}/send
+ */
+declare const createInboxClient: (apiKey: string, apiUrl?: string) => {
+    /** List inbox threads across email, SMS, and LinkedIn. */
+    list(params?: InboxListParams): Promise<{
+        data: InboxThread[];
+    }>;
+    /** Get a single inbox thread. Defaults to email channel. */
+    get(replyId: string, channel?: InboxChannel): Promise<InboxThread>;
+    /** Assign a user to an inbox thread. */
+    assign(replyId: string, assigneeEmail: string, channel?: InboxChannel): Promise<InboxAssignResult>;
+    /** Attach tag IDs to an inbox thread. */
+    tag(replyId: string, tagIds: string[], channel?: InboxChannel): Promise<InboxTagResult>;
+    /**
+     * Generate an AI draft reply for a thread.
+     * Charges credits — server returns 402 if balance is insufficient.
+     */
+    draft(replyId: string, channel?: InboxChannel): Promise<InboxDraft>;
+    /** Send a reply through email, SMS, or LinkedIn. */
+    send(replyId: string, payload: InboxSendParams): Promise<InboxSendResult>;
+};
+
 interface Deal {
     id: string | null;
     name: string | null;
@@ -81,7 +1224,7 @@ interface ContactDeal {
     owner_id: string | null;
     created_at: string | null;
 }
-interface PaginationMeta {
+interface PaginationMeta$1 {
     page: number;
     limit: number;
     total: number;
@@ -108,7 +1251,7 @@ declare const createDealsClient: (apiKey: string, apiUrl?: string) => {
     /** List deals org-wide with optional filters and pagination. */
     list(params?: DealListParams): Promise<{
         data: Deal[];
-        pagination?: PaginationMeta;
+        pagination?: PaginationMeta$1;
     }>;
     /** Create a new deal. */
     create(deal: DealCreateParams): Promise<Deal>;
@@ -624,20 +1767,314 @@ interface CallAnalysis {
 }
 type VoiceEvent = "connected" | "transcription" | "ended" | "error";
 type VoiceCallback = (data: Record<string, unknown>) => void;
+interface VoicePagination {
+    total_items: number;
+    total_pages: number;
+    current_page: number;
+    page_size: number;
+}
+interface DialerSessionSummary {
+    session_id: string;
+    status: string | null;
+    user_id: string | null;
+    user_email: string | null;
+    org_id: string | null;
+    from_phone: string | null;
+    campaign_id: string | null;
+    campaign_builder_campaign_id: string | null;
+    name: string | null;
+    session_metadata: Record<string, unknown> | null;
+    total_calls: number | null;
+    created_at: string | null;
+    updated_at: string | null;
+    contact_ids: unknown[];
+}
+interface DialerSessionsListResult {
+    sessions: DialerSessionSummary[];
+    pagination: VoicePagination;
+}
+interface DialerSessionsListParams {
+    page?: number;
+    /** Default 50, max 200. */
+    page_size?: number;
+    /** Comma-separated status list (e.g. "ACTIVE,PAUSED"). */
+    status?: string;
+    user_email?: string;
+    /** Substring search on session name. */
+    name?: string;
+    campaign_id?: string;
+    list_id?: string;
+    list_name?: string;
+    /** ISO 8601 timestamp. */
+    date_from?: string;
+    /** ISO 8601 timestamp. */
+    date_to?: string;
+    sort_by?: string;
+    /** Default "desc". */
+    sort_order?: "asc" | "desc";
+}
+interface DialerStatsParams {
+    session_id?: string;
+    user_email?: string;
+    /** YYYY-MM-DD. */
+    date_from?: string;
+    /** YYYY-MM-DD. */
+    date_to?: string;
+    /** Default "DAILY". */
+    aggregation?: "DAILY" | "TOTAL";
+}
+interface DialerReportFilters {
+    session_id: string | null;
+    user_email: string | null;
+    org_id: string | null;
+    date_from: string | null;
+    date_to: string | null;
+    aggregation: string | null;
+}
+interface DialerReportMetric {
+    date: string | null;
+    sdr_name: string | null;
+    org_id: string | null;
+    list_title: string | null;
+    total_dials: number;
+    total_connections: number;
+    connection_rate: number;
+    total_voicemails: number;
+    voicemail_rate: number;
+    talk_time_minutes: number;
+    avg_call_duration_minutes: number;
+    dispositions: Record<string, unknown> | null;
+    success_rate: number;
+    unique_sessions: number;
+    avg_calls_per_session: number;
+    redial_count: number;
+    redial_success_rate: number | null;
+    peak_calling_hour: number | null;
+    total_callbacks: number;
+}
+interface DialerStatsResult {
+    filters: DialerReportFilters;
+    metrics: DialerReportMetric[];
+    summary: DialerReportMetric | null;
+}
+interface DialerNumberInfo {
+    number: string;
+    /** Default "ai". */
+    inbound_type: string;
+    /** Default "twilio". */
+    telephony_provider: string;
+    calls_today: number;
+    calls_7d: number;
+    connect_rate_7d: number;
+    is_valid: boolean;
+    daily_limit: number;
+    assigned_to: string | null;
+    created_at: string | null;
+}
+interface DialerNumbersListResult {
+    numbers: DialerNumberInfo[];
+}
+interface MissedCallback {
+    id: string | number | null;
+    caller_phone: string | null;
+    inbound_number: string | null;
+    first_name: string | null;
+    last_name: string | null;
+    email: string | null;
+    contact_id: string | number | null;
+    parallel_session_id: string | null;
+    created_at: string | null;
+    call_duration: number | null;
+    is_callback: boolean;
+}
+interface MissedCallbacksResult {
+    missed_callbacks: MissedCallback[];
+    count: number;
+}
+interface CallGradingResult {
+    room_name: string;
+    /** "ready" or "pending". */
+    status: string;
+    grading: Record<string, unknown> | null;
+    reviewed: boolean;
+    reviewed_at: string | null;
+}
+interface DialerAgentSummary {
+    agent_id: string;
+    agent_name: string | null;
+    /** "SDR", etc. */
+    role: string | null;
+    agent_status: string | null;
+    /** "agent" or "twin". */
+    entity_type: string | null;
+    description: string | null;
+    phone: string | null;
+    is_template: boolean;
+}
+interface DialerAgentsListResult {
+    agents: DialerAgentSummary[];
+    total_count: number;
+}
+interface DialerAgentsListParams {
+    /** e.g. "SDR". */
+    role?: string;
+    agent_status?: string;
+    /** "agent" or "twin". */
+    entity_type?: "agent" | "twin";
+    /** Substring filter on name/description. */
+    search?: string;
+}
+interface DialerSessionCreateParams {
+    /** 1-200 chars. */
+    name: string;
+    /** Org's dialer phone (E.164, 9-16 chars). */
+    from_phone: string;
+    /** Contact list ID (stored in session metadata). */
+    list_id?: string;
+    /** Display title for the source list. */
+    list_title?: string;
+    /** V2 agent UUID. */
+    agent_id?: string;
+    /** V1 fallback name. Defaults to "default_agent". */
+    agent_name?: string;
+    /** "agent" or "twin". */
+    entity_type?: "agent" | "twin";
+    /** Campaign Builder UUID. */
+    studio_campaign_id?: string;
+    /** IANA timezone (e.g. "America/New_York"). */
+    user_timezone?: string;
+    /** Per-session voicemail-skip override. null/omit = use SDR default. */
+    skip_voicemails?: boolean;
+}
+interface DialerSessionCreateResult {
+    session_id: string;
+    status: string;
+    name: string | null;
+    org_id: string | null;
+    user_id: string | null;
+    user_email: string | null;
+    from_phone: string | null;
+    session_metadata: Record<string, unknown> | null;
+    total_calls: number;
+    created_at: string | null;
+    message: string | null;
+}
+/** "ACTIVE" resumes, "PAUSED" pauses, "COMPLETED" stops. "FAILED" is rejected. */
+type DialerSessionStatus = "ACTIVE" | "PAUSED" | "COMPLETED";
+interface DialerSessionStatusUpdateResult {
+    session_id: string;
+    status: string;
+    message: string | null;
+    name: string | null;
+    org_id: string | null;
+    user_id: string | null;
+    user_email: string | null;
+    from_phone: string | null;
+    session_metadata: Record<string, unknown> | null;
+    total_calls: number;
+    created_at: string | null;
+    updated_at: string | null;
+}
+interface DialerSessionResumeResult extends DialerSessionStatusUpdateResult {
+    /** Contacts actually placed in this batch (voice caps at 4). */
+    dialed_count: number;
+}
 /**
- * Voice AI - start AI voice calls, get transcriptions and analysis. Requires API key.
+ * Voice AI — start AI voice calls, get transcriptions and analysis.
+ * Plus full parallel-dialer session control via the `dialer` namespace.
+ * Requires API key (server-side).
+ *
+ * Backed by:
+ *   GET    /api/v1/voice/dialer/sessions
+ *   POST   /api/v1/voice/dialer/sessions
+ *   PATCH  /api/v1/voice/dialer/sessions/{session_id}/status
+ *   POST   /api/v1/voice/dialer/sessions/{session_id}/resume
+ *   GET    /api/v1/voice/dialer/stats
+ *   GET    /api/v1/voice/dialer/numbers
+ *   GET    /api/v1/voice/dialer/missed-callbacks
+ *   GET    /api/v1/voice/dialer/calls/{room_name}/grading
+ *   GET    /api/v1/voice/dialer/agents
  */
 declare const createVoiceClient: (apiKey: string, apiUrl?: string) => {
-    /** Start an AI voice session. */
+    /**
+     * Start an AI voice session.
+     * @deprecated Preview surface — for parallel-dialer flows use `voice.dialer.createSession()`.
+     */
     start(config: {
         agent?: string;
         contactId?: number;
         context?: Record<string, unknown>;
     }): Promise<VoiceSession>;
-    /** Get call analysis for a completed session. */
+    /**
+     * Get call analysis for a completed session.
+     * @deprecated Preview surface — for dialer-call grading use `voice.dialer.callGrading(roomName)`.
+     */
     analysis(sessionId: string): Promise<CallAnalysis>;
     /** Listen for voice events. */
     on(event: VoiceEvent, callback: VoiceCallback): void;
+    /** Parallel-dialer session control + analytics. */
+    dialer: {
+        /** List parallel-dialer sessions with filters + pagination. */
+        listSessions(params?: DialerSessionsListParams): Promise<DialerSessionsListResult>;
+        /** Create a parallel-dialer session in PAUSED state. SDR opens UI to start dialing. */
+        createSession(payload: DialerSessionCreateParams): Promise<DialerSessionCreateResult>;
+        /** Pause / resume / stop a dialer session via status flip. */
+        updateSessionStatus(sessionId: string, status: DialerSessionStatus): Promise<DialerSessionStatusUpdateResult>;
+        /**
+         * Resume a PAUSED dialer session. Auto-fetches the next batch from the source list,
+         * filters already-called + phoneless rows, and forwards to voice's start-session.
+         * @param maxContacts 1-4 (voice caps parallel dialing at 4). Default 4.
+         */
+        resumeSession(sessionId: string, maxContacts?: number): Promise<DialerSessionResumeResult>;
+        /** Aggregated dialer analytics (daily breakdown or total). */
+        stats(params?: DialerStatsParams): Promise<DialerStatsResult>;
+        /** List dialer-eligible phone numbers with 7-day stats + daily limits. */
+        numbers(userEmail?: string): Promise<DialerNumbersListResult>;
+        /** List missed inbound callbacks with caller / contact info. */
+        missedCallbacks(limit?: number): Promise<MissedCallbacksResult>;
+        /** AI grading for a single dialer call (returns "pending" while in progress). */
+        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>>;
+        }>;
+    };
 };
 
 interface AnalyticsOverview {
@@ -728,24 +2165,210 @@ declare const createCampaignsClient: (apiKey: string, apiUrl?: string) => {
     stats(campaignId: string): Promise<CampaignStats>;
 };
 
-interface Sequence {
-    id: string;
-    name: string;
-    status: string;
-    step_count: number | null;
-    contact_count: number | null;
-}
 interface AddToSequenceConfig {
     sequenceId: string;
     contactIds: number[];
     listId: number;
 }
+interface SequenceListItem {
+    id: string;
+    name: string | null;
+    status: string | null;
+    user_email: string | null;
+    step_count: number | null;
+    contact_count: number | null;
+    sequence_kind: string | null;
+    associated_list_id: number | null;
+    created_at: string | null;
+    updated_at: string | null;
+}
+interface SequenceListParams {
+    page?: number;
+    limit?: number;
+    /** Filter by sequence status (e.g. "live", "draft", "paused"). */
+    status?: string;
+}
+interface SequenceDetail {
+    id: string;
+    name: string | null;
+    description: string | null;
+    status: string | null;
+    user_email: string | null;
+    associated_list_id: number | null;
+    finish_on_reply: boolean;
+    send_in_same_thread: boolean;
+    wait_for_new_contacts: boolean;
+    paused_at: string | null;
+    resumed_at: string | null;
+    created_at: string | null;
+    updated_at: string | null;
+}
+interface SequenceContactItem {
+    id: string | null;
+    contact_id: number | null;
+    state: string | null;
+    current_step_order: number | null;
+    created_at: string | null;
+    updated_at: string | null;
+}
+interface SequenceContactsParams {
+    page?: number;
+    limit?: number;
+    /** Filter by contact state (e.g. "active", "completed", "replied"). */
+    state?: string;
+}
+interface SequenceActionResult {
+    sequence_id: string;
+    status: string;
+    contacts_affected: number;
+}
+/**
+ * Step type. Note: LinkedIn flows use "HEYREACH" — there is no "LINKEDIN" step type.
+ * Server is case-insensitive on input but stores uppercase.
+ */
+type SequenceStepType = "EMAIL" | "PHONE" | "SMS" | "WHATSAPP" | "HEYREACH" | "MANUAL_DIALER";
+type SequenceStepInputType = "ON_DEMAND" | "MANUAL_TEMPLATE" | "AI_GENERATED_TEMPLATE";
+interface SequenceStepConfig {
+    step_order: number;
+    step_type: SequenceStepType | string;
+    /** Defaults to "ON_DEMAND". */
+    input_type?: SequenceStepInputType | string;
+    /** Wait time before this step in seconds. Defaults to 0. */
+    time_interval?: number;
+    /** Template body, AI prompt, or other step-type-specific config. */
+    step_data?: Record<string, unknown>;
+}
+interface SequenceChannelConfig {
+    channel_id: number;
+    channel_value: string;
+    channel_type: string;
+    channel_data?: Record<string, unknown>;
+}
+interface SequenceCreateParams {
+    name: string;
+    user_email: string;
+    description?: string;
+    finish_on_reply?: boolean;
+    send_in_same_thread?: boolean;
+    wait_for_new_contacts?: boolean;
+    associated_list_id?: number;
+    steps?: SequenceStepConfig[];
+    channels?: SequenceChannelConfig[];
+    campaign_id?: string;
+}
+interface SequenceCreateResult {
+    id: string;
+    name: string;
+    status: string;
+    created_at: string | null;
+}
+interface SequenceUpdateParams {
+    name?: string;
+    description?: string;
+    is_shared?: boolean;
+    finish_on_reply?: boolean;
+    send_in_same_thread?: boolean;
+    wait_for_new_contacts?: boolean;
+    schedule_id?: string;
+    appointment_id?: number;
+}
+interface SequenceStepUpdateParams {
+    step_data?: Record<string, unknown>;
+    time_interval?: number;
+    step_type?: SequenceStepType | string;
+    input_type?: SequenceStepInputType | string;
+}
+interface SequencePreviewStep {
+    id: string;
+    step_order: number;
+    step_type: string;
+    input_type: string;
+    time_interval: number | null;
+    step_data: Record<string, unknown> | null;
+}
+interface SequencePreviewChannel {
+    id: string;
+    channel_id: number | null;
+    channel_value: string | null;
+    channel_type: string | null;
+}
+interface SequencePreview {
+    id: string;
+    name: string | null;
+    status: string | null;
+    description: string | null;
+    steps: SequencePreviewStep[];
+    channels: SequencePreviewChannel[];
+}
+interface SequenceAnalytics {
+    overview: Record<string, unknown>;
+    performance: Record<string, unknown>;
+    engagement: Record<string, unknown>;
+    timeline: Record<string, unknown>[];
+    contact_distribution: Record<string, unknown>;
+    step_breakdown: Record<string, unknown>[];
+    step_creation_methods: Record<string, unknown>[];
+    sender_distribution: Record<string, unknown>[];
+}
+interface PaginationMeta {
+    page: number;
+    limit: number;
+    total: number;
+    has_next: boolean;
+}
 /**
- * Sequences - manage outbound sequences. Requires API key (server-side).
+ * Sequences API — list, create, run, pause, update, analyze multi-channel sequences.
+ * Requires API key (server-side).
+ *
+ * Backed by:
+ *   GET    /api/v1/sequences
+ *   POST   /api/v1/sequences
+ *   GET    /api/v1/sequences/{sequence_id}
+ *   PATCH  /api/v1/sequences/{sequence_id}
+ *   DELETE /api/v1/sequences/{sequence_id}
+ *   GET    /api/v1/sequences/{sequence_id}/contacts
+ *   POST   /api/v1/sequences/{sequence_id}/contacts
+ *   POST   /api/v1/sequences/{sequence_id}/run
+ *   POST   /api/v1/sequences/{sequence_id}/pause
+ *   POST   /api/v1/sequences/{sequence_id}/resume
+ *   PATCH  /api/v1/sequences/{sequence_id}/steps/{step_id}
+ *   GET    /api/v1/sequences/{sequence_id}/preview
+ *   GET    /api/v1/sequences/{sequence_id}/analytics
  */
 declare const createSequencesClient: (apiKey: string, apiUrl?: string) => {
-    list(page?: number, limit?: number): Promise<Sequence[]>;
-    add(config: AddToSequenceConfig): Promise<void>;
+    /** List sequences with pagination + optional status filter. */
+    list: {
+        (): Promise<SequenceListItem[]>;
+        (page: number, limit?: number): Promise<SequenceListItem[]>;
+        (params: SequenceListParams): Promise<SequenceListItem[]>;
+    };
+    /** Get full sequence details by ID. */
+    get(sequenceId: string): Promise<SequenceDetail>;
+    /** List contacts enrolled in a sequence. Filter by state (e.g. "active", "replied"). */
+    contacts(sequenceId: string, params?: SequenceContactsParams): Promise<{
+        data: SequenceContactItem[];
+        pagination?: PaginationMeta;
+    }>;
+    /** Add contacts to a sequence (V2 queuing). Live or drafted sequences only. */
+    add(config: AddToSequenceConfig): Promise<SequenceActionResult>;
+    /** Create a new sequence with optional steps + channels. */
+    create(payload: SequenceCreateParams): Promise<SequenceCreateResult>;
+    /** Update sequence metadata. Rejected (409) if sequence is in a transitional status. */
+    update(sequenceId: string, fields: SequenceUpdateParams): Promise<SequenceActionResult>;
+    /** Update a single step within a sequence. */
+    updateStep(sequenceId: string, stepId: string, fields: SequenceStepUpdateParams): Promise<SequenceActionResult>;
+    /** Soft-delete (archive) a sequence. */
+    delete(sequenceId: string): Promise<SequenceActionResult>;
+    /** Run/start a DRAFTED sequence (V2 orchestration). */
+    run(sequenceId: string): Promise<SequenceActionResult>;
+    /** Pause a live sequence. */
+    pause(sequenceId: string): Promise<SequenceActionResult>;
+    /** Resume a paused sequence. */
+    resume(sequenceId: string): Promise<SequenceActionResult>;
+    /** Read-only sequence preview with all steps + channels (no enrollment). */
+    preview(sequenceId: string): Promise<SequencePreview>;
+    /** Comprehensive analytics for a sequence. */
+    analytics(sequenceId: string): Promise<SequenceAnalytics>;
 };
 
 interface PersonEnrichment {
@@ -1076,6 +2699,14 @@ declare const useG8: () => {
         _tasks: ReturnType<typeof createTasksClient> | null;
         _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;
@@ -1129,8 +2760,26 @@ declare const useG8: () => {
             search(filters: SearchFilter[], page?: number, limit?: number): Promise<SearchResults>;
         };
         get sequences(): {
-            list(page?: number, limit?: number): Promise<Sequence[]>;
-            add(config: AddToSequenceConfig): Promise<void>;
+            list: {
+                (): Promise<SequenceListItem[]>;
+                (page: number, limit?: number): Promise<SequenceListItem[]>;
+                (params: SequenceListParams): Promise<SequenceListItem[]>;
+            };
+            get(sequenceId: string): Promise<SequenceDetail>;
+            contacts(sequenceId: string, params?: SequenceContactsParams): Promise<{
+                data: SequenceContactItem[];
+                pagination?: PaginationMeta;
+            }>;
+            add(config: AddToSequenceConfig): Promise<SequenceActionResult>;
+            create(payload: SequenceCreateParams): Promise<SequenceCreateResult>;
+            update(sequenceId: string, fields: SequenceUpdateParams): Promise<SequenceActionResult>;
+            updateStep(sequenceId: string, stepId: string, fields: SequenceStepUpdateParams): Promise<SequenceActionResult>;
+            delete(sequenceId: string): Promise<SequenceActionResult>;
+            run(sequenceId: string): Promise<SequenceActionResult>;
+            pause(sequenceId: string): Promise<SequenceActionResult>;
+            resume(sequenceId: string): Promise<SequenceActionResult>;
+            preview(sequenceId: string): Promise<SequencePreview>;
+            analytics(sequenceId: string): Promise<SequenceAnalytics>;
         };
         get campaigns(): {
             list(page?: number, limit?: number): Promise<Campaign[]>;
@@ -1164,6 +2813,51 @@ declare const useG8: () => {
             }): Promise<VoiceSession>;
             analysis(sessionId: string): Promise<CallAnalysis>;
             on(event: "error" | "ended" | "connected" | "transcription", callback: (data: Record<string, unknown>) => void): void;
+            dialer: {
+                listSessions(params?: DialerSessionsListParams): Promise<DialerSessionsListResult>;
+                createSession(payload: DialerSessionCreateParams): Promise<DialerSessionCreateResult>;
+                updateSessionStatus(sessionId: string, status: DialerSessionStatus): Promise<DialerSessionStatusUpdateResult>;
+                resumeSession(sessionId: string, maxContacts?: number): Promise<DialerSessionResumeResult>;
+                stats(params?: DialerStatsParams): Promise<DialerStatsResult>;
+                numbers(userEmail?: string): Promise<DialerNumbersListResult>;
+                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(): {
             clone(url: string): Promise<LandingPage>;
@@ -1294,7 +2988,7 @@ declare const useG8: () => {
             }>;
             list(params?: DealListParams): Promise<{
                 data: Deal[];
-                pagination?: PaginationMeta;
+                pagination?: PaginationMeta$1;
             }>;
             create(deal: DealCreateParams): Promise<Deal>;
             get(dealId: string): Promise<Deal>;
@@ -1311,6 +3005,361 @@ declare const useG8: () => {
                 data: ContactDeal[];
             }>;
         };
+        get inbox(): {
+            list(params?: InboxListParams): Promise<{
+                data: InboxThread[];
+            }>;
+            get(replyId: string, channel?: InboxChannel): Promise<InboxThread>;
+            assign(replyId: string, assigneeEmail: string, channel?: InboxChannel): Promise<InboxAssignResult>;
+            tag(replyId: string, tagIds: string[], channel?: InboxChannel): Promise<InboxTagResult>;
+            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;