@graph8/sdk 0.2.0

package/dist/react.d.ts

@@ -0,0 +1,860 @@
+import * as _jitsu_js from '@jitsu/js';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+
+interface ContactList {
+    id: number;
+    title: string;
+    type: "contacts" | "companies";
+    contact_count: number | null;
+    created_at: string | null;
+}
+interface ListContact {
+    id: number;
+    first_name: string | null;
+    last_name: string | null;
+    work_email: string | null;
+    job_title: string | null;
+    company_name: string | null;
+}
+/**
+ * Lists API - manage contact and company lists. Requires API key (server-side).
+ */
+declare const createListsClient: (apiKey: string, apiUrl?: string) => {
+    /** List all lists. */
+    list(page?: number, limit?: number): Promise<{
+        data: ContactList[];
+        total: number;
+    }>;
+    /** Create a new list. */
+    create(title: string, type?: "contacts" | "companies"): Promise<ContactList>;
+    /** Delete a list (soft-delete). */
+    delete(listId: number): Promise<{
+        deleted: boolean;
+    }>;
+    /** Get contacts in a list. */
+    contacts(listId: number, page?: number, limit?: number): Promise<{
+        data: ListContact[];
+        total: number;
+    }>;
+    /** Add contacts to a list. */
+    addContacts(listId: number, contactIds: number[]): Promise<{
+        added: number;
+    }>;
+    /** Remove contacts from a list. */
+    removeContacts(listId: number, contactIds: number[]): Promise<{
+        removed: number;
+    }>;
+};
+
+interface Company {
+    id: number;
+    name: string | null;
+    domain: string | null;
+    industry: string | null;
+    employee_count: number | null;
+    revenue: number | null;
+    founded_year: number | null;
+    description: string | null;
+    linkedin_url: string | null;
+    country: string | null;
+    state: string | null;
+    city: string | null;
+}
+interface CompanyListParams {
+    page?: number;
+    limit?: number;
+    domain?: string;
+    industry?: string;
+    name?: string;
+    country?: string;
+}
+interface CompanyUpdateParams {
+    name?: string;
+    domain?: string;
+    industry?: string;
+    description?: string;
+    linkedin_url?: string;
+    country?: string;
+    state?: string;
+    city?: string;
+}
+interface CompanyContact {
+    id: number;
+    first_name: string | null;
+    last_name: string | null;
+    work_email: string | null;
+    job_title: string | null;
+}
+/**
+ * Companies API - search and manage CRM companies. Requires API key (server-side).
+ */
+declare const createCompaniesClient: (apiKey: string, apiUrl?: string) => {
+    /** List companies with optional filters. */
+    list(params?: CompanyListParams): Promise<{
+        data: Company[];
+        total: number;
+    }>;
+    /** Get a single company by ID. */
+    get(companyId: number): Promise<Company>;
+    /** Get contacts belonging to a company. */
+    contacts(companyId: number, limit?: number, offset?: number): Promise<{
+        data: CompanyContact[];
+        total: number;
+    }>;
+    /** Update a company (partial). */
+    update(companyId: number, fields: CompanyUpdateParams): Promise<{
+        updated: number;
+    }>;
+    /** Delete a company (soft-delete). */
+    delete(companyId: number): Promise<{
+        deleted: boolean;
+    }>;
+};
+
+interface Contact {
+    id: number;
+    first_name: string | null;
+    last_name: string | null;
+    work_email: string | null;
+    job_title: string | null;
+    seniority_level: string | null;
+    company_name: string | null;
+    company_domain: string | null;
+    linkedin_url: string | null;
+    direct_phone: string | null;
+    mobile_phone: string | null;
+    city: string | null;
+    state: string | null;
+    country: string | null;
+}
+interface ContactListParams {
+    page?: number;
+    limit?: number;
+    email?: string;
+    name?: string;
+    job_title?: string;
+    seniority_level?: string;
+    company_name?: string;
+    country?: string;
+    list_id?: number;
+}
+interface ContactCreateParams {
+    work_email: string;
+    first_name?: string;
+    last_name?: string;
+    job_title?: string;
+    company_domain?: string;
+    linkedin_url?: string;
+    direct_phone?: string;
+    mobile_phone?: string;
+    city?: string;
+    state?: string;
+    country?: string;
+    list_id?: number;
+}
+interface ContactUpdateParams {
+    first_name?: string;
+    last_name?: string;
+    work_email?: string;
+    job_title?: string;
+    company_domain?: string;
+    linkedin_url?: string;
+    direct_phone?: string;
+    mobile_phone?: string;
+    city?: string;
+    state?: string;
+    country?: string;
+}
+/**
+ * Contacts API - full CRUD for CRM contacts. Requires API key (server-side).
+ */
+declare const createContactsClient: (apiKey: string, apiUrl?: string) => {
+    /** List contacts with optional filters. */
+    list(params?: ContactListParams): Promise<{
+        data: Contact[];
+        total: number;
+    }>;
+    /** Get a single contact by ID. */
+    get(contactId: number): Promise<Contact>;
+    /** Create a new contact. */
+    create(contact: ContactCreateParams): Promise<Contact>;
+    /** Update a contact (partial). */
+    update(contactId: number, fields: ContactUpdateParams): Promise<{
+        updated: number;
+    }>;
+    /** Delete a contact (soft-delete). */
+    delete(contactId: number): Promise<{
+        deleted: boolean;
+    }>;
+};
+
+type WebhookEvent = "reply_received" | "meeting_booked" | "contact_enriched" | "contact_created" | "sequence_completed" | "sequence_replied" | "campaign_launched" | "form_submitted" | "visitor_identified";
+type WebhookCallback = (data: Record<string, unknown>) => void;
+/**
+ * Webhooks - listen for graph8 events. Requires API key (server-side).
+ *
+ * For client-side real-time events, use g8.visitors.onIntent() or g8.chat.on() instead.
+ */
+declare const createWebhooksClient: (apiKey: string, apiUrl?: string) => {
+    /** Register a listener for a webhook event. Starts polling automatically. */
+    on(event: WebhookEvent, callback: WebhookCallback): void;
+    /** Stop all webhook polling. */
+    stop(): void;
+};
+
+interface LandingPage {
+    id: string;
+    title: string;
+    slug: string;
+    status: string;
+    published_url: string | null;
+}
+/**
+ * Landing pages - clone, create, publish. Requires API key (server-side).
+ */
+declare const createPagesClient: (apiKey: string, apiUrl?: string) => {
+    /** Clone a landing page from any URL. */
+    clone(url: string): Promise<LandingPage>;
+    /** Create a landing page from a template. */
+    create(config: {
+        template?: string;
+        title?: string;
+        content?: Record<string, unknown>;
+    }): Promise<LandingPage>;
+    /** Publish a landing page to CDN. */
+    publish(pageId: string): Promise<{
+        url: string;
+    }>;
+};
+
+interface VoiceSession {
+    id: string;
+    status: string;
+    agent: string;
+    started_at: string;
+}
+interface CallAnalysis {
+    duration_seconds: number;
+    sentiment: "positive" | "neutral" | "negative";
+    summary: string;
+    next_steps: string[];
+    objections: string[];
+    transcript: Array<{
+        speaker: string;
+        text: string;
+        timestamp: number;
+    }>;
+}
+type VoiceEvent = "connected" | "transcription" | "ended" | "error";
+type VoiceCallback = (data: Record<string, unknown>) => void;
+/**
+ * Voice AI - start AI voice calls, get transcriptions and analysis. Requires API key.
+ */
+declare const createVoiceClient: (apiKey: string, apiUrl?: string) => {
+    /** Start an AI voice session. */
+    start(config: {
+        agent?: string;
+        contactId?: number;
+        context?: Record<string, unknown>;
+    }): Promise<VoiceSession>;
+    /** Get call analysis for a completed session. */
+    analysis(sessionId: string): Promise<CallAnalysis>;
+    /** Listen for voice events. */
+    on(event: VoiceEvent, callback: VoiceCallback): void;
+};
+
+interface AnalyticsOverview {
+    visitors: number;
+    contacts_created: number;
+    emails_sent: number;
+    emails_opened: number;
+    replies: number;
+    meetings_booked: number;
+    period: string;
+}
+/**
+ * Analytics - dashboard data and metrics. Requires API key (server-side).
+ */
+declare const createAnalyticsClient: (apiKey: string, apiUrl?: string) => {
+    overview(config?: {
+        period?: string;
+        metrics?: string[];
+    }): Promise<AnalyticsOverview>;
+};
+
+interface IntentSignals {
+    domain: string;
+    score: number;
+    intent: "low" | "medium" | "high";
+    signals: string[];
+    last_seen: string | null;
+}
+/**
+ * Intent signals - company-level buying signals. Write key for public, API key for full access.
+ */
+declare const createSignalsClient: (key: string, isApiKey: boolean, apiUrl?: string) => {
+    /** Get intent signals for a specific company domain. */
+    company(domain: string): Promise<IntentSignals>;
+    /** Stream intent signals - calls callback every 30s with latest data. */
+    stream(domains: string[], callback: (signals: IntentSignals[]) => void): () => void;
+};
+
+interface Integration {
+    id: string;
+    provider: string;
+    status: string;
+    connected_at: string | null;
+}
+/**
+ * Integrations - connect CRM platforms, trigger syncs. Requires API key (server-side).
+ */
+declare const createIntegrationsClient: (apiKey: string, apiUrl?: string) => {
+    list(): Promise<Integration[]>;
+    connect(provider: string, config?: Record<string, unknown>): Promise<void>;
+    sync(provider: string, config?: {
+        direction?: "inbound" | "outbound" | "bidirectional";
+    }): Promise<void>;
+};
+
+interface Campaign {
+    id: string;
+    name: string;
+    slug: string;
+    status: string;
+    category: string | null;
+    goal: string | null;
+    target_persona: string | null;
+}
+interface CampaignCreateConfig {
+    name: string;
+    category?: string;
+    brief?: string;
+    core_concept?: string;
+    primary_hook?: string;
+    target_persona?: string;
+    goal?: string;
+}
+interface CampaignStats {
+    sent: number;
+    opened: number;
+    replied: number;
+    meetings: number;
+}
+/**
+ * Campaigns - create, manage, launch campaigns. Requires API key (server-side).
+ */
+declare const createCampaignsClient: (apiKey: string, apiUrl?: string) => {
+    list(page?: number, limit?: number): Promise<Campaign[]>;
+    get(campaignId: string): Promise<Campaign>;
+    create(config: CampaignCreateConfig): Promise<Campaign>;
+    launch(campaignId: string): Promise<void>;
+    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;
+}
+/**
+ * Sequences - manage outbound sequences. Requires API key (server-side).
+ */
+declare const createSequencesClient: (apiKey: string, apiUrl?: string) => {
+    list(page?: number, limit?: number): Promise<Sequence[]>;
+    add(config: AddToSequenceConfig): Promise<void>;
+};
+
+interface PersonEnrichment {
+    found: boolean;
+    confidence: number;
+    data: Record<string, unknown>;
+}
+interface CompanyEnrichment {
+    found: boolean;
+    confidence: number;
+    data: Record<string, unknown>;
+}
+interface EmailVerification {
+    email: string;
+    valid: boolean;
+    deliverable: boolean;
+    catch_all: boolean;
+}
+interface SearchFilter {
+    field: string;
+    operator: "any_of" | "contains" | "all_of" | "none_of" | "is_empty" | "is_not_empty" | "between" | "exists";
+    value: unknown;
+}
+interface SearchResults {
+    contacts: Record<string, unknown>[];
+    total: number;
+    page: number;
+}
+/**
+ * Enrichment API - person/company lookup, email verification, prospecting search.
+ *
+ * Requires API key (server-side only). Credits charged per call.
+ */
+declare const createEnrichClient: (apiKey: string, apiUrl?: string) => {
+    /** Look up a person by email, LinkedIn, or name + company. Costs 1 credit. */
+    person(params: {
+        email?: string;
+        linkedin_url?: string;
+        first_name?: string;
+        last_name?: string;
+        company_domain?: string;
+    }): Promise<PersonEnrichment>;
+    /** Look up a company by domain or name. Costs 1 credit. */
+    company(params: {
+        domain?: string;
+        name?: string;
+    }): Promise<CompanyEnrichment>;
+    /** Verify an email address. Costs 1 credit. */
+    verifyEmail(email: string): Promise<EmailVerification>;
+    /** Search 300M+ contacts with filters. Credits charged per result. */
+    search(filters: SearchFilter[], page?: number, limit?: number): Promise<SearchResults>;
+};
+
+interface CalendarConfig {
+    /** Event type slug (e.g. "demo-30min") */
+    eventType: string;
+    /** Username of the host */
+    username: string;
+    /** Pre-fill attendee info */
+    prefill?: {
+        name?: string;
+        email?: string;
+        notes?: string;
+    };
+}
+interface TimeSlot {
+    start: string;
+    end: string;
+    available: boolean;
+}
+interface Booking {
+    uid: string;
+    confirmation_url: string;
+    start_time: string;
+    end_time: string;
+}
+interface BookingRequest {
+    event_type_id: number;
+    slot: string;
+    attendee: {
+        name: string;
+        email: string;
+        notes?: string;
+    };
+}
+type CalendarEvent = "booked" | "cancelled" | "slot_selected";
+type CalendarCallback = (data: Record<string, unknown>) => void;
+/**
+ * Calendar and booking - show scheduling widgets, get slots, book meetings.
+ *
+ * Public endpoints - no API key needed.
+ */
+declare const createCalendarClient: (apiUrl?: string) => {
+    /** Show a booking modal overlay. */
+    show(config: CalendarConfig): void;
+    /** Embed booking widget inline in a container element. */
+    embed(selector: string, config: CalendarConfig): void;
+    /** Get available time slots for an event type. */
+    slots(username: string, eventSlug: string, range: {
+        start: string;
+        end: string;
+    }): Promise<TimeSlot[]>;
+    /** Book a meeting programmatically. */
+    book(request: BookingRequest): Promise<Booking | null>;
+    /** Listen for calendar events. */
+    on(event: CalendarEvent, callback: CalendarCallback): void;
+};
+
+interface ChatConfig {
+    /** Agent ID to connect to */
+    agentId?: string;
+    /** Pre-filled first message */
+    message?: string;
+    /** Widget position */
+    position?: "bottom-right" | "bottom-left";
+    /** Widget theme */
+    theme?: "light" | "dark" | "auto";
+    /** Custom greeting */
+    greeting?: string;
+    /** Custom avatar URL */
+    avatar?: string;
+}
+type ChatEvent = "message" | "human_transfer" | "open" | "close" | "error";
+type ChatCallback = (data: Record<string, unknown>) => void;
+/**
+ * Webchat - live chat + AI chat embedded in any app.
+ *
+ * Uses WebSocket connection to the voice/chat agent backend.
+ * Public - no API key needed (org/agent IDs are in the config).
+ */
+declare const createChatClient: (writeKey: string, apiUrl?: string) => {
+    /** Open the chat widget. */
+    open(config?: ChatConfig): void;
+    /** Send a message. */
+    send(message: string): void;
+    /** Listen for chat events. */
+    on(event: ChatEvent, callback: ChatCallback): void;
+    /** Configure the chat appearance. */
+    configure(config: Partial<ChatConfig>): void;
+    /** Close the chat widget. */
+    close(): void;
+};
+
+interface CopilotConfig {
+    /** Initial greeting message */
+    greeting?: string;
+    /** Context passed to the AI */
+    context?: Record<string, unknown>;
+    /** Widget position */
+    position?: "bottom-right" | "bottom-left";
+    /** Widget theme */
+    theme?: "light" | "dark" | "auto";
+}
+type CopilotEvent = "message" | "tool_used" | "open" | "close" | "error";
+type CopilotCallback = (data: Record<string, unknown>) => void;
+type ActionHandler = (params: Record<string, unknown>) => void | Promise<void>;
+/**
+ * Copilot - embeddable AI assistant with org knowledge base access.
+ *
+ * Client-side (write key) for the widget embed.
+ */
+declare const createCopilotClient: (writeKey: string, apiUrl?: string) => {
+    /** Open the copilot widget. */
+    open(config?: CopilotConfig): void;
+    /** Send a message to the copilot programmatically. */
+    ask(message: string): Promise<string>;
+    /** Register a custom action the copilot can trigger. */
+    registerAction(name: string, handler: ActionHandler): void;
+    /** Listen for copilot events. */
+    on(event: CopilotEvent, callback: CopilotCallback): void;
+    /** Close the copilot widget. */
+    close(): void;
+};
+
+interface VisitorCompany {
+    company_name: string | null;
+    company_domain: string | null;
+    industry: string | null;
+    employee_count: string | null;
+    city: string | null;
+    country: string | null;
+    confidence: number;
+}
+interface VisitorScore {
+    engagement: number;
+    intent: "low" | "medium" | "high";
+    signals: string[];
+}
+type IntentCallback = (visitor: VisitorCompany & VisitorScore) => void;
+/**
+ * Visitor intelligence - identify anonymous visitors by IP → company.
+ *
+ * Requires write key auth. Works client-side only.
+ */
+declare const createVisitorsClient: (writeKey: string, apiUrl?: string) => {
+    /** Identify the current visitor's company from their IP address. */
+    identify(): Promise<VisitorCompany>;
+    /** Get engagement score for the current visitor. */
+    score(): Promise<VisitorScore>;
+    /** Listen for visitors matching an intent level. Polls every 30 seconds. */
+    onIntent(level: "low" | "medium" | "high", callback: IntentCallback): () => void;
+};
+
+/** Configuration for g8.init() */
+interface G8Config {
+    /** Write key for client-side tracking (from Settings > MCP & API) */
+    writeKey?: string;
+    /** API key for server-side operations (from Settings > MCP & API > API tab) */
+    apiKey?: string;
+    /** Tracking host URL (default: https://t.graph8.com) */
+    host?: string;
+    /** Backend API URL (default: https://be.graph8.com) */
+    apiUrl?: string;
+    /** Privacy controls */
+    privacy?: G8PrivacyConfig;
+    /** Enable debug logging (default: false) */
+    debug?: boolean;
+}
+interface G8PrivacyConfig {
+    /** Disable all cookies and event sending */
+    dontSend?: boolean;
+    /** Disable storing user identifiers */
+    dontStoreUserIds?: boolean;
+    /** IP address handling policy */
+    ipPolicy?: "keep" | "stripLastOctet" | "remove";
+}
+/** Properties for g8.track() events */
+interface TrackProperties {
+    [key: string]: string | number | boolean | null | undefined;
+}
+/** Properties for g8.identify() calls */
+interface IdentifyProperties {
+    email?: string;
+    name?: string;
+    first_name?: string;
+    last_name?: string;
+    company?: string;
+    company_domain?: string;
+    job_title?: string;
+    phone?: string;
+    [key: string]: string | number | boolean | null | undefined;
+}
+/** Result from g8.forms.lookup() */
+interface EnrichLookupResult {
+    found: boolean;
+    known_fields: Record<string, string>;
+    missing_fields: string[];
+}
+
+/**
+ * Progressive form enrichment - checks what fields graph8 already knows
+ * about a contact so your form can skip those fields.
+ *
+ * Calls POST /api/v1/public/enrich/lookup (authenticated via write key).
+ */
+declare const createFormsClient: (writeKey: string, apiUrl?: string) => {
+    /**
+     * Look up known fields for an email address.
+     *
+     * Use this in progressive forms: after the user enters their email,
+     * check what graph8 already knows and only show missing fields.
+     */
+    lookup(email: string): Promise<EnrichLookupResult>;
+};
+
+interface G8ProviderProps {
+    /** Your graph8 write key */
+    writeKey: string;
+    /** Tracking host (default: https://t.graph8.com) */
+    host?: string;
+    /** Additional config options */
+    config?: Partial<Omit<G8Config, "writeKey" | "host">>;
+    children: ReactNode;
+}
+/**
+ * graph8 React provider. Initializes the SDK once and provides it to all children.
+ *
+ * Usage:
+ *   import { G8Provider } from '@graph8/js/react';
+ *
+ *   <G8Provider writeKey="your_write_key">
+ *     <App />
+ *   </G8Provider>
+ */
+declare const G8Provider: ({ writeKey, host, config, children, }: G8ProviderProps) => react_jsx_runtime.JSX.Element;
+/**
+ * Hook to access the graph8 SDK from any component.
+ *
+ * Usage:
+ *   const { track, identify, page, forms } = useG8();
+ *   track('button_click', { button: 'cta' });
+ */
+declare const useG8: () => {
+    /** Track a custom event */
+    track: (event: string, properties?: TrackProperties) => void;
+    /** Identify a user */
+    identify: (userId: string, properties?: IdentifyProperties) => void;
+    /** Track a page view */
+    page: (properties?: TrackProperties) => void;
+    /** Clear user identity */
+    reset: () => void;
+    /** Progressive form helpers */
+    forms: {
+        lookup(email: string): Promise<EnrichLookupResult>;
+    };
+    /** Raw g8 client instance */
+    g8: {
+        client: _jitsu_js.AnalyticsInterface | null;
+        config: G8Config | null;
+        _forms: ReturnType<typeof createFormsClient> | null;
+        _visitors: ReturnType<typeof createVisitorsClient> | null;
+        _copilot: ReturnType<typeof createCopilotClient> | null;
+        _chat: ReturnType<typeof createChatClient> | null;
+        _calendar: ReturnType<typeof createCalendarClient> | null;
+        _enrich: ReturnType<typeof createEnrichClient> | null;
+        _sequences: ReturnType<typeof createSequencesClient> | null;
+        _campaigns: ReturnType<typeof createCampaignsClient> | null;
+        _integrations: ReturnType<typeof createIntegrationsClient> | null;
+        _signals: ReturnType<typeof createSignalsClient> | null;
+        _analytics: ReturnType<typeof createAnalyticsClient> | null;
+        _voice: ReturnType<typeof createVoiceClient> | null;
+        _pages: ReturnType<typeof createPagesClient> | null;
+        _webhooks: ReturnType<typeof createWebhooksClient> | null;
+        _contacts: ReturnType<typeof createContactsClient> | null;
+        _companies: ReturnType<typeof createCompaniesClient> | null;
+        _lists: ReturnType<typeof createListsClient> | null;
+        init(config: G8Config): void;
+        track(event: string, properties?: TrackProperties): void;
+        identify(userId: string, properties?: IdentifyProperties): void;
+        page(properties?: TrackProperties): void;
+        reset(): void;
+        get forms(): {
+            lookup(email: string): Promise<EnrichLookupResult>;
+        };
+        get visitors(): {
+            identify(): Promise<VisitorCompany>;
+            score(): Promise<VisitorScore>;
+            onIntent(level: "low" | "medium" | "high", callback: (visitor: VisitorCompany & VisitorScore) => void): () => void;
+        };
+        get copilot(): {
+            open(config?: CopilotConfig): void;
+            ask(message: string): Promise<string>;
+            registerAction(name: string, handler: (params: Record<string, unknown>) => void | Promise<void>): void;
+            on(event: "message" | "tool_used" | "open" | "close" | "error", callback: (data: Record<string, unknown>) => void): void;
+            close(): void;
+        };
+        get chat(): {
+            open(config?: ChatConfig): void;
+            send(message: string): void;
+            on(event: "message" | "open" | "close" | "error" | "human_transfer", callback: (data: Record<string, unknown>) => void): void;
+            configure(config: Partial<ChatConfig>): void;
+            close(): void;
+        };
+        get calendar(): {
+            show(config: CalendarConfig): void;
+            embed(selector: string, config: CalendarConfig): void;
+            slots(username: string, eventSlug: string, range: {
+                start: string;
+                end: string;
+            }): Promise<TimeSlot[]>;
+            book(request: BookingRequest): Promise<Booking | null>;
+            on(event: "booked" | "cancelled" | "slot_selected", callback: (data: Record<string, unknown>) => void): void;
+        };
+        get enrich(): {
+            person(params: {
+                email?: string;
+                linkedin_url?: string;
+                first_name?: string;
+                last_name?: string;
+                company_domain?: string;
+            }): Promise<PersonEnrichment>;
+            company(params: {
+                domain?: string;
+                name?: string;
+            }): Promise<CompanyEnrichment>;
+            verifyEmail(email: string): Promise<EmailVerification>;
+            search(filters: SearchFilter[], page?: number, limit?: number): Promise<SearchResults>;
+        };
+        get sequences(): {
+            list(page?: number, limit?: number): Promise<Sequence[]>;
+            add(config: AddToSequenceConfig): Promise<void>;
+        };
+        get campaigns(): {
+            list(page?: number, limit?: number): Promise<Campaign[]>;
+            get(campaignId: string): Promise<Campaign>;
+            create(config: CampaignCreateConfig): Promise<Campaign>;
+            launch(campaignId: string): Promise<void>;
+            stats(campaignId: string): Promise<CampaignStats>;
+        };
+        get integrations(): {
+            list(): Promise<Integration[]>;
+            connect(provider: string, config?: Record<string, unknown>): Promise<void>;
+            sync(provider: string, config?: {
+                direction?: "inbound" | "outbound" | "bidirectional";
+            }): Promise<void>;
+        };
+        get signals(): {
+            company(domain: string): Promise<IntentSignals>;
+            stream(domains: string[], callback: (signals: IntentSignals[]) => void): () => void;
+        };
+        get analytics(): {
+            overview(config?: {
+                period?: string;
+                metrics?: string[];
+            }): Promise<AnalyticsOverview>;
+        };
+        get voice(): {
+            start(config: {
+                agent?: string;
+                contactId?: number;
+                context?: Record<string, unknown>;
+            }): Promise<VoiceSession>;
+            analysis(sessionId: string): Promise<CallAnalysis>;
+            on(event: "error" | "ended" | "connected" | "transcription", callback: (data: Record<string, unknown>) => void): void;
+        };
+        get pages(): {
+            clone(url: string): Promise<LandingPage>;
+            create(config: {
+                template?: string;
+                title?: string;
+                content?: Record<string, unknown>;
+            }): Promise<LandingPage>;
+            publish(pageId: string): Promise<{
+                url: string;
+            }>;
+        };
+        get webhooks(): {
+            on(event: WebhookEvent, callback: (data: Record<string, unknown>) => void): void;
+            stop(): void;
+        };
+        get contacts(): {
+            list(params?: ContactListParams): Promise<{
+                data: Contact[];
+                total: number;
+            }>;
+            get(contactId: number): Promise<Contact>;
+            create(contact: ContactCreateParams): Promise<Contact>;
+            update(contactId: number, fields: ContactUpdateParams): Promise<{
+                updated: number;
+            }>;
+            delete(contactId: number): Promise<{
+                deleted: boolean;
+            }>;
+        };
+        get companies(): {
+            list(params?: CompanyListParams): Promise<{
+                data: Company[];
+                total: number;
+            }>;
+            get(companyId: number): Promise<Company>;
+            contacts(companyId: number, limit?: number, offset?: number): Promise<{
+                data: CompanyContact[];
+                total: number;
+            }>;
+            update(companyId: number, fields: CompanyUpdateParams): Promise<{
+                updated: number;
+            }>;
+            delete(companyId: number): Promise<{
+                deleted: boolean;
+            }>;
+        };
+        get lists(): {
+            list(page?: number, limit?: number): Promise<{
+                data: ContactList[];
+                total: number;
+            }>;
+            create(title: string, type?: "contacts" | "companies"): Promise<ContactList>;
+            delete(listId: number): Promise<{
+                deleted: boolean;
+            }>;
+            contacts(listId: number, page?: number, limit?: number): Promise<{
+                data: ListContact[];
+                total: number;
+            }>;
+            addContacts(listId: number, contactIds: number[]): Promise<{
+                added: number;
+            }>;
+            removeContacts(listId: number, contactIds: number[]): Promise<{
+                removed: number;
+            }>;
+        };
+        get initialized(): boolean;
+        _assertInit(): void;
+        _assertKey(module: string): void;
+    };
+};
+
+export { G8Provider, useG8 };