@startsimpli/api 0.5.5 → 0.5.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@startsimpli/api",
-  "version": "0.5.5",
+  "version": "0.5.7",
   "description": "Type-safe Django REST API client for StartSimpli apps",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/constants/endpoints.ts

@@ -40,6 +40,10 @@ export const ENDPOINTS = {
   // Funnels
   FUNNELS: 'api/v1/funnels',
   FUNNEL: (id: string) => `api/v1/funnels/${id}`,
+  FUNNEL_PIPELINE: (id: string) => `api/v1/funnels/${id}/pipeline`,
+  FUNNEL_ADD_ENTITY: (id: string) => `api/v1/funnels/${id}/add_entity`,
+  FUNNEL_MOVE: (id: string) => `api/v1/funnels/${id}/move`,
+  FUNNEL_STATS: (id: string) => `api/v1/funnels/${id}/stats`,
   FUNNEL_RUN: (id: string) => `api/v1/funnels/${id}/run`,
   FUNNEL_RUNS: (id: string) => `api/v1/funnels/${id}/runs`,
   FUNNEL_RUN_ITEM: (funnelId: string, runId: string) => `api/v1/funnels/${funnelId}/runs/${runId}`,
@@ -49,6 +53,10 @@ export const ENDPOINTS = {
   FUNNEL_RUN_BY_ID: (runId: string) => `api/v1/funnel-runs/${runId}`,
   FUNNEL_RUN_CANCEL: (runId: string) => `api/v1/funnel-runs/${runId}/cancel`,
   FUNNEL_RUNS_GLOBAL: 'api/v1/funnel-runs',
+  // Enrichment
+  ENRICHMENT_QUEUE: 'api/v1/enrichment/start-processing',
+  CONTACT_ENRICH: (id: string) => `api/v1/contacts/${id}/enrich`,
+
   // Users
   USER_ME: 'api/v1/users/me',
   USER_CHANGE_PASSWORD: 'api/v1/users/me/change-password',

package/src/index.ts

@@ -15,11 +15,29 @@ export { OrganizationsApi } from './lib/organizations-api';
 export { EntitiesApi } from './lib/entities-api';
 export { WorkflowsApi } from './lib/workflows-api';
 export { MessagesApi } from './lib/messages-api';
-export type { Message, MessageStatus as MessageApiStatus, MessageRecipient, MessagingChannel as MessagingChannelType } from './lib/messages-api';
+export type { Message, MessageStatus as MessageApiStatus, MessageRecipient, MessagingChannel as MessagingChannelType, MessageFilters, CreateMessageInput, ScheduleMessageInput, SendTestInput } from './lib/messages-api';
+export { MessageTemplatesApi } from './lib/message-templates-api';
+export type { MessageTemplate, MessageTemplateFilters, CreateMessageTemplateInput } from './lib/message-templates-api';
 export { UsersApi } from './lib/users-api';
 export type { UserProfile, UpdateProfileRequest, ChangePasswordRequest, ChangePasswordResponse } from './types/user';
 export { FunnelsApi, isFunnelRunConflict, isFunnelValidationError } from './lib/funnels-api';
 export type { FunnelPreviewResult, FunnelRunFilters, FunnelTemplate } from './lib/funnels-api';
+export { EnrichmentApi } from './lib/enrichment-api';
+export { TargetListsApi } from './lib/target-lists-api';
+export type {
+  TargetList,
+  TargetListMember,
+  CreateTargetListInput,
+  UpdateTargetListInput,
+  TargetListFilters,
+  TargetListMemberFilters,
+  TargetType,
+  ListSourceType,
+  RefreshStrategy,
+  AddMembersResult,
+  RemoveMembersResult,
+  RefreshResult,
+} from './lib/target-lists-api';
 
 // Feature flags
 export { FeatureFlagsApi, FeatureFlagProvider, useFeatureFlags } from './lib/feature-flags';
@@ -129,6 +147,9 @@ import { MessagesApi } from './lib/messages-api';
 import { FunnelsApi } from './lib/funnels-api';
 import { FeatureFlagsApi } from './lib/feature-flags';
 import { UsersApi } from './lib/users-api';
+import { EnrichmentApi } from './lib/enrichment-api';
+import { TargetListsApi } from './lib/target-lists-api';
+import { MessageTemplatesApi } from './lib/message-templates-api';
 
 import type { ApiClientConfig } from './lib/api-client';
 
@@ -149,5 +170,8 @@ export function createStartSimpliApi(config: ApiClientConfig = {}) {
     funnels: new FunnelsApi(client),
     featureFlags: new FeatureFlagsApi(client),
     users: new UsersApi(client),
+    enrichment: new EnrichmentApi(client),
+    targetLists: new TargetListsApi(client),
+    messageTemplates: new MessageTemplatesApi(client),
   };
 }

package/src/lib/enrichment-api.ts

@@ -0,0 +1,57 @@
+/**
+ * Enrichment API wrapper for /api/v1/enrichment/ and /api/v1/contacts/:id/enrich/
+ */
+
+import type { EnrichmentResult, QueueStatus } from '../types';
+import { ENDPOINTS } from '../constants/endpoints';
+import type { ApiClient } from './api-client';
+
+export class EnrichmentApi {
+  constructor(private client: ApiClient) {}
+
+  /**
+   * Enrich a single contact by ID
+   */
+  async enrich(contactId: string): Promise<EnrichmentResult> {
+    return this.client.fetch.post<EnrichmentResult>(
+      ENDPOINTS.CONTACT_ENRICH(contactId),
+      {}
+    );
+  }
+
+  /**
+   * Enrich multiple contacts. Calls the single-contact endpoint for each ID.
+   * Returns results in order, including failures.
+   */
+  async bulkEnrich(
+    contactIds: string[],
+    onProgress?: (completed: number, total: number) => void
+  ): Promise<EnrichmentResult[]> {
+    const results: EnrichmentResult[] = [];
+
+    for (let i = 0; i < contactIds.length; i++) {
+      try {
+        const result = await this.enrich(contactIds[i]);
+        results.push(result);
+      } catch (err: unknown) {
+        results.push({
+          contactId: contactIds[i],
+          contactName: '',
+          success: false,
+          fieldsUpdated: [],
+          error: err instanceof Error ? err.message : 'Enrichment failed',
+        });
+      }
+      onProgress?.(i + 1, contactIds.length);
+    }
+
+    return results;
+  }
+
+  /**
+   * Get the current enrichment queue status
+   */
+  async getQueueStatus(): Promise<QueueStatus> {
+    return this.client.fetch.get<QueueStatus>(ENDPOINTS.ENRICHMENT_QUEUE);
+  }
+}

package/src/lib/funnels-api.ts

@@ -123,6 +123,44 @@ export class FunnelsApi {
     return this.client.delete<void>(ENDPOINTS.FUNNEL(id));
   }
 
+  // ── Generic pipeline actions (work with any funnel/profile) ──────────
+
+  /**
+   * Get entities grouped by stage (kanban view).
+   * Works for any funnel that has a membership run with entities in stages.
+   */
+  async pipeline(id: string): Promise<Record<string, FunnelResult[]>> {
+    return this.client.get<Record<string, FunnelResult[]>>(ENDPOINTS.FUNNEL_PIPELINE(id));
+  }
+
+  /**
+   * Add an entity to a funnel's membership run.
+   * Creates a FunnelResult with the entity + optional context (deal amount, notes, etc.)
+   */
+  async addEntity(
+    funnelId: string,
+    data: { entityId: string; stage?: string; context?: Record<string, unknown> }
+  ): Promise<FunnelResult> {
+    return this.client.post<FunnelResult>(ENDPOINTS.FUNNEL_ADD_ENTITY(funnelId), data);
+  }
+
+  /**
+   * Move an entity to a different stage within a funnel.
+   */
+  async move(
+    funnelId: string,
+    data: { entityId: string; newStage: string; context?: Record<string, unknown> }
+  ): Promise<FunnelResult> {
+    return this.client.post<FunnelResult>(ENDPOINTS.FUNNEL_MOVE(funnelId), data);
+  }
+
+  /**
+   * Get funnel statistics (stage counts, conversion rates, etc.)
+   */
+  async stats(funnelId: string): Promise<Record<string, unknown>> {
+    return this.client.get<Record<string, unknown>>(ENDPOINTS.FUNNEL_STATS(funnelId));
+  }
+
   /**
    * Execute a funnel run
    */
@@ -157,24 +195,26 @@ export class FunnelsApi {
     return this.client.get<FunnelRun>(ENDPOINTS.FUNNEL_RUN_BY_ID(runId));
   }
 
-  // BEAD: fund-your-startup-rgi4 - funnels/{id}/results endpoint missing from Django FunnelViewSet
+  /**
+   * Get results (entities) from a funnel's latest completed run.
+   */
   async getResults(
-    _funnelId: string,
-    _pagination?: PaginationParams
+    funnelId: string,
+    pagination?: PaginationParams
   ): Promise<PaginatedResponse<FunnelResult>> {
-    throw new Error('Not implemented - BEAD: fund-your-startup-rgi4. funnels/{id}/results action does not exist in Django.');
-    // const params = new URLSearchParams();
-    // if (_pagination?.page) params.append('page', String(_pagination.page));
-    // if (_pagination?.pageSize) params.append('pageSize', String(_pagination.pageSize));
-    // const query = params.toString();
-    // const endpoint = query ? `${ENDPOINTS.FUNNEL_RESULTS(_funnelId)}?${query}` : ENDPOINTS.FUNNEL_RESULTS(_funnelId);
-    // return this.client.get<PaginatedResponse<FunnelResult>>(endpoint);
-  }
-
-  // BEAD: fund-your-startup-rgi4 - funnels/{id}/preview endpoint missing. Django has /funnels/preview-icp/ (different signature).
-  async preview(_funnelId: string, _stages?: Funnel['stages']): Promise<FunnelPreviewResult> {
-    throw new Error('Not implemented - BEAD: fund-your-startup-rgi4. funnels/{id}/preview action does not exist in Django.');
-    // return this.client.post<FunnelPreviewResult>(ENDPOINTS.FUNNEL_PREVIEW(_funnelId), { stages: _stages });
+    const params = new URLSearchParams();
+    if (pagination?.page) params.append('page', String(pagination.page));
+    if (pagination?.pageSize) params.append('page_size', String(pagination.pageSize));
+    const query = params.toString();
+    const endpoint = query ? `${ENDPOINTS.FUNNEL_RESULTS(funnelId)}?${query}` : ENDPOINTS.FUNNEL_RESULTS(funnelId);
+    return this.client.get<PaginatedResponse<FunnelResult>>(endpoint);
+  }
+
+  /**
+   * Preview funnel execution without persisting results.
+   */
+  async preview(funnelId: string, stages?: Funnel['stages']): Promise<FunnelPreviewResult> {
+    return this.client.post<FunnelPreviewResult>(ENDPOINTS.FUNNEL_PREVIEW(funnelId), { stages });
   }
 
   /**

package/src/lib/message-templates-api.ts

@@ -0,0 +1,95 @@
+/**
+ * Message Templates API wrapper
+ *
+ * Provides type-safe access to Django Message Templates API
+ */
+
+import type { ApiClient } from './api-client';
+
+export interface MessageTemplate {
+  id: string;
+  name: string;
+  description: string | null;
+  subjectTemplate: string;
+  bodyTemplate: string;
+  channel: string | null;
+  entityType: string | null;
+  category: string | null;
+  isDefault: boolean;
+  useCount: number;
+  blocks: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface MessageTemplateFilters {
+  channel?: string;
+  entityType?: string;
+  category?: string;
+  search?: string;
+  page?: number;
+  pageSize?: number;
+  ordering?: string;
+}
+
+export interface CreateMessageTemplateInput {
+  name: string;
+  description?: string;
+  subjectTemplate: string;
+  bodyTemplate: string;
+  channel?: string;
+  entityType?: string;
+  category?: string;
+  blocks?: string | null;
+}
+
+export class MessageTemplatesApi {
+  constructor(private client: ApiClient) {}
+
+  /**
+   * List message templates with optional filters
+   */
+  async list(filters?: MessageTemplateFilters) {
+    const params = new URLSearchParams();
+
+    if (filters?.channel) params.append('channel', filters.channel);
+    if (filters?.entityType) params.append('entityType', filters.entityType);
+    if (filters?.category) params.append('category', filters.category);
+    if (filters?.search) params.append('search', filters.search);
+    if (filters?.page) params.append('page', String(filters.page));
+    if (filters?.pageSize) params.append('pageSize', String(filters.pageSize));
+    if (filters?.ordering) params.append('ordering', filters.ordering);
+
+    return this.client.get<{ results: MessageTemplate[]; count: number; next: string | null; previous: string | null }>(
+      `/api/v1/message-templates/?${params.toString()}`
+    );
+  }
+
+  /**
+   * Get message template by ID
+   */
+  async get(id: string) {
+    return this.client.get<MessageTemplate>(`/api/v1/message-templates/${id}/`);
+  }
+
+  /**
+   * Create a new message template
+   */
+  async create(data: CreateMessageTemplateInput) {
+    return this.client.post<MessageTemplate>('/api/v1/message-templates/', data);
+  }
+
+  /**
+   * Update message template
+   */
+  async update(id: string, data: Partial<CreateMessageTemplateInput>) {
+    return this.client.patch<MessageTemplate>(`/api/v1/message-templates/${id}/`, data);
+  }
+
+  /**
+   * Delete message template
+   */
+  async delete(id: string) {
+    return this.client.delete(`/api/v1/message-templates/${id}/`);
+  }
+}

package/src/lib/target-lists-api.ts

@@ -0,0 +1,190 @@
+/**
+ * Target Lists API wrapper for /api/v1/targets/lists/
+ *
+ * Shared across all StartSimpli apps for managing contact/organization lists.
+ * All types use camelCase — FetchWrapper auto-converts snake_case↔camelCase.
+ */
+
+import type { ApiClient } from './api-client';
+import type { PaginatedResponse } from '../types';
+
+// ── Types (camelCase — auto-converted from Django snake_case by FetchWrapper) ──
+
+export type TargetType = 'contact' | 'organization';
+export type ListSourceType = 'static' | 'funnel' | 'query';
+export type RefreshStrategy = 'manual' | 'on_funnel_run' | 'scheduled';
+
+export interface TargetList {
+  id: string;
+  name: string;
+  description: string;
+  targetType: TargetType;
+  sourceType: ListSourceType;
+  memberCount: number;
+  refreshStrategy: RefreshStrategy;
+  lastRefreshedAt: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface TargetListMember {
+  id: string;
+  objectId: string;
+  contentType: string;
+  addedAt: string;
+  metadata: Record<string, unknown>;
+  name?: string;
+  email?: string;
+  firm?: string;
+}
+
+export interface CreateTargetListInput {
+  name: string;
+  description?: string;
+  targetType?: TargetType;
+  sourceType?: ListSourceType;
+}
+
+export interface UpdateTargetListInput {
+  name?: string;
+  description?: string;
+}
+
+export interface TargetListFilters {
+  targetType?: TargetType;
+  search?: string;
+  page?: number;
+  pageSize?: number;
+  ordering?: string;
+}
+
+export interface TargetListMemberFilters {
+  search?: string;
+  page?: number;
+  pageSize?: number;
+  ordering?: string;
+}
+
+export interface AddMembersResult {
+  added: number;
+  alreadyExists: number;
+  total: number;
+}
+
+export interface RemoveMembersResult {
+  removed: number;
+  total: number;
+}
+
+export interface RefreshResult {
+  added: number;
+  removed: number;
+  total: number;
+}
+
+// ── Endpoints ────────────────────────────────────────────────────────────
+
+const LISTS_BASE = 'api/v1/targets/lists';
+const LIST = (id: string) => `${LISTS_BASE}/${id}`;
+const LIST_MEMBERS = (id: string) => `${LISTS_BASE}/${id}/members`;
+const LIST_ADD_MEMBERS = (id: string) => `${LISTS_BASE}/${id}/add_members`;
+const LIST_REMOVE_MEMBERS = (id: string) => `${LISTS_BASE}/${id}/remove_members`;
+const LIST_REFRESH = (id: string) => `${LISTS_BASE}/${id}/refresh`;
+
+// ── API Class ────────────────────────────────────────────────────────────
+
+export class TargetListsApi {
+  constructor(private client: ApiClient) {}
+
+  /** List all target lists with pagination and filters */
+  async list(filters?: TargetListFilters): Promise<PaginatedResponse<TargetList>> {
+    // Query params use snake_case (sent directly to Django as URL params)
+    const params: Record<string, string> = {};
+    if (filters?.targetType) params.target_type = filters.targetType;
+    if (filters?.search) params.search = filters.search;
+    if (filters?.page) params.page = String(filters.page);
+    if (filters?.pageSize) params.page_size = String(filters.pageSize);
+    if (filters?.ordering) params.ordering = filters.ordering;
+
+    const response = await this.client.fetch.get<PaginatedResponse<TargetList> | TargetList[]>(
+      LISTS_BASE,
+      { params }
+    );
+
+    if (Array.isArray(response)) {
+      return { count: response.length, results: response, next: null, previous: null };
+    }
+    return response as PaginatedResponse<TargetList>;
+  }
+
+  /** Get a single target list by ID */
+  async get(id: string): Promise<TargetList> {
+    return this.client.fetch.get<TargetList>(LIST(id));
+  }
+
+  /** Create a new target list (camelCase body → auto-converted to snake_case by serializeBody) */
+  async create(data: CreateTargetListInput): Promise<TargetList> {
+    return this.client.fetch.post<TargetList>(LISTS_BASE, {
+      name: data.name,
+      description: data.description || '',
+      targetType: data.targetType || 'contact',
+      sourceType: data.sourceType || 'static',
+    });
+  }
+
+  /** Update an existing target list */
+  async update(id: string, data: UpdateTargetListInput): Promise<TargetList> {
+    return this.client.fetch.patch<TargetList>(LIST(id), data);
+  }
+
+  /** Delete a target list */
+  async delete(id: string): Promise<void> {
+    return this.client.fetch.delete(LIST(id));
+  }
+
+  /** Get members of a target list with pagination */
+  async getMembers(
+    listId: string,
+    filters?: TargetListMemberFilters
+  ): Promise<PaginatedResponse<TargetListMember>> {
+    const params: Record<string, string> = {};
+    if (filters?.search) params.search = filters.search;
+    if (filters?.page) params.page = String(filters.page);
+    if (filters?.pageSize) params.page_size = String(filters.pageSize);
+    if (filters?.ordering) params.ordering = filters.ordering;
+
+    const response = await this.client.fetch.get<PaginatedResponse<TargetListMember> | TargetListMember[]>(
+      LIST_MEMBERS(listId),
+      { params }
+    );
+
+    if (Array.isArray(response)) {
+      return { count: response.length, results: response, next: null, previous: null };
+    }
+    return response as PaginatedResponse<TargetListMember>;
+  }
+
+  /** Add members (camelCase body → auto-converted to snake_case) */
+  async addMembers(
+    listId: string,
+    objectIds: string[],
+    metadata?: Record<string, unknown>
+  ): Promise<AddMembersResult> {
+    return this.client.fetch.post<AddMembersResult>(LIST_ADD_MEMBERS(listId), {
+      objectIds,
+      ...(metadata ? { metadata } : {}),
+    });
+  }
+
+  /** Remove members */
+  async removeMembers(listId: string, objectIds: string[]): Promise<RemoveMembersResult> {
+    return this.client.fetch.post<RemoveMembersResult>(LIST_REMOVE_MEMBERS(listId), {
+      objectIds,
+    });
+  }
+
+  /** Refresh a funnel/query-based list */
+  async refresh(listId: string): Promise<RefreshResult> {
+    return this.client.fetch.post<RefreshResult>(LIST_REFRESH(listId));
+  }
+}

package/src/types/enrichment.ts

@@ -0,0 +1,28 @@
+/**
+ * Enrichment types — shared across all StartSimpli apps
+ */
+
+export interface EnrichmentResult {
+  contactId: string;
+  contactName: string;
+  success: boolean;
+  fieldsUpdated: string[];
+  error?: string;
+}
+
+export interface QueueStatus {
+  pending: number;
+  processing: number;
+  completed: number;
+  failed: number;
+}
+
+export type EnrichmentProvider = 'apollo' | 'hunter';
+
+export interface IntegrationStatus {
+  name: string;
+  provider: EnrichmentProvider;
+  connected: boolean;
+  description: string;
+  lastSync?: string;
+}

package/src/types/index.ts

@@ -89,6 +89,14 @@ export type {
   ChangePasswordResponse,
 } from './user';
 
+// Enrichment types
+export type {
+  EnrichmentResult,
+  QueueStatus,
+  EnrichmentProvider,
+  IntegrationStatus,
+} from './enrichment';
+
 // Error types
 export type {
   FieldError,

package/src/types/user.ts

@@ -1,29 +1,30 @@
 /**
  * User types for /api/v1/users/ endpoints
+ * camelCase — FetchWrapper auto-converts snake_case↔camelCase at boundary
  */
 
 export interface UserProfile {
   id: string;
   email: string;
-  first_name: string;
-  last_name: string;
-  full_name: string;
-  is_email_verified: boolean;
+  firstName: string;
+  lastName: string;
+  fullName: string;
+  isEmailVerified: boolean;
   company: string | null;
-  is_active: boolean;
-  created_at: string;
-  updated_at: string;
+  isActive: boolean;
+  createdAt: string;
+  updatedAt: string;
 }
 
 export interface UpdateProfileRequest {
-  first_name?: string;
-  last_name?: string;
+  firstName?: string;
+  lastName?: string;
 }
 
 export interface ChangePasswordRequest {
-  old_password: string;
-  new_password: string;
-  new_password_confirm: string;
+  oldPassword: string;
+  newPassword: string;
+  newPasswordConfirm: string;
 }
 
 export interface ChangePasswordResponse {