@graph8/sdk 0.251.0 → 0.262.0

package/dist/types/core.d.ts

@@ -0,0 +1,1052 @@
+import type { AnalyticsInterface } from "@jitsu/js";
+import type { G8Config, TrackProperties, IdentifyProperties } from "./types";
+import { createFormsClient } from "./forms";
+import { createVisitorsClient } from "./visitors";
+import { createCopilotClient } from "./copilot";
+import { createChatClient } from "./chat";
+import { createCalendarClient } from "./calendar";
+import { createEnrichClient } from "./enrich";
+import { createSequencesClient } from "./sequences";
+import { createCampaignsClient } from "./campaigns";
+import { createSignalsClient } from "./signals";
+import { createVoiceClient } from "./voice";
+import { createWebhooksClient } from "./webhooks";
+import { createContactsClient } from "./contacts";
+import { createCompaniesClient } from "./companies";
+import { createListsClient } from "./lists";
+import { createNotesClient } from "./notes";
+import { createMailboxesClient } from "./mailboxes";
+import { createApiClient } from "./api";
+import { createNewsletterClient } from "./newsletter";
+import { createTasksClient } from "./tasks";
+import { createAppsClient } from "./apps";
+import { createAppPlatformClient } from "./appPlatform";
+import { createFieldsClient } from "./fields";
+import { createObjectsClient } from "./objects";
+import { createDealsClient } from "./deals";
+import { createInboxClient } from "./inbox";
+import { createQuotesClient } from "./quotes";
+import { createPipelinesClient } from "./pipelines";
+import { createWorkflowsClient } from "./workflows";
+import { createSkillsClient } from "./skills";
+import { createIntentClient } from "./intent";
+import { createStudioClient } from "./studio";
+import { createMeetingsClient } from "./meetings";
+import { createAudiencesClient } from "./audiences";
+import { createSearchClient } from "./search";
+import { createAgencyClient } from "./agency";
+import { createMarketplaceClient } from "./marketplace";
+import { createSnippetClient } from "./snippet";
+/**
+ * graph8 SDK client.
+ *
+ * Handles event tracking, identity, and progressive forms.
+ *
+ * Usage:
+ *   import { g8 } from '@graph8/sdk';
+ *   g8.init({ writeKey: 'your_write_key' });
+ *   g8.track('page_view', { page: '/pricing' });
+ *   g8.identify('user@acme.com', { name: 'John', company: 'Acme' });
+ */
+declare class G8 {
+    /** @internal */ client: AnalyticsInterface | null;
+    /** @internal */ config: G8Config | null;
+    /** @internal */ _forms: ReturnType<typeof createFormsClient> | null;
+    /** @internal */ _visitors: ReturnType<typeof createVisitorsClient> | null;
+    /** @internal */ _copilot: ReturnType<typeof createCopilotClient> | null;
+    /** @internal */ _chat: ReturnType<typeof createChatClient> | null;
+    /** @internal */ _calendar: ReturnType<typeof createCalendarClient> | null;
+    /** @internal */ _enrich: ReturnType<typeof createEnrichClient> | null;
+    /** @internal */ _sequences: ReturnType<typeof createSequencesClient> | null;
+    /** @internal */ _campaigns: ReturnType<typeof createCampaignsClient> | null;
+    /** @internal */ _signals: ReturnType<typeof createSignalsClient> | null;
+    /** @internal */ _voice: ReturnType<typeof createVoiceClient> | null;
+    /** @internal */ _webhooks: ReturnType<typeof createWebhooksClient> | null;
+    /** @internal */ _contacts: ReturnType<typeof createContactsClient> | null;
+    /** @internal */ _companies: ReturnType<typeof createCompaniesClient> | null;
+    /** @internal */ _lists: ReturnType<typeof createListsClient> | null;
+    /** @internal */ _notes: ReturnType<typeof createNotesClient> | null;
+    /** @internal */ _mailboxes: ReturnType<typeof createMailboxesClient> | null;
+    /** @internal */ _api: ReturnType<typeof createApiClient> | null;
+    /** @internal */ _newsletter: ReturnType<typeof createNewsletterClient> | null;
+    /** @internal */ _tasks: ReturnType<typeof createTasksClient> | null;
+    /** @internal */ _fields: ReturnType<typeof createFieldsClient> | null;
+    /** @internal */ _apps: ReturnType<typeof createAppsClient> | null;
+    /** @internal */ _appPlatform: ReturnType<typeof createAppPlatformClient> | null;
+    /** @internal */ _objects: ReturnType<typeof createObjectsClient> | null;
+    /** @internal */ _deals: ReturnType<typeof createDealsClient> | null;
+    /** @internal */ _inbox: ReturnType<typeof createInboxClient> | null;
+    /** @internal */ _quotes: ReturnType<typeof createQuotesClient> | null;
+    /** @internal */ _pipelines: ReturnType<typeof createPipelinesClient> | null;
+    /** @internal */ _workflows: ReturnType<typeof createWorkflowsClient> | null;
+    /** @internal */ _skills: ReturnType<typeof createSkillsClient> | null;
+    /** @internal */ _intent: ReturnType<typeof createIntentClient> | null;
+    /** @internal */ _studio: ReturnType<typeof createStudioClient> | null;
+    /** @internal */ _meetings: ReturnType<typeof createMeetingsClient> | null;
+    /** @internal */ _audiences: ReturnType<typeof createAudiencesClient> | null;
+    /** @internal */ _search: ReturnType<typeof createSearchClient> | null;
+    /** @internal */ _agency: ReturnType<typeof createAgencyClient> | null;
+    /** @internal */ _marketplace: ReturnType<typeof createMarketplaceClient> | null;
+    /** @internal */ _snippet: ReturnType<typeof createSnippetClient> | null;
+    /**
+     * Initialize the graph8 SDK. Must be called before any other method.
+     * Safe to call on the server (SSR) - becomes a no-op for tracking.
+     */
+    init(config: G8Config): void;
+    /** Track a custom event. */
+    track(event: string, properties?: TrackProperties): void;
+    /** Identify a user with properties. */
+    identify(userId: string, properties?: IdentifyProperties): void;
+    /** Track a page view. */
+    page(properties?: TrackProperties): void;
+    /** Clear user identity (on logout). */
+    reset(): void;
+    /** Progressive form helpers. */
+    get forms(): {
+        lookup(email: string): Promise<import("./types").EnrichLookupResult>;
+    };
+    /** Visitor intelligence - IP to company, engagement scoring. */
+    get visitors(): {
+        identify(): Promise<import("./visitors").VisitorCompany>;
+        score(): Promise<import("./visitors").VisitorScore>;
+        onIntent(level: "low" | "medium" | "high", callback: (visitor: import("./visitors").VisitorCompany & import("./visitors").VisitorScore) => void): () => void;
+    };
+    /** AI copilot widget. */
+    get copilot(): {
+        open(config?: import("./copilot").CopilotConfig): void;
+        ask(message: string): Promise<string>;
+        registerAction(name: string, handler: (params: Record<string, unknown>) => void | Promise<void>): void;
+        on(event: "message" | "error" | "open" | "close" | "tool_used", callback: (data: Record<string, unknown>) => void): void;
+        close(): void;
+    };
+    /** Webchat widget. */
+    get chat(): {
+        open(config?: import("./chat").ChatConfig): void;
+        send(message: string): void;
+        on(event: "message" | "error" | "open" | "close" | "human_transfer", callback: (data: Record<string, unknown>) => void): void;
+        configure(config: Partial<import("./chat").ChatConfig>): void;
+        close(): void;
+    };
+    /** Calendar and booking. */
+    get calendar(): {
+        show(config: import("./calendar").CalendarConfig): void;
+        embed(selector: string, config: import("./calendar").CalendarConfig): void;
+        slots(username: string, eventSlug: string, range: {
+            start: string;
+            end: string;
+        }): Promise<import("./calendar").TimeSlot[]>;
+        book(request: import("./calendar").BookingRequest): Promise<import("./calendar").Booking | null>;
+        on(event: "booked" | "cancelled" | "slot_selected", callback: (data: Record<string, unknown>) => void): void;
+    };
+    /** Enrichment API (requires API key). */
+    get enrich(): {
+        person(params: {
+            email?: string;
+            linkedin_url?: string;
+            first_name?: string;
+            last_name?: string;
+            company_domain?: string;
+        }): Promise<import("./enrich").PersonEnrichment>;
+        company(params: {
+            domain?: string;
+            name?: string;
+        }): Promise<import("./enrich").CompanyEnrichment>;
+        verifyEmail(email: string): Promise<import("./enrich").EmailVerification>;
+        search(filters: import("./enrich").SearchFilter[], page?: number, limit?: number): Promise<import("./enrich").SearchResults>;
+    };
+    /** Sequences (requires API key). */
+    get sequences(): {
+        list: {
+            (): Promise<import("./sequences").SequenceListItem[]>;
+            (page: number, limit?: number): Promise<import("./sequences").SequenceListItem[]>;
+            (params: import("./sequences").SequenceListParams): Promise<import("./sequences").SequenceListItem[]>;
+        };
+        get(sequenceId: string): Promise<import("./sequences").SequenceDetail>;
+        contacts(sequenceId: string, params?: import("./sequences").SequenceContactsParams): Promise<{
+            data: import("./sequences").SequenceContactItem[];
+            pagination?: import("./sequences").PaginationMeta;
+        }>;
+        add(config: import("./sequences").AddToSequenceConfig, idempotencyKey?: string): Promise<import("./sequences").SequenceActionResult>;
+        create(payload: import("./sequences").SequenceCreateParams, idempotencyKey?: string): Promise<import("./sequences").SequenceCreateResult>;
+        update(sequenceId: string, fields: import("./sequences").SequenceUpdateParams): Promise<import("./sequences").SequenceActionResult>;
+        updateStep(sequenceId: string, stepId: string, fields: import("./sequences").SequenceStepUpdateParams): Promise<import("./sequences").SequenceActionResult>;
+        delete(sequenceId: string): Promise<import("./sequences").SequenceActionResult>;
+        run(sequenceId: string, idempotencyKey?: string): Promise<import("./sequences").SequenceActionResult>;
+        pause(sequenceId: string, idempotencyKey?: string): Promise<import("./sequences").SequenceActionResult>;
+        resume(sequenceId: string, idempotencyKey?: string): Promise<import("./sequences").SequenceActionResult>;
+        preview(sequenceId: string): Promise<import("./sequences").SequencePreview>;
+        analytics(sequenceId: string): Promise<import("./sequences").SequenceAnalytics>;
+    };
+    /** Campaigns (requires API key). */
+    get campaigns(): {
+        list(page?: number, limit?: number): Promise<import("./campaigns").Campaign[]>;
+        get(campaignId: string): Promise<import("./campaigns").Campaign>;
+        create(config: import("./campaigns").CampaignCreateConfig): Promise<import("./campaigns").Campaign>;
+        launch(campaignId: string): Promise<import("./campaigns").CampaignLaunchResult>;
+    };
+    /** Intent signals. */
+    get signals(): {
+        company(domain: string): Promise<import("./signals").IntentSignals>;
+        stream(domains: string[], callback: (signals: import("./signals").IntentSignals[]) => void): () => void;
+    };
+    /** Voice AI (requires API key). */
+    get voice(): {
+        on(event: "error" | "connected" | "ended" | "transcription", callback: (data: Record<string, unknown>) => void): void;
+        dialer: {
+            listSessions(params?: import("./voice").DialerSessionsListParams): Promise<import("./voice").DialerSessionsListResult>;
+            createSession(payload: import("./voice").DialerSessionCreateParams): Promise<import("./voice").DialerSessionCreateResult>;
+            updateSessionStatus(sessionId: string, status: import("./voice").DialerSessionStatus): Promise<import("./voice").DialerSessionStatusUpdateResult>;
+            resumeSession(sessionId: string, maxContacts?: number): Promise<import("./voice").DialerSessionResumeResult>;
+            stats(params?: import("./voice").DialerStatsParams): Promise<import("./voice").DialerStatsResult>;
+            numbers(userEmail?: string): Promise<import("./voice").DialerNumbersListResult>;
+            missedCallbacks(limit?: number): Promise<import("./voice").MissedCallbacksResult>;
+            callGrading(roomName: string): Promise<import("./voice").CallGradingResult>;
+            agents(params?: import("./voice").DialerAgentsListParams): Promise<import("./voice").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?: import("./voice").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>>;
+            }>;
+        };
+    };
+    /** Webhook event listeners (requires API key). */
+    get webhooks(): {
+        baseUrl: string;
+        knownEvents: readonly ["campaign.created", "campaign.updated", "campaign.deleted", "campaign.launched", "campaign.paused", "campaign.completed", "campaign.status_changed", "campaign.content_ready", "document.generated", "document.failed", "intelligence.completed", "intelligence.failed", "company.enriched", "company_intelligence.completed", "audience.ready", "audience.failed", "sequence.draft_created", "sequence.started", "sequence.paused", "sequence.completed", "engagement.email_sent", "engagement.email_replied", "engagement.email_bounced", "engagement.email_skipped", "engagement.call_dispatched", "engagement.call_connected", "engagement.call_graded", "engagement.sms_sent", "engagement.sms_replied", "engagement.whatsapp_sent", "engagement.linkedin_connection_sent", "engagement.linkedin_message_sent", "engagement.linkedin_inmail_sent", "engagement.linkedin_reply_received", "engagement.linkedin_connection_accepted", "meeting.booked", "meeting.cancelled", "meeting.rescheduled", "deal.won", "crm.record.created", "crm.record.updated", "crm.record.archived", "crm.record.restored", "sequence.contact_enrolled", "sequence.contact_removed", "sequence.step_completed", "sequence.step_failed", "engagement.contact_unsubscribed", "engagement.sms_delivered", "engagement.sms_failed", "engagement.whatsapp_delivered", "engagement.whatsapp_failed", "engagement.call_started", "engagement.call_completed", "engagement.call_disposition_set", "engagement.voicemail_detected", "engagement.voicemail_left", "engagement.email_clicked", "engagement.link_clicked", "engagement.call_recording_ready", "meeting.no_show", "voice_ai.call_started", "voice_ai.call_completed", "voice_ai.voicemail_left", "deal.created", "deal.updated", "deal.stage_changed", "deal.deleted", "quote.created", "quote.updated", "quote.sent", "quote.resent", "quote.resend_failed", "quote.link_generated", "quote.viewed", "quote.accepted", "quote.declined", "quote.expired", "quote.voided", "quote.superseded", "quote.archived", "quote.unarchived", "quote.payment_received", "quote.payment_failed", "quote.subscription_canceled", "quote.provisioned", "form.submitted", "visitor.identified", "intent.signal", "task.created", "task.updated", "task.completed", "task.deleted", "enrichment.job_completed", "enrichment.job_failed", "workflow.execution_completed", "workflow.execution_failed"];
+        constructEvent(payload: string, signature: string, timestamp: string | number, secret: string, opts?: import("./webhooks").ConstructEventOptions): import("./webhooks").WebhookEventPayload;
+    };
+    /** Contacts CRUD (requires API key). */
+    get contacts(): {
+        list(params?: import("./contacts").ContactListParams): Promise<{
+            data: import("./contacts").Contact[];
+            total: number;
+        }>;
+        getMany: (contactIds: number[], options?: {
+            includeCustomFields?: boolean;
+        }) => Promise<import("./contacts").ContactBulkGetItem[]>;
+        listDetailed(params?: import("./contacts").ContactListParams, options?: {
+            includeCustomFields?: boolean;
+        }): Promise<{
+            data: import("./contacts").ContactDetail[];
+            total: number;
+            missing: number[];
+        }>;
+        get(contactId: number): Promise<import("./contacts").Contact>;
+        create(contact: import("./contacts").ContactCreateParams, idempotencyKey?: string): Promise<import("./contacts").Contact>;
+        upsert(contact: import("./contacts").ContactUpsertParams): Promise<import("./contacts").ContactUpsertResult>;
+        update(contactId: number, fields: import("./contacts").ContactUpdateParams): Promise<{
+            updated: number;
+        }>;
+        delete(contactId: number): Promise<{
+            deleted: boolean;
+        }>;
+        listColumns(listId?: number): Promise<{
+            data: import("./contacts").ContactColumn[];
+        }>;
+        createColumn(params: import("./contacts").ContactColumnCreateParams): Promise<import("./contacts").ContactColumn>;
+    };
+    /** Companies CRUD (requires API key). */
+    get companies(): {
+        create(params: import("./companies").CompanyCreateParams): Promise<import("./companies").CompanyCreateResult>;
+        list(params?: import("./companies").CompanyListParams): Promise<{
+            data: import("./companies").Company[];
+            total: number;
+        }>;
+        get(companyId: number): Promise<import("./companies").Company>;
+        contacts(companyId: number, limit?: number, offset?: number): Promise<{
+            data: import("./companies").CompanyContact[];
+            total: number;
+        }>;
+        update(companyId: number, fields: import("./companies").CompanyUpdateParams): Promise<{
+            updated: number;
+        }>;
+        delete(companyId: number): Promise<{
+            deleted: boolean;
+        }>;
+        listColumns(listId?: number): Promise<{
+            data: import("./companies").CompanyColumn[];
+        }>;
+        createColumn(params: import("./companies").CompanyColumnCreateParams): Promise<import("./companies").CompanyColumn>;
+    };
+    /** Lists management (requires API key). */
+    get lists(): {
+        list(page?: number, limit?: number): Promise<{
+            data: import("./lists").ContactList[];
+            total: number;
+        }>;
+        create(title: string, type?: "contacts" | "companies"): Promise<import("./lists").ContactList>;
+        delete(listId: number): Promise<{
+            deleted: boolean;
+        }>;
+        contacts(listId: number, page?: number, limit?: number): Promise<{
+            data: import("./lists").ListContact[];
+            total: number;
+        }>;
+        addContacts(listId: number, contactIds: number[]): Promise<{
+            added: number;
+        }>;
+        removeContacts(listId: number, contactIds: number[]): Promise<{
+            removed: number;
+        }>;
+    };
+    /** Notes on contacts, companies and deals (requires API key). */
+    get notes(): {
+        list(contactId: number): Promise<{
+            data: import("./notes").Note[];
+        }>;
+        create(contactId: number, content: string): Promise<import("./notes").Note>;
+        listForCompany(companyId: number): Promise<{
+            data: import("./notes").Note[];
+        }>;
+        createForCompany(companyId: number, content: string): Promise<import("./notes").Note>;
+        listForDeal(dealId: string): Promise<{
+            data: import("./notes").Note[];
+        }>;
+        createForDeal(dealId: string, content: string): Promise<import("./notes").Note>;
+        update(noteId: string, content: string): Promise<import("./notes").Note>;
+        delete(noteId: string): Promise<{
+            data: {
+                deleted: boolean;
+            };
+        }>;
+    };
+    /** Sending mailboxes — connect, read, update, test-connection, delete, list, warmup (requires API key). */
+    get mailboxes(): {
+        list(params?: import("./mailboxes").MailboxListParams): Promise<{
+            data: import("./mailboxes").MailboxListItem[];
+        }>;
+        warmup(mailboxId: number): Promise<import("./mailboxes").MailboxWarmupAnalytics>;
+        create(params: import("./mailboxes").MailboxCreateParams): Promise<import("./mailboxes").Mailbox>;
+        get(mailboxId: number): Promise<import("./mailboxes").Mailbox>;
+        update(mailboxId: number, params: import("./mailboxes").MailboxUpdateParams): Promise<import("./mailboxes").Mailbox>;
+        delete(mailboxId: number): Promise<import("./mailboxes").MailboxDeleteResult>;
+        testConnection(mailboxId: number, params?: import("./mailboxes").MailboxTestConnectionParams): Promise<import("./mailboxes").MailboxTestConnectionResult>;
+    };
+    /**
+     * The full published Developer API, generated from the contract (requires API key).
+     *
+     * Covers every operation the API serves, including the surfaces that have no
+     * hand-written client. Two equivalent call styles:
+     *
+     *   await g8.api.contacts.listContacts({ query: { limit: 50 } });
+     *   await g8.api.call("list_contacts_contacts_get", { query: { limit: 50 } });
+     *
+     * Unlike the ergonomic clients above it returns the response envelope exactly
+     * as the contract declares it — nothing is unwrapped or renamed. Prefer the
+     * hand-written client when one exists; reach for this for everything else.
+     */
+    get api(): import("./api").ApiClient;
+    /** Newsletters, issues and subscribers (requires API key). */
+    get newsletter(): {
+        list(params?: import("./newsletter").NewsletterListParams): Promise<{
+            data: import("./newsletter").Newsletter[];
+        }>;
+        create(params: import("./newsletter").NewsletterCreateParams): Promise<import("./newsletter").Newsletter>;
+        templates(): Promise<{
+            data: import("./newsletter").NewsletterTemplate[];
+        }>;
+        get(newsletterId: string): Promise<import("./newsletter").Newsletter>;
+        listIssues(newsletterId: string): Promise<{
+            data: import("./newsletter").NewsletterIssue[];
+        }>;
+        createIssue(newsletterId: string, params: import("./newsletter").NewsletterIssueCreateParams): Promise<import("./newsletter").NewsletterIssue>;
+        getIssue(newsletterId: string, issueId: string): Promise<import("./newsletter").NewsletterIssue>;
+        updateIssue(newsletterId: string, issueId: string, params: import("./newsletter").NewsletterIssueUpdateParams): Promise<import("./newsletter").NewsletterIssue>;
+        duplicateIssue(newsletterId: string, issueId: string): Promise<import("./newsletter").NewsletterIssue>;
+        sendIssue(newsletterId: string, issueId: string, opts?: {
+            idempotencyKey?: string;
+            scheduled_at?: string;
+        }): Promise<{
+            data: unknown;
+        }>;
+        sendTestEmail(newsletterId: string, issueId: string, testEmail: string): Promise<{
+            data: unknown;
+        }>;
+        issueKpis(newsletterId: string, issueId: string): Promise<import("./newsletter").NewsletterIssueKpis>;
+        listSubscribers(newsletterId: string, params?: import("./newsletter").NewsletterListParams): Promise<{
+            data: import("./newsletter").NewsletterSubscriber[];
+        }>;
+        addSubscriber(newsletterId: string, email: string, opts?: {
+            first_name?: string;
+            last_name?: string;
+        }): Promise<import("./newsletter").NewsletterSubscriber>;
+        unsubscribe(newsletterId: string, subscriberId: string): Promise<{
+            data: unknown;
+        }>;
+    };
+    /** Tasks on contacts (requires API key). */
+    get tasks(): {
+        listForContact(contactId: number, status?: string): Promise<{
+            data: import("./tasks").Task[];
+        }>;
+        list(params?: import("./tasks").TaskListParams): Promise<{
+            data: import("./tasks").Task[];
+        }>;
+        create(contactId: number, task: import("./tasks").TaskCreateParams): Promise<import("./tasks").Task>;
+        update(taskId: string, fields: import("./tasks").TaskUpdateParams): Promise<import("./tasks").Task>;
+        delete(taskId: string): Promise<{
+            data: {
+                deleted: boolean;
+            };
+        }>;
+    };
+    /** Custom fields management (requires API key). */
+    get fields(): {
+        listContactFields(listId?: number): Promise<{
+            data: import("./fields").Field[];
+        }>;
+        listCompanyFields(listId?: number): Promise<{
+            data: import("./fields").Field[];
+        }>;
+        create(params: import("./fields").FieldCreateParams): Promise<import("./fields").CreatedField>;
+        delete(columnId: number, params?: import("./fields").FieldDeleteParams): Promise<{
+            data: {
+                column_id: number;
+                deleted: boolean;
+            };
+        }>;
+        setValue(columnId: number, params: import("./fields").SetFieldValueParams): Promise<{
+            data: {
+                column_id: number;
+                record_id: number;
+                updated: boolean;
+            };
+        }>;
+    };
+    /** Apps you build on graph8 — lifecycle, installs, usage, limits (requires API key). PREVIEW. */
+    get apps(): {
+        list(): Promise<{
+            data: import("./apps").App[];
+        }>;
+        get(appId: string): Promise<import("./apps").App>;
+        create(params: import("./apps").AppCreateParams): Promise<import("./apps").App>;
+        setStatus(appId: string, status: Exclude<import("./apps").AppStatus, "suspended">): Promise<import("./apps").App>;
+        listInstalls(appId: string): Promise<{
+            data: import("./apps").AppInstallation[];
+        }>;
+        usage(appId: string, period?: string): Promise<import("./apps").AppUsageSummary>;
+        getLimit(appId: string): Promise<import("./apps").AppLimit | null>;
+    };
+    /**
+     * Ship a hosted app: bind a source, deploy, promote, attach a hostname, read
+     * build logs (requires API key). PREVIEW.
+     *
+     * Separate from `apps` on purpose. `apps` is the app's IDENTITY -- create it,
+     * see who installed it, what it cost. This is its LIFECYCLE, and the two have
+     * different blast radii: a mistake here takes a customer's app down.
+     */
+    get appPlatform(): {
+        setSource(appId: string, params: import("./appPlatform").AppSourceParams): Promise<Record<string, unknown>>;
+        clearSource(appId: string): Promise<Record<string, unknown>>;
+        listDeployments(appId: string): Promise<{
+            data: import("./appPlatform").Deployment[];
+        }>;
+        deploy(appId: string, params: import("./appPlatform").CreateDeploymentParams): Promise<import("./appPlatform").Deployment>;
+        getDeployment(appId: string, deploymentId: string): Promise<import("./appPlatform").Deployment>;
+        activeDeployment(appId: string): Promise<import("./appPlatform").Deployment | null>;
+        promote(appId: string, deploymentId: string, imageDigest: string): Promise<import("./appPlatform").Deployment>;
+        rollback(appId: string, deploymentId: string): Promise<import("./appPlatform").Deployment>;
+        deploymentLogs(appId: string, deploymentId: string, tailLines?: number): Promise<import("./appPlatform").AppLogs>;
+        logs(appId: string, tailLines?: number): Promise<import("./appPlatform").AppLogs>;
+        listDomains(appId: string): Promise<{
+            data: import("./appPlatform").AppDomain[];
+        }>;
+        claimDomain(appId: string, hostname: string): Promise<import("./appPlatform").DomainVerificationInstructions>;
+        verifyDomain(appId: string, hostname: string): Promise<import("./appPlatform").AppDomain>;
+        releaseDomain(appId: string, hostname: string): Promise<{
+            hostname: string;
+            released: boolean;
+        }>;
+        listSecrets(appId: string): Promise<{
+            data: import("./appPlatform").AppSecretMetadata[];
+        }>;
+        putSecret(appId: string, secretKey: string, providerRef?: string): Promise<import("./appPlatform").AppSecretMetadata>;
+        deleteSecret(appId: string, secretKey: string): Promise<{
+            secret_key: string;
+            removed: boolean;
+        }>;
+        publishSchemaVersion(appId: string, objects: unknown[]): Promise<{
+            version: import("./appPlatform").SchemaVersion;
+        }>;
+        listSchemaVersions(appId: string): Promise<{
+            data: import("./appPlatform").SchemaVersion[];
+        }>;
+    };
+    /** Custom object types, their schema, and their records (requires API key). PREVIEW. */
+    get objects(): {
+        list(params?: {
+            include_archived?: boolean;
+        }): Promise<{
+            data: import("./objects").CustomObject[];
+        }>;
+        create(input: import("./objects").CreateCustomObject): Promise<import("./objects").CustomObject>;
+        update(objectSlug: string, input: import("./objects").UpdateCustomObject): Promise<import("./objects").CustomObject>;
+        archive(objectSlug: string): Promise<import("./objects").CustomObject>;
+        get(objectSlug: string): Promise<import("./objects").CustomObject>;
+        listAttributes(objectSlug: string, params?: {
+            include_archived?: boolean;
+        }): Promise<{
+            data: import("./objects").CustomObjectAttribute[];
+        }>;
+        createAttribute(objectSlug: string, input: import("./objects").CreateCustomObjectAttribute): Promise<import("./objects").CustomObjectAttribute>;
+        updateAttribute(objectSlug: string, attributeSlug: string, input: import("./objects").UpdateCustomObjectAttribute): Promise<import("./objects").CustomObjectAttribute>;
+        archiveAttribute(objectSlug: string, attributeSlug: string): Promise<import("./objects").CustomObjectAttribute>;
+        listRecords(objectSlug: string, params?: import("./objects").ListRecordsParams): Promise<{
+            data: import("./objects").CustomObjectRecord[];
+            pagination?: import("./objects").ObjectPagination;
+        }>;
+        createRecord(objectSlug: string, values: Record<string, unknown>): Promise<import("./objects").CustomObjectRecord>;
+        upsertRecord(objectSlug: string, matchingAttribute: string, values: Record<string, unknown>, options?: {
+            expectedRevision?: number;
+        }): Promise<import("./objects").CustomObjectRecord>;
+        getRecord(objectSlug: string, recordId: string): Promise<import("./objects").CustomObjectRecord>;
+        updateRecord(objectSlug: string, recordId: string, values: Record<string, unknown>, options?: {
+            expectedRevision?: number;
+            appendValues?: Record<string, unknown[]>;
+            removeValues?: Record<string, unknown[]>;
+        }): Promise<import("./objects").CustomObjectRecord>;
+        archiveRecord(objectSlug: string, recordId: string): Promise<import("./objects").CustomObjectRecord>;
+        restoreRecord(objectSlug: string, recordId: string): Promise<import("./objects").CustomObjectRecord>;
+        history(objectSlug: string, recordId: string, limit?: number): Promise<import("./objects").CustomObjectHistory>;
+        changes(objectSlug: string, recordId: string, options?: {
+            limit?: number;
+            cursor?: string;
+        }): Promise<import("./objects").CustomObjectMutations>;
+    };
+    /** Deals and pipelines (requires API key). */
+    get deals(): {
+        pipelines(): Promise<{
+            data: import("./deals").Pipeline[];
+        }>;
+        list(params?: import("./deals").DealListParams): Promise<{
+            data: import("./deals").Deal[];
+            pagination?: import("./deals").PaginationMeta;
+        }>;
+        create(deal: import("./deals").DealCreateParams): Promise<import("./deals").Deal>;
+        get(dealId: string): Promise<import("./deals").Deal>;
+        update(dealId: string, fields: import("./deals").DealUpdateParams): Promise<import("./deals").Deal>;
+        delete(dealId: string): Promise<{
+            data: {
+                deleted: boolean;
+            };
+        }>;
+        forContact(contactId: number): Promise<{
+            data: import("./deals").ContactDeal[];
+        }>;
+        forCompany(companyId: number): Promise<{
+            data: import("./deals").ContactDeal[];
+        }>;
+    };
+    /** Multi-channel inbox — read + reply across email, SMS, LinkedIn (requires API key). */
+    get inbox(): {
+        list(params?: import("./inbox").InboxListParams): Promise<{
+            data: import("./inbox").InboxThread[];
+        }>;
+        get(replyId: string, channel?: import("./inbox").InboxChannel): Promise<import("./inbox").InboxThread>;
+        assign(replyId: string, assigneeEmail: string, channel?: import("./inbox").InboxChannel): Promise<import("./inbox").InboxAssignResult>;
+        tag(replyId: string, tagIds: string[], channel?: import("./inbox").InboxChannel): Promise<import("./inbox").InboxTagResult>;
+        draft(replyId: string, channel?: import("./inbox").InboxChannel): Promise<import("./inbox").InboxDraft>;
+        send(replyId: string, payload: import("./inbox").InboxSendParams): Promise<import("./inbox").InboxSendResult>;
+    };
+    /** Quote-to-cash: draft, send, sign, payment-link quotes (requires API key). */
+    get quotes(): {
+        list(params?: import("./quotes").QuoteListParams): Promise<{
+            data: import("./quotes").QuoteSummary[];
+            pagination?: import("./quotes").PaginationMeta;
+        }>;
+        get(quoteId: string): Promise<import("./quotes").QuoteDetail>;
+        create(quote: import("./quotes").QuoteCreateParams): Promise<import("./quotes").QuoteDetail>;
+        update(quoteId: string, fields: import("./quotes").QuoteUpdateParams): Promise<import("./quotes").QuoteDetail>;
+        delete(quoteId: string): Promise<{
+            data: {
+                deleted: boolean;
+            };
+        }>;
+        duplicate(quoteId: string): Promise<import("./quotes").QuoteDetail>;
+        editAsDraft(quoteId: string): Promise<{
+            data: {
+                id: string;
+                status: string;
+            };
+        }>;
+        send(quoteId: string, params: import("./quotes").QuoteSendParams): Promise<import("./quotes").QuoteDetail>;
+        products(): Promise<{
+            data: import("./quotes").QuotableProduct[];
+        }>;
+        settings(): Promise<import("./quotes").QuoteSettings>;
+        forContact(contactId: number): Promise<{
+            data: import("./quotes").QuoteSummary[];
+        }>;
+        forCompany(companyId: number): Promise<{
+            data: import("./quotes").QuoteSummary[];
+        }>;
+    };
+    /** Stage Checklist v2 pipelines: workflow stages with evidence + scripts (requires API key). */
+    get pipelines(): {
+        list(): Promise<{
+            data: import("./pipelines").StagePipeline[];
+        }>;
+        get(pipelineId: string): Promise<import("./pipelines").StagePipeline>;
+        evidenceLibrary(): Promise<{
+            data: import("./pipelines").EvidenceKey[];
+        }>;
+        create(params: import("./pipelines").StagePipelineCreateParams): Promise<import("./pipelines").StagePipeline>;
+        update(pipelineId: string, fields: import("./pipelines").StagePipelineUpdateParams): Promise<import("./pipelines").StagePipeline>;
+        delete(pipelineId: string): Promise<{
+            data: {
+                deleted: boolean;
+            };
+        }>;
+        createStage(pipelineId: string, stage: import("./pipelines").StageCreateParams): Promise<import("./pipelines").StagePipelineStage>;
+        updateStage(pipelineId: string, stageId: string, fields: import("./pipelines").StageUpdateParams): Promise<import("./pipelines").StagePipelineStage>;
+        reorderStages(pipelineId: string, stageIds: string[]): Promise<{
+            data: import("./pipelines").StagePipelineStage[];
+        }>;
+        deleteStage(pipelineId: string, stageId: string): Promise<{
+            data: {
+                deleted: boolean;
+            };
+        }>;
+        suggest(): Promise<{
+            data: import("./pipelines").PipelineSuggestion;
+        }>;
+        fromSuggestion(suggestionId: string, overrides?: Partial<{
+            name: string;
+            target: string;
+        }>): Promise<import("./pipelines").StagePipeline>;
+    };
+    /** Workflow builder — multi-node automation graphs with execution lifecycle (requires API key). */
+    get workflows(): {
+        list(params?: import("./workflows").WorkflowListParams): Promise<{
+            data: import("./workflows").Workflow[];
+        }>;
+        get(workflowId: string): Promise<import("./workflows").Workflow>;
+        create(params: import("./workflows").WorkflowCreateParams): Promise<import("./workflows").Workflow>;
+        update(workflowId: string, fields: import("./workflows").WorkflowUpdateParams): Promise<import("./workflows").Workflow>;
+        delete(workflowId: string): Promise<{
+            data: {
+                deleted: boolean;
+            };
+        }>;
+        validate(workflow: {
+            config: import("./workflows").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<import("./workflows").WorkflowExecution>;
+        getExecution(executionId: string): Promise<import("./workflows").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: import("./workflows").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;
+            }>;
+        }>;
+    };
+    /** Skill authoring — LLM and API building blocks that workflows compose (requires API key). */
+    get skills(): {
+        list(params?: import("./skills").SkillListParams): Promise<{
+            data: import("./skills").Skill[];
+        }>;
+        get(skillId: string): Promise<import("./skills").Skill>;
+        getVariables(skillId: string): Promise<{
+            data: import("./skills").SkillInputField[];
+        }>;
+        listModels(): Promise<{
+            data: Array<{
+                id: string;
+                label: string;
+                provider: string;
+            }>;
+        }>;
+        listTemplates(params?: {
+            type?: import("./skills").SkillType;
+        }): Promise<{
+            data: import("./skills").SkillTemplate[];
+        }>;
+        createLLM(params: import("./skills").SkillCreateLLMParams): Promise<import("./skills").Skill>;
+        createAPI(params: import("./skills").SkillCreateAPIParams): Promise<import("./skills").Skill>;
+        createFromTemplate(params: {
+            title: string;
+            template_id: string;
+            overrides?: Record<string, unknown>;
+        }): Promise<import("./skills").Skill>;
+        createFromNode(params: {
+            title: string;
+            description?: string;
+            node_id: string;
+            input_mapping?: Record<string, string>;
+            output_mapping?: Record<string, string>;
+        }): Promise<import("./skills").Skill>;
+        updateLLM(skillId: string, fields: import("./skills").SkillUpdateLLMParams): Promise<import("./skills").Skill>;
+        updateAPI(skillId: string, fields: import("./skills").SkillUpdateAPIParams): Promise<import("./skills").Skill>;
+        delete(skillId: string): Promise<{
+            data: {
+                deleted: boolean;
+            };
+        }>;
+        validate(skill: Partial<import("./skills").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;
+            };
+        }>;
+    };
+    /** Intent tracking — keyword groups, page visitors, account-level intent (requires API key). */
+    get intent(): {
+        stats(): Promise<{
+            data: import("./intent").IntentStats;
+        }>;
+        listKeywords(params?: {
+            page?: number;
+            limit?: number;
+            search?: string;
+        }): Promise<{
+            data: import("./intent").IntentKeyword[];
+        }>;
+        createFromDomain(domain: string): Promise<{
+            data: import("./intent").IntentKeyword;
+        }>;
+        deleteKeyword(keywordId: string): Promise<{
+            data: {
+                deleted: boolean;
+            };
+        }>;
+        keywordCompanies(keywordId: string, params?: {
+            limit?: number;
+            date_from?: string;
+            date_to?: string;
+        }): Promise<{
+            data: import("./intent").IntentCompany[];
+        }>;
+        keywordContacts(keywordId: string, params?: {
+            limit?: number;
+            date_from?: string;
+            date_to?: string;
+        }): Promise<{
+            data: import("./intent").IntentContact[];
+        }>;
+        keywordUrls(keywordId: string, params?: {
+            limit?: number;
+        }): Promise<{
+            data: import("./intent").IntentPage[];
+        }>;
+        pagesByDomain(domain: string, params?: {
+            limit?: number;
+        }): Promise<{
+            data: import("./intent").IntentPage[];
+        }>;
+        searchPages(query: string, params?: {
+            limit?: number;
+        }): Promise<{
+            data: import("./intent").IntentPage[];
+        }>;
+        pageVisitors(pageUrl: string, params?: {
+            limit?: number;
+            date_from?: string;
+            date_to?: string;
+        }): Promise<{
+            data: import("./intent").IntentVisitor[];
+        }>;
+        pageContacts(pageUrl: string, params?: {
+            limit?: number;
+        }): Promise<{
+            data: import("./intent").IntentContact[];
+        }>;
+        pageVisitorCounts(urls: string[]): Promise<{
+            data: Array<{
+                url: string;
+                visitor_count: number;
+            }>;
+        }>;
+        urlCompanies(url: string, params?: {
+            limit?: number;
+            days?: number;
+            date_from?: string;
+            date_to?: string;
+        }): Promise<import("./intent").IntentUrlCompaniesResponse>;
+    };
+    /** Studio context — ICPs, personas, brand briefs, intelligence, AI research reports (requires API key). */
+    get studio(): {
+        globalContext(params?: {
+            category?: string;
+            limit?: number;
+            include_content?: boolean;
+        }): Promise<{
+            data: import("./studio").GlobalContextDocument[];
+        }>;
+        icps(params?: {
+            status?: string;
+            limit?: number;
+        }): Promise<{
+            data: import("./studio").ICP[];
+        }>;
+        personas(params?: {
+            status?: string;
+            limit
+            /** @internal */ ? /** @internal */: number;
+        }): Promise<{
+            data: import("./studio").Persona[];
+        }>;
+        intelligenceData(params?: {
+            source_type?: string;
+            limit?: number;
+        }): Promise<{
+            data: import("./studio").IntelligenceData[];
+        }>;
+        researchReports(params?: {
+            category?: string;
+            limit?: number;
+        }): Promise<{
+            data: import("./studio").ResearchReport[];
+        }>;
+        createIcp(body: {
+            name: string;
+            website_url: string;
+            description?: string;
+            firmographics?: Record<string, unknown>;
+            tech_stack?: Record<string, unknown>;
+            buying_signals?: unknown[];
+            estimated_market_size?: number;
+        }): Promise<{
+            data: import("./studio").ICP;
+        }>;
+        updateIcp(icpId: string, body: {
+            name?: string;
+            description?: string;
+            firmographics?: Record<string, unknown>;
+            tech_stack?: Record<string, unknown>;
+            buying_signals?: unknown[];
+            estimated_market_size?: number;
+        }): Promise<{
+            data: import("./studio").ICP;
+        }>;
+        archiveIcp(icpId: string): Promise<{
+            data: import("./studio").ICP;
+        }>;
+        createPersona(body: {
+            title: string;
+            website_url: string;
+            priority?: number;
+            confidence?: string;
+            why_target?: string;
+            key_signals?: unknown[];
+            expected_receptivity?: string;
+            campaign_approach?: string;
+            recommended_goal?: string;
+            source?: string;
+        }): Promise<{
+            data: import("./studio").Persona;
+        }>;
+        updatePersona(personaId: string, body: {
+            title?: string;
+            priority?: number;
+            confidence?: string;
+            why_target?: string;
+            key_signals?: unknown[];
+            expected_receptivity?: string;
+            campaign_approach?: string;
+            recommended_goal?: string;
+            status?: string;
+        }): Promise<{
+            data: import("./studio").Persona;
+        }>;
+        archivePersona(personaId: string): Promise<{
+            data: import("./studio").Persona;
+        }>;
+    };
+    /** Meetings — read scheduled, completed, cancelled meetings with transcripts + AI analysis (requires API key). */
+    get meetings(): {
+        list(params?: import("./meetings").MeetingListParams): Promise<{
+            data: import("./meetings").MeetingSummary[];
+            pagination?: {
+                page: number;
+                limit: number;
+                total: number;
+                has_next: boolean;
+            };
+        }>;
+        get(meetingId: string): Promise<import("./meetings").MeetingDetail>;
+    };
+    /** Audiences — sync audience lists to ad platforms (Meta, LinkedIn, Google, X) (requires API key). */
+    get audiences(): {
+        list(): Promise<{
+            data: import("./audiences").AudienceSync[];
+        }>;
+        create(params: import("./audiences").AudienceSyncCreateParams): Promise<import("./audiences").AudienceSync>;
+        get(configId: number): Promise<import("./audiences").AudienceSync>;
+        update(configId: number, fields: import("./audiences").AudienceSyncUpdateParams): Promise<import("./audiences").AudienceSync>;
+        delete(configId: number): Promise<{
+            data: Record<string, unknown>;
+        }>;
+        trigger(configId: number): Promise<{
+            data: Record<string, unknown>;
+        }>;
+        runs(configId: number): Promise<{
+            data: import("./audiences").AudienceSyncRun[];
+        }>;
+        errors(configId: number): Promise<{
+            data: import("./audiences").AudienceSyncError[];
+        }>;
+    };
+    /** Search — prospect open-data contacts + companies by filter, optionally save to a list (requires API key). */
+    get search(): {
+        contacts(params?: import("./search").SearchParams): Promise<{
+            data: import("./search").SearchContactItem[];
+        }>;
+        companies(params?: import("./search").SearchParams): Promise<{
+            data: import("./search").SearchCompanyItem[];
+        }>;
+        saveContacts(params: import("./search").SearchSaveParams): Promise<import("./search").SearchSaveResult>;
+        saveCompanies(params: import("./search").SearchSaveParams): Promise<import("./search").SearchSaveResult>;
+    };
+    /** Agency — for agency keys: discover the agency credential + the client orgs it may target (requires API key). */
+    get agency(): {
+        me(): Promise<import("./agency").AgencyInfo>;
+        clients(): Promise<{
+            data: import("./agency").AgencyClient[];
+        }>;
+    };
+    /** Marketplace — for SDR/AE talent: profile, hire offers (accept/reject), active hirings (requires API key). */
+    get marketplace(): {
+        profile(): Promise<import("./marketplace").MarketplaceProfile>;
+        offers(): Promise<{
+            offers: import("./marketplace").MarketplaceOffer[];
+            count: number;
+        }>;
+        acceptOffer(hiringId: string): Promise<Record<string, unknown>>;
+        rejectOffer(hiringId: string): Promise<Record<string, unknown>>;
+        hirings(): Promise<{
+            hirings: import("./marketplace").MarketplaceHiring[];
+            count: number;
+        }>;
+    };
+    /** Snippet — fetch your org's tracking snippet (write key + React/script-tag embeds + config) for embedding (requires API key). */
+    get snippet(): {
+        get(): Promise<import("./snippet").Snippet>;
+    };
+    /** Whether the SDK has been initialized. */
+    get initialized(): boolean;
+    /** @internal */
+    _assertInit(): void;
+    /** @internal */
+    _assertKey(module: string): void;
+}
+export declare const g8: G8;
+export {};