@clianta/sdk 1.7.2 → 1.7.3

package/dist/index.d.ts

@@ -57,6 +57,10 @@ interface TrackingEvent {
     visitorId: string;
     /** Session identifier */
     sessionId: string;
+    /** CRM contact ID (set after a successful identify() call) */
+    contactId?: string;
+    /** Group ID (set after a successful group() call) */
+    groupId?: string;
     /** Event type category */
     eventType: EventType;
     /** Human-readable event name */
@@ -69,8 +73,12 @@ interface TrackingEvent {
     properties: Record<string, unknown>;
     /** Device information */
     device: DeviceInfo;
-    /** UTM parameters */
-    utm?: UTMParams;
+    /** UTM parameters (flat, root-level — matches backend schema) */
+    utmSource?: string;
+    utmMedium?: string;
+    utmCampaign?: string;
+    utmTerm?: string;
+    utmContent?: string;
     /** ISO timestamp */
     timestamp: string;
     /** SDK version */
@@ -82,13 +90,6 @@ interface DeviceInfo {
     language: string;
     timezone?: string;
 }
-interface UTMParams {
-    utmSource?: string;
-    utmMedium?: string;
-    utmCampaign?: string;
-    utmTerm?: string;
-    utmContent?: string;
-}
 interface GroupTraits {
     /** Company/account name */
     name?: string;
@@ -162,6 +163,8 @@ interface TrackerCore {
     onReady(callback: () => void): void;
     /** Check if the SDK is fully initialized and ready */
     isReady(): boolean;
+    /** Register a schema for event validation (active in debug mode) */
+    registerEventSchema(eventType: string, schema: Record<string, 'string' | 'number' | 'boolean' | 'object' | 'array'>): void;
     /** Create or update a contact by email (upsert) */
     createContact(data: PublicContactData): Promise<PublicCrmResult>;
     /** Update an existing contact by ID (limited fields) */
@@ -175,6 +178,246 @@ interface TrackerCore {
     /** Destroy the tracker instance, flush pending events, and clean up plugins */
     destroy(): Promise<void>;
 }
+interface Contact {
+    _id?: string;
+    workspaceId: string;
+    email: string;
+    firstName?: string;
+    lastName?: string;
+    company?: string;
+    jobTitle?: string;
+    phone?: string;
+    status?: 'lead' | 'contact' | 'customer';
+    lifecycleStage?: 'subscriber' | 'lead' | 'mql' | 'sql' | 'opportunity' | 'customer' | 'evangelist';
+    source?: string;
+    tags?: string[];
+    leadScore?: number;
+    customFields?: Record<string, unknown>;
+    companyId?: string;
+    assignedTo?: string;
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface Company {
+    _id?: string;
+    workspaceId: string;
+    name: string;
+    industry?: string;
+    website?: string;
+    phone?: string;
+    address?: {
+        street?: string;
+        city?: string;
+        state?: string;
+        country?: string;
+        postalCode?: string;
+    };
+    companySize?: string;
+    annualRevenue?: number;
+    status?: 'prospect' | 'active' | 'inactive' | 'churned';
+    accountTier?: 'enterprise' | 'mid-market' | 'smb';
+    isTargetAccount?: boolean;
+    tags?: string[];
+    customFields?: Record<string, unknown>;
+    assignedTo?: string;
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface Pipeline {
+    _id?: string;
+    workspaceId: string;
+    name: string;
+    description?: string;
+    stages: PipelineStage[];
+    isDefault?: boolean;
+    isActive?: boolean;
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface PipelineStage {
+    _id?: string;
+    name: string;
+    order: number;
+    probability?: number;
+    color?: string;
+    rottenDays?: number;
+}
+interface Task {
+    _id?: string;
+    workspaceId: string;
+    title: string;
+    description?: string;
+    status?: 'pending' | 'in_progress' | 'completed' | 'cancelled';
+    priority?: 'low' | 'medium' | 'high' | 'urgent';
+    dueDate?: string;
+    reminderDate?: string;
+    completedAt?: string;
+    tags?: string[];
+    relatedContactId?: string;
+    relatedCompanyId?: string;
+    relatedOpportunityId?: string;
+    assignedTo?: string;
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface Activity {
+    _id?: string;
+    workspaceId: string;
+    type: 'call' | 'email' | 'meeting' | 'note' | 'task' | 'other';
+    title: string;
+    description?: string;
+    direction?: 'inbound' | 'outbound';
+    duration?: number;
+    outcome?: string;
+    emailSubject?: string;
+    emailBody?: string;
+    metadata?: Record<string, unknown>;
+    contactId?: string;
+    companyId?: string;
+    opportunityId?: string;
+    userId?: string;
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface Opportunity {
+    _id?: string;
+    workspaceId: string;
+    contactId: string;
+    companyId?: string;
+    pipelineId: string;
+    stageId: string;
+    title: string;
+    value?: number;
+    currency?: string;
+    probability?: number;
+    expectedCloseDate?: string;
+    status?: 'open' | 'won' | 'lost';
+    priority?: 'low' | 'medium' | 'high';
+    lostReason?: string;
+    customFields?: Record<string, unknown>;
+    assignedTo?: string;
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface ApiResponse<T> {
+    success: boolean;
+    data?: T;
+    error?: string;
+    status: number;
+}
+interface PaginatedResponse<T> {
+    data: T[];
+    pagination: {
+        page: number;
+        limit: number;
+        total: number;
+        pages: number;
+    };
+}
+type TriggerEventType = 'contact.created' | 'contact.updated' | 'contact.deleted' | 'opportunity.created' | 'opportunity.updated' | 'opportunity.stage_changed' | 'opportunity.won' | 'opportunity.lost' | 'task.created' | 'task.completed' | 'task.overdue' | 'activity.logged' | 'form.submitted';
+interface TriggerCondition {
+    /**
+     * Field to check - supports dynamic field names including custom fields
+     * Examples: 'status', 'lifecycleStage', 'leadScore', 'customFields.industry'
+     * Use dot notation for nested fields: 'contact.email', 'customFields.accountType'
+     */
+    field: string;
+    /** Operator for comparison */
+    operator: 'equals' | 'not_equals' | 'contains' | 'greater_than' | 'less_than' | 'in' | 'not_in';
+    /** Value to compare against */
+    value: unknown;
+}
+interface EmailTemplate {
+    /** Template ID */
+    _id?: string;
+    /** Template name */
+    name: string;
+    /** Email subject line (supports variables) */
+    subject: string;
+    /** Email body (supports HTML and variables) */
+    body: string;
+    /** Variables available in this template */
+    variables?: string[];
+    /** Sender email address */
+    fromEmail?: string;
+    /** Sender name */
+    fromName?: string;
+}
+interface EmailAction {
+    /** Action type identifier */
+    type: 'send_email';
+    /** Email template ID or inline template */
+    templateId?: string;
+    /** Inline email subject (if not using template) */
+    subject?: string;
+    /** Inline email body (if not using template) */
+    body?: string;
+    /** Recipient email (supports variables like {{contact.email}}) */
+    to: string;
+    /** CC recipients */
+    cc?: string[];
+    /** BCC recipients */
+    bcc?: string[];
+    /** Sender email */
+    from?: string;
+    /** Delay in minutes before sending */
+    delayMinutes?: number;
+}
+interface WebhookAction {
+    /** Action type identifier */
+    type: 'webhook';
+    /** Webhook URL to call */
+    url: string;
+    /** HTTP method */
+    method: 'POST' | 'PUT' | 'PATCH';
+    /** Custom headers */
+    headers?: Record<string, string>;
+    /** Request body template (supports variables) */
+    body?: string;
+}
+interface TaskAction {
+    /** Action type identifier */
+    type: 'create_task';
+    /** Task title (supports variables) */
+    title: string;
+    /** Task description */
+    description?: string;
+    /** Task priority */
+    priority?: 'low' | 'medium' | 'high' | 'urgent';
+    /** Due date in days from trigger */
+    dueDays?: number;
+    /** Assign to user ID */
+    assignedTo?: string;
+}
+interface ContactUpdateAction {
+    /** Action type identifier */
+    type: 'update_contact';
+    /** Fields to update */
+    updates: Partial<Contact>;
+}
+type TriggerAction = EmailAction | WebhookAction | TaskAction | ContactUpdateAction;
+interface EventTrigger {
+    /** Trigger ID */
+    _id?: string;
+    /** Workspace ID */
+    workspaceId: string;
+    /** Trigger name */
+    name: string;
+    /** Description of what this trigger does */
+    description?: string;
+    /** Event type that activates this trigger */
+    eventType: TriggerEventType;
+    /** Conditions that must be met for trigger to fire */
+    conditions?: TriggerCondition[];
+    /** Actions to execute when trigger fires */
+    actions: TriggerAction[];
+    /** Whether this trigger is active */
+    isActive?: boolean;
+    /** Created timestamp */
+    createdAt?: string;
+    /** Updated timestamp */
+    updatedAt?: string;
+}
 interface PublicContactData {
     email: string;
     firstName?: string;
@@ -526,6 +769,583 @@ interface StoredConsent {
 /** SDK Version */
 declare const SDK_VERSION = "1.7.2";
 
+/**
+ * Clianta SDK - Event Triggers Manager
+ * Manages event-driven automation and email notifications
+ */
+
+/**
+ * Event Triggers Manager
+ * Handles event-driven automation based on CRM actions
+ *
+ * Similar to:
+ * - Salesforce: Process Builder, Flow Automation
+ * - HubSpot: Workflows, Email Sequences
+ * - Pipedrive: Workflow Automation
+ */
+declare class EventTriggersManager {
+    private apiEndpoint;
+    private workspaceId;
+    private authToken?;
+    private triggers;
+    private listeners;
+    constructor(apiEndpoint: string, workspaceId: string, authToken?: string);
+    /**
+     * Set authentication token
+     */
+    setAuthToken(token: string): void;
+    /**
+     * Make authenticated API request
+     */
+    private request;
+    /**
+     * Get all event triggers
+     */
+    getTriggers(): Promise<ApiResponse<EventTrigger[]>>;
+    /**
+     * Get a single trigger by ID
+     */
+    getTrigger(triggerId: string): Promise<ApiResponse<EventTrigger>>;
+    /**
+     * Create a new event trigger
+     */
+    createTrigger(trigger: Partial<EventTrigger>): Promise<ApiResponse<EventTrigger>>;
+    /**
+     * Update an existing trigger
+     */
+    updateTrigger(triggerId: string, updates: Partial<EventTrigger>): Promise<ApiResponse<EventTrigger>>;
+    /**
+     * Delete a trigger
+     */
+    deleteTrigger(triggerId: string): Promise<ApiResponse<void>>;
+    /**
+     * Activate a trigger
+     */
+    activateTrigger(triggerId: string): Promise<ApiResponse<EventTrigger>>;
+    /**
+     * Deactivate a trigger
+     */
+    deactivateTrigger(triggerId: string): Promise<ApiResponse<EventTrigger>>;
+    /**
+     * Register a local event listener for client-side triggers
+     * This allows immediate client-side reactions to events
+     */
+    on(eventType: TriggerEventType, callback: (data: unknown) => void): void;
+    /**
+     * Remove an event listener
+     */
+    off(eventType: TriggerEventType, callback: (data: unknown) => void): void;
+    /**
+     * Emit an event (client-side only)
+     * This will trigger any registered local listeners
+     */
+    emit(eventType: TriggerEventType, data: unknown): void;
+    /**
+     * Check if conditions are met for a trigger
+     * Supports dynamic field evaluation including custom fields and nested paths
+     */
+    private evaluateConditions;
+    /**
+     * Execute actions for a triggered event (client-side preview)
+     * Note: Actual execution happens on the backend
+     */
+    executeActions(trigger: EventTrigger, data: Record<string, unknown>): Promise<void>;
+    /**
+     * Execute a single action
+     */
+    private executeAction;
+    /**
+     * Execute send email action (via backend API)
+     */
+    private executeSendEmail;
+    /**
+     * Execute webhook action
+     */
+    private executeWebhook;
+    /**
+     * Execute create task action
+     */
+    private executeCreateTask;
+    /**
+     * Execute update contact action
+     */
+    private executeUpdateContact;
+    /**
+     * Replace variables in a string template
+     * Supports syntax like {{contact.email}}, {{opportunity.value}}
+     */
+    private replaceVariables;
+    /**
+     * Get nested value from object using dot notation
+     * Supports dynamic field access including custom fields
+     */
+    private getNestedValue;
+    /**
+     * Extract all available field paths from a data object
+     * Useful for dynamic field discovery based on platform-specific attributes
+     * @param obj - The data object to extract fields from
+     * @param prefix - Internal use for nested paths
+     * @param maxDepth - Maximum depth to traverse (default: 3)
+     * @returns Array of field paths (e.g., ['email', 'contact.firstName', 'customFields.industry'])
+     */
+    private extractAvailableFields;
+    /**
+     * Get available fields from sample data
+     * Helps with dynamic field detection for platform-specific attributes
+     * @param sampleData - Sample data object to analyze
+     * @returns Array of available field paths
+     */
+    getAvailableFields(sampleData: Record<string, unknown>): string[];
+    /**
+     * Create a simple email trigger
+     * Helper method for common use case
+     */
+    createEmailTrigger(config: {
+        name: string;
+        eventType: TriggerEventType;
+        to: string;
+        subject: string;
+        body: string;
+        conditions?: TriggerCondition[];
+    }): Promise<ApiResponse<EventTrigger>>;
+    /**
+     * Create a task creation trigger
+     */
+    createTaskTrigger(config: {
+        name: string;
+        eventType: TriggerEventType;
+        taskTitle: string;
+        taskDescription?: string;
+        priority?: 'low' | 'medium' | 'high' | 'urgent';
+        dueDays?: number;
+        conditions?: TriggerCondition[];
+    }): Promise<ApiResponse<EventTrigger>>;
+    /**
+     * Create a webhook trigger
+     */
+    createWebhookTrigger(config: {
+        name: string;
+        eventType: TriggerEventType;
+        webhookUrl: string;
+        method?: 'POST' | 'PUT' | 'PATCH';
+        conditions?: TriggerCondition[];
+    }): Promise<ApiResponse<EventTrigger>>;
+}
+
+/**
+ * Clianta SDK - CRM API Client
+ * @see SDK_VERSION in core/config.ts
+ */
+
+type InboundEventType = 'user.registered' | 'user.updated' | 'user.subscribed' | 'user.unsubscribed' | 'contact.created' | 'contact.updated' | 'purchase.completed';
+interface InboundEventPayload {
+    /** Event type (e.g. "user.registered") */
+    event: InboundEventType;
+    /** Contact data — at least email or phone is required */
+    contact: {
+        email?: string;
+        phone?: string;
+        firstName?: string;
+        lastName?: string;
+        company?: string;
+        jobTitle?: string;
+        tags?: string[];
+    };
+    /** Optional extra data stored as customFields on the contact */
+    data?: Record<string, unknown>;
+}
+interface InboundEventResult {
+    success: boolean;
+    contactCreated: boolean;
+    contactId?: string;
+    event: string;
+    error?: string;
+}
+/**
+ * CRM API Client for managing contacts and opportunities
+ */
+declare class CRMClient {
+    private apiEndpoint;
+    private workspaceId;
+    private authToken?;
+    private apiKey?;
+    triggers: EventTriggersManager;
+    constructor(apiEndpoint: string, workspaceId: string, authToken?: string, apiKey?: string);
+    /**
+     * Set authentication token for API requests (user JWT)
+     */
+    setAuthToken(token: string): void;
+    /**
+     * Set workspace API key for server-to-server requests.
+     * Use this instead of setAuthToken when integrating from an external app.
+     */
+    setApiKey(key: string): void;
+    /**
+     * Validate required parameter exists
+     * @throws {Error} if value is null/undefined or empty string
+     */
+    private validateRequired;
+    /**
+     * Make authenticated API request
+     */
+    private request;
+    /**
+     * Send an inbound event from an external app (e.g. user signup on client website).
+     * Requires the client to be initialized with an API key via setApiKey() or the constructor.
+     *
+     * The contact is upserted in the CRM and matching workflow automations fire automatically.
+     *
+     * @example
+     * const crm = new CRMClient('http://localhost:5000', 'WORKSPACE_ID');
+     * crm.setApiKey('mm_live_...');
+     *
+     * await crm.sendEvent({
+     *   event: 'user.registered',
+     *   contact: { email: 'alice@example.com', firstName: 'Alice' },
+     *   data: { plan: 'free', signupSource: 'homepage' },
+     * });
+     */
+    sendEvent(payload: InboundEventPayload): Promise<InboundEventResult>;
+    /**
+     * Get all contacts with pagination
+     */
+    getContacts(params?: {
+        page?: number;
+        limit?: number;
+        search?: string;
+        status?: string;
+    }): Promise<ApiResponse<PaginatedResponse<Contact>>>;
+    /**
+     * Get a single contact by ID
+     */
+    getContact(contactId: string): Promise<ApiResponse<Contact>>;
+    /**
+     * Create a new contact
+     */
+    createContact(contact: Partial<Contact>): Promise<ApiResponse<Contact>>;
+    /**
+     * Update an existing contact
+     */
+    updateContact(contactId: string, updates: Partial<Contact>): Promise<ApiResponse<Contact>>;
+    /**
+     * Delete a contact
+     */
+    deleteContact(contactId: string): Promise<ApiResponse<void>>;
+    /**
+     * Get all opportunities with pagination
+     */
+    getOpportunities(params?: {
+        page?: number;
+        limit?: number;
+        pipelineId?: string;
+        stageId?: string;
+    }): Promise<ApiResponse<PaginatedResponse<Opportunity>>>;
+    /**
+     * Get a single opportunity by ID
+     */
+    getOpportunity(opportunityId: string): Promise<ApiResponse<Opportunity>>;
+    /**
+     * Create a new opportunity
+     */
+    createOpportunity(opportunity: Partial<Opportunity>): Promise<ApiResponse<Opportunity>>;
+    /**
+     * Update an existing opportunity
+     */
+    updateOpportunity(opportunityId: string, updates: Partial<Opportunity>): Promise<ApiResponse<Opportunity>>;
+    /**
+     * Delete an opportunity
+     */
+    deleteOpportunity(opportunityId: string): Promise<ApiResponse<void>>;
+    /**
+     * Move opportunity to a different stage
+     */
+    moveOpportunity(opportunityId: string, stageId: string): Promise<ApiResponse<Opportunity>>;
+    /**
+     * Get all companies with pagination
+     */
+    getCompanies(params?: {
+        page?: number;
+        limit?: number;
+        search?: string;
+        status?: string;
+        industry?: string;
+    }): Promise<ApiResponse<PaginatedResponse<Company>>>;
+    /**
+     * Get a single company by ID
+     */
+    getCompany(companyId: string): Promise<ApiResponse<Company>>;
+    /**
+     * Create a new company
+     */
+    createCompany(company: Partial<Company>): Promise<ApiResponse<Company>>;
+    /**
+     * Update an existing company
+     */
+    updateCompany(companyId: string, updates: Partial<Company>): Promise<ApiResponse<Company>>;
+    /**
+     * Delete a company
+     */
+    deleteCompany(companyId: string): Promise<ApiResponse<void>>;
+    /**
+     * Get contacts belonging to a company
+     */
+    getCompanyContacts(companyId: string, params?: {
+        page?: number;
+        limit?: number;
+    }): Promise<ApiResponse<PaginatedResponse<Contact>>>;
+    /**
+     * Get deals/opportunities belonging to a company
+     */
+    getCompanyDeals(companyId: string, params?: {
+        page?: number;
+        limit?: number;
+    }): Promise<ApiResponse<PaginatedResponse<Opportunity>>>;
+    /**
+     * Get all pipelines
+     */
+    getPipelines(): Promise<ApiResponse<Pipeline[]>>;
+    /**
+     * Get a single pipeline by ID
+     */
+    getPipeline(pipelineId: string): Promise<ApiResponse<Pipeline>>;
+    /**
+     * Create a new pipeline
+     */
+    createPipeline(pipeline: Partial<Pipeline>): Promise<ApiResponse<Pipeline>>;
+    /**
+     * Update an existing pipeline
+     */
+    updatePipeline(pipelineId: string, updates: Partial<Pipeline>): Promise<ApiResponse<Pipeline>>;
+    /**
+     * Delete a pipeline
+     */
+    deletePipeline(pipelineId: string): Promise<ApiResponse<void>>;
+    /**
+     * Get all tasks with pagination
+     */
+    getTasks(params?: {
+        page?: number;
+        limit?: number;
+        status?: string;
+        priority?: string;
+        contactId?: string;
+        companyId?: string;
+        opportunityId?: string;
+    }): Promise<ApiResponse<PaginatedResponse<Task>>>;
+    /**
+     * Get a single task by ID
+     */
+    getTask(taskId: string): Promise<ApiResponse<Task>>;
+    /**
+     * Create a new task
+     */
+    createTask(task: Partial<Task>): Promise<ApiResponse<Task>>;
+    /**
+     * Update an existing task
+     */
+    updateTask(taskId: string, updates: Partial<Task>): Promise<ApiResponse<Task>>;
+    /**
+     * Mark a task as completed
+     */
+    completeTask(taskId: string): Promise<ApiResponse<Task>>;
+    /**
+     * Delete a task
+     */
+    deleteTask(taskId: string): Promise<ApiResponse<void>>;
+    /**
+     * Get activities for a contact
+     */
+    getContactActivities(contactId: string, params?: {
+        page?: number;
+        limit?: number;
+        type?: string;
+    }): Promise<ApiResponse<PaginatedResponse<Activity>>>;
+    /**
+     * Get activities for an opportunity/deal
+     */
+    getOpportunityActivities(opportunityId: string, params?: {
+        page?: number;
+        limit?: number;
+        type?: string;
+    }): Promise<ApiResponse<PaginatedResponse<Activity>>>;
+    /**
+     * Create a new activity
+     */
+    createActivity(activity: Partial<Activity>): Promise<ApiResponse<Activity>>;
+    /**
+     * Update an existing activity
+     */
+    updateActivity(activityId: string, updates: Partial<Activity>): Promise<ApiResponse<Activity>>;
+    /**
+     * Delete an activity
+     */
+    deleteActivity(activityId: string): Promise<ApiResponse<void>>;
+    /**
+     * Log a call activity
+     */
+    logCall(data: {
+        contactId?: string;
+        opportunityId?: string;
+        direction: 'inbound' | 'outbound';
+        duration?: number;
+        outcome?: string;
+        notes?: string;
+    }): Promise<ApiResponse<Activity>>;
+    /**
+     * Log a meeting activity
+     */
+    logMeeting(data: {
+        contactId?: string;
+        opportunityId?: string;
+        title: string;
+        duration?: number;
+        outcome?: string;
+        notes?: string;
+    }): Promise<ApiResponse<Activity>>;
+    /**
+     * Add a note to a contact or opportunity
+     */
+    addNote(data: {
+        contactId?: string;
+        opportunityId?: string;
+        content: string;
+    }): Promise<ApiResponse<Activity>>;
+    /**
+     * Get all email templates
+     */
+    getEmailTemplates(params?: {
+        page?: number;
+        limit?: number;
+    }): Promise<ApiResponse<PaginatedResponse<EmailTemplate>>>;
+    /**
+     * Get a single email template by ID
+     */
+    getEmailTemplate(templateId: string): Promise<ApiResponse<EmailTemplate>>;
+    /**
+     * Create a new email template
+     */
+    createEmailTemplate(template: Partial<EmailTemplate>): Promise<ApiResponse<EmailTemplate>>;
+    /**
+     * Update an email template
+     */
+    updateEmailTemplate(templateId: string, updates: Partial<EmailTemplate>): Promise<ApiResponse<EmailTemplate>>;
+    /**
+     * Delete an email template
+     */
+    deleteEmailTemplate(templateId: string): Promise<ApiResponse<void>>;
+    /**
+     * Send an email using a template
+     */
+    sendEmail(data: {
+        to: string;
+        templateId?: string;
+        subject?: string;
+        body?: string;
+        cc?: string[];
+        bcc?: string[];
+        variables?: Record<string, unknown>;
+        contactId?: string;
+    }): Promise<ApiResponse<{
+        messageId: string;
+    }>>;
+    /**
+     * Get a contact by email address.
+     * Returns the first matching contact from a search query.
+     */
+    getContactByEmail(email: string): Promise<ApiResponse<PaginatedResponse<Contact>>>;
+    /**
+     * Get activity timeline for a contact
+     */
+    getContactActivity(contactId: string, params?: {
+        page?: number;
+        limit?: number;
+        type?: string;
+        startDate?: string;
+        endDate?: string;
+    }): Promise<ApiResponse<PaginatedResponse<Activity>>>;
+    /**
+     * Get engagement metrics for a contact (via their linked visitor data)
+     */
+    getContactEngagement(contactId: string): Promise<ApiResponse<{
+        totalTimeOnSiteSeconds: number;
+        averageSessionDurationSeconds: number;
+        totalPageViews: number;
+        totalSessions: number;
+        engagementScore: number;
+        lastActiveAt: string;
+    }>>;
+    /**
+     * Get a full timeline for a contact including events, activities, and opportunities
+     */
+    getContactTimeline(contactId: string, params?: {
+        page?: number;
+        limit?: number;
+    }): Promise<ApiResponse<PaginatedResponse<{
+        type: 'event' | 'activity' | 'opportunity' | 'note';
+        title: string;
+        description?: string;
+        timestamp: string;
+        metadata?: Record<string, unknown>;
+    }>>>;
+    /**
+     * Search contacts with advanced filters
+     */
+    searchContacts(query: string, filters?: {
+        status?: string;
+        lifecycleStage?: string;
+        source?: string;
+        tags?: string[];
+        page?: number;
+        limit?: number;
+    }): Promise<ApiResponse<PaginatedResponse<Contact>>>;
+    /**
+     * List all webhook subscriptions
+     */
+    listWebhooks(params?: {
+        page?: number;
+        limit?: number;
+    }): Promise<ApiResponse<PaginatedResponse<{
+        _id: string;
+        url: string;
+        events: string[];
+        isActive: boolean;
+        createdAt: string;
+    }>>>;
+    /**
+     * Create a new webhook subscription
+     */
+    createWebhook(data: {
+        url: string;
+        events: string[];
+        secret?: string;
+    }): Promise<ApiResponse<{
+        _id: string;
+        url: string;
+        events: string[];
+        isActive: boolean;
+    }>>;
+    /**
+     * Delete a webhook subscription
+     */
+    deleteWebhook(webhookId: string): Promise<ApiResponse<void>>;
+    /**
+     * Get all event triggers
+     */
+    getEventTriggers(): Promise<ApiResponse<EventTrigger[]>>;
+    /**
+     * Create a new event trigger
+     */
+    createEventTrigger(trigger: Partial<EventTrigger>): Promise<ApiResponse<EventTrigger>>;
+    /**
+     * Update an event trigger
+     */
+    updateEventTrigger(triggerId: string, updates: Partial<EventTrigger>): Promise<ApiResponse<EventTrigger>>;
+    /**
+     * Delete an event trigger
+     */
+    deleteEventTrigger(triggerId: string): Promise<ApiResponse<void>>;
+}
+
 /**
  * Clianta SDK
  * Client-side tracking SDK for CRM — tracks visitors, identifies contacts,
@@ -563,5 +1383,5 @@ declare const SDK_VERSION = "1.7.2";
  */
 declare function clianta(workspaceId: string, config?: CliantaConfig): TrackerCore;
 
-export { ConsentManager, SDK_VERSION, Tracker, clianta, clianta as default };
-export type { CliantaConfig, ConsentChangeCallback, ConsentConfig, ConsentManagerConfig, ConsentState, EventType, GroupTraits, MiddlewareFn, Plugin, PluginName, PublicActivityData, PublicContactData, PublicContactUpdate, PublicCrmResult, PublicFormSubmission, PublicOpportunityData, StoredConsent, TrackerCore, TrackingEvent, UserTraits };
+export { CRMClient, ConsentManager, SDK_VERSION, Tracker, clianta, clianta as default };
+export type { CliantaConfig, ConsentChangeCallback, ConsentConfig, ConsentManagerConfig, ConsentState, EventType, GroupTraits, InboundEventPayload, InboundEventResult, InboundEventType, MiddlewareFn, Plugin, PluginName, PublicActivityData, PublicContactData, PublicContactUpdate, PublicCrmResult, PublicFormSubmission, PublicOpportunityData, StoredConsent, TrackerCore, TrackingEvent, UserTraits };