@startsimpli/api 0.1.0 → 0.2.2

package/dist/index.js

@@ -0,0 +1,2092 @@
+'use strict';
+
+var DOMPurify = require('isomorphic-dompurify');
+var zod = require('zod');
+var react = require('react');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var DOMPurify__default = /*#__PURE__*/_interopDefault(DOMPurify);
+
+// src/utils/url-builder.ts
+function buildUrl({ baseUrl, endpoint, params, id }) {
+  const cleanBase = baseUrl.replace(/\/$/, "");
+  const cleanEndpoint = endpoint.replace(/^\//, "");
+  let path = `${cleanBase}/${cleanEndpoint}`;
+  if (id !== void 0) {
+    path += `/${id}`;
+  }
+  if (!path.endsWith("/")) {
+    path += "/";
+  }
+  if (params && Object.keys(params).length > 0) {
+    const queryString = buildQueryString(params);
+    if (queryString) {
+      path += `?${queryString}`;
+    }
+  }
+  return path;
+}
+function buildQueryString(params) {
+  const searchParams = new URLSearchParams();
+  Object.entries(params).forEach(([key, value]) => {
+    if (value === void 0 || value === null) {
+      return;
+    }
+    if (Array.isArray(value)) {
+      value.forEach((item) => {
+        searchParams.append(key, String(item));
+      });
+    } else if (typeof value === "object") {
+      searchParams.append(key, JSON.stringify(value));
+    } else {
+      searchParams.append(key, String(value));
+    }
+  });
+  return searchParams.toString();
+}
+function resolveApiUrl(path, baseUrl = "") {
+  if (/^https?:\/\//i.test(path)) return path;
+  const normalized = path.startsWith("/") ? path : `/${path}`;
+  if (!baseUrl) return normalized;
+  if (/^https?:\/\//i.test(baseUrl)) {
+    return new URL(normalized, baseUrl).toString();
+  }
+  const cleanBase = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+  return `${cleanBase}${normalized}`;
+}
+function normalizeId(id) {
+  if (typeof id === "string" && id.includes("/")) {
+    const parts = id.split("/").filter(Boolean);
+    return parts[parts.length - 1];
+  }
+  return id;
+}
+
+// src/utils/query-params.ts
+function buildFilterParams(filters) {
+  const params = {};
+  Object.entries(filters).forEach(([key, value]) => {
+    if (value === void 0 || value === null) {
+      return;
+    }
+    if (typeof value === "boolean") {
+      params[key] = value;
+      return;
+    }
+    if (Array.isArray(value)) {
+      if (value.length > 0) {
+        params[`${key}__in`] = value.join(",");
+      }
+      return;
+    }
+    if (key.endsWith("_gte") || key.endsWith("_lte") || key.endsWith("_gt") || key.endsWith("_lt")) {
+      params[key] = value;
+      return;
+    }
+    params[key] = value;
+  });
+  return params;
+}
+function buildOrderingParam(field, direction = "asc") {
+  if (!field) {
+    return void 0;
+  }
+  return direction === "desc" ? `-${field}` : field;
+}
+function mergeQueryParams(pagination, sorting, filters) {
+  return {
+    ...filters,
+    ...pagination,
+    ...sorting
+  };
+}
+
+// src/utils/validate-response.ts
+function validateApiResponse(data, schema, context) {
+  const result = schema.safeParse(data);
+  if (!result.success) {
+    const label = context ? `[${context}]` : "[API validation]";
+    console.warn(
+      `${label} Schema mismatch \u2014 returning raw data.`,
+      result.error.flatten().fieldErrors
+    );
+    return data;
+  }
+  return result.data;
+}
+
+// src/utils/entity-query-builder.ts
+var EntityQueryBuilder = class {
+  constructor() {
+    this.params = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Filter by entity type
+   */
+  entityType(type) {
+    this.params.set("entity_type", type);
+    return this;
+  }
+  /**
+   * Add tag filters (compact format: "category:name")
+   *
+   * @example
+   * .withTags('quality:tier_1', 'status:prospect')
+   * // produces: tags=quality:tier_1,status:prospect
+   */
+  withTags(...tags) {
+    if (tags.length > 0) {
+      const existing = this.params.get("tags");
+      const combined = existing ? `${existing},${tags.join(",")}` : tags.join(",");
+      this.params.set("tags", combined);
+    }
+    return this;
+  }
+  /**
+   * Add metric filters (compact format: "type:subtype__operator:value")
+   *
+   * @example
+   * .withMetrics('financial:aum__gte:100000000', 'check_size:min__gte:1000000')
+   */
+  withMetrics(...metrics) {
+    if (metrics.length > 0) {
+      const existing = this.params.get("metrics");
+      const combined = existing ? `${existing},${metrics.join(",")}` : metrics.join(",");
+      this.params.set("metrics", combined);
+    }
+    return this;
+  }
+  /**
+   * Add profile filters (compact format: "type:subtype")
+   *
+   * @example
+   * .withProfiles('professional:linkedin', 'social:twitter')
+   */
+  withProfiles(...profiles) {
+    if (profiles.length > 0) {
+      const existing = this.params.get("profiles");
+      const combined = existing ? `${existing},${profiles.join(",")}` : profiles.join(",");
+      this.params.set("profiles", combined);
+    }
+    return this;
+  }
+  /**
+   * Add attribute filters (compact format: "type:subtype:value")
+   *
+   * @example
+   * .withAttributes('demographic:location:san_francisco')
+   */
+  withAttributes(...attrs) {
+    if (attrs.length > 0) {
+      const existing = this.params.get("attributes");
+      const combined = existing ? `${existing},${attrs.join(",")}` : attrs.join(",");
+      this.params.set("attributes", combined);
+    }
+    return this;
+  }
+  /**
+   * Set pagination parameters
+   */
+  paginate(page, pageSize) {
+    this.params.set("page", String(page));
+    this.params.set("page_size", String(pageSize));
+    return this;
+  }
+  /**
+   * Set search query
+   */
+  search(query) {
+    const trimmed = query.trim();
+    if (trimmed) {
+      this.params.set("search", trimmed);
+    }
+    return this;
+  }
+  /**
+   * Set sort field and direction (maps to Django's `ordering` param)
+   */
+  sort(field, direction = "asc") {
+    const prefix = direction === "desc" ? "-" : "";
+    this.params.set("ordering", `${prefix}${field}`);
+    return this;
+  }
+  /**
+   * Add a date range filter on a given field
+   *
+   * @example
+   * .withDateRange('created', new Date('2024-01-01'), new Date('2024-12-31'))
+   * // produces: created_after=2024-01-01&created_before=2024-12-31
+   */
+  withDateRange(field, from, to) {
+    if (from) {
+      this.params.set(`${field}_after`, from.toISOString().split("T")[0]);
+    }
+    if (to) {
+      this.params.set(`${field}_before`, to.toISOString().split("T")[0]);
+    }
+    return this;
+  }
+  /**
+   * Set an arbitrary query parameter
+   */
+  param(key, value) {
+    this.params.set(key, value);
+    return this;
+  }
+  /**
+   * Build as a plain object (suitable for URLSearchParams or fetch helpers)
+   */
+  build() {
+    const result = {};
+    this.params.forEach((value, key) => {
+      result[key] = value;
+    });
+    return result;
+  }
+  /**
+   * Build as a query string (includes leading `?`)
+   * Returns empty string if no params.
+   */
+  toQueryString() {
+    if (this.params.size === 0) return "";
+    const searchParams = new URLSearchParams();
+    this.params.forEach((value, key) => {
+      searchParams.set(key, value);
+    });
+    return `?${searchParams.toString()}`;
+  }
+  /**
+   * Reset all parameters
+   */
+  clear() {
+    this.params.clear();
+    return this;
+  }
+};
+
+// src/utils/drf-transforms.ts
+function normalizePaginated(response, page, pageSize) {
+  const total = response.count || 0;
+  return {
+    items: response.results || [],
+    total,
+    page,
+    pageSize,
+    hasNext: response.next !== null,
+    hasPrev: response.previous !== null
+  };
+}
+function isDRFPaginatedResponse(response) {
+  return typeof response === "object" && response !== null && "results" in response && "count" in response;
+}
+
+// src/lib/error-handler.ts
+var ApiException = class extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = "ApiException";
+    this.status = options?.status;
+    this.statusText = options?.statusText;
+    this.errors = options?.errors;
+    this.detail = options?.detail;
+  }
+  toJSON() {
+    return {
+      message: this.message,
+      detail: this.detail,
+      status: this.status,
+      statusText: this.statusText,
+      errors: this.errors
+    };
+  }
+};
+async function parseErrorResponse(response) {
+  const contentType = response.headers?.get("content-type");
+  if (contentType?.includes("application/json")) {
+    try {
+      const data = await response.json();
+      if (data.detail) {
+        return {
+          detail: data.detail,
+          message: data.detail,
+          status: response.status,
+          statusText: response.statusText
+        };
+      }
+      if (typeof data === "object") {
+        return {
+          errors: data,
+          message: "Validation error",
+          status: response.status,
+          statusText: response.statusText
+        };
+      }
+      return {
+        message: JSON.stringify(data),
+        status: response.status,
+        statusText: response.statusText
+      };
+    } catch {
+    }
+  }
+  const text = await response.text().catch(() => response.statusText);
+  return {
+    message: text || response.statusText || "Unknown error",
+    status: response.status,
+    statusText: response.statusText
+  };
+}
+function handleFetchError(error) {
+  if (error instanceof ApiException) {
+    throw error;
+  }
+  if (error instanceof TypeError && error.message.includes("fetch")) {
+    throw new ApiException("Network error - please check your connection", {
+      status: 0,
+      statusText: "Network Error"
+    });
+  }
+  if (error instanceof Error) {
+    throw new ApiException(error.message, {
+      status: 0,
+      statusText: "Client Error"
+    });
+  }
+  throw new ApiException("Unknown error occurred", {
+    status: 0,
+    statusText: "Unknown Error"
+  });
+}
+function isApiException(error) {
+  return error instanceof ApiException;
+}
+function isValidationError(error) {
+  return isApiException(error) && error.status === 400 && !!error.errors;
+}
+function isAuthError(error) {
+  return isApiException(error) && (error.status === 401 || error.status === 403);
+}
+function isNotFoundError(error) {
+  return isApiException(error) && error.status === 404;
+}
+
+// src/lib/fetch-wrapper.ts
+var FetchWrapper = class _FetchWrapper {
+  constructor(config) {
+    this.isRefreshing = false;
+    this.refreshPromise = null;
+    this.config = config;
+  }
+  /**
+   * Build headers with auth token
+   */
+  async buildHeaders(customHeaders) {
+    const headers = new Headers(this.config.defaultHeaders);
+    if (customHeaders) {
+      const customHeadersObj = new Headers(customHeaders);
+      customHeadersObj.forEach((value, key) => {
+        headers.set(key, value);
+      });
+    }
+    if (this.config.getToken) {
+      const token = await this.config.getToken();
+      if (token) {
+        headers.set("Authorization", `Bearer ${token}`);
+      }
+    }
+    if (!headers.has("Content-Type")) {
+      headers.set("Content-Type", "application/json");
+    }
+    return headers;
+  }
+  /**
+   * Execute fetch request
+   */
+  async execute(method, endpoint, options) {
+    try {
+      const { params, headers: customHeaders, ...fetchOptions } = options || {};
+      const url = buildUrl({
+        baseUrl: this.config.baseUrl ?? "",
+        endpoint,
+        params
+      });
+      const headers = await this.buildHeaders(customHeaders);
+      let response = await fetch(url, {
+        method,
+        headers,
+        credentials: "include",
+        ...fetchOptions
+      });
+      if (response.status === 401) {
+        if (this.config.onTokenRefresh) {
+          if (!this.isRefreshing) {
+            this.isRefreshing = true;
+            this.refreshPromise = this.config.onTokenRefresh().finally(() => {
+              this.isRefreshing = false;
+              this.refreshPromise = null;
+            });
+          }
+          const newToken = await this.refreshPromise;
+          if (newToken) {
+            const retryHeaders = new Headers(headers);
+            retryHeaders.set("Authorization", `Bearer ${newToken}`);
+            response = await fetch(url, {
+              method,
+              headers: retryHeaders,
+              credentials: "include",
+              ...fetchOptions
+            });
+          } else if (this.config.onUnauthorized) {
+            this.config.onUnauthorized();
+          }
+        } else if (this.config.onUnauthorized) {
+          this.config.onUnauthorized();
+        }
+      }
+      if (!response.ok) {
+        const error = await parseErrorResponse(response);
+        throw new ApiException(error.message || "Request failed", error);
+      }
+      if (response.status === 204) {
+        return void 0;
+      }
+      return await response.json();
+    } catch (error) {
+      handleFetchError(error);
+    }
+  }
+  /**
+   * Return a new FetchWrapper with selected config fields overridden.
+   */
+  reconfigure(partial) {
+    return new _FetchWrapper({ ...this.config, ...partial });
+  }
+  /**
+   * GET request
+   */
+  async get(endpoint, options) {
+    return this.execute("GET", endpoint, options);
+  }
+  /**
+   * POST request
+   */
+  async post(endpoint, data, options) {
+    return this.execute("POST", endpoint, {
+      ...options,
+      body: data ? JSON.stringify(data) : void 0
+    });
+  }
+  /**
+   * PUT request
+   */
+  async put(endpoint, data, options) {
+    return this.execute("PUT", endpoint, {
+      ...options,
+      body: data ? JSON.stringify(data) : void 0
+    });
+  }
+  /**
+   * PATCH request
+   */
+  async patch(endpoint, data, options) {
+    return this.execute("PATCH", endpoint, {
+      ...options,
+      body: data ? JSON.stringify(data) : void 0
+    });
+  }
+  /**
+   * DELETE request
+   */
+  async delete(endpoint, options) {
+    return this.execute("DELETE", endpoint, options);
+  }
+};
+
+// src/lib/api-client.ts
+var ApiClient = class {
+  constructor(config) {
+    this.baseUrl = config.baseUrl ?? "";
+    this.fetcher = new FetchWrapper({
+      baseUrl: config.baseUrl,
+      getToken: config.getToken,
+      onUnauthorized: config.onUnauthorized,
+      onTokenRefresh: config.onTokenRefresh,
+      defaultHeaders: {
+        "Content-Type": "application/json",
+        "Accept": "application/json"
+      }
+    });
+  }
+  /**
+   * Get the fetch wrapper instance for direct access
+   */
+  get fetch() {
+    return this.fetcher;
+  }
+  /**
+   * Update auth token getter
+   */
+  setTokenGetter(getToken) {
+    this.fetcher = this.fetcher.reconfigure({ getToken });
+  }
+  /**
+   * Update unauthorized handler
+   */
+  setUnauthorizedHandler(onUnauthorized) {
+    this.fetcher = this.fetcher.reconfigure({ onUnauthorized });
+  }
+  /**
+   * Convenience HTTP methods that delegate to FetchWrapper
+   */
+  async get(endpoint, options) {
+    return this.fetcher.get(endpoint, options);
+  }
+  async post(endpoint, data, options) {
+    return this.fetcher.post(endpoint, data, options);
+  }
+  async patch(endpoint, data, options) {
+    return this.fetcher.patch(endpoint, data, options);
+  }
+  async delete(endpoint, options) {
+    return this.fetcher.delete(endpoint, options);
+  }
+};
+function createApiClient(config) {
+  return new ApiClient(config);
+}
+
+// src/constants/endpoints.ts
+var ENDPOINTS = {
+  // Contacts
+  CONTACTS: "contacts",
+  CONTACTS_BULK: "contacts/bulk",
+  CONTACT: (id) => `contacts/${id}`,
+  // Organizations
+  ORGANIZATIONS: "organizations",
+  ORGANIZATIONS_BULK: "organizations/bulk",
+  ORGANIZATION: (id) => `organizations/${id}`,
+  // Core entities
+  TAGS: "core/tags",
+  TAG: (id) => `core/tags/${id}`,
+  ENTITY_TAGS: "core/entity-tags",
+  ENTITY_TAG: (id) => `core/entity-tags/${id}`,
+  METRICS: "core/metrics",
+  METRIC: (id) => `core/metrics/${id}`,
+  PROFILES: "core/profiles",
+  PROFILE: (id) => `core/profiles/${id}`,
+  ATTRIBUTES: "core/attributes",
+  ATTRIBUTE: (id) => `core/attributes/${id}`,
+  RELATIONSHIPS: "core/relationships",
+  RELATIONSHIP: (id) => `core/relationships/${id}`,
+  // Workflows
+  WORKFLOWS: "workflows",
+  WORKFLOW: (id) => `workflows/${id}`,
+  WORKFLOW_EXECUTE: (id) => `workflows/${id}/execute`,
+  // Messages
+  MESSAGES: "messages",
+  MESSAGE: (id) => `messages/${id}`,
+  MESSAGE_SEND: (id) => `messages/${id}/send`,
+  // Funnels
+  FUNNELS: "funnels",
+  FUNNEL: (id) => `funnels/${id}`,
+  FUNNEL_RUN: (id) => `funnels/${id}/run`,
+  FUNNEL_RUNS: (id) => `funnels/${id}/runs`,
+  FUNNEL_RUN_ITEM: (funnelId, runId) => `funnels/${funnelId}/runs/${runId}`,
+  FUNNEL_PREVIEW: (id) => `funnels/${id}/preview`,
+  FUNNEL_RESULTS: (id) => `funnels/${id}/results`,
+  FUNNEL_TEMPLATES: "funnels/templates",
+  FUNNEL_RUN_BY_ID: (runId) => `funnel-runs/${runId}`,
+  FUNNEL_RUN_CANCEL: (runId) => `funnel-runs/${runId}/cancel`,
+  FUNNEL_RUNS_GLOBAL: "funnel-runs"
+};
+
+// src/lib/contacts-api.ts
+var ContactsApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List contacts with pagination and filters
+   */
+  async list(filters, pagination, sorting) {
+    const params = mergeQueryParams(
+      pagination,
+      sorting,
+      filters ? buildFilterParams(filters) : void 0
+    );
+    return this.client.fetch.get(ENDPOINTS.CONTACTS, { params });
+  }
+  /**
+   * Get contact by ID
+   */
+  async get(id) {
+    return this.client.fetch.get(ENDPOINTS.CONTACT(id));
+  }
+  /**
+   * Create new contact
+   */
+  async create(data) {
+    return this.client.fetch.post(ENDPOINTS.CONTACTS, data);
+  }
+  /**
+   * Update contact
+   */
+  async update(id, data) {
+    return this.client.fetch.patch(ENDPOINTS.CONTACT(id), data);
+  }
+  /**
+   * Delete contact
+   */
+  async delete(id) {
+    return this.client.fetch.delete(ENDPOINTS.CONTACT(id));
+  }
+  /**
+   * Bulk create contacts
+   */
+  async bulkCreate(data) {
+    return this.client.fetch.post(ENDPOINTS.CONTACTS_BULK, data);
+  }
+  /**
+   * Search contacts by name, email, or company
+   */
+  async search(query, pagination) {
+    return this.list({ search: query }, pagination);
+  }
+  /**
+   * Get contacts by tier
+   */
+  async getByTier(tier, pagination) {
+    return this.list({ tier }, pagination);
+  }
+  /**
+   * Get contacts by firm
+   */
+  async getByFirm(firmId, pagination) {
+    return this.list({ firmId }, pagination);
+  }
+  /**
+   * Get contacts with LinkedIn profiles
+   */
+  async getWithLinkedIn(pagination) {
+    return this.list({ hasLinkedin: true }, pagination);
+  }
+};
+
+// src/lib/organizations-api.ts
+var OrganizationsApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List organizations with pagination and filters
+   */
+  async list(filters, pagination, sorting) {
+    const params = mergeQueryParams(
+      pagination,
+      sorting,
+      filters ? buildFilterParams(filters) : void 0
+    );
+    return this.client.fetch.get(ENDPOINTS.ORGANIZATIONS, {
+      params
+    });
+  }
+  /**
+   * Get organization by ID
+   */
+  async get(id) {
+    return this.client.fetch.get(ENDPOINTS.ORGANIZATION(id));
+  }
+  /**
+   * Create new organization
+   */
+  async create(data) {
+    return this.client.fetch.post(ENDPOINTS.ORGANIZATIONS, data);
+  }
+  /**
+   * Update organization
+   */
+  async update(id, data) {
+    return this.client.fetch.patch(ENDPOINTS.ORGANIZATION(id), data);
+  }
+  /**
+   * Delete organization
+   */
+  async delete(id) {
+    return this.client.fetch.delete(ENDPOINTS.ORGANIZATION(id));
+  }
+  /**
+   * Bulk create organizations
+   */
+  async bulkCreate(data) {
+    return this.client.fetch.post(ENDPOINTS.ORGANIZATIONS_BULK, data);
+  }
+  /**
+   * Search organizations by name, domain, or location
+   */
+  async search(query, pagination) {
+    return this.list({ search: query }, pagination);
+  }
+  /**
+   * Get organizations by tier
+   */
+  async getByTier(tier, pagination) {
+    return this.list({ tier }, pagination);
+  }
+  /**
+   * Get organizations by stage
+   */
+  async getByStage(stage, pagination) {
+    return this.list({ stage }, pagination);
+  }
+  /**
+   * Get organizations by focus area
+   */
+  async getByFocusArea(focusArea, pagination) {
+    return this.list({ focusArea }, pagination);
+  }
+  /**
+   * Get organizations by check size range
+   */
+  async getByCheckSizeRange(min, max, pagination) {
+    const filters = {};
+    if (min !== void 0) {
+      filters.checkSizeMinGte = min;
+    }
+    if (max !== void 0) {
+      filters.checkSizeMaxLte = max;
+    }
+    return this.list(filters, pagination);
+  }
+};
+
+// src/lib/entities-api.ts
+var EntitiesApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Tags
+   */
+  async listTags(pagination) {
+    const params = mergeQueryParams(pagination);
+    return this.client.fetch.get(ENDPOINTS.TAGS, { params });
+  }
+  async getTag(id) {
+    return this.client.fetch.get(ENDPOINTS.TAG(String(id)));
+  }
+  async createTag(data) {
+    return this.client.fetch.post(ENDPOINTS.TAGS, data);
+  }
+  /**
+   * Entity Tags
+   */
+  async listEntityTags(pagination, filters) {
+    const params = mergeQueryParams(pagination, void 0, filters);
+    return this.client.fetch.get(ENDPOINTS.ENTITY_TAGS, {
+      params
+    });
+  }
+  async getEntityTag(id) {
+    return this.client.fetch.get(ENDPOINTS.ENTITY_TAG(String(id)));
+  }
+  /**
+   * Metrics
+   */
+  async listMetrics(pagination, filters) {
+    const params = mergeQueryParams(pagination, void 0, filters);
+    return this.client.fetch.get(ENDPOINTS.METRICS, { params });
+  }
+  async getMetric(id) {
+    return this.client.fetch.get(ENDPOINTS.METRIC(String(id)));
+  }
+  /**
+   * Profiles
+   */
+  async listProfiles(pagination, filters) {
+    const params = mergeQueryParams(pagination, void 0, filters);
+    return this.client.fetch.get(ENDPOINTS.PROFILES, { params });
+  }
+  async getProfile(id) {
+    return this.client.fetch.get(ENDPOINTS.PROFILE(String(id)));
+  }
+  /**
+   * Attributes
+   */
+  async listAttributes(pagination, filters) {
+    const params = mergeQueryParams(pagination, void 0, filters);
+    return this.client.fetch.get(ENDPOINTS.ATTRIBUTES, {
+      params
+    });
+  }
+  async getAttribute(id) {
+    return this.client.fetch.get(ENDPOINTS.ATTRIBUTE(String(id)));
+  }
+  /**
+   * Relationships
+   */
+  async listRelationships(pagination, filters) {
+    const params = mergeQueryParams(pagination, void 0, filters);
+    return this.client.fetch.get(ENDPOINTS.RELATIONSHIPS, {
+      params
+    });
+  }
+  async getRelationship(id) {
+    return this.client.fetch.get(ENDPOINTS.RELATIONSHIP(String(id)));
+  }
+};
+
+// src/lib/workflows-api.ts
+var WorkflowsApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List workflows with optional filters
+   */
+  async list(filters) {
+    const params = new URLSearchParams();
+    if (filters?.team) params.append("team", filters.team);
+    if (filters?.isActive !== void 0) params.append("isActive", String(filters.isActive));
+    if (filters?.isTemplate !== void 0) params.append("isTemplate", String(filters.isTemplate));
+    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(
+      `/api/v1/workflows/?${params.toString()}`
+    );
+  }
+  /**
+   * Get workflow by ID
+   */
+  async get(id) {
+    return this.client.get(`/api/v1/workflows/${id}/`);
+  }
+  /**
+   * Create a new workflow
+   */
+  async create(data) {
+    return this.client.post("/api/v1/workflows/", data);
+  }
+  /**
+   * Update workflow
+   */
+  async update(id, data) {
+    return this.client.patch(`/api/v1/workflows/${id}/`, data);
+  }
+  /**
+   * Delete workflow
+   */
+  async delete(id) {
+    return this.client.delete(`/api/v1/workflows/${id}/`);
+  }
+  /**
+   * Execute workflow
+   */
+  async execute(id, input) {
+    return this.client.post(
+      `/api/v1/workflows/${id}/execute/`,
+      input || {}
+    );
+  }
+  /**
+   * Get workflow templates
+   */
+  async templates() {
+    return this.client.get("/api/v1/workflows/templates/");
+  }
+  /**
+   * List workflow executions
+   */
+  async listExecutions(filters) {
+    const params = new URLSearchParams();
+    if (filters?.workflow) params.append("workflow", filters.workflow);
+    if (filters?.status) params.append("status", filters.status);
+    if (filters?.page) params.append("page", String(filters.page));
+    if (filters?.pageSize) params.append("pageSize", String(filters.pageSize));
+    return this.client.get(
+      `/api/v1/workflow-executions/?${params.toString()}`
+    );
+  }
+  /**
+   * Get workflow execution details
+   */
+  async getExecution(id) {
+    return this.client.get(`/api/v1/workflow-executions/${id}/`);
+  }
+};
+
+// src/lib/messages-api.ts
+var MessagesApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List messages with optional filters
+   */
+  async list(filters) {
+    const params = new URLSearchParams();
+    if (filters?.status) params.append("status", filters.status);
+    if (filters?.contentType) params.append("contentType", filters.contentType);
+    if (filters?.scheduledAfter) params.append("scheduledAfter", filters.scheduledAfter);
+    if (filters?.scheduledBefore) params.append("scheduledBefore", filters.scheduledBefore);
+    if (filters?.sentAfter) params.append("sentAfter", filters.sentAfter);
+    if (filters?.sentBefore) params.append("sentBefore", filters.sentBefore);
+    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(
+      `/api/v1/messages/?${params.toString()}`
+    );
+  }
+  /**
+   * Get message by ID
+   */
+  async get(id) {
+    return this.client.get(`/api/v1/messages/${id}/`);
+  }
+  /**
+   * Create a new message
+   */
+  async create(data) {
+    return this.client.post("/api/v1/messages/", data);
+  }
+  /**
+   * Update message (draft only)
+   */
+  async update(id, data) {
+    return this.client.patch(`/api/v1/messages/${id}/`, data);
+  }
+  /**
+   * Delete message (draft only)
+   */
+  async delete(id) {
+    return this.client.delete(`/api/v1/messages/${id}/`);
+  }
+  /**
+   * Schedule message for future sending
+   */
+  async schedule(id, input) {
+    return this.client.post(
+      `/api/v1/messages/${id}/schedule/`,
+      input
+    );
+  }
+  /**
+   * Send message immediately
+   */
+  async sendNow(id) {
+    return this.client.post(
+      `/api/v1/messages/${id}/send_now/`,
+      {}
+    );
+  }
+  /**
+   * Send test message
+   */
+  async sendTest(id, input) {
+    return this.client.post(
+      `/api/v1/messages/${id}/send_test/`,
+      input || {}
+    );
+  }
+  /**
+   * Preview message rendering
+   */
+  async preview(id) {
+    return this.client.get(`/api/v1/messages/${id}/preview/`);
+  }
+  /**
+   * List recipients for a message
+   */
+  async getRecipients(id, page, pageSize) {
+    const params = new URLSearchParams();
+    if (page) params.append("page", String(page));
+    if (pageSize) params.append("pageSize", String(pageSize));
+    return this.client.get(
+      `/api/v1/messages/${id}/recipients/?${params.toString()}`
+    );
+  }
+  /**
+   * Add recipients to a message
+   */
+  async addRecipients(id, recipients) {
+    return this.client.post(`/api/v1/messages/${id}/add_recipients/`, { recipients });
+  }
+  /**
+   * Get available messaging channels
+   */
+  async getChannels() {
+    return this.client.get("/api/v1/messages/channels/");
+  }
+};
+
+// src/lib/funnels-api.ts
+function isFunnelRunConflict(error) {
+  return isApiException(error) && error.status === 409;
+}
+function isFunnelValidationError(error) {
+  return isApiException(error) && error.status === 400 && !!error.errors;
+}
+var FunnelsApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List funnels with optional filters.
+   * Tags are passed as repeated query params: ?tags=campaign:abc&tags=product:market-simpli
+   */
+  async list(filters) {
+    const params = new URLSearchParams();
+    if (filters?.status) params.append("status", filters.status);
+    if (filters?.entityType) params.append("entityType", filters.entityType);
+    if (filters?.search) params.append("search", filters.search);
+    if (filters?.createdBy) params.append("createdBy", filters.createdBy);
+    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);
+    if (filters?.tags?.length) {
+      for (const tag of filters.tags) {
+        params.append("tags", tag);
+      }
+    }
+    const query = params.toString();
+    const endpoint = query ? `${ENDPOINTS.FUNNELS}?${query}` : ENDPOINTS.FUNNELS;
+    return this.client.get(endpoint);
+  }
+  /**
+   * Get funnel by ID
+   */
+  async get(id) {
+    return this.client.get(ENDPOINTS.FUNNEL(id));
+  }
+  /**
+   * Create a new funnel
+   */
+  async create(data) {
+    return this.client.post(ENDPOINTS.FUNNELS, data);
+  }
+  /**
+   * Update funnel (partial)
+   */
+  async update(id, data) {
+    return this.client.patch(ENDPOINTS.FUNNEL(id), data);
+  }
+  /**
+   * Delete funnel
+   */
+  async delete(id) {
+    return this.client.delete(ENDPOINTS.FUNNEL(id));
+  }
+  /**
+   * Execute a funnel run
+   */
+  async run(id, input) {
+    return this.client.post(ENDPOINTS.FUNNEL_RUN(id), input ?? {});
+  }
+  /**
+   * List run history for a funnel
+   */
+  async getRuns(funnelId, filters) {
+    const params = new URLSearchParams();
+    if (filters?.page) params.append("page", String(filters.page));
+    if (filters?.pageSize) params.append("pageSize", String(filters.pageSize));
+    if (filters?.status) params.append("status", filters.status);
+    if (filters?.ordering) params.append("ordering", filters.ordering);
+    const query = params.toString();
+    const endpoint = query ? `${ENDPOINTS.FUNNEL_RUNS(funnelId)}?${query}` : ENDPOINTS.FUNNEL_RUNS(funnelId);
+    return this.client.get(endpoint);
+  }
+  /**
+   * Get a specific run by ID. funnelId param is ignored (runs are accessed globally).
+   */
+  async getRun(_funnelId, runId) {
+    return this.client.get(ENDPOINTS.FUNNEL_RUN_BY_ID(runId));
+  }
+  // BEAD: fund-your-startup-rgi4 - funnels/{id}/results endpoint missing from Django FunnelViewSet
+  async getResults(_funnelId, _pagination) {
+    throw new Error("Not implemented - BEAD: fund-your-startup-rgi4. funnels/{id}/results action does not exist in Django.");
+  }
+  // BEAD: fund-your-startup-rgi4 - funnels/{id}/preview endpoint missing. Django has /funnels/preview-icp/ (different signature).
+  async preview(_funnelId, _stages) {
+    throw new Error("Not implemented - BEAD: fund-your-startup-rgi4. funnels/{id}/preview action does not exist in Django.");
+  }
+  /**
+   * List all funnel runs globally (across all funnels, scoped to current user)
+   */
+  async listRunsGlobal(filters) {
+    const params = new URLSearchParams();
+    if (filters?.funnel) params.append("funnel", filters.funnel);
+    if (filters?.status) params.append("status", filters.status);
+    if (filters?.page) params.append("page", String(filters.page));
+    if (filters?.pageSize) params.append("pageSize", String(filters.pageSize));
+    if (filters?.startedAfter) params.append("startedAfter", filters.startedAfter);
+    if (filters?.startedBefore) params.append("startedBefore", filters.startedBefore);
+    const query = params.toString();
+    const endpoint = query ? `${ENDPOINTS.FUNNEL_RUNS_GLOBAL}?${query}` : ENDPOINTS.FUNNEL_RUNS_GLOBAL;
+    return this.client.get(endpoint);
+  }
+  /**
+   * Cancel a running funnel run.
+   */
+  async cancelRun(runId) {
+    return this.client.post(ENDPOINTS.FUNNEL_RUN_CANCEL(runId), {});
+  }
+  /**
+   * List available funnel templates
+   */
+  async listTemplates(filters) {
+    const params = new URLSearchParams();
+    if (filters?.category) params.append("category", filters.category);
+    if (filters?.page) params.append("page", String(filters.page));
+    if (filters?.pageSize) params.append("pageSize", String(filters.pageSize));
+    const query = params.toString();
+    const endpoint = query ? `${ENDPOINTS.FUNNEL_TEMPLATES}?${query}` : ENDPOINTS.FUNNEL_TEMPLATES;
+    return this.client.get(endpoint);
+  }
+};
+
+// src/lib/errors.ts
+var AppErrorCode = /* @__PURE__ */ ((AppErrorCode2) => {
+  AppErrorCode2["VALIDATION_ERROR"] = "VALIDATION_ERROR";
+  AppErrorCode2["AUTHENTICATION_REQUIRED"] = "AUTHENTICATION_REQUIRED";
+  AppErrorCode2["INVALID_CREDENTIALS"] = "INVALID_CREDENTIALS";
+  AppErrorCode2["SESSION_EXPIRED"] = "SESSION_EXPIRED";
+  AppErrorCode2["FORBIDDEN"] = "FORBIDDEN";
+  AppErrorCode2["INSUFFICIENT_PERMISSIONS"] = "INSUFFICIENT_PERMISSIONS";
+  AppErrorCode2["NOT_FOUND"] = "NOT_FOUND";
+  AppErrorCode2["RESOURCE_NOT_FOUND"] = "RESOURCE_NOT_FOUND";
+  AppErrorCode2["CONFLICT"] = "CONFLICT";
+  AppErrorCode2["DUPLICATE_RESOURCE"] = "DUPLICATE_RESOURCE";
+  AppErrorCode2["RATE_LIMITED"] = "RATE_LIMITED";
+  AppErrorCode2["BAD_REQUEST"] = "BAD_REQUEST";
+  AppErrorCode2["INTERNAL_ERROR"] = "INTERNAL_ERROR";
+  AppErrorCode2["DATABASE_ERROR"] = "DATABASE_ERROR";
+  AppErrorCode2["EXTERNAL_SERVICE_ERROR"] = "EXTERNAL_SERVICE_ERROR";
+  AppErrorCode2["SERVICE_UNAVAILABLE"] = "SERVICE_UNAVAILABLE";
+  return AppErrorCode2;
+})(AppErrorCode || {});
+var AppError = class _AppError extends Error {
+  constructor(message, code = "INTERNAL_ERROR" /* INTERNAL_ERROR */, statusCode = 500, details, isOperational = true) {
+    super(message);
+    this.name = "AppError";
+    this.code = code;
+    this.statusCode = statusCode;
+    this.details = details;
+    this.isOperational = isOperational;
+    Error.captureStackTrace(this, this.constructor);
+  }
+  /**
+   * Serialize error for API response
+   */
+  toResponse() {
+    return {
+      error: {
+        code: this.code,
+        message: this.message,
+        ...this.details && { details: this.details }
+      }
+    };
+  }
+  /**
+   * Check if an error is an operational error (expected) vs programming error
+   */
+  static isOperationalError(error) {
+    return error instanceof _AppError && error.isOperational;
+  }
+};
+var ValidationError = class _ValidationError extends AppError {
+  constructor(message = "Validation failed", fieldErrors = {}) {
+    super(
+      message,
+      "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+      400,
+      { fields: fieldErrors }
+    );
+    this.name = "ValidationError";
+    this.fieldErrors = fieldErrors;
+  }
+  /**
+   * Create from Zod error
+   */
+  static fromZodError(zodError) {
+    const fieldErrors = {};
+    for (const error of zodError.errors) {
+      const path = error.path.join(".");
+      if (!fieldErrors[path]) {
+        fieldErrors[path] = [];
+      }
+      fieldErrors[path].push(error.message);
+    }
+    const message = Object.entries(fieldErrors).map(([field, errors]) => `${field}: ${errors.join(", ")}`).join("; ");
+    return new _ValidationError(`Validation failed: ${message}`, fieldErrors);
+  }
+};
+var AuthenticationError = class _AuthenticationError extends AppError {
+  constructor(message = "Authentication required", code = "AUTHENTICATION_REQUIRED" /* AUTHENTICATION_REQUIRED */) {
+    super(message, code, 401);
+    this.name = "AuthenticationError";
+  }
+  /**
+   * Create for invalid credentials
+   */
+  static invalidCredentials() {
+    return new _AuthenticationError("Invalid credentials", "INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */);
+  }
+  /**
+   * Create for expired session
+   */
+  static sessionExpired() {
+    return new _AuthenticationError("Session has expired", "SESSION_EXPIRED" /* SESSION_EXPIRED */);
+  }
+};
+var AuthorizationError = class _AuthorizationError extends AppError {
+  constructor(message = "Access denied", code = "FORBIDDEN" /* FORBIDDEN */) {
+    super(message, code, 403);
+    this.name = "AuthorizationError";
+  }
+  /**
+   * Create for insufficient permissions
+   */
+  static insufficientPermissions(requiredPermission) {
+    const message = requiredPermission ? `Insufficient permissions. Required: ${requiredPermission}` : "Insufficient permissions";
+    return new _AuthorizationError(message, "INSUFFICIENT_PERMISSIONS" /* INSUFFICIENT_PERMISSIONS */);
+  }
+};
+var NotFoundError = class _NotFoundError extends AppError {
+  constructor(message = "Resource not found", resourceType, resourceId) {
+    super(
+      message,
+      "NOT_FOUND" /* NOT_FOUND */,
+      404,
+      resourceType || resourceId ? { resourceType, resourceId } : void 0
+    );
+    this.name = "NotFoundError";
+    this.resourceType = resourceType;
+    this.resourceId = resourceId;
+  }
+  /**
+   * Create for a specific resource
+   */
+  static forResource(resourceType, resourceId) {
+    const message = resourceId ? `${resourceType} with ID '${resourceId}' not found` : `${resourceType} not found`;
+    return new _NotFoundError(message, resourceType, resourceId);
+  }
+};
+var ConflictError = class _ConflictError extends AppError {
+  constructor(message = "Resource conflict", conflictingField) {
+    super(
+      message,
+      "CONFLICT" /* CONFLICT */,
+      409,
+      conflictingField ? { field: conflictingField } : void 0
+    );
+    this.name = "ConflictError";
+    this.conflictingField = conflictingField;
+  }
+  /**
+   * Create for duplicate resource
+   */
+  static duplicate(resourceType, field) {
+    const message = field ? `A ${resourceType} with this ${field} already exists` : `A ${resourceType} with these values already exists`;
+    return new _ConflictError(message, field);
+  }
+};
+var RateLimitError = class extends AppError {
+  constructor(message = "Too many requests", retryAfter) {
+    super(
+      message,
+      "RATE_LIMITED" /* RATE_LIMITED */,
+      429,
+      retryAfter ? { retryAfter } : void 0
+    );
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var DatabaseError = class _DatabaseError extends AppError {
+  constructor(message = "Database operation failed", details) {
+    const safeDetails = process.env.NODE_ENV === "development" ? details : void 0;
+    super(message, "DATABASE_ERROR" /* DATABASE_ERROR */, 500, safeDetails);
+    this.name = "DatabaseError";
+  }
+  /**
+   * Create from Prisma error
+   */
+  static fromPrismaError(error) {
+    const code = error.code;
+    switch (code) {
+      case "P2002":
+        throw ConflictError.duplicate("record", error.meta?.target?.[0]);
+      case "P2025":
+        throw new NotFoundError("Record not found");
+      case "P2003":
+        throw new ConflictError("Cannot perform operation due to related records");
+      default:
+        return new _DatabaseError("Database operation failed", { code });
+    }
+  }
+};
+var ExternalServiceError = class extends AppError {
+  constructor(serviceName, message = "External service error", details) {
+    super(
+      message,
+      "EXTERNAL_SERVICE_ERROR" /* EXTERNAL_SERVICE_ERROR */,
+      502,
+      { service: serviceName, ...details }
+    );
+    this.name = "ExternalServiceError";
+    this.serviceName = serviceName;
+  }
+};
+function isPrismaError(error) {
+  return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string";
+}
+function toAppError(error) {
+  if (error instanceof AppError) {
+    return error;
+  }
+  if (isPrismaError(error)) {
+    return DatabaseError.fromPrismaError(error);
+  }
+  if (error instanceof Error) {
+    return new AppError(
+      error.message,
+      "INTERNAL_ERROR" /* INTERNAL_ERROR */,
+      500,
+      process.env.NODE_ENV === "development" ? { stack: error.stack } : void 0
+    );
+  }
+  return new AppError(
+    "An unexpected error occurred",
+    "INTERNAL_ERROR" /* INTERNAL_ERROR */,
+    500
+  );
+}
+function sanitizeHtml(input) {
+  return DOMPurify__default.default.sanitize(input, {
+    ALLOWED_TAGS: ["b", "i", "em", "strong", "a", "p", "br"],
+    ALLOWED_ATTR: ["href"],
+    ALLOW_DATA_ATTR: false
+  });
+}
+function sanitizeSearchQuery(query) {
+  if (!query || typeof query !== "string") {
+    return "";
+  }
+  return query.trim().replace(/[.*+?^${}()|[\]\\]/g, "\\$&").substring(0, 100);
+}
+function validateIdentifier(input) {
+  return /^[a-zA-Z0-9_-]+$/.test(input);
+}
+
+// src/lib/llm-sanitize.ts
+var MAX_PROMPT_LENGTH = 2e3;
+var MAX_CHAT_MESSAGE_LENGTH = 1e3;
+var INJECTION_PATTERNS = [
+  // System/role injection attempts
+  /\bSYSTEM\s*:/gi,
+  /\bASSISTANT\s*:/gi,
+  /\bUSER\s*:/gi,
+  /\bHUMAN\s*:/gi,
+  /\bAI\s*:/gi,
+  // Instruction override attempts
+  /\bignore\s+(previous|above|all)\s+instructions?\b/gi,
+  /\bdisregard\s+(previous|above|all)\s+instructions?\b/gi,
+  /\bforget\s+(previous|above|all)\s+instructions?\b/gi,
+  /\bnew\s+instructions?\s*:/gi,
+  /\boverride\s*:/gi,
+  // Role-playing attempts
+  /\byou\s+are\s+now\b/gi,
+  /\bact\s+as\s+(if|a|an|the)\b/gi,
+  /\bpretend\s+(to\s+be|you\s+are)\b/gi,
+  // JSON/schema manipulation
+  /\b(output|respond|return)\s+only\s*:/gi,
+  /\bformat\s*:\s*json\b/gi
+];
+var FORMATTING_MARKERS = [
+  "```",
+  // Code blocks
+  "---",
+  // Horizontal rules (when at line start)
+  "***",
+  // Alternative horizontal rules
+  "##",
+  // Headers (when at line start)
+  ">>"
+  // Potential quote injection
+];
+var CONTROL_CHAR_REGEX = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g;
+function sanitizeUserInput(input, maxLength = MAX_PROMPT_LENGTH) {
+  if (!input || typeof input !== "string") {
+    return "";
+  }
+  let sanitized = input;
+  sanitized = sanitized.replace(CONTROL_CHAR_REGEX, "");
+  sanitized = sanitized.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\n{3,}/g, "\n\n").replace(/[ \t]{3,}/g, "  ").trim();
+  for (const pattern of INJECTION_PATTERNS) {
+    sanitized = sanitized.replace(pattern, (match) => {
+      return `[${match.replace(/:/g, "")}]`;
+    });
+  }
+  for (const marker of FORMATTING_MARKERS) {
+    const escapeRegex = new RegExp(`(^|\\n)(${escapeRegexChars(marker)})`, "g");
+    sanitized = sanitized.replace(escapeRegex, (_, prefix, match) => {
+      return `${prefix}[${match}]`;
+    });
+  }
+  if (sanitized.length > maxLength) {
+    sanitized = truncateAtWordBoundary(sanitized, maxLength);
+  }
+  return sanitized;
+}
+function sanitizeChatMessage(input) {
+  return sanitizeUserInput(input, MAX_CHAT_MESSAGE_LENGTH);
+}
+function truncateAtWordBoundary(text, maxLength) {
+  if (text.length <= maxLength) {
+    return text;
+  }
+  const truncated = text.slice(0, maxLength);
+  const lastSpace = truncated.lastIndexOf(" ");
+  if (lastSpace > maxLength * 0.8) {
+    return truncated.slice(0, lastSpace).trim();
+  }
+  return truncated.trim();
+}
+function escapeRegexChars(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/lib/cors.ts
+var DEFAULT_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"];
+var DEFAULT_HEADERS = ["Content-Type", "Authorization", "X-Requested-With", "Accept", "X-CSRF-Token"];
+function isAllowed(origin, options) {
+  if (!origin) return false;
+  if (options.origins === "*") return true;
+  return options.origins.includes(origin);
+}
+function getCorsHeaders(origin, options) {
+  if (!isAllowed(origin, options)) {
+    return {};
+  }
+  const methods = options.methods ?? DEFAULT_METHODS;
+  const headers = options.headers ?? DEFAULT_HEADERS;
+  const credentials = options.credentials ?? options.origins !== "*";
+  const maxAge = options.maxAge ?? 86400;
+  const result = {
+    "Access-Control-Allow-Origin": options.origins === "*" ? "*" : origin,
+    "Access-Control-Allow-Methods": methods.join(", "),
+    "Access-Control-Allow-Headers": headers.join(", "),
+    "Access-Control-Max-Age": String(maxAge)
+  };
+  if (credentials && options.origins !== "*") {
+    result["Access-Control-Allow-Credentials"] = "true";
+  }
+  return result;
+}
+function applyCorsHeaders(responseHeaders, origin, options) {
+  const corsHeaders = getCorsHeaders(origin, options);
+  for (const [key, value] of Object.entries(corsHeaders)) {
+    responseHeaders.set(key, value);
+  }
+}
+function createCorsMiddleware(options) {
+  return function corsMiddleware(request) {
+    const origin = request.headers.get("origin");
+    if (request.method === "OPTIONS") {
+      const corsHeaders = getCorsHeaders(origin, options);
+      return new Response(null, { status: 204, headers: corsHeaders });
+    }
+    return null;
+  };
+}
+
+// src/types/response.ts
+var ErrorCodes = /* @__PURE__ */ ((ErrorCodes2) => {
+  ErrorCodes2["UNAUTHORIZED"] = "UNAUTHORIZED";
+  ErrorCodes2["FORBIDDEN"] = "FORBIDDEN";
+  ErrorCodes2["NOT_FOUND"] = "NOT_FOUND";
+  ErrorCodes2["VALIDATION_ERROR"] = "VALIDATION_ERROR";
+  ErrorCodes2["CONFLICT"] = "CONFLICT";
+  ErrorCodes2["INTERNAL_ERROR"] = "INTERNAL_ERROR";
+  ErrorCodes2["SERVICE_UNAVAILABLE"] = "SERVICE_UNAVAILABLE";
+  ErrorCodes2["RATE_LIMITED"] = "RATE_LIMITED";
+  return ErrorCodes2;
+})(ErrorCodes || {});
+var FieldErrorSchema = zod.z.object({
+  field: zod.z.string(),
+  messages: zod.z.array(zod.z.string()),
+  code: zod.z.string().optional()
+});
+var StandardErrorResponseSchema = zod.z.object({
+  error: zod.z.string(),
+  code: zod.z.string(),
+  statusCode: zod.z.number().int().min(400).max(599),
+  fieldErrors: zod.z.array(FieldErrorSchema).optional(),
+  details: zod.z.record(zod.z.unknown()).optional(),
+  requestId: zod.z.string().optional(),
+  timestamp: zod.z.string().datetime().optional()
+});
+var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
+  ErrorCode2["BAD_REQUEST"] = "bad_request";
+  ErrorCode2["UNAUTHORIZED"] = "unauthorized";
+  ErrorCode2["FORBIDDEN"] = "forbidden";
+  ErrorCode2["NOT_FOUND"] = "not_found";
+  ErrorCode2["METHOD_NOT_ALLOWED"] = "method_not_allowed";
+  ErrorCode2["VALIDATION_ERROR"] = "validation_error";
+  ErrorCode2["CONFLICT"] = "conflict";
+  ErrorCode2["RATE_LIMITED"] = "rate_limited";
+  ErrorCode2["INTERNAL_ERROR"] = "internal_error";
+  ErrorCode2["SERVICE_UNAVAILABLE"] = "service_unavailable";
+  ErrorCode2["GATEWAY_TIMEOUT"] = "gateway_timeout";
+  ErrorCode2["NETWORK_ERROR"] = "network_error";
+  ErrorCode2["TIMEOUT"] = "timeout";
+  ErrorCode2["UNKNOWN"] = "unknown";
+  return ErrorCode2;
+})(ErrorCode || {});
+function getErrorCodeFromStatus(status) {
+  const codeMap = {
+    400: "bad_request" /* BAD_REQUEST */,
+    401: "unauthorized" /* UNAUTHORIZED */,
+    403: "forbidden" /* FORBIDDEN */,
+    404: "not_found" /* NOT_FOUND */,
+    405: "method_not_allowed" /* METHOD_NOT_ALLOWED */,
+    409: "conflict" /* CONFLICT */,
+    422: "validation_error" /* VALIDATION_ERROR */,
+    429: "rate_limited" /* RATE_LIMITED */,
+    500: "internal_error" /* INTERNAL_ERROR */,
+    503: "service_unavailable" /* SERVICE_UNAVAILABLE */,
+    504: "gateway_timeout" /* GATEWAY_TIMEOUT */
+  };
+  return codeMap[status] || "unknown" /* UNKNOWN */;
+}
+var ErrorMessages = {
+  ["bad_request" /* BAD_REQUEST */]: "The request was invalid. Please check your input.",
+  ["unauthorized" /* UNAUTHORIZED */]: "You need to log in to access this resource.",
+  ["forbidden" /* FORBIDDEN */]: "You don't have permission to access this resource.",
+  ["not_found" /* NOT_FOUND */]: "The requested resource was not found.",
+  ["method_not_allowed" /* METHOD_NOT_ALLOWED */]: "This operation is not allowed.",
+  ["validation_error" /* VALIDATION_ERROR */]: "Please fix the errors in your form.",
+  ["conflict" /* CONFLICT */]: "This operation conflicts with existing data.",
+  ["rate_limited" /* RATE_LIMITED */]: "Too many requests. Please slow down.",
+  ["internal_error" /* INTERNAL_ERROR */]: "An unexpected error occurred. Please try again.",
+  ["service_unavailable" /* SERVICE_UNAVAILABLE */]: "The service is temporarily unavailable.",
+  ["gateway_timeout" /* GATEWAY_TIMEOUT */]: "The request took too long. Please try again.",
+  ["network_error" /* NETWORK_ERROR */]: "Network error. Please check your connection.",
+  ["timeout" /* TIMEOUT */]: "The request timed out. Please try again.",
+  ["unknown" /* UNKNOWN */]: "An unknown error occurred."
+};
+
+// src/lib/rate-limit.ts
+var CLEANUP_INTERVAL_MS = 10 * 60 * 1e3;
+function createRateLimiter(options) {
+  const { windowMs, maxRequests, keyPrefix = "" } = options;
+  const store = /* @__PURE__ */ new Map();
+  let lastCleanup = Date.now();
+  function cleanup() {
+    const now = Date.now();
+    if (now - lastCleanup < CLEANUP_INTERVAL_MS) return;
+    lastCleanup = now;
+    for (const [key, entry] of store.entries()) {
+      if (now > entry.resetAt) store.delete(key);
+    }
+  }
+  return function check(key) {
+    cleanup();
+    const storeKey = keyPrefix ? `${keyPrefix}:${key}` : key;
+    const now = Date.now();
+    const entry = store.get(storeKey);
+    if (!entry || now > entry.resetAt) {
+      const resetAt = now + windowMs;
+      store.set(storeKey, { count: 1, resetAt });
+      return { success: true, remaining: maxRequests - 1, resetAt };
+    }
+    if (entry.count >= maxRequests) {
+      const retryAfter = Math.ceil((entry.resetAt - now) / 1e3);
+      return { success: false, remaining: 0, resetAt: entry.resetAt, retryAfter };
+    }
+    entry.count++;
+    return { success: true, remaining: maxRequests - entry.count, resetAt: entry.resetAt };
+  };
+}
+function getClientIP(request) {
+  const forwarded = request.headers.get("x-forwarded-for");
+  if (forwarded) return forwarded.split(",")[0].trim();
+  const real = request.headers.get("x-real-ip");
+  if (real) return real;
+  return "unknown";
+}
+
+// src/lib/cache-store.ts
+var DEFAULT_CONFIG = {
+  maxSize: 1e3,
+  defaultTTL: 60 * 1e3
+};
+var CacheStore = class {
+  constructor(config = {}) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.hits = 0;
+    this.misses = 0;
+    this.accessCounter = 0;
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) {
+      this.misses++;
+      return void 0;
+    }
+    if (Date.now() > entry.expiresAt) {
+      this.cache.delete(key);
+      this.misses++;
+      return void 0;
+    }
+    entry.accessOrder = ++this.accessCounter;
+    this.hits++;
+    return entry.value;
+  }
+  set(key, value, ttl) {
+    if (this.cache.size >= this.config.maxSize) this.evictLRU();
+    this.cache.set(key, {
+      value,
+      expiresAt: Date.now() + (ttl ?? this.config.defaultTTL),
+      accessOrder: ++this.accessCounter
+    });
+  }
+  has(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return false;
+    if (Date.now() > entry.expiresAt) {
+      this.cache.delete(key);
+      return false;
+    }
+    return true;
+  }
+  delete(key) {
+    return this.cache.delete(key);
+  }
+  /** Delete all keys matching a string prefix or RegExp pattern */
+  deletePattern(pattern) {
+    const regex = typeof pattern === "string" ? new RegExp(pattern) : pattern;
+    let deleted = 0;
+    for (const key of this.cache.keys()) {
+      if (regex.test(key)) {
+        this.cache.delete(key);
+        deleted++;
+      }
+    }
+    return deleted;
+  }
+  clear() {
+    this.cache.clear();
+    this.hits = 0;
+    this.misses = 0;
+    this.accessCounter = 0;
+  }
+  /** Remove expired entries and return count removed */
+  cleanup() {
+    const now = Date.now();
+    let removed = 0;
+    for (const [key, entry] of this.cache.entries()) {
+      if (now > entry.expiresAt) {
+        this.cache.delete(key);
+        removed++;
+      }
+    }
+    return removed;
+  }
+  getStats() {
+    const total = this.hits + this.misses;
+    return {
+      size: this.cache.size,
+      maxSize: this.config.maxSize,
+      hits: this.hits,
+      misses: this.misses,
+      hitRate: total > 0 ? this.hits / total : 0
+    };
+  }
+  evictLRU() {
+    let oldestKey = null;
+    let oldestOrder = Infinity;
+    for (const [key, entry] of this.cache.entries()) {
+      if (entry.accessOrder < oldestOrder) {
+        oldestOrder = entry.accessOrder;
+        oldestKey = key;
+      }
+    }
+    if (oldestKey) this.cache.delete(oldestKey);
+  }
+};
+
+// src/lib/cache-manager.ts
+var DEFAULT_CONFIG2 = {
+  entity: { maxSize: 500, defaultTTL: 5 * 60 * 1e3 },
+  query: { maxSize: 200, defaultTTL: 60 * 1e3 }
+};
+var CacheManager = class {
+  constructor(enabled = true, config = {}) {
+    this.entity = new CacheStore({ ...DEFAULT_CONFIG2.entity, ...config.entity });
+    this.query = new CacheStore({ ...DEFAULT_CONFIG2.query, ...config.query });
+    this.enabled = enabled;
+  }
+  /**
+   * Cache-aside: return the cached value if present, otherwise call fetchFn,
+   * store the result, and return it.
+   */
+  async getOrSet(key, ttlMs, fetchFn) {
+    if (this.enabled) {
+      const cached = this.query.get(key);
+      if (cached !== void 0) return cached;
+    }
+    const value = await fetchFn();
+    if (this.enabled) this.query.set(key, value, ttlMs);
+    return value;
+  }
+  /** Invalidate a specific key in the query cache */
+  invalidateKey(key) {
+    this.query.delete(key);
+  }
+  /** Invalidate all query cache keys matching a string prefix or RegExp */
+  invalidatePattern(pattern) {
+    this.query.deletePattern(pattern);
+  }
+  /** Invalidate all entity and query cache entries for the given prefix */
+  invalidateAll(prefix) {
+    this.entity.deletePattern(prefix);
+    this.query.deletePattern(prefix);
+  }
+  setEnabled(enabled) {
+    this.enabled = enabled;
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  /** Remove expired entries from both stores */
+  maintenance() {
+    return {
+      entityRemoved: this.entity.cleanup(),
+      queryRemoved: this.query.cleanup()
+    };
+  }
+  clear() {
+    this.entity.clear();
+    this.query.clear();
+  }
+  getStats() {
+    return { entity: this.entity.getStats(), query: this.query.getStats() };
+  }
+};
+var _cacheManager = null;
+function getCacheManager(config) {
+  if (!_cacheManager) _cacheManager = new CacheManager(true, config);
+  return _cacheManager;
+}
+function resetCacheManager() {
+  _cacheManager?.clear();
+  _cacheManager = null;
+}
+
+// src/constants/options.ts
+var COMPANY_SIZE_OPTIONS = [
+  { value: "startup", label: "Startup (1-10)" },
+  { value: "small", label: "Small (11-50)" },
+  { value: "smb", label: "SMB (51-200)" },
+  { value: "mid_market", label: "Mid-Market (201-1000)" },
+  { value: "enterprise", label: "Enterprise (1000+)" }
+];
+var LIFECYCLE_STAGE_OPTIONS = [
+  { value: "subscriber", label: "Subscriber" },
+  { value: "lead", label: "Lead" },
+  { value: "mql", label: "MQL" },
+  { value: "sql", label: "SQL" },
+  { value: "opportunity", label: "Opportunity" },
+  { value: "customer", label: "Customer" },
+  { value: "evangelist", label: "Evangelist" }
+];
+var REVENUE_RANGE_OPTIONS = [
+  { value: "pre_revenue", label: "Pre-revenue" },
+  { value: "0_1m", label: "$0-$1M" },
+  { value: "1m_10m", label: "$1M-$10M" },
+  { value: "10m_50m", label: "$10M-$50M" },
+  { value: "50m_plus", label: "$50M+" }
+];
+var ACTIVITY_TYPE_OPTIONS = [
+  { value: "call", label: "Call" },
+  { value: "email", label: "Email" },
+  { value: "meeting", label: "Meeting" },
+  { value: "demo", label: "Demo" },
+  { value: "note", label: "Note" },
+  { value: "task", label: "Task" }
+];
+var ACTIVITY_OUTCOME_OPTIONS = [
+  { value: "scheduled_demo", label: "Scheduled Demo" },
+  { value: "scheduled_meeting", label: "Scheduled Meeting" },
+  { value: "callback_later", label: "Callback Later" },
+  { value: "left_voicemail", label: "Left Voicemail" },
+  { value: "no_answer", label: "No Answer" },
+  { value: "not_interested", label: "Not Interested" },
+  { value: "successful", label: "Successful" },
+  { value: "unsuccessful", label: "Unsuccessful" }
+];
+var LOSS_REASON_OPTIONS = [
+  { value: "price", label: "Price / Budget" },
+  { value: "timing", label: "Bad Timing" },
+  { value: "competitor", label: "Chose Competitor" },
+  { value: "no_need", label: "No Need" },
+  { value: "no_response", label: "No Response" },
+  { value: "other", label: "Other" }
+];
+var DEAL_STAGE_OPTIONS = [
+  { value: "qualification", label: "Qualification" },
+  { value: "discovery", label: "Discovery" },
+  { value: "demo", label: "Demo" },
+  { value: "proposal", label: "Proposal" },
+  { value: "negotiation", label: "Negotiation" },
+  { value: "closed_won", label: "Closed Won" },
+  { value: "closed_lost", label: "Closed Lost" }
+];
+function useServerList(endpoint, options = {}) {
+  const {
+    pageSize: initialPageSize = 25,
+    initialPage = 1,
+    initialSearch = "",
+    initialSortField = "",
+    initialSortDir = "asc",
+    params: extraParams = {},
+    disabled = false,
+    fetcher = fetch
+  } = options;
+  const [page, setPage] = react.useState(initialPage);
+  const [pageSize, setPageSize] = react.useState(initialPageSize);
+  const [search, setSearchState] = react.useState(initialSearch);
+  const [sortField, setSortField] = react.useState(initialSortField);
+  const [sortDir, setSortDir] = react.useState(initialSortDir);
+  const [data, setData] = react.useState([]);
+  const [total, setTotal] = react.useState(0);
+  const [loading, setLoading] = react.useState(!disabled);
+  const [error, setError] = react.useState(null);
+  const refreshCountRef = react.useRef(0);
+  const fetchData = react.useCallback(async () => {
+    if (disabled) return;
+    setLoading(true);
+    setError(null);
+    const searchParams = new URLSearchParams();
+    searchParams.set("page", String(page));
+    searchParams.set("pageSize", String(pageSize));
+    if (sortField) {
+      searchParams.set("sortField", sortField);
+      searchParams.set("sortDirection", sortDir);
+    }
+    if (search) searchParams.set("search", search);
+    for (const [k, v] of Object.entries(extraParams)) {
+      searchParams.set(k, String(v));
+    }
+    const sep = endpoint.includes("?") ? "&" : "?";
+    const url = `${endpoint}${sep}${searchParams.toString()}`;
+    try {
+      const response = await fetcher(url);
+      if (!response.ok) {
+        throw new Error(`Request failed: ${response.status} ${response.statusText}`);
+      }
+      const json = await response.json();
+      if (Array.isArray(json)) {
+        setData(json);
+        setTotal(json.length);
+      } else if (json.results !== void 0) {
+        setData(json.results);
+        setTotal(json.count ?? json.results.length);
+      } else if (json.data !== void 0) {
+        setData(json.data);
+        setTotal(json.total ?? json.data.length);
+      } else {
+        setData([]);
+        setTotal(0);
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to load data");
+      setData([]);
+    } finally {
+      setLoading(false);
+    }
+  }, [endpoint, page, pageSize, search, sortField, sortDir, disabled, fetcher, refreshCountRef.current]);
+  react.useEffect(() => {
+    fetchData();
+  }, [fetchData]);
+  const setSearch = react.useCallback((value) => {
+    setPage(1);
+    setSearchState(value);
+  }, []);
+  const setSort = react.useCallback(
+    (field, dir) => {
+      if (field === sortField && !dir) {
+        setSortDir((prev) => prev === "asc" ? "desc" : "asc");
+      } else {
+        setSortField(field);
+        setSortDir(dir ?? "asc");
+      }
+      setPage(1);
+    },
+    [sortField]
+  );
+  const refresh = react.useCallback(() => {
+    refreshCountRef.current += 1;
+    fetchData();
+  }, [fetchData]);
+  return {
+    data,
+    total,
+    loading,
+    error,
+    page,
+    pageSize,
+    search,
+    sortField,
+    sortDir,
+    setPage,
+    setPageSize,
+    setSearch,
+    setSort,
+    refresh
+  };
+}
+function useServerDetail(endpoint, id, options = {}) {
+  const { fetcher = fetch, disabled = false } = options;
+  const [data, setData] = react.useState(null);
+  const [loading, setLoading] = react.useState(!disabled && id !== null && id !== void 0);
+  const [error, setError] = react.useState(null);
+  const fetchData = react.useCallback(async () => {
+    if (disabled || id === null) return;
+    const url = id !== void 0 ? `${endpoint}${endpoint.endsWith("/") ? "" : "/"}${id}/` : endpoint;
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await fetcher(url);
+      if (!response.ok) {
+        throw new Error(`Request failed: ${response.status} ${response.statusText}`);
+      }
+      setData(await response.json());
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to load data");
+    } finally {
+      setLoading(false);
+    }
+  }, [endpoint, id, disabled, fetcher]);
+  react.useEffect(() => {
+    fetchData();
+  }, [fetchData]);
+  return { data, loading, error, refresh: fetchData };
+}
+
+// src/lib/env.ts
+function getRequiredEnv(key) {
+  const value = process.env[key];
+  if (!value) {
+    throw new Error(`Missing required environment variable: ${key}`);
+  }
+  return value;
+}
+function getOptionalEnv(key, defaultValue) {
+  return process.env[key] ?? defaultValue;
+}
+function validateEnvVars(required) {
+  const missing = required.filter((key) => !process.env[key]);
+  if (missing.length > 0) {
+    throw new Error(`Missing required environment variables: ${missing.join(", ")}`);
+  }
+}
+
+// src/index.ts
+function createStartSimpliApi(config = {}) {
+  const client = createApiClient(config);
+  return {
+    client,
+    contacts: new ContactsApi(client),
+    organizations: new OrganizationsApi(client),
+    entities: new EntitiesApi(client),
+    workflows: new WorkflowsApi(client),
+    messages: new MessagesApi(client),
+    funnels: new FunnelsApi(client)
+  };
+}
+
+exports.ACTIVITY_OUTCOME_OPTIONS = ACTIVITY_OUTCOME_OPTIONS;
+exports.ACTIVITY_TYPE_OPTIONS = ACTIVITY_TYPE_OPTIONS;
+exports.ApiClient = ApiClient;
+exports.ApiException = ApiException;
+exports.AppError = AppError;
+exports.AppErrorCode = AppErrorCode;
+exports.AuthenticationError = AuthenticationError;
+exports.AuthorizationError = AuthorizationError;
+exports.COMPANY_SIZE_OPTIONS = COMPANY_SIZE_OPTIONS;
+exports.CacheManager = CacheManager;
+exports.CacheStore = CacheStore;
+exports.ConflictError = ConflictError;
+exports.ContactsApi = ContactsApi;
+exports.DEAL_STAGE_OPTIONS = DEAL_STAGE_OPTIONS;
+exports.DatabaseError = DatabaseError;
+exports.ENDPOINTS = ENDPOINTS;
+exports.EntitiesApi = EntitiesApi;
+exports.EntityQueryBuilder = EntityQueryBuilder;
+exports.ErrorCode = ErrorCode;
+exports.ErrorCodes = ErrorCodes;
+exports.ErrorMessages = ErrorMessages;
+exports.ExternalServiceError = ExternalServiceError;
+exports.FetchWrapper = FetchWrapper;
+exports.FieldErrorSchema = FieldErrorSchema;
+exports.FunnelsApi = FunnelsApi;
+exports.LIFECYCLE_STAGE_OPTIONS = LIFECYCLE_STAGE_OPTIONS;
+exports.LOSS_REASON_OPTIONS = LOSS_REASON_OPTIONS;
+exports.MAX_CHAT_MESSAGE_LENGTH = MAX_CHAT_MESSAGE_LENGTH;
+exports.MAX_PROMPT_LENGTH = MAX_PROMPT_LENGTH;
+exports.MessagesApi = MessagesApi;
+exports.NotFoundError = NotFoundError;
+exports.OrganizationsApi = OrganizationsApi;
+exports.REVENUE_RANGE_OPTIONS = REVENUE_RANGE_OPTIONS;
+exports.RateLimitError = RateLimitError;
+exports.StandardErrorResponseSchema = StandardErrorResponseSchema;
+exports.ValidationError = ValidationError;
+exports.WorkflowsApi = WorkflowsApi;
+exports.applyCorsHeaders = applyCorsHeaders;
+exports.buildFilterParams = buildFilterParams;
+exports.buildOrderingParam = buildOrderingParam;
+exports.buildQueryString = buildQueryString;
+exports.buildUrl = buildUrl;
+exports.createApiClient = createApiClient;
+exports.createCorsMiddleware = createCorsMiddleware;
+exports.createRateLimiter = createRateLimiter;
+exports.createStartSimpliApi = createStartSimpliApi;
+exports.getCacheManager = getCacheManager;
+exports.getClientIP = getClientIP;
+exports.getCorsHeaders = getCorsHeaders;
+exports.getErrorCodeFromStatus = getErrorCodeFromStatus;
+exports.getOptionalEnv = getOptionalEnv;
+exports.getRequiredEnv = getRequiredEnv;
+exports.handleFetchError = handleFetchError;
+exports.isApiException = isApiException;
+exports.isAuthError = isAuthError;
+exports.isDRFPaginatedResponse = isDRFPaginatedResponse;
+exports.isFunnelRunConflict = isFunnelRunConflict;
+exports.isFunnelValidationError = isFunnelValidationError;
+exports.isNotFoundError = isNotFoundError;
+exports.isPrismaError = isPrismaError;
+exports.isValidationError = isValidationError;
+exports.mergeQueryParams = mergeQueryParams;
+exports.normalizeId = normalizeId;
+exports.normalizePaginated = normalizePaginated;
+exports.parseErrorResponse = parseErrorResponse;
+exports.resetCacheManager = resetCacheManager;
+exports.resolveApiUrl = resolveApiUrl;
+exports.sanitizeChatMessage = sanitizeChatMessage;
+exports.sanitizeHtml = sanitizeHtml;
+exports.sanitizeSearchQuery = sanitizeSearchQuery;
+exports.sanitizeUserInput = sanitizeUserInput;
+exports.toAppError = toAppError;
+exports.useServerDetail = useServerDetail;
+exports.useServerList = useServerList;
+exports.validateApiResponse = validateApiResponse;
+exports.validateEnvVars = validateEnvVars;
+exports.validateIdentifier = validateIdentifier;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map