@graph8/sdk 0.251.0 → 0.260.0

package/dist/types/react.d.ts

@@ -0,0 +1,978 @@
+import * as React from "react";
+import { type ReactNode } from "react";
+import type { G8Config } from "./types";
+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/sdk/react';
+ *
+ *   <G8Provider writeKey="your_write_key">
+ *     <App />
+ *   </G8Provider>
+ */
+export declare const G8Provider: ({ writeKey, host, config, children, }: G8ProviderProps) => React.JSX.Element;
+/**
+ * Hook to access the graph8 SDK from any component.
+ *
+ * Usage:
+ *   const { track, identify, page, forms } = useG8();
+ *   track('button_click', { button: 'cta' });
+ */
+export declare const useG8: () => {
+    /** Track a custom event */
+    track: (event: string, properties?: import("./types").TrackProperties) => void;
+    /** Identify a user */
+    identify: (userId: string, properties?: import("./types").IdentifyProperties) => void;
+    /** Track a page view */
+    page: (properties?: import("./types").TrackProperties) => void;
+    /** Clear user identity */
+    reset: () => void;
+    /** Progressive form helpers (read lazily, so useG8() never throws on its own) */
+    readonly forms: {
+        lookup(email: string): Promise<import("./types").EnrichLookupResult>;
+    };
+    /** Raw g8 client instance */
+    g8: {
+        client: import("@jitsu/js").AnalyticsInterface | null;
+        config: G8Config | null;
+        _forms: ReturnType<typeof import("./forms").createFormsClient> | null;
+        _visitors: ReturnType<typeof import("./visitors").createVisitorsClient> | null;
+        _copilot: ReturnType<typeof import("./copilot").createCopilotClient> | null;
+        _chat: ReturnType<typeof import("./chat").createChatClient> | null;
+        _calendar: ReturnType<typeof import("./calendar").createCalendarClient> | null;
+        _enrich: ReturnType<typeof import("./enrich").createEnrichClient> | null;
+        _sequences: ReturnType<typeof import("./sequences").createSequencesClient> | null;
+        _campaigns: ReturnType<typeof import("./campaigns").createCampaignsClient> | null;
+        _signals: ReturnType<typeof import("./signals").createSignalsClient> | null;
+        _voice: ReturnType<typeof import("./voice").createVoiceClient> | null;
+        _webhooks: ReturnType<typeof import("./webhooks").createWebhooksClient> | null;
+        _contacts: ReturnType<typeof import("./contacts").createContactsClient> | null;
+        _companies: ReturnType<typeof import("./companies").createCompaniesClient> | null;
+        _lists: ReturnType<typeof import("./lists").createListsClient> | null;
+        _notes: ReturnType<typeof import("./notes").createNotesClient> | null;
+        _mailboxes: ReturnType<typeof import("./mailboxes").createMailboxesClient> | null;
+        _api: ReturnType<typeof import("./api").createApiClient> | null;
+        _newsletter: ReturnType<typeof import("./newsletter").createNewsletterClient> | null;
+        _tasks: ReturnType<typeof import("./tasks").createTasksClient> | null;
+        _fields: ReturnType<typeof import("./fields").createFieldsClient> | null;
+        _apps: ReturnType<typeof import("./apps").createAppsClient> | null;
+        _appPlatform: ReturnType<typeof import("./appPlatform").createAppPlatformClient> | null;
+        _objects: ReturnType<typeof import("./objects").createObjectsClient> | null;
+        _deals: ReturnType<typeof import("./deals").createDealsClient> | null;
+        _inbox: ReturnType<typeof import("./inbox").createInboxClient> | null;
+        _quotes: ReturnType<typeof import("./quotes").createQuotesClient> | null;
+        _pipelines: ReturnType<typeof import("./pipelines").createPipelinesClient> | null;
+        _workflows: ReturnType<typeof import("./workflows").createWorkflowsClient> | null;
+        _skills: ReturnType<typeof import("./skills").createSkillsClient> | null;
+        _intent: ReturnType<typeof import("./intent").createIntentClient> | null;
+        _studio: ReturnType<typeof import("./studio").createStudioClient> | null;
+        _meetings: ReturnType<typeof import("./meetings").createMeetingsClient> | null;
+        _audiences: ReturnType<typeof import("./audiences").createAudiencesClient> | null;
+        _search: ReturnType<typeof import("./search").createSearchClient> | null;
+        _agency: ReturnType<typeof import("./agency").createAgencyClient> | null;
+        _marketplace: ReturnType<typeof import("./marketplace").createMarketplaceClient> | null;
+        _snippet: ReturnType<typeof import("./snippet").createSnippetClient> | null;
+        init(config: G8Config): void;
+        track(event: string, properties?: import("./types").TrackProperties): void;
+        identify(userId: string, properties?: import("./types").IdentifyProperties): void;
+        page(properties?: import("./types").TrackProperties): void;
+        reset(): void;
+        get forms(): {
+            lookup(email: string): Promise<import("./types").EnrichLookupResult>;
+        };
+        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;
+        };
+        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;
+        };
+        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;
+        };
+        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;
+        };
+        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? /** Identify a user */: 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>;
+        };
+        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>;
+        };
+        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>;
+        };
+        get signals(): {
+            company(domain: string): Promise<import("./signals").IntentSignals>;
+            stream(domains: string[], callback: (signals: import("./signals").IntentSignals[]) => void): () => void;
+        };
+        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>>;
+                }>;
+            };
+        };
+        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;
+        };
+        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>;
+        };
+        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>;
+        };
+        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;
+            }>;
+        };
+        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;
+                };
+            }>;
+        };
+        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>;
+        };
+        get api(): import("./api").ApiClient;
+        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;
+            }>;
+        };
+        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;
+                };
+            }>;
+        };
+        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;
+                };
+            }>;
+        };
+        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>;
+        };
+        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[];
+            }>;
+        };
+        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>;
+        };
+        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[];
+            }>;
+        };
+        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>;
+        };
+        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[];
+            }>;
+        };
+        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>;
+        };
+        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;
+                }>;
+            }>;
+        };
+        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;
+                };
+            }>;
+        };
+        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>;
+        };
+        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?: 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;
+            }>;
+        };
+        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>;
+        };
+        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[];
+            }>;
+        };
+        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>;
+        };
+        get agency(): {
+            me(): Promise<import("./agency").AgencyInfo>;
+            clients(): Promise<{
+                data: import("./agency").AgencyClient[];
+            }>;
+        };
+        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;
+            }>;
+        };
+        get snippet(): {
+            get(): Promise<import("./snippet").Snippet>;
+        };
+        get initialized(): boolean;
+        _assertInit(): void;
+        _assertKey(module: string): void;
+    };
+};
+export {};