@ecodrix/erix-api 1.4.3 → 1.5.0

package/dist/ts/esm/index.d.ts

@@ -61,6 +61,1485 @@ declare class Agency extends APIResource {
     createStaff<T = any>(payload: any): Promise<T>;
 }
 
+/**
+ * Adaptive Onboarding type definitions.
+ *
+ * These types mirror the Postgres data shapes from the
+ * `adaptive-onboarding-ai-persona` spec — see
+ * `.kiro/specs/adaptive-onboarding-ai-persona/design.md` §"Data Models" and
+ * §"Onboarding engine".
+ *
+ * NO RUNTIME CODE. Types only. Both saas (Next.js) and server (Express)
+ * import from here so the wire shape stays in lockstep.
+ */
+/**
+ * Renderable step kinds. The saas selects the appropriate React component
+ * from `components/onboarding/steps/*` based on this discriminator.
+ */
+type OnboardingStepType = "single_choice" | "multi_choice" | "text_input" | "ai_summary_confirm" | "feature_preview" | "completion";
+/**
+ * One selectable answer option in a `single_choice` / `multi_choice` step.
+ */
+interface OnboardingOption {
+    /** Internal value persisted in `session.answers[stepId]`. */
+    value: string;
+    /** Human-readable label shown to the user. */
+    label: string;
+    /** Optional short description rendered under the label. */
+    description?: string;
+    /** Optional icon identifier (Lucide name, image URL, or emoji). */
+    icon?: string;
+}
+/**
+ * Declares which persona field a step's answer writes to.
+ *
+ * Engine flow: when the step is answered, the value is written to
+ * `session.draftPersona.<targetField>`, optionally passed through a named
+ * transformation. On `complete()` the draft persona is upserted to
+ * `ecodrix_ai_personas`.
+ */
+interface OnboardingMemoryMapping {
+    /**
+     * Dot-path into the persona document, e.g.
+     * `"identity.nicheSubtype"` or `"behaviorRules.outreachTone"`.
+     */
+    targetField: string;
+    /**
+     * Optional named transformation applied to the raw answer before write.
+     * Engine-defined (`"map_to_niche_config"`, `"lowercase"`, `"split_csv"`,
+     * etc.).
+     */
+    transformation?: string;
+}
+/**
+ * A single step in an `OnboardingConfig`.
+ *
+ * Branching is via `showIf` / `skipIf` JsonLogic expressions evaluated
+ * against `session.answers`. The engine never reaches an undefined step —
+ * a missing `nextStepId` terminates the flow.
+ */
+interface OnboardingStep {
+    /** Stable identifier referenced by branch expressions and analytics. */
+    stepId: string;
+    /** Title rendered above the question. */
+    title: string;
+    /** Optional secondary line under the title. */
+    subtitle?: string;
+    /** Discriminator — drives which renderer the saas picks. */
+    type: OnboardingStepType;
+    /**
+     * JsonLogic expression. When present and false, the engine skips this
+     * step (does not render). Evaluated against `session.answers`.
+     */
+    showIf?: unknown;
+    /**
+     * JsonLogic expression. When present and true, the engine skips this
+     * step. Evaluated alongside / after `showIf`.
+     */
+    skipIf?: unknown;
+    /** The actual question text shown to the user. */
+    question: string;
+    /** Optional helper / "Why we ask" tooltip text (REQ-018). */
+    helperText?: string;
+    /** Selectable options for `single_choice` / `multi_choice` types. */
+    options?: OnboardingOption[];
+    /** Where the answer lands in the persona draft. */
+    memoryMapping: OnboardingMemoryMapping;
+    /**
+     * Workspace module keys that this step's completion makes visible
+     * (drives `WorkspaceProfile.modules.<key>.locked = false`).
+     */
+    unlocks?: string[];
+}
+/**
+ * A versioned onboarding flow for one product. Stored as a row in
+ * `ecodrix_onboarding_configs` and as `niche_pack.onboarding_config`.
+ */
+interface OnboardingConfig {
+    /** `"crm" | "laie" | "flow"` (string for forward-compat). */
+    productId: string;
+    /** Monotonic version string, e.g. `"crm-v1"`, `"crm-v2"`. */
+    version: string;
+    /** Ordered list of steps; engine walks these honoring branch logic. */
+    steps: OnboardingStep[];
+}
+/**
+ * Lifecycle status of an onboarding session row.
+ */
+type OnboardingSessionStatus = "active" | "completed" | "abandoned" | "archived";
+/**
+ * Persisted onboarding session — one per `(userId, productId)` until
+ * completed or abandoned. ISO strings for timestamps so the shape is
+ * JSON-safe over the wire.
+ */
+interface OnboardingSession {
+    id: string;
+    orgId: string;
+    userId: string;
+    productId: string;
+    /** `<top_level>__<leaf>` slug, e.g. `"healthcare__clinic"`. May be null
+     *  before the niche pick step. */
+    nichePackSlug: string | null;
+    /** Version of the `OnboardingConfig` driving this session. */
+    configVersion: string;
+    /** ID of the step the user is currently on, or null when finished. */
+    currentStepId: string | null;
+    /** `{ [stepId]: answerValue }` map persisted on every PATCH. */
+    answers: Record<string, unknown>;
+    /** Persona-shaped draft built incrementally from `answers` via memoryMapping. */
+    draftPersona: Record<string, unknown>;
+    status: OnboardingSessionStatus;
+    /** Optional A/B cohort, e.g. `"A"` / `"B"`. */
+    cohort: string | null;
+    /**
+     * Slug of the running experiment that drove the session's config
+     * resolution at start-time, or `null` when no experiment was active.
+     * Stamped by `POST /:productId/start` from the engine's
+     * `resolveSessionConfig` result so analytics can correlate sessions
+     * to experiments without re-resolving the cohort routing.
+     */
+    experimentSlug?: string | null;
+    /**
+     * `OnboardingConfig` version the session was rendered against — the
+     * concrete version chosen by the variant resolver (when an
+     * experiment ran) or the latest-published path. May differ from
+     * `configVersion` when the resolver picked a variant that maps to a
+     * different version than the latest published config.
+     */
+    variantConfigVersion?: string | null;
+    startedAt: string;
+    completedAt: string | null;
+    lastActiveAt: string;
+}
+/**
+ * Visibility + cosmetic configuration for one sidebar/workspace module.
+ */
+interface WorkspaceModuleConfig {
+    /** Whether the module renders at all in the sidebar. */
+    enabled: boolean;
+    /** Niche-tuned label, e.g. `"Patients"` instead of `"Contacts"`. */
+    label: string;
+    /** When true, module renders with a lock icon + tooltip. */
+    locked: boolean;
+    /** Sort order within the sidebar (ascending). */
+    sortOrder: number;
+    /**
+     * Optional gate name; the saas calls a Server Action that returns
+     * whether the gate currently passes given persona state.
+     */
+    onboardingGate?: string;
+}
+/**
+ * Default pipeline produced by the workspace shaper. Mirrors the existing
+ * `erix_pipelines` / `erix_pipeline_stages` rows that are materialized.
+ */
+interface WorkspaceDefaultPipeline {
+    name: string;
+    isDefault?: boolean;
+    stages: Array<{
+        name: string;
+        color?: string;
+        probability?: number;
+        isWon?: boolean;
+        isLost?: boolean;
+        order: number;
+    }>;
+}
+/**
+ * Default custom-field definition produced by the workspace shaper.
+ * Mirrors `erix_custom_fields` rows.
+ */
+interface WorkspaceDefaultField {
+    key: string;
+    label: string;
+    type: string;
+    required?: boolean;
+    options?: string[] | Array<{
+        label: string;
+        value: string;
+    }>;
+    group?: string;
+}
+/**
+ * Default automation produced by the workspace shaper. Mirrors
+ * `erix_automation_rules` rows.
+ */
+interface WorkspaceDefaultAutomation {
+    name: string;
+    trigger: string;
+    /** Free-form condition payload understood by the automation engine. */
+    conditions?: Record<string, unknown>;
+    /** Ordered list of action descriptors. */
+    actions: Array<Record<string, unknown>>;
+    enabled?: boolean;
+}
+/**
+ * Default dashboard layout — opaque grid descriptor consumed by the
+ * dashboard renderer.
+ */
+interface WorkspaceDashboardLayout {
+    widgets: Array<Record<string, unknown>>;
+    [extra: string]: unknown;
+}
+/**
+ * The full per-product workspace shape produced by
+ * `workspaceShaper.produce(persona, nichePack)` and persisted at
+ * `ecodrix_organizations.service_config -> '<productId>' -> 'workspace'`.
+ */
+interface WorkspaceProfile {
+    workspaceId: string;
+    productId: string;
+    /** Niche slug this profile was shaped for, e.g. `"agency__digital_marketing"`. */
+    niche: string;
+    modules: Record<string, WorkspaceModuleConfig>;
+    defaultPipelines: WorkspaceDefaultPipeline[];
+    defaultFields: WorkspaceDefaultField[];
+    defaultAutomations: WorkspaceDefaultAutomation[];
+    defaultDashboardLayout: WorkspaceDashboardLayout;
+}
+/**
+ * Org-wide onboarding flags under `service_config.global`.
+ */
+interface ServiceConfigGlobal {
+    /** Product the user picked at signup. */
+    primaryProduct: "crm" | "laie" | "flow" | "not_sure";
+    /** Feature flag — when false, legacy 4-step wizard is used. */
+    useAdaptiveOnboarding: boolean;
+    /**
+     * A/B-test cohort assigned by `ensureOnboardingCohort` — a stable
+     * deterministic bucket in `[0, 99]` derived from `hash(userId)`.
+     * Once written, it is never reassigned.
+     */
+    onboardingCohort?: number;
+}
+/**
+ * Per-product onboarding state under `service_config.<productId>`.
+ *
+ * Drives the dashboard CTA logic (REQ-002):
+ *   `onboardingComplete=true && enabledAt!=null` → "Open {Product}"
+ *   `enabledAt!=null  && onboardingComplete=false` → "Open {Product}" + banner
+ *   `enabledAt==null` → "Enable {Product}"
+ */
+interface ServiceConfigPerProduct {
+    onboardingComplete: boolean;
+    /** Last persisted step the user was on (for resumability). */
+    onboardingStep?: number | string;
+    /** Version of the `OnboardingConfig` that produced the persona. */
+    onboardingVersion?: string;
+    /** Niche slug, e.g. `"healthcare__clinic"`. */
+    niche?: string;
+    /** Mirrored from `ecodrix_ai_personas.confidence_score`. */
+    personaConfidence?: number;
+    /** Opt-in for confidence ≥ 70 auto-pilot features. */
+    autoPilotEnabled?: boolean;
+    /** ISO timestamp the user clicked "Enable {Product}" (REQ-002). */
+    enabledAt?: string;
+    /** Materialized workspace shape from the shaper. */
+    workspace?: WorkspaceProfile;
+}
+/**
+ * Full org-level `service_config` JSONB shape.
+ *
+ * The shape is open (it lives in JSONB), but every consumer should treat
+ * it as if it conforms to this interface and prefer named keys over
+ * arbitrary top-level extensions.
+ */
+interface ServiceConfig {
+    global: ServiceConfigGlobal;
+    crm?: ServiceConfigPerProduct;
+    laie?: ServiceConfigPerProduct;
+    flow?: ServiceConfigPerProduct;
+}
+/**
+ * Status lifecycle for a niche pack version. Only `published` rows are
+ * served by the runtime engine; `draft` is admin-authoring only and
+ * `archived` keeps history accessible to already-bootstrapped personas.
+ */
+type NichePackStatus = "draft" | "published" | "archived";
+/**
+ * Loose shape of `researchConfig` — the LAIE-side blob that drives lead
+ * validation, outreach style, and (now, task 3.1.5) reinforcement
+ * signal enrichment.
+ *
+ * The shape stays open (`[extra: string]: unknown`) because seeded
+ * packs and admin-edited packs can carry additional product-specific
+ * fields the platform doesn't model strictly.
+ *
+ * Two naming conventions are supported for the same arrays:
+ *
+ *   - `validation` / `disqualification`             — the literal
+ *     shape the seeded LAIE niche packs ship today.
+ *   - `validationSignals` / `disqualificationSignals` — the spec's
+ *     forward-looking name (used by the persona derivation layer).
+ *
+ * Consumers should accept either, prefer the explicit `*Signals` form
+ * when both are present, and fall back to the legacy short name.
+ */
+interface NichePackResearchConfig {
+    validation?: string[];
+    disqualification?: string[];
+    validationSignals?: string[];
+    disqualificationSignals?: string[];
+    /**
+     * Per-niche follow-up question templates the persona self-review
+     * Loop 1 (REQ-016, confidence-gap detection) fires when a given
+     * persona subfield is judged the weakest signal.
+     *
+     * Keys are persona dot-paths (e.g. `"icp.industryTargets"`,
+     * `"behaviorRules.outreachTone"`); values are free-form question
+     * strings. The placeholder `{niche}` is interpolated with
+     * `persona.identity.nicheSubtype` at fire time (falls back to
+     * `"your niche"` when the persona has no niche set).
+     *
+     * When a key is missing the loop falls back to the platform-wide
+     * default in `defaultFollowupTemplate(targetField)`.
+     */
+    followupTemplates?: Record<string, string>;
+    [extra: string]: unknown;
+}
+/**
+ * Lifecycle status for an `OnboardingExperiment`. Only `running`
+ * experiments influence the runtime engine's variant routing
+ * (task 4.2.3) — `paused` keeps the row visible without affecting
+ * cohort assignment, and `completed` is a terminal state.
+ */
+type OnboardingExperimentStatus = "draft" | "running" | "paused" | "completed";
+/**
+ * Half-open cohort bucket range. `from` is INCLUSIVE, `to` is
+ * EXCLUSIVE. Both endpoints must satisfy `0 <= from < to <= 100` and
+ * align with the bucket assignment in
+ * `service_config.global.onboardingCohort` (a stable integer in
+ * `[0, 99]`).
+ */
+interface OnboardingCohortRange {
+    /** Inclusive lower bound. */
+    from: number;
+    /** Exclusive upper bound. */
+    to: number;
+}
+/**
+ * One variant in an `OnboardingExperiment`.
+ *
+ * Variant ranges may not overlap (the admin-side validator rejects
+ * such payloads); when a user's cohort falls in a gap (or no variant
+ * is defined), the engine serves `controlConfigVersion` instead.
+ */
+interface OnboardingExperimentVariant {
+    /** Cohort range claimed by this variant — see `OnboardingCohortRange`. */
+    cohortRange: OnboardingCohortRange;
+    /**
+     * Versioned `OnboardingConfig` slug, e.g. `"crm@1.0.0"` or any
+     * value the engine's config loader resolves.
+     */
+    configVersion: string;
+    /** Optional sampling weight for analytics; defaults to 1. */
+    weight?: number;
+    /** Optional human-readable label, e.g. `"treatment"`. */
+    label?: string;
+}
+/**
+ * Full experiment row. Mirrors the Postgres
+ * `ecodrix_onboarding_experiments` table (see
+ * `server/src/shared/db/schema/platform/onboarding-experiments.ts`).
+ */
+interface OnboardingExperiment {
+    /** UUID primary key — opaque to SDK callers. */
+    id: string;
+    /** Admin-facing handle, unique platform-wide. */
+    slug: string;
+    /** Product family this experiment targets. */
+    productId: "crm" | "laie" | "flow" | string;
+    /** Display name for admin surfaces. */
+    name: string;
+    /** Optional long-form description. */
+    description?: string | null;
+    status: OnboardingExperimentStatus;
+    /** Cohort routing table — empty array for fresh drafts. */
+    variants: OnboardingExperimentVariant[];
+    /**
+     * Fallback config version served when no variant matches. Null
+     * defers to the product's latest published `OnboardingConfig` row.
+     */
+    controlConfigVersion?: string | null;
+    /** ISO 8601 timestamps — server clock. */
+    createdAt: string;
+    updatedAt: string;
+    startedAt?: string | null;
+    endedAt?: string | null;
+    /** Admin staff id (UUID) of the authoring user, when known. */
+    createdBy?: string | null;
+}
+/**
+ * Versioned bundle of `OnboardingConfig` + `WorkspaceProfile` +
+ * `ResearchConfig` for a single niche slug. One row per `(slug,
+ * version)` in `ecodrix_niche_packs`.
+ *
+ * Niche packs are PLATFORM-WIDE reference data — they are NOT
+ * tenant-scoped. Per-tenant assignment lives at
+ * `ecodrix_organizations.service_config -> '<productId>' -> 'niche'`.
+ */
+interface NichePack {
+    /** Niche slug, e.g. `"healthcare__clinic"`, `"designer__ui_ux"`. */
+    slug: string;
+    /** Product family this pack targets. */
+    productId: "crm" | "laie" | "flow" | string;
+    /** Semantic version, e.g. `"1.0.0"`. */
+    version: string;
+    /** Lifecycle status. Only `"published"` is served at runtime. */
+    status: NichePackStatus;
+    /** Optional — full branching onboarding flow. */
+    onboardingConfig?: OnboardingConfig;
+    /** Optional — default workspace shape. */
+    workspaceProfile?: WorkspaceProfile;
+    /** Optional — research / validation config (LAIE only today). */
+    researchConfig?: NichePackResearchConfig;
+}
+
+/**
+ * Identity block — who the user is, what they sell, where they operate.
+ * Stored at `ecodrix_ai_personas.identity` (JSONB).
+ */
+interface PersonaIdentity {
+    /** Top-level taxonomy slug, e.g. `"designer"`, `"healthcare"`. */
+    niche?: string;
+    /** Leaf slug, e.g. `"designer__ui_ux"`. Partition key for niche packs. */
+    nicheSubtype?: string;
+    /** Free-form business model descriptor, e.g. `"freelancer"`, `"agency"`. */
+    businessModel?: string;
+    /** `"solo" | "2-5" | "6-20" | "20+"` (string for forward-compat). */
+    teamSize?: string;
+    /** Revenue stage, e.g. `"pre-revenue"`, `"<10k_mrr"`, `">100k_mrr"`. */
+    revenueStage?: string;
+    /** Geographies the user serves, ISO-2 country codes or freeform region names. */
+    geographyFocus?: string[];
+    /** Preferred operating language(s). */
+    languages?: string[];
+    [extra: string]: unknown;
+}
+/**
+ * Behavior rules — how the AI should act on the user's behalf.
+ * Stored at `ecodrix_ai_personas.behavior_rules` (JSONB).
+ */
+interface BehaviorRules {
+    /** Tone, e.g. `"warm"`, `"direct"`, `"playful"`. */
+    outreachTone?: string;
+    /** Style, e.g. `"audit_first"`, `"value_first"`, `"roi_data_first"`. */
+    outreachStyle?: string;
+    /** Cadence preset name or descriptor. */
+    outreachCadence?: string;
+    /** Hard rules — strings/phrases the AI must never use. */
+    avoidPatterns?: string[];
+    /** Signals that should immediately validate a lead. */
+    validationSignals?: string[];
+    /** Signals that should immediately disqualify a lead. */
+    disqualificationSignals?: string[];
+    /**
+     * Auto-derived rules from the pattern-generalisation loop (REQ-016 §3),
+     * each carrying a `confidence` weight.
+     */
+    derivedRules?: Array<{
+        expression: string;
+        confidence: number;
+        derivedAt?: string;
+    }>;
+    /**
+     * Bookkeeping for the pattern-generalisation loop (REQ-016 §3,
+     * Task 3.5.3.1). The worker uses `lastClusterAt` to short-circuit
+     * Loop 3 until the persona's `totalReinforcement` crosses a new
+     * 50-event boundary since the previous derived-rule write.
+     */
+    derivedRulesMeta?: {
+        /** `learningMemory.totalReinforcement` at the time of the last
+         *  derived-rule write. */
+        lastClusterAt?: number;
+    };
+    [extra: string]: unknown;
+}
+/**
+ * Vocabulary — phrases the AI should reuse for resonance.
+ * Stored at `ecodrix_ai_personas.vocabulary` (JSONB).
+ */
+interface Vocabulary {
+    clientPainPoints?: string[];
+    serviceValueProps?: string[];
+    proofStatements?: string[];
+    signaturePhrases?: string[];
+    [extra: string]: unknown;
+}
+/**
+ * Ideal Customer Profile. Stored at `ecodrix_ai_personas.icp` (JSONB).
+ */
+interface ICP {
+    industryTargets?: string[];
+    decisionMakerRole?: string[];
+    budgetRange?: {
+        min?: number;
+        max?: number;
+        currency?: string;
+    };
+    geographyTargets?: string[];
+    techStack?: string[];
+    fundingStages?: string[];
+    companySize?: string[];
+    [extra: string]: unknown;
+}
+/**
+ * One observed lead pattern — recorded on approve / reject so the
+ * confidence and pattern-generalisation loops can converge over time.
+ */
+interface LeadPattern {
+    /** UUID of the originating reinforcement event (for idempotency). */
+    eventId: string;
+    /** Signal name, e.g. `"funding_stage"`, `"company_size"`. */
+    signal: string;
+    /** Observed value, e.g. `"series_a"`, `"1-10"`. */
+    value: string;
+    /** Soft weight in [0, 1]; older patterns decay. */
+    weight: number;
+    createdAt: string;
+}
+/**
+ * One captured edit of an AI-generated outreach message — feeds the
+ * outreach-style-drift detection loop (REQ-016 §4).
+ */
+interface OutreachEdit {
+    eventId: string;
+    outreachId: string;
+    /** RFC 6902 JSON Patch describing the user's edit. */
+    diff: Array<Record<string, unknown>>;
+    /** Optional categorisation supplied by the user. */
+    reason?: string;
+    createdAt: string;
+}
+/**
+ * One user-issued correction of an AI assumption (REQ-007). Surfaced via
+ * the inline "Not quite" buttons on persona-displayed assumptions.
+ */
+interface Correction {
+    eventId: string;
+    /** Dot-path to the corrected persona field, e.g. `"icp.industryTargets"`. */
+    field: string;
+    oldValue: unknown;
+    newValue: unknown;
+    createdAt: string;
+}
+/**
+ * One captured user-action against an AI suggestion surface — the
+ * granular audit trail that powers REQ-007 reinforcement learning AND
+ * REQ-012 audit-grade memory for every accept / reject the user
+ * issues at any AI suggestion site (CRM follow-up, LAIE outreach
+ * accept/regenerate, lead-score narrative thumbs, dashboard
+ * next-action, …).
+ *
+ * Stored as `learningMemory.acceptedSuggestionEvents[]` /
+ * `learningMemory.rejectedSuggestionEvents[]` (Task 3.1.4). The
+ * counters `acceptedSuggestions` / `rejectedSuggestions` continue to
+ * carry the cumulative totals so existing confidence math stays
+ * untouched; the per-event arrays are the new audit log.
+ */
+interface SuggestionEvent {
+    /** Idempotency key — the worker dedupes on this. */
+    eventId: string;
+    /** Stable id of the suggestion the user acted on. */
+    suggestionId: string;
+    /**
+     * Suggestion taxonomy slug, e.g. `"follow_up_message"`,
+     * `"lead_score_narrative"`, `"outreach_subject"`, `"next_action"`,
+     * `"inbox_reply"`. Used by the pattern-generalisation loop to bucket
+     * accept/reject ratios per suggestion type.
+     */
+    suggestionType: string;
+    /**
+     * UI surface the user acted from, e.g. `"crm.deal.followup"`,
+     * `"saas.inbox.reply"`, `"laie.lead.score"`. Free-form but
+     * conventionally a dot-path under `<product>.<area>.<surface>`.
+     */
+    surface: string;
+    /**
+     * Surface-specific extra context (`dealId`, `leadId`, `conversationId`,
+     * etc) so the audit trail can correlate the action back to the
+     * originating row without bloating the top-level shape. Optional.
+     */
+    productContext?: Record<string, unknown>;
+    /** Optional rejection reason (`rejected` arrays only). */
+    rejectionReason?: string;
+    createdAt: string;
+}
+/**
+ * One captured `ai_outreach_sent` event — a row recorded every time
+ * an AI-generated outreach actually goes out. Pairs with
+ * {@link OutreachEdit} as the denominator side of the rolling
+ * edit-ratio that drives REQ-016 §4 (outreach style drift).
+ *
+ * Stored at `learningMemory.aiOutreachSent[]`. The writer caps the
+ * array at 500 entries (oldest rolled off) — same blast-radius
+ * pattern as `outreachEditHistory` to keep the JSONB blob bounded.
+ */
+interface OutreachSent {
+    /** ISO 8601. The detector's window predicate runs on this. */
+    createdAt: string;
+    /** Optional id of the outreach row this corresponds to. */
+    outreachId?: string;
+    /**
+     * Originating product. Optional — recorded for telemetry / future
+     * per-product drift breakdowns. Free-form so non-`crm | laie | flow`
+     * surfaces can also log here without a discriminated-union update.
+     */
+    productId?: string;
+    /** Optional channel descriptor, e.g. `"email"`, `"linkedin"`. */
+    channel?: string;
+}
+/**
+ * Learning memory — append-only signals derived from reinforcement
+ * events. Trimmed by the workers; rotated to history on overflow.
+ *
+ * Stored at `ecodrix_ai_personas.learning_memory` (JSONB).
+ */
+interface LearningMemory {
+    approvedLeadPatterns: LeadPattern[];
+    rejectedLeadPatterns: LeadPattern[];
+    wonDealSignals: LeadPattern[];
+    lostDealSignals: LeadPattern[];
+    outreachEditHistory: OutreachEdit[];
+    corrections: Correction[];
+    /**
+     * Audit log of every `ai_suggestion_accepted` event applied to this
+     * persona. Counters below carry the rolling totals; this array is
+     * the per-event trail required by REQ-012. Trimmed by the worker
+     * when growth becomes a token-budget concern.
+     */
+    acceptedSuggestionEvents: SuggestionEvent[];
+    /** Audit log of every `ai_suggestion_rejected` event. See above. */
+    rejectedSuggestionEvents: SuggestionEvent[];
+    /** Cumulative count, used by the confidence math (REQ-008). */
+    acceptedSuggestions: number;
+    /** Cumulative count, used by the confidence math (REQ-008). */
+    rejectedSuggestions: number;
+    /** Sum of all reinforcement events ever applied to this persona. */
+    totalReinforcement: number;
+    /**
+     * Append-only log of AI-generated outreach that was actually sent.
+     * Powers the denominator of the 7-day rolling edit-ratio (REQ-016
+     * §4 / Task 3.5.4.1). Optional because pre-Loop 4 personas don't
+     * carry the field; the writer initialises it to `[]` on every new
+     * row written after Phase 3.5. Capped at 500 entries by the writer
+     * (oldest rolled off) — same pattern as `outreachEditHistory`.
+     */
+    aiOutreachSent?: OutreachSent[];
+    /**
+     * Cooldown gate for the outreach style drift loop (REQ-016 §4 /
+     * Task 3.5.4.2). When the worker emits a `style_drift` warning it
+     * stamps this field; subsequent loop runs skip the persona until
+     * the configured cooldown elapses (default 7 days). Absent on
+     * personas that have never tripped a drift warning.
+     */
+    lastStyleDriftWarningAt?: string;
+    [extra: string]: unknown;
+}
+/**
+ * Full AI persona — one row per `(userId, orgId, productId)` in
+ * `ecodrix_ai_personas`. Returned by `GET /api/persona/:productId`.
+ */
+interface AIPersona {
+    id: string;
+    orgId: string;
+    userId: string;
+    productId: "crm" | "laie" | "flow";
+    identity: PersonaIdentity;
+    behaviorRules: BehaviorRules;
+    vocabulary: Vocabulary;
+    icp: ICP;
+    learningMemory: LearningMemory;
+    /** Version string of the `OnboardingConfig` that bootstrapped this row. */
+    onboardingVersion: string | null;
+    onboardingCompletedAt: string | null;
+    lastReinforced: string | null;
+    /** Monotonically increasing per persona; bumped on every write. */
+    memoryVersion: number;
+    /** True only after onboarding completes; false on the generic baseline. */
+    isBootstrapped: boolean;
+    /** 0–100 — see REQ-008 for the formula. */
+    confidenceScore: number;
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * Common envelope fields shared by every reinforcement event.
+ * `eventId` enables worker-side idempotency (Property 5 in design.md).
+ */
+interface ReinforcementEventBase {
+    /** Unique id (uuid) for idempotent re-delivery. */
+    eventId: string;
+    productId: "crm" | "laie" | "flow";
+    /** Wall-clock at the originating UI surface. ISO 8601 string. */
+    occurredAt?: string;
+}
+/**
+ * REQ-007 — discriminated union of every reinforcement event the
+ * platform emits. Workers fan these into `learning_memory` mutations.
+ */
+type ReinforcementEvent = (ReinforcementEventBase & {
+    kind: "lead_approved";
+    leadId: string;
+    /**
+     * Optional `(signal, value, weight?)` tuples. Weight defaults to
+     * `1.0` on the writer and is bounded `[0, 1]`. The reinforcement
+     * worker enriches this list via the signal-derivation layer
+     * (task 3.1.5) before the writer persists it.
+     */
+    signals?: Array<{
+        signal: string;
+        value: string;
+        weight?: number;
+    }>;
+}) | (ReinforcementEventBase & {
+    kind: "lead_rejected";
+    leadId: string;
+    signals?: Array<{
+        signal: string;
+        value: string;
+        weight?: number;
+    }>;
+    reason?: string;
+}) | (ReinforcementEventBase & {
+    kind: "deal_won";
+    leadId: string;
+    dealValue?: number;
+    signals?: Array<{
+        signal: string;
+        value: string;
+        weight?: number;
+    }>;
+}) | (ReinforcementEventBase & {
+    kind: "deal_lost";
+    leadId: string;
+    reason?: string;
+    signals?: Array<{
+        signal: string;
+        value: string;
+        weight?: number;
+    }>;
+}) | (ReinforcementEventBase & {
+    kind: "outreach_edited";
+    outreachId: string;
+    diff: Array<Record<string, unknown>>;
+    reason?: string;
+}) | (ReinforcementEventBase & {
+    /**
+     * Recorded every time an AI-generated outreach actually goes
+     * out. Feeds the denominator of the 7-day rolling edit-ratio
+     * that drives REQ-016 §4 (outreach style drift detection,
+     * Task 3.5.4). The writer appends one
+     * {@link OutreachSent} entry to
+     * `learningMemory.aiOutreachSent` and caps the array at 500
+     * entries (oldest rolled off).
+     */
+    kind: "outreach_sent";
+    /** Optional id of the originating outreach row. */
+    outreachId?: string;
+    /** Optional channel descriptor, e.g. `"email"`, `"linkedin"`. */
+    channel?: string;
+}) | (ReinforcementEventBase & {
+    kind: "ai_suggestion_accepted";
+    /** Stable id of the AI suggestion the user accepted. */
+    suggestionId: string;
+    /**
+     * Suggestion taxonomy slug, e.g. `"follow_up_message"`,
+     * `"lead_score_narrative"`, `"outreach_subject"`, `"next_action"`,
+     * `"inbox_reply"`.
+     */
+    suggestionType: string;
+    /**
+     * UI surface the user acted from, e.g. `"crm.deal.followup"`,
+     * `"saas.inbox.reply"`, `"laie.lead.score"`.
+     */
+    surface: string;
+    /**
+     * Surface-specific extra context (`dealId`, `leadId`,
+     * `conversationId`, etc).
+     */
+    productContext?: Record<string, unknown>;
+    /**
+     * Persona memory version that produced the AI generation.
+     * Threaded through history for attribution.
+     */
+    personaVersion?: number | null;
+}) | (ReinforcementEventBase & {
+    kind: "ai_suggestion_rejected";
+    suggestionId: string;
+    suggestionType: string;
+    surface: string;
+    /** Optional user-supplied rejection reason. */
+    rejectionReason?: string;
+    productContext?: Record<string, unknown>;
+    personaVersion?: number | null;
+}) | (ReinforcementEventBase & {
+    kind: "ai_assumption_corrected";
+    field: string;
+    oldValue: unknown;
+    newValue: unknown;
+}) | (ReinforcementEventBase & {
+    kind: "followup_answer";
+    questionId: string;
+    targetField: string;
+    answer: unknown;
+});
+/**
+ * Response of `POST /api/persona/reinforce`.
+ */
+interface ReinforceResponse {
+    ok: true;
+    /** Persona memory version after this event was applied. */
+    version: number;
+}
+/**
+ * Response of `GET /api/persona/confidence`.
+ */
+interface ConfidenceResponse {
+    /** 0–100 score per REQ-008. */
+    score: number;
+    /** Same breakdown the saas pill exposes on click. */
+    breakdown: {
+        acceptRatioContribution: number;
+        reinforcementContribution: number;
+        bootstrapContribution: number;
+    };
+}
+/**
+ * One row of a persona's version history. Mirrors the wire shape of
+ * `GET /api/persona/:productId/timeline` produced by
+ * `personaHistory.listTimeline` on the server.
+ *
+ * The DB stores 50 of these per persona (`personaHistory.appendAndPrune`
+ * caps retention); the saas timeline page renders the diff for each
+ * row inline via the `diff` array of RFC 6902 ops.
+ */
+interface PersonaTimelineEntry {
+    id: string;
+    personaId: string;
+    /** Monotonically increasing per persona; matches `AIPersona.memoryVersion`
+     *  at the time of write. */
+    memoryVersion: number;
+    /** One of `onboarding_edit | reinforcement | admin_override | self_review`,
+     *  but typed loosely so a new server reason doesn't break SDK consumers. */
+    changeReason: string;
+    /** User id, `system`, or `worker:<name>`. */
+    changedBy: string;
+    /** RFC 6902 JSON Patch ops applied by this version. */
+    diff: Array<Record<string, unknown>>;
+    /** Snapshot of the persona BEFORE this change. */
+    prevSnapshot: Record<string, unknown>;
+    /** ISO 8601 wall-clock at the time of write. */
+    createdAt: string;
+}
+/**
+ * Response shape of `GET /api/persona/:productId/timeline`.
+ *
+ * `hasMore` is a soft "did we hit the page size?" hint — the server
+ * doesn't run a second COUNT(*) to compute an exact total. The saas
+ * treats it as a CTA gate: render "Load older" when true.
+ */
+interface PersonaTimelineResponse {
+    entries: PersonaTimelineEntry[];
+    hasMore: boolean;
+}
+/** Optional query parameters for `Persona.timeline(...)`. */
+interface PersonaTimelineOptions {
+    /** Page size — clamped server-side to `[1, 50]`. Default `50`. */
+    limit?: number;
+    /** Cursor — return entries with `memoryVersion < before`. */
+    before?: number;
+}
+/**
+ * One pending followup question synthesised by the
+ * confidence-gap-detection loop (REQ-016 Loop 1). The saas
+ * `<FollowupQuestionCard>` renders the newest pending entry inline
+ * on the relevant product page; the user's answer routes through
+ * `POST /api/persona/:productId/followups/:id/answer` (which flips
+ * `answeredAt` on the row) and additionally fires a
+ * `kind: "followup_answer"` reinforcement event so the persona's
+ * `corrections[]` audit slot is updated.
+ *
+ * Mirrors the wire shape returned by
+ * `GET /api/persona/:productId/followups`. The DB row carries
+ * `answeredAt` and `answer` columns; we deliberately omit them here
+ * because the reader only ever returns pending rows (both columns
+ * are NULL until the user answers).
+ */
+interface PersonaFollowupQuestion {
+    id: string;
+    personaId: string;
+    question: string;
+    /** Persona JSONB dot-path the answer maps to,
+     *  e.g. `"icp.industryTargets"` or `"behaviorRules.outreachTone"`. */
+    targetField: string;
+    /** ISO 8601 — when the worker generated the question. */
+    askedAt: string;
+    /**
+     * Open structured payload for advanced followup kinds (REQ-016
+     * §4 / Task 3.5.4.2 — outreach style drift recalibration).
+     *
+     * Loop 4 fills this with `{ kind: "style_recalibration", ratio,
+     * options: [{ id, label }, ...] }` so the saas
+     * `<FollowupQuestionCard>` can render a multi-choice toggle
+     * instead of the simpler free-text textarea. Absent / `null` on
+     * rows created by the Loop 1 confidence-gap path.
+     *
+     * Free-form by design — workers can extend the payload without an
+     * SDK rebuild and saas surfaces ignore unknown keys gracefully.
+     */
+    metadata?: {
+        kind?: string;
+        options?: Array<{
+            id: string;
+            label: string;
+        }>;
+        ratio?: number;
+        [k: string]: unknown;
+    } | null;
+}
+/**
+ * Body shape of `POST /api/persona/:productId/followups/:id/answer`.
+ *
+ * Two acceptable forms:
+ *   - Plain string answer — the legacy path used by Loop 1
+ *     confidence-gap followups. The string is stored verbatim on the
+ *     row and forwarded to the persona as a `kind: "followup_answer"`
+ *     reinforcement event.
+ *   - Structured `{ dimension, detail? }` answer — the Loop 4
+ *     style-recalibration path. The route validates `dimension`
+ *     against the five recognised ids (`tone | length |
+ *     personalization | cta | structure`), forwards the answer to
+ *     `personaWriter.applyStyleRecalibration`, AND additionally fires
+ *     the standard reinforcement event for the audit trail.
+ */
+type AnswerFollowupBody = {
+    answer: string;
+} | {
+    answer: {
+        dimension: "tone" | "length" | "personalization" | "cta" | "structure";
+        detail?: string;
+    };
+};
+/**
+ * Response shape of `GET /api/persona/:productId/followups`.
+ *
+ * The list is ordered newest-first by `askedAt` and capped at 5
+ * server-side. The saas card only ever renders the first entry.
+ */
+interface PersonaFollowupsResponse {
+    entries: PersonaFollowupQuestion[];
+}
+/**
+ * AI persona resource.
+ *
+ * Mounted on the main client as `ecod.persona`. Reads the persona row,
+ * accepts reinforcement events, and exposes the live confidence score.
+ *
+ * @example
+ * ```typescript
+ * const persona = await ecod.persona.get("crm");
+ *
+ * await ecod.persona.reinforce({
+ *   eventId: crypto.randomUUID(),
+ *   productId: "laie",
+ *   kind: "lead_approved",
+ *   leadId: "lead_123",
+ *   signals: [{ signal: "funding_stage", value: "series_a" }],
+ * });
+ *
+ * const { score } = await ecod.persona.confidence("laie");
+ * ```
+ */
+declare class Persona extends APIResource {
+    /**
+     * Read the persona for the calling user + given product. Returns the
+     * generic baseline shape when the user hasn't bootstrapped yet
+     * (`isBootstrapped === false`).
+     *
+     * Note: this method shadows `APIResource.get` (which is `protected`).
+     * The override widens visibility to public and narrows the return type
+     * to `AIPersona`, which TypeScript flags as a structural override
+     * mismatch — that mismatch is intentional and benign here, hence the
+     * directive below. Implementation delegates to `super.get(...)`.
+     */
+    get(productId: "crm" | "laie" | "flow"): Promise<AIPersona>;
+    /**
+     * Submit a reinforcement event. The server enqueues it onto the
+     * `persona-reinforcement` queue and returns the post-apply memory
+     * version. Idempotent on `eventId`.
+     */
+    reinforce(event: ReinforcementEvent): Promise<ReinforceResponse>;
+    /**
+     * Read the live confidence score + the per-component breakdown.
+     */
+    confidence(productId: "crm" | "laie" | "flow"): Promise<ConfidenceResponse>;
+    /**
+     * Read the persona's version history — one entry per `personaWriter`
+     * mutation, with the RFC 6902 patch + previous snapshot.
+     *
+     * Returns at most 50 rows per call (matches the per-persona
+     * retention cap enforced server-side by
+     * `personaHistory.appendAndPrune`). When `hasMore === true`, page
+     * back with `{ before: entries[entries.length - 1].memoryVersion }`.
+     *
+     * Note: this method shadows `APIResource.get` (which is `protected`)
+     * via the public override above on `get(...)`. The same caveat
+     * applies here — we intentionally widen visibility and narrow the
+     * return type to the timeline envelope. Implementation delegates
+     * to `super.get(...)`.
+     */
+    timeline(productId: "crm" | "laie" | "flow", options?: PersonaTimelineOptions): Promise<PersonaTimelineResponse>;
+    /**
+     * Read the persona's pending followup questions — the
+     * confidence-gap-detection loop (REQ-016 Loop 1) writes one row
+     * per `(persona, weakest subfield)` pair when
+     * `confidenceScore < 50` AND `learningMemory.totalReinforcement
+     * >= 20`. The saas `<FollowupQuestionCard>` mounts on the
+     * relevant product page and renders the newest pending entry
+     * inline.
+     *
+     * Returns the unwrapped `entries` array (no surrounding `{ success,
+     * data }` envelope) — matches the project's preference of having
+     * the SDK do the unwrap so call sites stay slim. An empty list
+     * means there's nothing pending; the card opts itself out and
+     * returns `null` in that case.
+     *
+     * Note: this method shadows `APIResource.get` (which is `protected`)
+     * — see the note above {@link Persona.get} / {@link Persona.timeline}.
+     */
+    followups(productId: "crm" | "laie" | "flow"): Promise<PersonaFollowupQuestion[]>;
+}
+
+/**
+ * Admin-side onboarding resource.
+ *
+ * Mounted on the main client as `ecod.adminOnboarding`. Mirrors the
+ * platform-admin endpoints under `/api/admin/onboarding/*` documented
+ * in `server/src/platform/routes/admin/onboarding.routes.ts`.
+ *
+ * Auth: every method requires the elevated platform `coreApiKey`. The
+ * SDK forwards it as `x-core-api-key`; admin server-side callers should
+ * always construct a client with `coreApiKey` set (see
+ * `admin/src/lib/client/erix-admin.ts`).
+ *
+ * Endpoints covered in this build (task 4.1.1 — list page):
+ *
+ *   - GET    /api/admin/onboarding/niche-packs               list
+ *   - GET    /api/admin/onboarding/niche-packs/:slug         fetch one
+ *   - POST   /api/admin/onboarding/niche-packs               create
+ *   - PATCH  /api/admin/onboarding/niche-packs/:slug         update
+ *   - POST   /api/admin/onboarding/niche-packs/:slug/publish publish
+ *   - POST   /api/admin/onboarding/niche-packs/:slug/unpublish back to draft
+ *   - POST   /api/admin/onboarding/niche-packs/:slug/fork    new draft copy
+ *   - GET    /api/admin/onboarding/configs                   list configs
+ *   - POST   /api/admin/onboarding/configs                   create config
+ *   - PATCH  /api/admin/onboarding/configs/:productId/:version  update
+ *   - POST   /api/admin/onboarding/configs/:productId/:version/publish publish
+ *
+ * Endpoints for A/B onboarding experiments (task 4.2.2):
+ *
+ *   - GET    /api/admin/onboarding/experiments               list
+ *   - GET    /api/admin/onboarding/experiments/:slug         fetch one
+ *   - POST   /api/admin/onboarding/experiments               create draft
+ *   - PATCH  /api/admin/onboarding/experiments/:slug         partial update
+ *   - DELETE /api/admin/onboarding/experiments/:slug         hard-delete
+ *
+ * Successive admin tasks (4.1.2–4.1.5) layer richer editor / fork /
+ * publish flows on top of these primitives.
+ */
+
+/** Niche pack row as returned by the admin list endpoint. */
+interface NichePackSummary {
+    id: string;
+    slug: string;
+    productId: NichePack["productId"];
+    version: string;
+    status: NichePackStatus;
+    /** ISO 8601 — creation timestamp (server clock). */
+    createdAt: string;
+    /** ISO 8601 — last edit timestamp. */
+    updatedAt: string;
+    /** ISO 8601 — first time `status` flipped to `published`. */
+    publishedAt?: string | null;
+    /** Admin staff id who created this version. */
+    createdBy?: string | null;
+}
+/** Filters accepted by `adminOnboarding.listNichePacks`. */
+interface ListNichePacksParams {
+    /** Restrict to a single product family. */
+    productId?: NichePack["productId"];
+    /** Restrict to one lifecycle status. */
+    status?: NichePackStatus;
+    /**
+     * Free-form fuzzy search. Matched (case-insensitive) against `slug`
+     * and `productId`. Whitespace is trimmed.
+     */
+    search?: string;
+    /** Page size — server clamps to 1..100, default 25. */
+    limit?: number;
+    /** Pagination offset, default 0. */
+    offset?: number;
+}
+/** Body accepted by the create-pack endpoint. */
+interface CreateNichePackPayload {
+    slug: string;
+    productId: NichePack["productId"];
+    /** Defaults to `"1.0.0"` server-side. */
+    version?: string;
+    onboardingConfig?: Record<string, unknown>;
+    workspaceProfile?: Record<string, unknown>;
+    researchConfig?: Record<string, unknown>;
+}
+/** Body accepted by the update-pack endpoint. At least one field required. */
+interface UpdateNichePackPayload {
+    status?: NichePackStatus;
+    onboardingConfig?: Record<string, unknown>;
+    workspaceProfile?: Record<string, unknown>;
+    researchConfig?: Record<string, unknown>;
+}
+/** Body accepted by the fork-pack endpoint. */
+interface ForkNichePackPayload {
+    /** Source version to clone; defaults to the latest row for the slug. */
+    fromVersion?: string;
+    /** Target version for the new draft; defaults to a server-side bump. */
+    version?: string;
+}
+/**
+ * Body accepted by `adminOnboarding.smokeTestNichePack` (task 4.1.5).
+ *
+ * Both fields are optional:
+ *
+ *   - `fromVersion` pins a specific row for the slug; without it the
+ *     server picks the most recent (typically the latest draft).
+ *   - `answers` is a `{ stepId: value }` map. When omitted (or missing
+ *     keys for some steps) the in-memory runner auto-picks the first
+ *     option of `single_choice` / `multi_choice` steps and uses a
+ *     placeholder for `text_input`.
+ */
+interface SmokeTestNichePackPayload {
+    fromVersion?: string;
+    answers?: Record<string, unknown>;
+}
+/**
+ * One materializer action the live `workspaceShaper.materialize` call
+ * WOULD perform if the smoke-tested pack were used in a real
+ * onboarding-complete flow. The summary string is what the admin
+ * panel renders verbatim ("Would create pipeline 'Patient Journey'
+ * with 5 stages").
+ */
+type SmokeTestMaterializerAction = {
+    kind: "pipeline";
+    name: string;
+    stageCount: number;
+    isDefault: boolean;
+    summary: string;
+} | {
+    kind: "field";
+    key: string;
+    label: string;
+    type: string;
+    required: boolean;
+    summary: string;
+} | {
+    kind: "automation";
+    name: string;
+    trigger: string;
+    enabled: boolean;
+    summary: string;
+};
+/**
+ * Result envelope returned by `adminOnboarding.smokeTestNichePack`.
+ *
+ * Mirrors `SmokeTestResult` in
+ * `server/src/erix/services/onboarding/smokeTestRunner.ts`.
+ */
+interface SmokeTestResult {
+    /** In-memory `OnboardingSession` produced by the simulator. */
+    session: OnboardingSession;
+    /** Persona shaped from the answers + memory mappings. */
+    persona: AIPersona;
+    /** Workspace profile produced by `workspaceShaper.produce`. */
+    workspaceProfile: WorkspaceProfile;
+    /** Actions the live materializer would perform. */
+    materializerActions: SmokeTestMaterializerAction[];
+    /** Wall-clock duration (millis) of the simulation. */
+    durationMs: number;
+    /** Step ids the engine visited (in order). */
+    visitedStepIds: string[];
+    /** Step ids the engine skipped via branching predicates. */
+    skippedStepIds: string[];
+    /** Whether the runner had to auto-pick at least one answer. */
+    autoPicked: boolean;
+}
+/** Standard `{ success, data }` envelope used by every admin endpoint. */
+interface ApiEnvelope<T> {
+    success: boolean;
+    data: T;
+}
+/** Envelope returned by `GET /admin/onboarding/niche-packs`. */
+interface ListNichePacksResponse extends ApiEnvelope<NichePackSummary[]> {
+    /**
+     * Total niche-pack rows matching the current filter set, ignoring
+     * the page window. Drives the saas-side paginator. Falls back to
+     * `data.length` when the server can't compute a true count.
+     */
+    total: number;
+}
+/** Envelope returned by single-pack endpoints (get / create / update / fork). */
+type NichePackResponse = ApiEnvelope<NichePack & NichePackSummary>;
+/** Filters accepted by `adminOnboarding.listOnboardingConfigs`. */
+interface ListOnboardingConfigsParams {
+    productId?: OnboardingConfig["productId"];
+    status?: NichePackStatus;
+}
+/** Body accepted by the create-config endpoint. */
+interface CreateOnboardingConfigPayload {
+    productId: OnboardingConfig["productId"];
+    version?: string;
+    config?: Record<string, unknown>;
+}
+/** Body accepted by the update-config endpoint. */
+interface UpdateOnboardingConfigPayload {
+    status?: NichePackStatus;
+    config?: Record<string, unknown>;
+}
+/** Filters accepted by `adminOnboarding.listOnboardingExperiments`. */
+interface ListOnboardingExperimentsParams {
+    productId?: OnboardingExperiment["productId"];
+    status?: OnboardingExperimentStatus;
+    /** Page size — server clamps to 1..100, default 25. */
+    limit?: number;
+    /** Pagination offset, default 0. */
+    offset?: number;
+} /** Body accepted by the create-experiment endpoint. */
+interface CreateOnboardingExperimentPayload {
+    /** Admin-facing handle; unique platform-wide. */
+    slug: string;
+    productId: OnboardingExperiment["productId"];
+    /** Display name shown in the admin panel. */
+    name: string;
+    description?: string;
+    /** Defaults to `"draft"` server-side. */
+    status?: OnboardingExperimentStatus;
+    /**
+     * Variant routing table — may be empty for a freshly created
+     * draft. Variants whose `cohortRange` overlaps are rejected with
+     * `OVERLAPPING_VARIANTS`.
+     */
+    variants?: OnboardingExperimentVariant[];
+    /** Fallback config version when no variant matches the user's bucket. */
+    controlConfigVersion?: string | null;
+}
+/** Body accepted by the patch-experiment endpoint. */
+interface UpdateOnboardingExperimentPayload {
+    name?: string;
+    description?: string | null;
+    status?: OnboardingExperimentStatus;
+    variants?: OnboardingExperimentVariant[];
+    controlConfigVersion?: string | null;
+}
+/** Envelope returned by `GET /admin/onboarding/experiments`. */
+interface ListOnboardingExperimentsResponse extends ApiEnvelope<OnboardingExperiment[]> {
+    /**
+     * Total experiments matching the current filter set, ignoring the
+     * page window. Drives the saas-side paginator. Falls back to
+     * `data.length` when the server can't compute a true count.
+     */
+    total: number;
+}
+/** Envelope returned by single-experiment endpoints. */
+type OnboardingExperimentResponse = ApiEnvelope<OnboardingExperiment>;
+/**
+ * Filters accepted by every analytics endpoint
+ * (`getOnboardingFunnel`, `getOnboardingTimeOnStep`,
+ * `getOnboardingAbandonment`).
+ *
+ * `productId` constrains by product family, `nicheSubtype` by the
+ * `nichePackSlug` recorded on the originating session row. `fromDate`
+ * / `toDate` are wire-side ISO 8601 strings (the server coerces them
+ * via Zod's `z.coerce.date()`); when omitted, the server defaults to
+ * the trailing 30 days. The server hard-caps the requested window at
+ * 180 days and rejects `fromDate >= toDate` with 400 INVALID_FIELD.
+ */
+interface OnboardingAnalyticsFiltersParams {
+    productId?: "crm" | "laie" | "flow" | string;
+    nicheSubtype?: string;
+    /** ISO 8601 datetime, e.g. `"2025-01-01T00:00:00.000Z"`. */
+    fromDate?: string;
+    /** ISO 8601 datetime. */
+    toDate?: string;
+}
+/** One funnel row — distinct sessions that reached `stepId`. */
+interface OnboardingFunnelStep {
+    productId: string;
+    nichePackSlug: string | null;
+    stepId: string;
+    /** Distinct sessions that emitted at least one event for this step. */
+    sessions: number;
+    /**
+     * Fraction `[0, 1]` of sessions that reached this step relative to
+     * the first step in the same `(productId, nichePackSlug)` flow.
+     * The first step always has `conversionRate = 1`.
+     */
+    conversionRate: number;
+}
+/** Result envelope for `getOnboardingFunnel`. */
+interface OnboardingFunnelResult {
+    /** Flat list, ordered by `(productId, nichePackSlug, sessions DESC)`. */
+    funnel: OnboardingFunnelStep[];
+    /** Distinct sessions across all rows in the window. */
+    totalSessions: number;
+}
+/** One time-on-step row — per `(productId, nichePackSlug, stepId)`. */
+interface OnboardingTimeOnStepRow {
+    productId: string;
+    nichePackSlug: string | null;
+    stepId: string;
+    /** Median (p50) milliseconds from `stepId` first event → next step. */
+    medianMs: number;
+    /** p95 milliseconds. */
+    p95Ms: number;
+    /** Number of (session, step) pairs that contributed a delta. */
+    sampleSize: number;
+}
+/** Result envelope for `getOnboardingTimeOnStep`. */
+interface OnboardingTimeOnStepResult {
+    rows: OnboardingTimeOnStepRow[];
+}
+/** One abandonment bucket — abandoned sessions whose last seen step was `stepId`. */
+interface OnboardingAbandonmentRow {
+    productId: string;
+    nichePackSlug: string | null;
+    stepId: string;
+    abandonedSessions: number;
+}
+/** Result envelope for `getOnboardingAbandonment`. */
+interface OnboardingAbandonmentResult {
+    rows: OnboardingAbandonmentRow[];
+    totalAbandoned: number;
+}
+/** `{ success, data: OnboardingFunnelResult }`. */
+type OnboardingFunnelResponse = ApiEnvelope<OnboardingFunnelResult>;
+/** `{ success, data: OnboardingTimeOnStepResult }`. */
+type OnboardingTimeOnStepResponse = ApiEnvelope<OnboardingTimeOnStepResult>;
+/** `{ success, data: OnboardingAbandonmentResult }`. */
+type OnboardingAbandonmentResponse = ApiEnvelope<OnboardingAbandonmentResult>;
+/**
+ * Admin-side onboarding control plane.
+ *
+ * @example
+ * ```typescript
+ * const { data, total } = await ecod.adminOnboarding.listNichePacks({
+ *   productId: "crm",
+ *   status: "published",
+ *   search: "clinic",
+ *   limit: 25,
+ *   offset: 0,
+ * });
+ * ```
+ */
+declare class AdminOnboarding extends APIResource {
+    /**
+     * List niche packs with optional filtering, search, and pagination.
+     * Server response shape: `{ success, data, total }`.
+     */
+    listNichePacks(params?: ListNichePacksParams): Promise<ListNichePacksResponse>;
+    /** Fetch a single niche pack by slug. Without `version` returns the latest. */
+    getNichePack(slug: string, version?: string): Promise<NichePackResponse>;
+    /** Create a new niche pack draft. */
+    createNichePack(payload: CreateNichePackPayload): Promise<NichePackResponse>;
+    /** Patch a draft niche pack. Server enforces "at least one field". */
+    updateNichePack(slug: string, payload: UpdateNichePackPayload, version?: string): Promise<NichePackResponse>;
+    /** Flip a niche pack to `published`. */
+    publishNichePack(slug: string, version?: string): Promise<NichePackResponse>;
+    /** Flip a niche pack back to `draft`. */
+    unpublishNichePack(slug: string, version?: string): Promise<NichePackResponse>;
+    /** Fork an existing niche pack into a new draft version. */
+    forkNichePack(slug: string, payload?: ForkNichePackPayload): Promise<NichePackResponse>;
+    /**
+     * Run an in-memory smoke test against a niche pack (task 4.1.5).
+     *
+     * The server resolves the pack row, walks its `onboardingConfig`
+     * with the supplied (or auto-picked) answers, shapes a persona
+     * + workspace profile, and returns the result without writing
+     * anything. Useful for admins to validate a draft pack before
+     * publishing.
+     *
+     * @param slug    - Niche pack slug.
+     * @param payload - Optional `{ fromVersion?, answers? }`. Both
+     *   fields are independently optional; `version` (the legacy
+     *   query-string equivalent) is also supported as a third
+     *   argument for parity with the other slug-keyed methods.
+     * @param version - Optional version override applied as a
+     *   `?version=` query param (kept for callers that already
+     *   thread version through the URL).
+     */
+    smokeTestNichePack(slug: string, payload?: SmokeTestNichePackPayload, version?: string): Promise<ApiEnvelope<SmokeTestResult>>;
+    listOnboardingConfigs(params?: ListOnboardingConfigsParams): Promise<ApiEnvelope<unknown[]>>;
+    createOnboardingConfig(payload: CreateOnboardingConfigPayload): Promise<ApiEnvelope<unknown>>;
+    updateOnboardingConfig(productId: OnboardingConfig["productId"], version: string, payload: UpdateOnboardingConfigPayload): Promise<ApiEnvelope<unknown>>;
+    publishOnboardingConfig(productId: OnboardingConfig["productId"], version: string): Promise<ApiEnvelope<unknown>>;
+    /**
+     * List onboarding A/B experiments with optional filters and
+     * pagination. Server response shape: `{ success, data, total }`.
+     */
+    listOnboardingExperiments(params?: ListOnboardingExperimentsParams): Promise<ListOnboardingExperimentsResponse>;
+    /** Fetch a single experiment by its slug. 404 when absent. */
+    getOnboardingExperiment(slug: string): Promise<OnboardingExperimentResponse>;
+    /**
+     * Create a draft experiment. The server enforces:
+     *
+     *   - `slug` non-empty + globally unique.
+     *   - `productId ∈ {crm, laie, flow}`.
+     *   - `variants` is an array (may be empty for a draft).
+     *   - Each variant's `cohortRange.from < cohortRange.to`, both in
+     *     `[0, 100]`.
+     *   - Variants don't overlap (returns 400 `OVERLAPPING_VARIANTS`).
+     */
+    createOnboardingExperiment(payload: CreateOnboardingExperimentPayload): Promise<OnboardingExperimentResponse>;
+    /**
+     * Patch an experiment. At least one of `name | description |
+     * status | variants | controlConfigVersion` must be supplied —
+     * the server returns 400 `NO_UPDATES` for an empty body. When
+     * `variants` is supplied the overlap validator re-runs.
+     */
+    updateOnboardingExperiment(slug: string, payload: UpdateOnboardingExperimentPayload): Promise<OnboardingExperimentResponse>;
+    /**
+     * Hard-delete an experiment. Returns the deleted row in `data` for
+     * audit-log convenience. Admin-only — no soft-delete column.
+     */
+    deleteOnboardingExperiment(slug: string): Promise<OnboardingExperimentResponse>;
+    /**
+     * Funnel-by-step counts for `(productId, nichePackSlug)`, plus
+     * conversion rates relative to each flow's first step.
+     *
+     * Server-side filters: `productId`, `nicheSubtype` (the niche pack
+     * slug — UI-friendly alias of the column name), `fromDate`,
+     * `toDate`. Both date bounds default to the trailing 30 days. The
+     * server clamps the window at 180 days and rejects
+     * `fromDate >= toDate` with 400 INVALID_FIELD.
+     *
+     * Powers the admin Sankey + per-step bar chart in Task 4.3.2.
+     */
+    getOnboardingFunnel(params?: OnboardingAnalyticsFiltersParams): Promise<OnboardingFunnelResponse>;
+    /**
+     * Median + p95 milliseconds spent on each step (per
+     * `(productId, nichePackSlug, stepId)`), computed via
+     * `LEAD(created_at) OVER (PARTITION BY session_id …)` on the event
+     * stream. Sample size accompanies each row so the saas can
+     * grey-out under-sampled buckets.
+     */
+    getOnboardingTimeOnStep(params?: OnboardingAnalyticsFiltersParams): Promise<OnboardingTimeOnStepResponse>;
+    /**
+     * Histogram of `stepId` values where sessions went inactive — i.e.
+     * `status = 'abandoned'` OR (active for >24h with no further
+     * events). The server also tallies a `totalAbandoned` aggregate so
+     * the saas can render a percentage column without re-summing.
+     */
+    getOnboardingAbandonment(params?: OnboardingAnalyticsFiltersParams): Promise<OnboardingAbandonmentResponse>;
+}
+
 interface CheckoutProduct {
     externalId: string;
     name: string;
@@ -628,9 +2107,15 @@ declare class Automations extends APIResource {
 }
 
 /**
- * The specific UI control type suggested for a field.
+ * The specific UI control type suggested for a field on a `ResourceManifest`.
+ *
+ * NOTE: this is the UI-hint vocabulary used by `ResourceManifest`. It is
+ * intentionally distinct from the custom-fields `FieldType` (16 storage
+ * types) exported from `./custom-fields`. Use `ManifestFieldType` when
+ * declaring auto-generated form fields, and `FieldType` (custom-fields)
+ * when declaring tenant-owned custom fields stored in `dynamic_fields`.
  */
-type FieldType = "string" | "number" | "boolean" | "date" | "datetime" | "select" | "multi-select" | "phone" | "email" | "currency" | "json" | "textarea" | "richtext" | "file" | "image";
+type ManifestFieldType = "string" | "number" | "boolean" | "date" | "datetime" | "select" | "multi-select" | "phone" | "email" | "currency" | "json" | "textarea" | "richtext" | "file" | "image";
 /**
  * Metadata defining a single field within a resource.
  * Used by UI kits to automatically generate forms and validation logic.
@@ -641,7 +2126,7 @@ interface FieldManifest {
     /** Human-readable label (localized if possible). */
     label: string;
     /** Suggested UI type. */
-    type: FieldType;
+    type: ManifestFieldType;
     /** Short hint/placeholder text. */
     description?: string;
     /** Whether the field is required for creation. */
@@ -689,13 +2174,70 @@ interface ResourceManifest {
 }
 
 /**
- * Valid statuses for a CRM Lead.
+ * Org-wide lifecycle status of a CRM Lead. Matches the `erix_leads.status`
+ * column in Postgres and the legacy Mongoose `Lead.status` enum.
+ *
+ *   open      — active in any pipeline (default for new leads)
+ *   won       — closed positively (set when stage.isWon = true)
+ *   lost      — closed negatively (set when stage.isLost = true)
+ *   archived  — soft-deleted / parked
+ *
+ * NOTE: the Kanban columns visible in the UI ("New", "Contacted",
+ * "Qualified", etc.) are *pipeline stages* (`Lead.stageId` →
+ * `PipelineStage`), NOT statuses. To move a lead between Kanban columns,
+ * call `leads.move(leadId, stageId)`. Use `leads.update(leadId, { status })`
+ * only to flip the lifecycle to one of the four values above.
  */
-type LeadStatus = "new" | "contacted" | "qualified" | "won" | "lost" | "archived";
+type LeadStatus = "open" | "won" | "lost" | "archived";
+/**
+ * Runtime list of every valid LeadStatus value. Use this when validating
+ * input or rendering selectors so the array stays in sync with the type.
+ */
+declare const LEAD_STATUS_VALUES: readonly ["open", "won", "lost", "archived"];
 /**
  * Common lead acquisition sources. Additional string values are allowed.
  */
 type LeadSource = "website" | "whatsapp" | "direct" | "referral" | string;
+/**
+ * Lead entity as returned by the API. Mongo-shaped (`_id`).
+ *
+ * `pipelineId` and `stageId` may be either an ID string or a populated
+ * sub-document depending on whether the endpoint expanded them.
+ */
+interface Lead {
+    _id: string;
+    firstName: string;
+    lastName?: string;
+    phone: string;
+    email?: string;
+    company?: string;
+    status: LeadStatus;
+    value?: number;
+    source?: string;
+    assignedTo?: string;
+    tags?: string[];
+    pipelineId?: string | {
+        _id: string;
+        name: string;
+        isDefault?: boolean;
+    };
+    stageId?: string | {
+        _id: string;
+        name: string;
+        color: string;
+        probability?: number;
+        isWon?: boolean;
+        isLost?: boolean;
+        order?: number;
+    };
+    score?: number;
+    lastContactedAt?: string;
+    createdAt: string;
+    updatedAt: string;
+    metadata?: Record<string, unknown>;
+    /** Custom fields dictionary keyed by FieldDefinition.id. */
+    dynamic_fields?: Record<string, unknown>;
+}
 /**
  * Parameters for creating a new CRM Lead.
  */
@@ -1051,6 +2593,32 @@ declare class Payments extends APIResource {
     }): Promise<T>;
 }
 
+/**
+ * A single stage inside a CRM pipeline (Mongo-shaped `_id`).
+ */
+interface PipelineStage {
+    _id: string;
+    name: string;
+    color: string;
+    probability?: number;
+    isWon?: boolean;
+    isLost?: boolean;
+    order: number;
+}
+/**
+ * A CRM pipeline returned by the API. Stages are embedded.
+ */
+interface Pipeline {
+    _id: string;
+    name: string;
+    isDefault: boolean;
+    stages: PipelineStage[];
+}
+interface CreatePipelineParams {
+    name: string;
+    isDefault?: boolean;
+    stages?: any[];
+}
 interface PipelineStageParams {
     name: string;
     color?: string;
@@ -1669,6 +3237,118 @@ declare class EventsResource extends APIResource {
     }): Promise<T>;
 }
 
+/**
+ * ERIX-Flow — no-code visual workflow orchestration.
+ *
+ * Create, manage, and trigger flow-based automations with a visual canvas.
+ * Mounted at `/api/flow/v1`.
+ *
+ * @example
+ * ```typescript
+ * const workflows = await ecod.flow.list();
+ * const run = await ecod.flow.run(workflowId, { seed: { person: { phone: "+91..." } } });
+ * const status = await ecod.flow.getRun(run.runId);
+ * ```
+ */
+declare class Flow extends APIResource {
+    /**
+     * List flow definitions for the tenant.
+     */
+    list<T = any>(params?: {
+        page?: number;
+        limit?: number;
+        status?: string;
+    }): Promise<T>;
+    /**
+     * Create a new flow definition.
+     */
+    create<T = any>(payload: {
+        name: string;
+        description?: string;
+        graph: {
+            nodes: unknown[];
+            edges: unknown[];
+        };
+        status?: string;
+        triggerType?: string;
+        triggerConfig?: unknown;
+    }): Promise<T>;
+    /**
+     * Get a single flow definition by ID.
+     */
+    getWorkflow<T = any>(id: string): Promise<T>;
+    /**
+     * Update a flow definition.
+     */
+    update<T = any>(id: string, payload: {
+        name?: string;
+        description?: string;
+        graph?: {
+            nodes: unknown[];
+            edges: unknown[];
+        };
+        status?: string;
+    }): Promise<T>;
+    /**
+     * Trigger a flow run. Returns the runId for tracking.
+     */
+    run<T = any>(workflowId: string, payload?: {
+        triggerType?: string;
+        seed?: {
+            recordId?: string;
+            person?: {
+                fullName?: string;
+                email?: string;
+                phone?: string;
+            };
+            company?: {
+                name?: string;
+                domain?: string;
+            };
+            crm?: {
+                contactRef?: string;
+                stage?: string;
+            };
+        };
+    }): Promise<T>;
+    /**
+     * Get a run's summary + node statuses.
+     */
+    getRun<T = any>(runId: string): Promise<T>;
+    /**
+     * Get run records (review surface, PII-redacted).
+     */
+    getRunRecords<T = any>(runId: string): Promise<T>;
+    /**
+     * Retry a failed run from the failed node.
+     */
+    retry<T = any>(runId: string): Promise<T>;
+    /**
+     * Approve/reject/edit at an approval checkpoint.
+     */
+    approve<T = any>(runId: string, payload: {
+        decision: "approve" | "reject" | "edit";
+        record?: Record<string, unknown>;
+        nodeId?: string;
+    }): Promise<T>;
+    /**
+     * Get run execution logs.
+     */
+    getRunLogs<T = any>(runId: string): Promise<T>;
+    /**
+     * List installable flow templates.
+     */
+    templates<T = any>(params?: {
+        category?: string;
+    }): Promise<T>;
+    /**
+     * Install a template into the tenant's workspace.
+     */
+    installTemplate<T = any>(templateId: string, payload?: {
+        name?: string;
+    }): Promise<T>;
+}
+
 interface SystemHealth {
     status: string;
     version: string;
@@ -1733,6 +3413,58 @@ declare class Health extends APIResource {
     jobStatus(jobId: string): Promise<JobStatus>;
 }
 
+/**
+ * Invoices — CRM invoice management.
+ *
+ * Create, send, and track invoices for CRM deals.
+ * Mounted at `/api/saas/invoices`.
+ *
+ * @example
+ * ```typescript
+ * const invoices = await ecod.invoices.list();
+ * const inv = await ecod.invoices.create({ leadId, items, currency: "INR" });
+ * await ecod.invoices.sendViaWhatsApp(inv.id);
+ * ```
+ */
+declare class Invoices extends APIResource {
+    /**
+     * List invoices for the tenant.
+     */
+    list<T = any>(params?: {
+        page?: number;
+        limit?: number;
+        status?: string;
+    }): Promise<T>;
+    /**
+     * Get a single invoice by ID.
+     */
+    getInvoice<T = any>(id: string): Promise<T>;
+    /**
+     * Create a new invoice.
+     */
+    create<T = any>(payload: Record<string, unknown>): Promise<T>;
+    /**
+     * Update an invoice.
+     */
+    update<T = any>(id: string, payload: Record<string, unknown>): Promise<T>;
+    /**
+     * Delete an invoice.
+     */
+    delete<T = any>(id: string): Promise<T>;
+    /**
+     * Send an invoice via WhatsApp to the linked lead.
+     */
+    sendViaWhatsApp<T = any>(id: string): Promise<T>;
+    /**
+     * Get invoice settings for the tenant.
+     */
+    getSettings<T = any>(): Promise<T>;
+    /**
+     * Update invoice settings.
+     */
+    updateSettings<T = any>(payload: Record<string, unknown>): Promise<T>;
+}
+
 interface LogPaginationQuery {
     page?: number;
     limit?: number;
@@ -2420,6 +4152,270 @@ declare class Notifications extends APIResource {
     retryAction<T = any>(notificationId: string): Promise<T>;
 }
 
+/**
+ * Body of `POST /api/onboarding/global` — the four-question signup form.
+ *
+ * Fields land directly on `ecodrix_organizations.*` columns (workspace
+ * name, timezone) and `service_config -> 'global'` (primary product,
+ * adaptive flag). See REQ-001.
+ */
+interface GlobalOnboardingPayload {
+    /** Workspace / org display name. Persisted to `ecodrix_organizations.name`. */
+    workspaceName: string;
+    /** Personal display name of the signing-up user. */
+    displayName: string;
+    /** IANA timezone, e.g. `"Asia/Kolkata"`. Persisted to `organizations.timezone`. */
+    timezone: string;
+    /**
+     * The product the user wants to start with. `"not_sure"` defers
+     * per-product onboarding to first product open.
+     */
+    primaryProduct: "crm" | "laie" | "flow" | "not_sure";
+}
+/**
+ * Body of `POST /api/onboarding/start` — opens a per-product onboarding
+ * session. Triggered by the explicit "Enable {Product}" click on
+ * `/products/<productId>` (REQ-002).
+ */
+interface StartOnboardingPayload {
+    productId: "crm" | "laie" | "flow";
+}
+/**
+ * Body of `POST /api/onboarding/answer` — records one step's answer and
+ * advances the engine. The saas calls this on every step submit (and as
+ * a debounced PATCH for resumability).
+ */
+interface AnswerOnboardingPayload {
+    sessionId: string;
+    stepId: string;
+    /** Shape depends on the step type — string, string[], boolean, etc. */
+    answer: unknown;
+}
+/**
+ * Body of `POST /api/onboarding/complete` — terminates the session,
+ * upserts the persona, and materializes the workspace defaults.
+ */
+interface CompleteOnboardingPayload {
+    sessionId: string;
+}
+/**
+ * Body of `POST /api/onboarding/edit` — post-completion edit of a single
+ * answer from `/settings/onboarding`. Triggers a `persona_recomputed`
+ * event (REQ-010).
+ */
+interface EditOnboardingPayload {
+    stepId: string;
+    answer: unknown;
+}
+/**
+ * Result of `POST /api/onboarding/start`.
+ */
+interface StartOnboardingResponse {
+    sessionId: string;
+    firstStep: OnboardingStep;
+}
+/**
+ * Result of `POST /api/onboarding/answer`.
+ */
+interface AnswerOnboardingResponse {
+    /** `null` when the engine has reached the final step. */
+    nextStep: OnboardingStep | null;
+    draftPersona: Record<string, unknown>;
+}
+/**
+ * Result of `GET /api/onboarding/state`. Returns the active session
+ * (status `"active"`) for `(userId, productId)`, plus the step the
+ * renderer should currently show.
+ */
+interface OnboardingStateResponse {
+    session: OnboardingSession | null;
+    currentStep: OnboardingStep | null;
+}
+/**
+ * Result of `POST /api/onboarding/complete`.
+ */
+interface CompleteOnboardingResponse {
+    /** Opaque persona document — full type lives in `resources/persona.ts`. */
+    persona: Record<string, unknown>;
+    workspaceProfile: WorkspaceProfile;
+}
+/**
+ * Result of `POST /api/onboarding/edit`.
+ */
+interface EditOnboardingResponse {
+    persona: Record<string, unknown>;
+    /** RFC 6902 JSON Patch describing what changed in the persona. */
+    diff: Array<Record<string, unknown>>;
+}
+/**
+ * Adaptive onboarding resource.
+ *
+ * Mounted on the main client as `ecod.onboarding`. Mirrors the seven
+ * tenant-facing routes documented in `design.md` § "API surface".
+ *
+ * @example
+ * ```typescript
+ * await ecod.onboarding.global({
+ *   workspaceName: "Acme Health",
+ *   displayName: "Alice",
+ *   timezone: "Asia/Kolkata",
+ *   primaryProduct: "crm",
+ * });
+ *
+ * const { sessionId, firstStep } = await ecod.onboarding.start({ productId: "crm" });
+ * await ecod.onboarding.answer({ sessionId, stepId: firstStep.stepId, answer: "healthcare" });
+ * await ecod.onboarding.complete({ sessionId });
+ * ```
+ */
+declare class Onboarding extends APIResource {
+    /**
+     * Submit the four-question global onboarding form (REQ-001).
+     * Updates `ecodrix_organizations.*` columns and
+     * `service_config.global.primaryProduct`.
+     */
+    global<T = unknown>(payload: GlobalOnboardingPayload): Promise<T>;
+    /**
+     * Open a per-product onboarding session. Called when the user clicks
+     * "Enable {Product}" on `/products/<productId>` (REQ-002).
+     */
+    start(payload: StartOnboardingPayload): Promise<StartOnboardingResponse>;
+    /**
+     * Record one step's answer and advance the engine. Returns the next
+     * step (or `null` at the end) and the in-progress draft persona.
+     */
+    answer(payload: AnswerOnboardingPayload): Promise<AnswerOnboardingResponse>;
+    /**
+     * Load the active session for the calling user + product. Used on
+     * page mount + every revisit to support resumability (REQ-010).
+     */
+    state(productId: string): Promise<OnboardingStateResponse>;
+    /**
+     * Finalise the session, upsert the persona, and materialize the
+     * niche-tuned workspace defaults.
+     */
+    complete(payload: CompleteOnboardingPayload): Promise<CompleteOnboardingResponse>;
+    /**
+     * Edit a previously-answered step from `/settings/onboarding`. The
+     * server emits a `persona_recomputed` event so the workspace and
+     * persona update in-session (REQ-010).
+     */
+    edit(payload: EditOnboardingPayload): Promise<EditOnboardingResponse>;
+    /**
+     * Preview the workspace profile that would be materialized if the
+     * session completed right now. Used by the `feature_preview` step.
+     */
+    previewWorkspace(sessionId: string): Promise<WorkspaceProfile>;
+}
+
+/**
+ * Portal Inbox — team-side unified inbox for portal conversations.
+ *
+ * Lists all projects with active client threads, retrieves messages,
+ * and posts replies. Mounted at `/api/saas/portal-inbox`.
+ *
+ * @example
+ * ```typescript
+ * const threads = await ecod.portalInbox.conversations();
+ * const messages = await ecod.portalInbox.messages(projectId);
+ * await ecod.portalInbox.reply(projectId, { body: "We'll get back to you!" });
+ * ```
+ */
+declare class PortalInbox extends APIResource {
+    /**
+     * List all projects with active portal conversation threads.
+     * Returns projectId, projectName, lastMessageAt, lastBody, lastSender, unreadCount.
+     */
+    conversations<T = any>(): Promise<T>;
+    /**
+     * Get paginated messages for a project's portal thread.
+     */
+    messages<T = any>(projectId: string): Promise<T>;
+    /**
+     * Post a reply from the team to a project's portal thread.
+     */
+    reply<T = any>(projectId: string, payload: {
+        body: string;
+        attachments?: Array<{
+            name: string;
+            url: string;
+        }>;
+    }): Promise<T>;
+}
+
+/**
+ * Project Documents + E-Sign — document management and digital signatures
+ * for CRM projects.
+ *
+ * Mounted at `/api/saas/projects/:projectId/documents`.
+ *
+ * @example
+ * ```typescript
+ * const docs = await ecod.projectDocuments.list(projectId);
+ * await ecod.projectDocuments.upload(projectId, { name: "Contract.pdf", fileKey, mimeType });
+ * await ecod.projectDocuments.toggleSignature(projectId, docId, true);
+ * await ecod.projectDocuments.addSigner(projectId, docId, { role: "client", name: "Alice" });
+ * await ecod.projectDocuments.stampSign(projectId, docId, { signatureImage: base64Png });
+ * ```
+ */
+declare class ProjectDocuments extends APIResource {
+    /**
+     * List all documents for a project.
+     */
+    list<T = any>(projectId: string): Promise<T>;
+    /**
+     * Register an uploaded document (after uploading to R2 via presigned URL).
+     */
+    upload<T = any>(projectId: string, payload: {
+        name: string;
+        fileKey: string;
+        mimeType: string;
+        sizeBytes?: string;
+    }): Promise<T>;
+    /**
+     * Toggle "Signature Required" on a document.
+     * When enabled, triggers notifications to signers.
+     */
+    toggleSignature<T = any>(projectId: string, docId: string, required: boolean): Promise<T>;
+    /**
+     * Add a signer to a document.
+     */
+    addSigner<T = any>(projectId: string, docId: string, signer: {
+        role: "owner" | "client";
+        name: string;
+        email?: string;
+        userId?: string;
+    }): Promise<T>;
+    /**
+     * Team user signs a document (simple mark — no PDF stamp).
+     */
+    sign<T = any>(projectId: string, docId: string, payload?: {
+        signedFileKey?: string;
+    }): Promise<T>;
+    /**
+     * Team user declines signing a document.
+     */
+    decline<T = any>(projectId: string, docId: string): Promise<T>;
+    /**
+     * Full signing ceremony — stamps a signature image onto the PDF,
+     * computes an audit seal, and re-uploads the signed copy.
+     *
+     * @param signatureImage - Base64-encoded PNG of the drawn/typed signature
+     * @param signerName - Name to stamp on the PDF
+     * @param position - Optional position override { page?, x?, y?, width?, height? }
+     */
+    stampSign<T = any>(projectId: string, docId: string, payload: {
+        signatureImage: string;
+        signerName?: string;
+        position?: {
+            page?: number;
+            x?: number;
+            y?: number;
+            width?: number;
+            height?: number;
+        };
+    }): Promise<T>;
+}
+
 interface JobStats {
     waiting: number;
     active: number;
@@ -2471,6 +4467,93 @@ declare class Queue extends APIResource {
     deleteJob<T = any>(jobId: string): Promise<T>;
 }
 
+/** Relay endpoint provenance. */
+type RelayOrigin = "seed" | "manual" | "auto";
+/** Relay egress type. */
+type RelayType = "cloudflare" | "gcp" | "lambda" | "browser" | "direct";
+/** Public relay record (secrets are NEVER included). */
+interface RelayRecord {
+    id: string;
+    type: RelayType;
+    url: string | null;
+    region: string | null;
+    priority: number;
+    enabled: boolean;
+    origin: RelayOrigin;
+    providerResourceId: string | null;
+    provisionedAt: string | null;
+    lastHealthyAt: string | null;
+    health?: RelayEndpointHealth | null;
+}
+interface RelayEndpointHealth {
+    key: string;
+    type: RelayType;
+    url?: string;
+    region?: string;
+    healthy: boolean;
+    degradedUntil?: number;
+    requestCount: number;
+    errorCount: number;
+    lastUsedAt?: number;
+}
+/** Hot-reloadable relay-fabric tuning. */
+interface RelayTuning {
+    relayTimeoutMs: number;
+    relayCooldownMs: number;
+    pingIntervalMs: number;
+    pingTimeoutMs: number;
+    maxRetries: number;
+    leadEnrichTimeoutMs: number;
+    aiStepTimeoutMs: number;
+    stuckJobTimeoutMs: number;
+    targetHealthyRelays: number;
+    autoProvisionEnabled: boolean;
+    maxAutoRelaysPerType: number;
+    maxAutoRelaysTotal: number;
+    retireAfterDegradedMs: number;
+}
+interface RelayCreatePayload {
+    type: RelayType;
+    url?: string;
+    region?: string;
+    priority?: number;
+    /** Key into the platform secret store — never a plaintext secret. */
+    secretRef?: string;
+}
+interface RelayUpdatePayload {
+    enabled?: boolean;
+    priority?: number;
+    region?: string;
+}
+interface RelayProvisionPayload {
+    provider?: "lambda" | "cloudflare";
+    region?: string;
+}
+/**
+ * Dynamic Relay Fabric control plane. Authenticated with the platform CORE API
+ * key (server-side only). Endpoints live under `/api/laie/v1/relays`.
+ */
+declare class Relays extends APIResource {
+    /** List relays + live health (per-type aggregate + per-endpoint). */
+    list<T = any>(): Promise<T>;
+    /** Add a manual relay. */
+    create<T = any>(payload: RelayCreatePayload): Promise<T>;
+    /** Enable/disable/repriority a relay. */
+    update<T = any>(id: string, payload: RelayUpdatePayload): Promise<T>;
+    /** Remove a manual/auto relay (seed relays are never removable). */
+    delete<T = any>(id: string): Promise<T>;
+    /** Read the hot-reloadable tuning config. */
+    getConfig<T = any>(): Promise<T>;
+    /** Update the tuning config (audited). */
+    updateConfig<T = any>(payload: Partial<RelayTuning>): Promise<T>;
+    /** Force a health ping and return the snapshot. */
+    ping<T = any>(): Promise<T>;
+    /** Manually provision a cloud relay (auto-provisioning must be enabled). */
+    provision<T = any>(payload?: RelayProvisionPayload): Promise<T>;
+    /** Manually retire a relay. */
+    retire<T = any>(id: string): Promise<T>;
+}
+
 declare class Clients extends APIResource {
     /**
      * List all clients in the ecosystem.
@@ -2591,7 +4674,7 @@ declare class Services extends APIResource {
     constructor(client: any);
 }
 
-declare class EmailConfig extends APIResource {
+declare class EmailConfig$1 extends APIResource {
     /**
      * Retrieve current email provider configuration and domain verification statuses.
      */
@@ -2646,7 +4729,7 @@ declare class EmailConfig extends APIResource {
     listProviders<T = any>(): Promise<T>;
 }
 declare class Settings extends APIResource {
-    email: EmailConfig;
+    email: EmailConfig$1;
     constructor(client: any);
 }
 
@@ -2818,6 +4901,24 @@ declare class Webhooks {
     constructEvent(payload: string | Buffer, signature: string | string[] | undefined, secret: string): Promise<any>;
 }
 
+/**
+ * Broadcast campaign entity returned by `/api/saas/chat/broadcasts`.
+ *
+ * Tracks the lifecycle of a bulk WhatsApp send and its delivery counters.
+ */
+interface Broadcast {
+    _id: string;
+    name: string;
+    templateName: string;
+    status: "draft" | "scheduled" | "sending" | "completed" | "failed";
+    recipientCount: number;
+    sentCount: number;
+    deliveredCount: number;
+    readCount: number;
+    createdAt: string;
+    scheduledAt?: string;
+    completedAt?: string;
+}
 interface CreateBroadcastParams {
     /** Optional name for the broadcast campaign */
     name?: string;
@@ -2899,6 +5000,28 @@ declare class Broadcasts extends APIResource {
     delete<T = any>(id: string): Promise<T>;
 }
 
+/**
+ * Conversation entity returned by `/api/saas/chat/conversations`.
+ *
+ * Represents a single WhatsApp thread between the workspace and an
+ * external phone number. `status` is the conversation lifecycle (open
+ * vs resolved) — distinct from `LeadStatus` on the linked lead.
+ */
+interface Conversation {
+    _id: string;
+    phone: string;
+    contactName?: string;
+    lastMessage?: {
+        body: string;
+        timestamp: string;
+        direction: "inbound" | "outbound";
+    };
+    unreadCount: number;
+    status: "open" | "resolved";
+    assignedTo?: string;
+    leadId?: string;
+    updatedAt: string;
+}
 interface ListParams {
     limit?: number;
     before?: string;
@@ -3000,6 +5123,20 @@ declare class Conversations extends APIResource {
     bulkDelete<T = any>(ids: string[]): Promise<T>;
 }
 
+/**
+ * A single chat message inside a `Conversation`.
+ */
+interface Message {
+    _id: string;
+    conversationId: string;
+    body?: string;
+    mediaUrl?: string;
+    mediaType?: "image" | "video" | "audio" | "document";
+    direction: "inbound" | "outbound";
+    status: "sent" | "delivered" | "read" | "failed";
+    timestamp: string;
+    replyToId?: string;
+}
 /**
  * Parameters for sending a free-form WhatsApp message.
  */
@@ -3207,6 +5344,28 @@ declare class Messages extends APIResource {
     }>;
 }
 
+/**
+ * Component of a Meta-approved WhatsApp template (HEADER / BODY / FOOTER /
+ * BUTTONS).
+ */
+interface TemplateComponent {
+    type: "HEADER" | "BODY" | "FOOTER" | "BUTTONS";
+    text?: string;
+    format?: string;
+}
+/**
+ * WhatsApp message template entity.
+ *
+ * Status mirrors Meta's approval pipeline: APPROVED / PENDING / REJECTED.
+ */
+interface Template {
+    _id: string;
+    name: string;
+    category: "MARKETING" | "UTILITY" | "AUTHENTICATION";
+    language: string;
+    status: "APPROVED" | "PENDING" | "REJECTED";
+    components: TemplateComponent[];
+}
 interface TemplateMapping {
     mappings: any[];
     onEmptyVariable: string;
@@ -3485,10 +5644,30 @@ declare class ECODrIxAPI {
     readonly settings: Settings;
     /** Dynamic Cross-Origin Resource Sharing network policies. */
     readonly cors: Cors;
+    /** LAIE Dynamic Relay Fabric control plane (CORE key, server-side only). */
+    readonly relays: Relays;
     /** ErixCheckout one-click checkout flow management. */
     readonly checkout: Checkout;
     /** ERIX-Connect — tenant connections (channels, credentials, DB residency). */
     readonly connect: Connect;
+    /** Adaptive onboarding — global + per-product config-driven flows. */
+    readonly onboarding: Onboarding;
+    /**
+     * Platform-admin onboarding control plane (niche packs +
+     * versioned onboarding configs). Server-side only — requires
+     * the elevated `coreApiKey`.
+     */
+    readonly adminOnboarding: AdminOnboarding;
+    /** AI persona memory — read, reinforce, confidence score. */
+    readonly persona: Persona;
+    /** ERIX-Flow — no-code visual workflow orchestration. */
+    readonly flow: Flow;
+    /** Portal Inbox — team-side unified inbox for portal conversations. */
+    readonly portalInbox: PortalInbox;
+    /** Project Documents + E-Sign — document management and digital signatures. */
+    readonly projectDocuments: ProjectDocuments;
+    /** Invoices — CRM invoice management. */
+    readonly invoices: Invoices;
     constructor(options: ECODrIxAPIOptions);
     private initSocket;
     /**
@@ -3571,6 +5750,243 @@ declare class ECODrIxAPI {
     request<T = any>(method: Method, path: string, data?: any, params?: any): Promise<T>;
 }
 
+/**
+ * Common response envelopes returned by the ERIX API.
+ */
+/**
+ * Standard paginated response shape.
+ *
+ * Used by list endpoints that page results (e.g. leads, conversations,
+ * broadcasts). Frontend consumers can rely on `data` + `pagination` being
+ * present.
+ */
+interface PaginatedResponse<T> {
+    data: T[];
+    pagination: {
+        page: number;
+        limit: number;
+        total: number;
+        pages: number;
+    };
+}
+
+/**
+ * Custom field type system for the ERIX CRM module.
+ *
+ * Defines the FieldType discriminated union, per-type config interfaces,
+ * and the stored value shapes persisted in a lead's `dynamic_fields`
+ * column.
+ *
+ * This is the single contract used by both the backend (server adapters,
+ * validators, formula evaluators) and the saas frontend (designer UI,
+ * editors, renderers). Keep saas + server in sync by sharing this file.
+ */
+/** The 16 supported custom field types. */
+type FieldType = "text" | "number" | "currency" | "dropdown" | "date" | "datetime" | "phone" | "email" | "file" | "formula" | "relation" | "rating" | "progress" | "tags" | "url" | "checkbox";
+interface BaseConfig {
+    required?: boolean;
+    description?: string;
+}
+interface TextConfig extends BaseConfig {
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+}
+interface NumberConfig extends BaseConfig {
+    min?: number;
+    max?: number;
+    integer?: boolean;
+}
+interface CurrencyConfig extends BaseConfig {
+    /** ISO 4217, default INR */
+    defaultCurrency?: string;
+    min?: number;
+    max?: number;
+}
+interface DropdownConfig extends BaseConfig {
+    options: {
+        value: string;
+        label: string;
+        color?: string;
+    }[];
+}
+/** ISO date */
+interface DateConfig extends BaseConfig {
+    min?: string;
+    max?: string;
+}
+/** ISO datetime */
+interface DateTimeConfig extends BaseConfig {
+    min?: string;
+    max?: string;
+}
+interface PhoneConfig extends BaseConfig {
+    region?: string;
+}
+type EmailConfig = BaseConfig;
+interface FileConfig extends BaseConfig {
+    maxSizeBytes?: number;
+    accept?: string[];
+}
+interface FormulaConfig extends BaseConfig {
+    expression: string;
+    resultType: "number" | "text" | "boolean";
+}
+interface RelationConfig extends BaseConfig {
+    targetEntity: "lead";
+    displayField?: string;
+}
+interface RatingConfig extends BaseConfig {
+    /** default 5 */
+    max?: 5 | 10;
+}
+interface ProgressConfig extends BaseConfig {
+    /** default 0..100 */
+    min?: number;
+    max?: number;
+}
+interface TagsConfig extends BaseConfig {
+    options?: {
+        value: string;
+        label: string;
+        color?: string;
+    }[];
+    allowFreeform?: boolean;
+}
+type UrlConfig = BaseConfig;
+type CheckboxConfig = BaseConfig;
+interface FieldDefBase {
+    id: string;
+    orgId: string;
+    name: string;
+    label: string;
+    order: number;
+    isActive: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+type FieldDefinition = (FieldDefBase & {
+    fieldType: "text";
+    config: TextConfig;
+}) | (FieldDefBase & {
+    fieldType: "number";
+    config: NumberConfig;
+}) | (FieldDefBase & {
+    fieldType: "currency";
+    config: CurrencyConfig;
+}) | (FieldDefBase & {
+    fieldType: "dropdown";
+    config: DropdownConfig;
+}) | (FieldDefBase & {
+    fieldType: "date";
+    config: DateConfig;
+}) | (FieldDefBase & {
+    fieldType: "datetime";
+    config: DateTimeConfig;
+}) | (FieldDefBase & {
+    fieldType: "phone";
+    config: PhoneConfig;
+}) | (FieldDefBase & {
+    fieldType: "email";
+    config: EmailConfig;
+}) | (FieldDefBase & {
+    fieldType: "file";
+    config: FileConfig;
+}) | (FieldDefBase & {
+    fieldType: "formula";
+    config: FormulaConfig;
+}) | (FieldDefBase & {
+    fieldType: "relation";
+    config: RelationConfig;
+}) | (FieldDefBase & {
+    fieldType: "rating";
+    config: RatingConfig;
+}) | (FieldDefBase & {
+    fieldType: "progress";
+    config: ProgressConfig;
+}) | (FieldDefBase & {
+    fieldType: "tags";
+    config: TagsConfig;
+}) | (FieldDefBase & {
+    fieldType: "url";
+    config: UrlConfig;
+}) | (FieldDefBase & {
+    fieldType: "checkbox";
+    config: CheckboxConfig;
+});
+type FieldConfig = FieldDefinition["config"];
+type CurrencyValue = {
+    amount: number;
+    currency: string;
+};
+type RelationValue = {
+    leadId: string;
+};
+type StoredFieldValue = string | number | boolean | null | string[] | CurrencyValue | RelationValue;
+type NormalizedFieldValue = StoredFieldValue;
+
+/**
+ * CRM view configuration and filter model.
+ *
+ * Defines the layout, column, filter, sort, and color-rule shapes that
+ * make up a saved CrmView, plus the adapter-level CustomFieldFilter
+ * passed into leads.list for backend-specific query translation.
+ */
+
+type LayoutType = "table" | "kanban" | "cards";
+interface ColumnConfig {
+    /** default field name or custom field id */
+    fieldKey: string;
+    visible: boolean;
+    /** px */
+    width: number;
+    order: number;
+}
+type FilterOperator = "contains" | "equals" | "startsWith" | "isEmpty" | "gt" | "lt" | "between" | "before" | "after" | "isAnyOf" | "isNoneOf";
+interface FilterRule {
+    fieldKey: string;
+    operator: FilterOperator;
+    value?: unknown;
+}
+interface SortRule {
+    fieldKey: string;
+    dir: "asc" | "desc";
+}
+interface ColorRule {
+    fieldKey: string;
+    operator: FilterOperator;
+    value?: unknown;
+    color: string;
+    target: "row" | "cell";
+}
+interface ViewConfig {
+    columns: ColumnConfig[];
+    sort: SortRule[];
+    filters: FilterRule[];
+    /** stage | source | assignedTo | <dropdown/tags field id> */
+    groupBy?: string;
+    colorRules: ColorRule[];
+}
+interface CrmView {
+    id: string;
+    orgId: string;
+    name: string;
+    layoutType: LayoutType;
+    config: ViewConfig;
+    isDefault: boolean;
+    isShared: boolean;
+    createdBy: string;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Adapter-level custom-field filter passed into leads.list. */
+interface CustomFieldFilter {
+    fieldId: string;
+    fieldType: FieldType;
+    operator: FilterOperator;
+    value?: unknown;
+}
+
 /**
  * HTTP status code to exception type mapping
  * Maps specific HTTP status codes to appropriate typed exceptions
@@ -3698,4 +6114,4 @@ declare function getRetryConfig(error: any): {
     readonly reason: "Generic API errors may be transient and worth retrying";
 };
 
-export { APIError, type ApplyCouponPayload, AuthenticationError, type CheckoutAmountBreakdown, type CheckoutOrderResponse, type CheckoutProduct, type CheckoutSession, type CreateOrderPayload, type CreateSessionPayload, ECODrIxAPI as ECODrIx, ECODrIxAPI, type ECODrIxAPIOptions, ERROR_RETRY_CONFIG, EcodrixError, type FieldManifest, type FieldType, HTTP_STATUS_ERROR_MAP, RateLimitError, type ResourceManifest, type VerifyPayload, ECODrIxAPI as default, getErrorDetails, getRetryConfig, handleAPIError, isAPIError };
+export { type AIPersona, APIError, AdminOnboarding, type AnswerFollowupBody, type AnswerOnboardingPayload, type AnswerOnboardingResponse, type ApplyCouponPayload, AuthenticationError, type BehaviorRules, type Broadcast, type CheckboxConfig, type CheckoutAmountBreakdown, type CheckoutOrderResponse, type CheckoutProduct, type CheckoutSession, type ColorRule, type ColumnConfig, type CompleteOnboardingPayload, type CompleteOnboardingResponse, type ConfidenceResponse, type Conversation, type ListParams as ConversationListParams, type Correction, type CreateBroadcastParams, type CreateLeadParams, type CreateNichePackPayload, type CreateOnboardingConfigPayload, type CreateOnboardingExperimentPayload, type CreateOrderPayload, type CreatePipelineParams, type CreateSessionPayload, type CrmView, type CurrencyConfig, type CurrencyValue, type CustomFieldFilter, type DateConfig, type DateTimeConfig, type DropdownConfig, ECODrIxAPI as ECODrIx, ECODrIxAPI, type ECODrIxAPIOptions, ERROR_RETRY_CONFIG, EcodrixError, type EditOnboardingPayload, type EditOnboardingResponse, type EmailConfig, type FieldConfig, type FieldDefinition, type FieldManifest, type FieldType, type FileConfig, type FilterOperator, type FilterRule, Flow, type ForkNichePackPayload, type FormulaConfig, type GlobalOnboardingPayload, HTTP_STATUS_ERROR_MAP, type ICP, Invoices, LEAD_STATUS_VALUES, type LayoutType, type Lead, type LeadPattern, type LeadSource, type LeadStatus, type LearningMemory, type ListLeadsParams, type ListNichePacksParams, type ListNichePacksResponse, type ListOnboardingConfigsParams, type ListOnboardingExperimentsParams, type ListOnboardingExperimentsResponse, type ManifestFieldType, type Message, type NichePack, type NichePackResearchConfig, type NichePackResponse, type NichePackStatus, type NichePackSummary, type NormalizedFieldValue, type NumberConfig, Onboarding, type OnboardingAbandonmentResponse, type OnboardingAbandonmentResult, type OnboardingAbandonmentRow, type OnboardingAnalyticsFiltersParams, type OnboardingCohortRange, type OnboardingConfig, type OnboardingExperiment, type OnboardingExperimentResponse, type OnboardingExperimentStatus, type OnboardingExperimentVariant, type OnboardingFunnelResponse, type OnboardingFunnelResult, type OnboardingFunnelStep, type OnboardingMemoryMapping, type OnboardingOption, type OnboardingSession, type OnboardingSessionStatus, type OnboardingStateResponse, type OnboardingStep, type OnboardingStepType, type OnboardingTimeOnStepResponse, type OnboardingTimeOnStepResult, type OnboardingTimeOnStepRow, type OutreachEdit, type PaginatedResponse, Persona, type PersonaFollowupQuestion, type PersonaFollowupsResponse, type PersonaIdentity, type PersonaTimelineEntry, type PersonaTimelineOptions, type PersonaTimelineResponse, type PhoneConfig, type Pipeline, type PipelineStage, type PipelineStageParams, PortalInbox, type ProgressConfig, ProjectDocuments, RateLimitError, type RatingConfig, type ReinforceResponse, type ReinforcementEvent, type RelationConfig, type RelationValue, type RelayCreatePayload, type RelayEndpointHealth, type RelayOrigin, type RelayProvisionPayload, type RelayRecord, type RelayTuning, type RelayType, type RelayUpdatePayload, Relays, type ResourceManifest, type SendMessageParams, type ServiceConfig, type ServiceConfigGlobal, type ServiceConfigPerProduct, type SmokeTestMaterializerAction, type SmokeTestNichePackPayload, type SmokeTestResult, type SortRule, type StartOnboardingPayload, type StartOnboardingResponse, type StoredFieldValue, type SuggestionEvent, type TagsConfig, type Template, type TemplateComponent, type TemplateMapping, type TextConfig, type UpdateNichePackPayload, type UpdateOnboardingConfigPayload, type UpdateOnboardingExperimentPayload, type UpsertLeadParams, type UrlConfig, type VerifyPayload, type ViewConfig, type Vocabulary, type WorkspaceDashboardLayout, type WorkspaceDefaultAutomation, type WorkspaceDefaultField, type WorkspaceDefaultPipeline, type WorkspaceModuleConfig, type WorkspaceProfile, ECODrIxAPI as default, getErrorDetails, getRetryConfig, handleAPIError, isAPIError };