@classytic/crm 0.1.1 → 0.5.0

package/dist/index.d.ts

@@ -1,374 +1,425 @@
-import { DomainEvent, EventHandler, EventTransport } from "@classytic/primitives/events";
+import * as mongoose1 from "mongoose";
+import { Connection, Model, Schema, SchemaDefinitionProperty } from "mongoose";
+import { PaginationConfig, PluginType, Repository } from "@classytic/mongokit";
+import { DomainEvent, EventHandler, EventMeta, EventTransport } from "@classytic/primitives/events";
 import { z } from "zod";
-import { OutboxStore } from "@classytic/primitives/outbox";
-import { ContactInfo, PersonName } from "@classytic/primitives/person";
-import { Money } from "@classytic/primitives/money";
+import { OperationContext } from "@classytic/primitives/context";
 
-//#region src/domain/entities/account.d.ts
-/**
- * An account (company / organization). Contacts, Opportunities, and
- * Activities can reference it.
- */
-interface Account {
-  id: string;
-  name: string;
-  /** Domain / website — used by host deduplication pipelines. */
-  domain?: string;
-  industry?: string;
-  /** Employee-count bucket, e.g. `1-10`, `11-50`. Free-form for flexibility. */
-  sizeBucket?: string;
-  annualRevenue?: {
-    amount: number;
-    currency: string;
-  };
-  ownerId?: string;
-  tags?: readonly string[];
-  metadata?: Record<string, unknown>;
-  createdAt: Date;
-  updatedAt: Date;
-}
-//#endregion
-//#region src/domain/ports/account-repository.port.d.ts
-interface AccountFilter {
-  ownerId?: string;
-  industry?: string;
-  domain?: string;
-  tags?: readonly string[];
-}
-interface AccountRepository {
-  findById(id: string): Promise<Account | null>;
-  findByDomain(domain: string): Promise<Account | null>;
-  list(filter?: AccountFilter): Promise<Account[]>;
-  create(a: Omit<Account, 'createdAt' | 'updatedAt'>): Promise<Account>;
-  update(id: string, patch: Partial<Account>): Promise<Account>;
-  delete(id: string): Promise<void>;
-}
+//#region src/events/event-constants.d.ts
+/** PACKAGE_RULES rule 12: `package:resource.verb`. */
+declare const CRM_EVENTS: {
+  readonly LEAD_CREATED: "crm:lead.created";
+  readonly LEAD_STATUS_CHANGED: "crm:lead.status_changed";
+  readonly LEAD_SCORED: "crm:lead.scored";
+  readonly LEAD_CONVERTED: "crm:lead.converted";
+  readonly LEAD_DISQUALIFIED: "crm:lead.disqualified";
+  readonly ACCOUNT_CREATED: "crm:account.created";
+  readonly ACCOUNT_UPDATED: "crm:account.updated";
+  readonly CONTACT_CREATED: "crm:contact.created";
+  readonly CONTACT_UPDATED: "crm:contact.updated";
+  readonly OPPORTUNITY_CREATED: "crm:opportunity.created";
+  readonly OPPORTUNITY_STAGE_ADVANCED: "crm:opportunity.stage_advanced";
+  readonly OPPORTUNITY_STAGE_REGRESSED: "crm:opportunity.stage_regressed";
+  readonly OPPORTUNITY_WON: "crm:opportunity.won";
+  readonly OPPORTUNITY_LOST: "crm:opportunity.lost";
+  readonly OPPORTUNITY_ABANDONED: "crm:opportunity.abandoned";
+  readonly PIPELINE_CREATED: "crm:pipeline.created";
+  readonly PIPELINE_ARCHIVED: "crm:pipeline.archived";
+  readonly ACTIVITY_PLANNED: "crm:activity.planned";
+  readonly ACTIVITY_COMPLETED: "crm:activity.completed";
+  readonly ACTIVITY_CANCELLED: "crm:activity.cancelled";
+  readonly NOTE_ADDED: "crm:note.added";
+  readonly CAMPAIGN_CREATED: "crm:campaign.created";
+  readonly CAMPAIGN_ACTIVATED: "crm:campaign.activated";
+  readonly CAMPAIGN_PAUSED: "crm:campaign.paused";
+  readonly CAMPAIGN_RESUMED: "crm:campaign.resumed";
+  readonly CAMPAIGN_COMPLETED: "crm:campaign.completed";
+  readonly CAMPAIGN_ARCHIVED: "crm:campaign.archived";
+  readonly SUBSCRIPTION_CREATED: "crm:subscription.created";
+  readonly SUBSCRIPTION_CONFIRMED: "crm:subscription.confirmed";
+  readonly SUBSCRIPTION_UNSUBSCRIBED: "crm:subscription.unsubscribed";
+  readonly SUBSCRIPTION_BOUNCED: "crm:subscription.bounced";
+  readonly SUBSCRIPTION_COMPLAINED: "crm:subscription.complained";
+  readonly EMAIL_EVENT_OPENED: "crm:email_event.opened";
+  readonly EMAIL_EVENT_CLICKED: "crm:email_event.clicked";
+  readonly EMAIL_EVENT_BOUNCED: "crm:email_event.bounced";
+  readonly EMAIL_EVENT_COMPLAINED: "crm:email_event.complained";
+  readonly EMAIL_EVENT_UNSUBSCRIBED: "crm:email_event.unsubscribed";
+  readonly LEAD_ENRICHED: "crm:lead.enriched";
+  readonly LEAD_ASSIGNED: "crm:lead.assigned";
+  readonly CONTACT_ENRICHED: "crm:contact.enriched";
+  readonly CONTACT_ASSIGNED: "crm:contact.assigned";
+  readonly CONTACT_MERGED: "crm:contact.merged";
+  readonly ACCOUNT_ENRICHED: "crm:account.enriched";
+  readonly ACCOUNT_ASSIGNED: "crm:account.assigned";
+  readonly ACCOUNT_MERGED: "crm:account.merged";
+  readonly OPPORTUNITY_ASSIGNED: "crm:opportunity.assigned";
+  readonly OPPORTUNITY_AMOUNT_CHANGED: "crm:opportunity.amount_changed";
+  readonly OPPORTUNITY_EXTENDED: "crm:opportunity.extended";
+  readonly ACTIVITY_RESCHEDULED: "crm:activity.rescheduled";
+  readonly ACTIVITY_OUTCOME_RECORDED: "crm:activity.outcome_recorded";
+  readonly CONVERSATION_CREATED: "crm:conversation.created";
+  readonly CONVERSATION_ASSIGNED: "crm:conversation.assigned";
+  readonly CONVERSATION_RESOLVED: "crm:conversation.resolved";
+  readonly CONVERSATION_REOPENED: "crm:conversation.reopened";
+  readonly MESSAGE_RECEIVED: "crm:message.received";
+  readonly MESSAGE_SENT: "crm:message.sent";
+};
+type CrmEventName = (typeof CRM_EVENTS)[keyof typeof CRM_EVENTS];
 //#endregion
-//#region src/domain/ports/clock.port.d.ts
-interface Clock {
-  now(): Date;
+//#region src/events/event-catalog.d.ts
+
+/** JSON-Schema object produced by `z.toJSONSchema` — what arc's registry consumes. */
+type CrmEventSchema = Record<string, unknown>;
+/** Structurally identical to arc's `EventDefinitionOutput` — do NOT import arc. */
+interface CrmEventDefinition<TSchema extends z.ZodType = z.ZodType> {
+  name: CrmEventName;
+  version: number;
+  description: string;
+  zodSchema: TSchema;
+  schema: CrmEventSchema;
+  create(payload: z.infer<TSchema>, meta?: Partial<EventMeta>): DomainEvent<z.infer<TSchema>>;
 }
-declare const systemClock: Clock;
+declare const LeadCreated: CrmEventDefinition<z.ZodObject<{
+  leadId: z.ZodString;
+  email: z.ZodOptional<z.ZodString>;
+  score: z.ZodNumber;
+}, z.core.$strip>>;
+declare const LeadStatusChanged: CrmEventDefinition<z.ZodObject<{
+  leadId: z.ZodString;
+  from: z.ZodString;
+  to: z.ZodString;
+}, z.core.$strip>>;
+declare const LeadScored: CrmEventDefinition<z.ZodObject<{
+  leadId: z.ZodString;
+  score: z.ZodNumber;
+}, z.core.$strip>>;
+declare const LeadConverted: CrmEventDefinition<z.ZodObject<{
+  leadId: z.ZodString;
+  contactId: z.ZodString;
+  accountId: z.ZodOptional<z.ZodString>;
+  opportunityId: z.ZodString;
+}, z.core.$strip>>;
+declare const LeadDisqualified: CrmEventDefinition<z.ZodObject<{
+  leadId: z.ZodString;
+  reason: z.ZodString;
+}, z.core.$strip>>;
+declare const LeadEnriched: CrmEventDefinition<z.ZodObject<{
+  leadId: z.ZodString;
+  fields: z.ZodArray<z.ZodString>;
+  provider: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const LeadAssigned: CrmEventDefinition<z.ZodObject<{
+  leadId: z.ZodString;
+  ownerId: z.ZodString;
+  previousOwnerId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const AccountCreated: CrmEventDefinition<z.ZodObject<{
+  accountId: z.ZodString;
+  name: z.ZodString;
+}, z.core.$strip>>;
+declare const AccountUpdated: CrmEventDefinition<z.ZodObject<{
+  accountId: z.ZodString;
+}, z.core.$strip>>;
+declare const AccountEnriched: CrmEventDefinition<z.ZodObject<{
+  accountId: z.ZodString;
+  fields: z.ZodArray<z.ZodString>;
+  provider: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const AccountAssigned: CrmEventDefinition<z.ZodObject<{
+  accountId: z.ZodString;
+  ownerId: z.ZodString;
+  previousOwnerId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const AccountMerged: CrmEventDefinition<z.ZodObject<{
+  primaryId: z.ZodString;
+  secondaryId: z.ZodString;
+  strategy: z.ZodEnum<{
+    preferPrimary: "preferPrimary";
+    preferSecondary: "preferSecondary";
+  }>;
+}, z.core.$strip>>;
+declare const ContactCreated: CrmEventDefinition<z.ZodObject<{
+  contactId: z.ZodString;
+  email: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const ContactUpdated: CrmEventDefinition<z.ZodObject<{
+  contactId: z.ZodString;
+}, z.core.$strip>>;
+declare const ContactEnriched: CrmEventDefinition<z.ZodObject<{
+  contactId: z.ZodString;
+  fields: z.ZodArray<z.ZodString>;
+  provider: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const ContactAssigned: CrmEventDefinition<z.ZodObject<{
+  contactId: z.ZodString;
+  ownerId: z.ZodString;
+  previousOwnerId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const ContactMerged: CrmEventDefinition<z.ZodObject<{
+  primaryId: z.ZodString;
+  secondaryId: z.ZodString;
+  strategy: z.ZodEnum<{
+    preferPrimary: "preferPrimary";
+    preferSecondary: "preferSecondary";
+  }>;
+}, z.core.$strip>>;
+declare const OpportunityCreated: CrmEventDefinition<z.ZodObject<{
+  opportunityId: z.ZodString;
+  pipelineId: z.ZodString;
+  stageId: z.ZodString;
+}, z.core.$strip>>;
+declare const OpportunityStageAdvanced: CrmEventDefinition<z.ZodObject<{
+  opportunityId: z.ZodString;
+  from: z.ZodObject<{
+    stageId: z.ZodString;
+    sequence: z.ZodNumber;
+  }, z.core.$strip>;
+  to: z.ZodObject<{
+    stageId: z.ZodString;
+    sequence: z.ZodNumber;
+  }, z.core.$strip>;
+}, z.core.$strip>>;
+declare const OpportunityStageRegressed: CrmEventDefinition<z.ZodObject<{
+  opportunityId: z.ZodString;
+  from: z.ZodObject<{
+    stageId: z.ZodString;
+    sequence: z.ZodNumber;
+  }, z.core.$strip>;
+  to: z.ZodObject<{
+    stageId: z.ZodString;
+    sequence: z.ZodNumber;
+  }, z.core.$strip>;
+}, z.core.$strip>>;
+declare const OpportunityWon: CrmEventDefinition<z.ZodObject<{
+  opportunityId: z.ZodString;
+  amount: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>>;
+declare const OpportunityLost: CrmEventDefinition<z.ZodObject<{
+  opportunityId: z.ZodString;
+  lostReasonId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const OpportunityAbandoned: CrmEventDefinition<z.ZodObject<{
+  opportunityId: z.ZodString;
+}, z.core.$strip>>;
+declare const OpportunityAssigned: CrmEventDefinition<z.ZodObject<{
+  opportunityId: z.ZodString;
+  ownerId: z.ZodString;
+  previousOwnerId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const OpportunityAmountChanged: CrmEventDefinition<z.ZodObject<{
+  opportunityId: z.ZodString;
+  amount: z.ZodNumber;
+  previousAmount: z.ZodOptional<z.ZodNumber>;
+  reason: z.ZodOptional<z.ZodString>;
+  by: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const OpportunityExtended: CrmEventDefinition<z.ZodObject<{
+  opportunityId: z.ZodString;
+  expectedCloseAt: z.ZodISODateTime;
+  previousExpectedCloseAt: z.ZodOptional<z.ZodISODateTime>;
+  reason: z.ZodOptional<z.ZodString>;
+  by: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const PipelineCreated: CrmEventDefinition<z.ZodObject<{
+  pipelineId: z.ZodString;
+}, z.core.$strip>>;
+declare const PipelineArchived: CrmEventDefinition<z.ZodObject<{
+  pipelineId: z.ZodString;
+}, z.core.$strip>>;
+declare const ActivityPlanned: CrmEventDefinition<z.ZodObject<{
+  activityId: z.ZodString;
+  type: z.ZodString;
+  subjectKind: z.ZodString;
+  subjectId: z.ZodString;
+}, z.core.$strip>>;
+declare const ActivityCompleted: CrmEventDefinition<z.ZodObject<{
+  activityId: z.ZodString;
+  completedAt: z.ZodISODateTime;
+}, z.core.$strip>>;
+declare const ActivityCancelled: CrmEventDefinition<z.ZodObject<{
+  activityId: z.ZodString;
+  reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const ActivityRescheduled: CrmEventDefinition<z.ZodObject<{
+  activityId: z.ZodString;
+  dueDate: z.ZodISODateTime;
+  previousDueDate: z.ZodOptional<z.ZodISODateTime>;
+  reason: z.ZodOptional<z.ZodString>;
+  by: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const ActivityOutcomeRecorded: CrmEventDefinition<z.ZodObject<{
+  activityId: z.ZodString;
+  outcome: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>>;
+declare const NoteAdded: CrmEventDefinition<z.ZodObject<{
+  noteId: z.ZodString;
+  subjectKind: z.ZodString;
+  subjectId: z.ZodString;
+}, z.core.$strip>>;
+declare const CampaignCreated: CrmEventDefinition<z.ZodObject<{
+  campaignId: z.ZodString;
+  name: z.ZodString;
+}, z.core.$strip>>;
+declare const CampaignActivated: CrmEventDefinition<z.ZodObject<{
+  campaignId: z.ZodString;
+}, z.core.$strip>>;
+declare const CampaignPaused: CrmEventDefinition<z.ZodObject<{
+  campaignId: z.ZodString;
+  reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const CampaignResumed: CrmEventDefinition<z.ZodObject<{
+  campaignId: z.ZodString;
+}, z.core.$strip>>;
+declare const CampaignCompleted: CrmEventDefinition<z.ZodObject<{
+  campaignId: z.ZodString;
+  actualRevenueAmount: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>>;
+declare const CampaignArchived: CrmEventDefinition<z.ZodObject<{
+  campaignId: z.ZodString;
+}, z.core.$strip>>;
+declare const SubscriptionCreated: CrmEventDefinition<z.ZodObject<{
+  subscriptionId: z.ZodString;
+  contactId: z.ZodString;
+  campaignId: z.ZodString;
+  requiresConfirmation: z.ZodBoolean;
+}, z.core.$strip>>;
+declare const SubscriptionConfirmed: CrmEventDefinition<z.ZodObject<{
+  subscriptionId: z.ZodString;
+  contactId: z.ZodString;
+  campaignId: z.ZodString;
+  confirmedAt: z.ZodISODateTime;
+}, z.core.$strip>>;
+declare const SubscriptionUnsubscribed: CrmEventDefinition<z.ZodObject<{
+  subscriptionId: z.ZodString;
+  contactId: z.ZodString;
+  campaignId: z.ZodString;
+  reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const SubscriptionBounced: CrmEventDefinition<z.ZodObject<{
+  subscriptionId: z.ZodString;
+  contactId: z.ZodString;
+  campaignId: z.ZodString;
+  reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const SubscriptionComplained: CrmEventDefinition<z.ZodObject<{
+  subscriptionId: z.ZodString;
+  contactId: z.ZodString;
+  campaignId: z.ZodString;
+}, z.core.$strip>>;
+declare const EmailEventOpened: CrmEventDefinition<z.ZodObject<{
+  eventId: z.ZodString;
+  kind: z.ZodString;
+  subjectKind: z.ZodString;
+  subjectId: z.ZodString;
+  campaignId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const EmailEventClicked: CrmEventDefinition<z.ZodObject<{
+  eventId: z.ZodString;
+  kind: z.ZodString;
+  subjectKind: z.ZodString;
+  subjectId: z.ZodString;
+  campaignId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const EmailEventBounced: CrmEventDefinition<z.ZodObject<{
+  eventId: z.ZodString;
+  kind: z.ZodString;
+  subjectKind: z.ZodString;
+  subjectId: z.ZodString;
+  campaignId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const EmailEventComplained: CrmEventDefinition<z.ZodObject<{
+  eventId: z.ZodString;
+  kind: z.ZodString;
+  subjectKind: z.ZodString;
+  subjectId: z.ZodString;
+  campaignId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const EmailEventUnsubscribed: CrmEventDefinition<z.ZodObject<{
+  eventId: z.ZodString;
+  kind: z.ZodString;
+  subjectKind: z.ZodString;
+  subjectId: z.ZodString;
+  campaignId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const ConversationCreated: CrmEventDefinition<z.ZodObject<{
+  conversationId: z.ZodString;
+  channel: z.ZodString;
+  participantKind: z.ZodString;
+  participantId: z.ZodString;
+}, z.core.$strip>>;
+declare const ConversationAssigned: CrmEventDefinition<z.ZodObject<{
+  conversationId: z.ZodString;
+  assigneeId: z.ZodString;
+  previousAssigneeId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const ConversationResolved: CrmEventDefinition<z.ZodObject<{
+  conversationId: z.ZodString;
+  status: z.ZodString;
+  previousStatus: z.ZodString;
+}, z.core.$strip>>;
+declare const ConversationReopened: CrmEventDefinition<z.ZodObject<{
+  conversationId: z.ZodString;
+  status: z.ZodString;
+  previousStatus: z.ZodString;
+}, z.core.$strip>>;
+declare const MessageReceived: CrmEventDefinition<z.ZodObject<{
+  messageId: z.ZodString;
+  conversationId: z.ZodString;
+  direction: z.ZodString;
+  externalMessageId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const MessageSent: CrmEventDefinition<z.ZodObject<{
+  messageId: z.ZodString;
+  conversationId: z.ZodString;
+  direction: z.ZodString;
+  externalMessageId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const crmEventDefinitions: ReadonlyArray<CrmEventDefinition>;
 //#endregion
-//#region src/domain/ports/id-generator.port.d.ts
-interface IdGenerator {
-  next(): string;
+//#region src/models/tenant-field.d.ts
+type TenantFieldType = 'objectId' | 'string';
+interface SchemaBuildConfig {
+  /** Schema type for the tenant column. Engine plumbs this everywhere. */
+  tenantFieldType: TenantFieldType;
 }
-//#endregion
-//#region src/services/mutation-options.d.ts
 /**
- * Options passed to every service mutation. All fields optional — hosts
- * opt into the behaviours they need.
+ * Tenant-column schema definition. Use this anywhere a model has
+ * `organizationId` — never write the raw type in a schema file.
  */
-interface MutationOptions {
-  /**
-   * When `false`, skip event emission for this call. Useful for bulk seeds
-   * and when a higher-level orchestration verb composes several services
-   * and only wants the outer event to fire (see `LeadService.convert`).
-   */
-  emitEvents?: boolean;
-  /**
-   * Host-provided DB transaction handle (mongoose `ClientSession`,
-   * Prisma tx, Postgres client with `BEGIN`, etc.). Typed as `unknown`
-   * to keep crm framework-agnostic.
-   *
-   * Forwarded to:
-   *   - The host's repository adapter (if it reads `options.session`) so
-   *     the business write joins the transaction.
-   *   - `outbox.save(event, { session })` so the outbox row commits
-   *     atomically with the business write — PACKAGE_RULES §5.5 + P8's
-   *     session-bound dispatch pattern.
-   *
-   * Wrap the CRM service call in your own transaction:
-   *
-   * ```ts
-   * const session = await mongoose.connection.startSession();
-   * try {
-   *   await session.withTransaction(async () => {
-   *     await accountService.create({ name: 'Acme' }, { session });
-   *   });
-   * } finally {
-   *   await session.endSession();
-   * }
-   * ```
-   */
-  session?: unknown;
-}
+declare function tenantFieldDef(config: SchemaBuildConfig): SchemaDefinitionProperty;
 //#endregion
-//#region src/services/account.service.d.ts
-interface AccountServiceConfig {
-  repo: AccountRepository;
-  events?: EventTransport | undefined;
-  /**
-   * Optional host-owned outbox. See `emitCrmEvent` for the dispatch contract:
-   * outbox save (session-bound when `options.session` is passed) is issued
-   * before the transport publish so durable at-least-once delivery works
-   * even when the transport is down.
-   */
-  outbox?: OutboxStore | undefined;
-  clock?: Clock;
-  ids?: IdGenerator;
-}
-interface CreateAccountInput {
+//#region src/models/pipeline.schema.d.ts
+/** Mongoose document shape for a single embedded stage. */
+interface IStageDocument {
+  _id: mongoose1.Types.ObjectId;
   name: string;
-  domain?: string;
-  industry?: string;
-  sizeBucket?: string;
-  annualRevenue?: {
-    amount: number;
-    currency: string;
-  };
-  ownerId?: string;
-  tags?: readonly string[];
-  metadata?: Record<string, unknown>;
-}
-declare class AccountService {
-  private readonly repo;
-  private readonly events;
-  private readonly outbox;
-  private readonly clock;
-  private readonly ids;
-  constructor(config: AccountServiceConfig);
-  create(input: CreateAccountInput, options?: MutationOptions): Promise<Account>;
-  update(id: string, patch: Partial<Account>, options?: MutationOptions): Promise<Account>;
-  delete(id: string): Promise<void>;
-  findById(id: string): Promise<Account | null>;
-  findByDomain(domain: string): Promise<Account | null>;
-  list(filter?: Parameters<AccountRepository['list']>[0]): Promise<Account[]>;
-  private _require;
-  private _emit;
-}
-//#endregion
-//#region src/domain/enums/activity.d.ts
-/**
- * Activity type vocabulary. The package stores `type` as free-form
- * string so hosts can extend; these constants cover the common
- * channels that automation tooling typically keys off.
- */
-declare const ACTIVITY_TYPES: readonly ["call", "email", "meeting", "task", "note", "sms", "social", "demo", "other"];
-type ActivityType = (typeof ACTIVITY_TYPES)[number];
-declare const ACTIVITY_STATUSES: readonly ["planned", "in_progress", "completed", "cancelled"];
-type ActivityStatus = (typeof ACTIVITY_STATUSES)[number];
-declare const ACTIVITY_TRANSITIONS: Record<ActivityStatus, readonly ActivityStatus[]>;
-declare function canTransitionActivity(from: ActivityStatus, to: ActivityStatus): boolean;
-/**
- * Kinds of entity an Activity can reference. Polymorphic linking lets
- * hosts log a call against a Lead, an Opportunity, a Contact, or a
- * stand-alone Account.
- */
-declare const SUBJECT_KINDS: readonly ["lead", "opportunity", "contact", "account"];
-type SubjectKind = (typeof SUBJECT_KINDS)[number];
-//#endregion
-//#region src/domain/entities/activity.d.ts
-/**
- * An activity is a polymorphic record of outreach / task / event
- * attached to any CRM entity. `subjectKind` + `subjectId` define the
- * link — this is how hosts build automation atop the package (subscribe
- * to `crm:activity.*` events, filter by `subjectKind`, react).
- */
-interface Activity {
-  id: string;
-  type: ActivityType | string;
-  status: ActivityStatus;
-  subjectKind: SubjectKind;
-  subjectId: string;
-  subject?: string;
-  body?: string;
-  /** When the activity is / was scheduled to happen. */
-  scheduledAt?: Date;
-  completedAt?: Date;
-  cancelledAt?: Date;
-  /** User-level ownership (call made by / task assigned to). */
-  ownerId?: string;
-  participantIds?: readonly string[];
-  /**
-   * Optional external ref — e.g. Calendar event id, email thread id,
-   * call-recording url. Host-owned semantics.
-   */
-  externalRef?: string;
-  metadata?: Record<string, unknown>;
-  createdAt: Date;
-  updatedAt: Date;
-}
-//#endregion
-//#region src/domain/entities/note.d.ts
-/**
- * A free-text note on a CRM entity. Separate from Activity because
- * notes aren't status-tracked — they're typed once and stay; they're
- * also the cheapest "activity log" entry to create.
- */
-interface Note {
-  id: string;
-  subjectKind: SubjectKind;
-  subjectId: string;
-  body: string;
-  authorId?: string;
-  /** Supports @-mentions, Markdown, etc. — host-interpreted. */
-  format?: 'plain' | 'markdown';
-  metadata?: Record<string, unknown>;
-  createdAt: Date;
-  updatedAt: Date;
-}
-//#endregion
-//#region src/domain/ports/activity-repository.port.d.ts
-interface ActivityFilter {
-  subjectKind?: SubjectKind;
-  subjectId?: string;
-  status?: ActivityStatus | readonly ActivityStatus[];
-  ownerId?: string;
-  scheduledBetween?: {
-    from: Date;
-    to: Date;
-  };
-}
-interface ActivityRepository {
-  findById(id: string): Promise<Activity | null>;
-  list(filter?: ActivityFilter): Promise<Activity[]>;
-  create(a: Omit<Activity, 'createdAt' | 'updatedAt'>): Promise<Activity>;
-  update(id: string, patch: Partial<Activity>): Promise<Activity>;
-  casStatus(id: string, expected: ActivityStatus, next: ActivityStatus, patch?: Partial<Activity>): Promise<Activity | null>;
-}
-//#endregion
-//#region src/domain/ports/note-repository.port.d.ts
-interface NoteRepository {
-  findById(id: string): Promise<Note | null>;
-  listBySubject(subjectKind: SubjectKind, subjectId: string): Promise<Note[]>;
-  create(n: Omit<Note, 'createdAt' | 'updatedAt'>): Promise<Note>;
-  update(id: string, patch: Partial<Note>): Promise<Note>;
-  delete(id: string): Promise<void>;
-}
-//#endregion
-//#region src/services/activity.service.d.ts
-interface ActivityServiceConfig {
-  repo: ActivityRepository;
-  notes: NoteRepository;
-  events?: EventTransport | undefined;
-  /** Optional host-owned outbox. See AccountServiceConfig.outbox. */
-  outbox?: OutboxStore | undefined;
-  clock?: Clock;
-  ids?: IdGenerator;
-}
-interface CreateActivityInput {
-  type: ActivityType | string;
-  subjectKind: SubjectKind;
-  subjectId: string;
-  subject?: string;
-  body?: string;
-  scheduledAt?: Date;
-  ownerId?: string;
-  participantIds?: readonly string[];
-  externalRef?: string;
-  metadata?: Record<string, unknown>;
-}
-interface CreateNoteInput {
-  subjectKind: SubjectKind;
-  subjectId: string;
-  body: string;
-  authorId?: string;
-  format?: 'plain' | 'markdown';
-  metadata?: Record<string, unknown>;
-}
-/**
- * Polymorphic activity / note service. Activities have a lifecycle
- * (`planned → in_progress → completed | cancelled`); notes are
- * immutable-ish (create + update body, no status).
- */
-declare class ActivityService {
-  private readonly repo;
-  private readonly noteRepo;
-  private readonly events;
-  private readonly outbox;
-  private readonly clock;
-  private readonly ids;
-  constructor(config: ActivityServiceConfig);
-  plan(input: CreateActivityInput, options?: MutationOptions): Promise<Activity>;
-  start(id: string, options?: MutationOptions): Promise<Activity>;
-  complete(id: string, completedAt?: Date, options?: MutationOptions): Promise<Activity>;
-  cancel(id: string, reason?: string, options?: MutationOptions): Promise<Activity>;
-  addNote(input: CreateNoteInput, options?: MutationOptions): Promise<Note>;
-  listBySubject(subjectKind: SubjectKind, subjectId: string): Promise<Activity[]>;
-  listNotesBySubject(subjectKind: SubjectKind, subjectId: string): Promise<Note[]>;
-  findById(id: string): Promise<Activity | null>;
-  private _transition;
-  private _emit;
+  /** Ascending order in the pipeline. Treated as identifier on `moveToStage`. */
+  sequence: number;
+  /** Default win-probability assigned to opportunities entering this stage. */
+  defaultProbability: number;
+  color?: string;
+  description?: string;
 }
-//#endregion
-//#region src/domain/entities/contact.d.ts
-/**
- * A person — the atom of a CRM. Contacts may belong to an Account,
- * but can also exist stand-alone (independent consultants, consumers).
- *
- * Structured `name` + `contact` come from `@classytic/primitives/person`.
- * Hosts projecting over a commerce Customer record embed the same shapes —
- * no translation needed at the boundary.
- */
-interface Contact {
-  id: string;
-  name: PersonName;
-  contact: ContactInfo;
-  jobTitle?: string;
-  accountId?: string;
-  ownerId?: string;
-  /** Free-form tags for segmentation. */
-  tags?: readonly string[];
-  /** Host-owned arbitrary payload (social handles, custom fields, etc.). */
+/** Mongoose document shape for a Pipeline. */
+interface IPipelineDocument {
+  _id: mongoose1.Types.ObjectId;
+  organizationId: mongoose1.Types.ObjectId | string;
+  name: string;
+  /** Deprecates the pipeline — existing opps still move, no new ones created. */
+  isArchived: boolean;
+  /** Embedded stages, kept ordered by `sequence`. */
+  stages: IStageDocument[];
+  /** Free-form label for the sales team / motion that owns this pipeline. */
+  teamRef?: string;
   metadata?: Record<string, unknown>;
   createdAt: Date;
   updatedAt: Date;
 }
+declare function buildPipelineSchema(config: SchemaBuildConfig): Schema<IPipelineDocument>;
+declare function createPipelineModel(connection: Connection, config: SchemaBuildConfig): Model<IPipelineDocument>;
 //#endregion
-//#region src/domain/ports/contact-repository.port.d.ts
-interface ContactFilter {
-  accountId?: string;
-  ownerId?: string;
-  email?: string;
-  tags?: readonly string[];
-}
-interface ContactRepository {
-  findById(id: string): Promise<Contact | null>;
-  findByEmail(email: string): Promise<Contact | null>;
-  list(filter?: ContactFilter): Promise<Contact[]>;
-  create(c: Omit<Contact, 'createdAt' | 'updatedAt'>): Promise<Contact>;
-  update(id: string, patch: Partial<Contact>): Promise<Contact>;
-  delete(id: string): Promise<void>;
-}
-//#endregion
-//#region src/services/contact.service.d.ts
-interface ContactServiceConfig {
-  repo: ContactRepository;
-  events?: EventTransport | undefined;
-  /** Optional host-owned outbox. See AccountServiceConfig.outbox. */
-  outbox?: OutboxStore | undefined;
-  clock?: Clock;
-  ids?: IdGenerator;
-}
-interface CreateContactInput {
-  name: PersonName;
-  contact?: ContactInfo;
-  jobTitle?: string;
-  accountId?: string;
-  ownerId?: string;
-  tags?: readonly string[];
-  metadata?: Record<string, unknown>;
-}
-declare class ContactService {
-  private readonly repo;
-  private readonly events;
-  private readonly outbox;
-  private readonly clock;
-  private readonly ids;
-  constructor(config: ContactServiceConfig);
-  create(input: CreateContactInput, options?: MutationOptions): Promise<Contact>;
-  update(id: string, patch: Partial<Contact>, options?: MutationOptions): Promise<Contact>;
-  delete(id: string): Promise<void>;
-  findById(id: string): Promise<Contact | null>;
-  findByEmail(email: string): Promise<Contact | null>;
-  list(filter?: Parameters<ContactRepository['list']>[0]): Promise<Contact[]>;
-  private _require;
-  private _emit;
-}
-//#endregion
-//#region src/domain/enums/lead-status.d.ts
+//#region src/enums/lead-status.d.ts
 /**
  * Lead lifecycle — from initial inquiry through conversion.
  *
@@ -384,56 +435,43 @@ type LeadStatus = (typeof LEAD_STATUSES)[number];
 declare const LEAD_TRANSITIONS: Record<LeadStatus, readonly LeadStatus[]>;
 declare function canTransitionLead(from: LeadStatus, to: LeadStatus): boolean;
 //#endregion
-//#region src/domain/entities/lead.d.ts
-/**
- * An unqualified inquiry. Leads are the top of the funnel — they
- * don't yet have a dedicated Contact + Account + Opportunity in the
- * system. `LeadService.convert(...)` creates all three and
- * transitions the lead to `converted`.
- */
-interface Lead {
-  id: string;
-  /** Name / email / phone / company captured at inquiry time. */
+//#region src/models/lead.schema.d.ts
+interface ILeadStatusEntry {
+  status: LeadStatus;
+  occurredAt: Date;
+  by?: string;
+  note?: string;
+}
+interface ILeadDocument {
+  _id: mongoose1.Types.ObjectId;
+  organizationId: mongoose1.Types.ObjectId | string;
+  fullName: string;
   firstName?: string;
   lastName?: string;
-  fullName: string;
   email?: string;
   phone?: string;
   companyName?: string;
   jobTitle?: string;
-  /** How the lead arrived (`web-form`, `referral`, `event`, `ads`, …). */
   source?: string;
-  /** Free-form campaign identifier — the host's campaign system owns its semantics. */
   campaignRef?: string;
-  /**
-   * Lead score — updated by `LeadService.recomputeScore(...)` whenever
-   * the score function decides. Stored on the record for indexing +
-   * routing. Raw score units; range is host-defined.
-   */
-  score?: number;
+  score: number;
   status: LeadStatus;
-  statusHistory: readonly LeadStatusEntry[];
+  statusHistory: ILeadStatusEntry[];
   ownerId?: string;
-  tags?: readonly string[];
-  /** On successful `convert`, links to the resulting records. */
-  convertedContactId?: string;
-  convertedAccountId?: string;
-  convertedOpportunityId?: string;
+  tags: string[];
+  convertedContactId?: mongoose1.Types.ObjectId | string;
+  convertedAccountId?: mongoose1.Types.ObjectId | string;
+  convertedOpportunityId?: mongoose1.Types.ObjectId | string;
   convertedAt?: Date;
-  /** Disqualification detail. */
   disqualifyReason?: string;
   metadata?: Record<string, unknown>;
   createdAt: Date;
   updatedAt: Date;
 }
-interface LeadStatusEntry {
-  status: LeadStatus;
-  occurredAt: Date;
-  by?: string;
-  note?: string;
-}
+declare function buildLeadSchema(config: SchemaBuildConfig): Schema<ILeadDocument>;
+declare function createLeadModel(connection: Connection, config: SchemaBuildConfig): Model<ILeadDocument>;
 //#endregion
-//#region src/domain/enums/opportunity-status.d.ts
+//#region src/enums/opportunity-status.d.ts
 /**
  * Top-level opportunity status. Movement through pipeline STAGES
  * happens while status is `open`; `won` / `lost` are terminal
@@ -446,975 +484,1004 @@ type OpportunityStatus = (typeof OPPORTUNITY_STATUSES)[number];
 declare const OPPORTUNITY_TRANSITIONS: Record<OpportunityStatus, readonly OpportunityStatus[]>;
 declare function canTransitionOpportunity(from: OpportunityStatus, to: OpportunityStatus): boolean;
 //#endregion
-//#region src/domain/entities/opportunity.d.ts
+//#region src/models/opportunity.schema.d.ts
+interface IOpportunityStatusEntry {
+  status: OpportunityStatus;
+  stageId?: string;
+  occurredAt: Date;
+  by?: string;
+  note?: string;
+}
+interface IOpportunityDocument {
+  _id: mongoose1.Types.ObjectId;
+  organizationId: mongoose1.Types.ObjectId | string;
+  name: string;
+  accountId?: mongoose1.Types.ObjectId | string;
+  primaryContactId?: mongoose1.Types.ObjectId | string;
+  pipelineId: mongoose1.Types.ObjectId | string;
+  stageId: string;
+  status: OpportunityStatus;
+  statusHistory: IOpportunityStatusEntry[];
+  amount?: number;
+  currency: string;
+  probability: number;
+  expectedCloseAt?: Date;
+  closedAt?: Date;
+  lostReasonId?: mongoose1.Types.ObjectId | string;
+  ownerId?: string;
+  sourceLeadId?: mongoose1.Types.ObjectId | string;
+  tags: string[];
+  metadata?: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
+}
+declare function buildOpportunitySchema(config: SchemaBuildConfig): Schema<IOpportunityDocument>;
+declare function createOpportunityModel(connection: Connection, config: SchemaBuildConfig): Model<IOpportunityDocument>;
+//#endregion
+//#region src/models/contact.schema.d.ts
+interface IContactName {
+  given: string;
+  family: string;
+  middle?: string;
+  prefix?: string;
+  suffix?: string;
+  preferred?: string;
+}
+interface IContactInfoEmbedded {
+  email?: string;
+  personalEmail?: string;
+  phone?: string;
+  alternatePhone?: string;
+  whatsapp?: string;
+  telegram?: string;
+  linkedin?: string;
+  instagram?: string;
+}
+interface IContactDocument {
+  _id: mongoose1.Types.ObjectId;
+  organizationId: mongoose1.Types.ObjectId | string;
+  name: IContactName;
+  contact: IContactInfoEmbedded;
+  jobTitle?: string;
+  accountId?: mongoose1.Types.ObjectId | string;
+  ownerId?: string;
+  tags: string[];
+  metadata?: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
+}
+declare function buildContactSchema(config: SchemaBuildConfig): Schema<IContactDocument>;
+declare function createContactModel(connection: Connection, config: SchemaBuildConfig): Model<IContactDocument>;
+//#endregion
+//#region src/models/account.schema.d.ts
+interface IAccountDocument {
+  _id: mongoose1.Types.ObjectId;
+  organizationId: mongoose1.Types.ObjectId | string;
+  name: string;
+  domain?: string;
+  industry?: string;
+  sizeBucket?: string;
+  annualRevenueAmount?: number;
+  annualRevenueCurrency: string;
+  ownerId?: string;
+  tags: string[];
+  metadata?: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
+}
+declare function buildAccountSchema(config: SchemaBuildConfig): Schema<IAccountDocument>;
+declare function createAccountModel(connection: Connection, config: SchemaBuildConfig): Model<IAccountDocument>;
+//#endregion
+//#region src/enums/campaign-status.d.ts
 /**
- * A qualified sales opportunity. Opportunities live inside a Pipeline
- * and progress through Stages. Status captures the outcome
- * (`open` / `won` / `lost` / `abandoned`); stage captures the current
- * step.
+ * Campaign lifecycle.
+ *
+ *   draft     — being built; not running, no sends, no UTM attribution counted
+ *   active    — running; participating in attribution + automation
+ *   paused    — temporarily halted; can be resumed; no sends fire
+ *   completed — finished its run; preserved for historical attribution
+ *   archived  — soft-hidden from the default UI; still queryable
  */
-interface Opportunity {
-  id: string;
+declare const CAMPAIGN_STATUSES: readonly ["draft", "active", "paused", "completed", "archived"];
+type CampaignStatus = (typeof CAMPAIGN_STATUSES)[number];
+declare const CAMPAIGN_TRANSITIONS: Record<CampaignStatus, readonly CampaignStatus[]>;
+declare function canTransitionCampaign(from: CampaignStatus, to: CampaignStatus): boolean;
+//#endregion
+//#region src/models/campaign.schema.d.ts
+interface ICampaignStatusEntry {
+  status: CampaignStatus;
+  occurredAt: Date;
+  by?: string;
+  note?: string;
+}
+interface ICampaignDocument {
+  _id: mongoose1.Types.ObjectId;
+  organizationId: mongoose1.Types.ObjectId | string;
   name: string;
-  accountId?: string;
-  primaryContactId?: string;
-  /** Which pipeline this opportunity belongs to (sales, partnerships, renewals). */
-  pipelineId: string;
-  /** Current stage — index INTO the pipeline's `stages` array. */
-  stageId: string;
-  status: OpportunityStatus;
-  statusHistory: readonly OpportunityStatusEntry[];
-  /** Host-expected deal value. */
-  amount?: Money;
-  /**
-   * Win probability (0-1). Defaults to the stage's probability at
-   * every stage move; host can override for hand-tuned forecasts.
-   */
-  probability: number;
-  /** When the deal is expected to close. Drives forecast grouping. */
-  expectedCloseAt?: Date;
-  /** Populated on win/lose. */
-  closedAt?: Date;
-  lostReasonId?: string;
+  description?: string;
+  status: CampaignStatus;
+  statusHistory: ICampaignStatusEntry[];
+  utmSource?: string;
+  utmMedium?: string;
+  utmCampaign?: string;
+  startDate?: Date;
+  endDate?: Date;
+  budgetAmount?: number;
+  expectedRevenueAmount?: number;
+  actualRevenueAmount?: number;
+  currency: string;
   ownerId?: string;
-  sourceLeadId?: string;
-  tags?: readonly string[];
+  tags: string[];
   metadata?: Record<string, unknown>;
   createdAt: Date;
   updatedAt: Date;
 }
-interface OpportunityStatusEntry {
-  status: OpportunityStatus;
-  stageId?: string;
+declare function buildCampaignSchema(config: SchemaBuildConfig): Schema<ICampaignDocument>;
+declare function createCampaignModel(connection: Connection, config: SchemaBuildConfig): Model<ICampaignDocument>;
+//#endregion
+//#region src/enums/subscription-status.d.ts
+/**
+ * Subscription lifecycle.
+ *
+ *   pending      — double-opt-in pending confirmation
+ *   confirmed    — actively subscribed; eligible to receive sends
+ *   unsubscribed — user opted out via unsubscribe link (or operator action)
+ *   bounced      — provider reported hard bounce; permanent suppression
+ *   complained   — recipient hit "spam" / "report" in their email client;
+ *                  permanent suppression (CAN-SPAM + provider trust)
+ *
+ * All terminal states are non-reopenable. Re-subscribing creates a new
+ * Subscription row — the audit trail of unsubscribes/bounces is preserved.
+ */
+declare const SUBSCRIPTION_STATUSES: readonly ["pending", "confirmed", "unsubscribed", "bounced", "complained"];
+type SubscriptionStatus = (typeof SUBSCRIPTION_STATUSES)[number];
+declare const SUBSCRIPTION_TRANSITIONS: Record<SubscriptionStatus, readonly SubscriptionStatus[]>;
+declare function canTransitionSubscription(from: SubscriptionStatus, to: SubscriptionStatus): boolean;
+//#endregion
+//#region src/models/subscription.schema.d.ts
+interface ISubscriptionStatusEntry {
+  status: SubscriptionStatus;
   occurredAt: Date;
   by?: string;
   note?: string;
 }
-//#endregion
-//#region src/domain/ports/lead-repository.port.d.ts
-interface LeadFilter {
-  status?: LeadStatus | readonly LeadStatus[];
-  ownerId?: string;
+interface ISubscriptionDocument {
+  _id: mongoose1.Types.ObjectId;
+  organizationId: mongoose1.Types.ObjectId | string;
+  contactId: mongoose1.Types.ObjectId | string;
+  campaignId: mongoose1.Types.ObjectId | string;
+  status: SubscriptionStatus;
+  statusHistory: ISubscriptionStatusEntry[];
   source?: string;
-  minScore?: number;
-}
-interface LeadRepository {
-  findById(id: string): Promise<Lead | null>;
-  findByEmail(email: string): Promise<Lead | null>;
-  list(filter?: LeadFilter): Promise<Lead[]>;
-  create(l: Omit<Lead, 'createdAt' | 'updatedAt'>): Promise<Lead>;
-  update(id: string, patch: Partial<Lead>): Promise<Lead>;
-  casStatus(id: string, expected: LeadStatus, next: LeadStatus, patch?: Partial<Lead>): Promise<Lead | null>;
+  consentTimestamp: Date;
+  consentIpAddress?: string;
+  consentUserAgent?: string;
+  confirmationToken?: string;
+  unsubscribeToken: string;
+  /** Audit timestamps for compliance — set on the matching transition. */
+  confirmedAt?: Date;
+  unsubscribedAt?: Date;
+  unsubscribeReason?: string;
+  bouncedAt?: Date;
+  bounceReason?: string;
+  complainedAt?: Date;
+  metadata?: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
 }
+declare function buildSubscriptionSchema(config: SchemaBuildConfig): Schema<ISubscriptionDocument>;
+declare function createSubscriptionModel(connection: Connection, config: SchemaBuildConfig): Model<ISubscriptionDocument>;
 //#endregion
-//#region src/domain/ports/opportunity-repository.port.d.ts
-interface OpportunityFilter {
-  status?: OpportunityStatus | readonly OpportunityStatus[];
-  pipelineId?: string;
-  stageId?: string;
+//#region src/enums/activity.d.ts
+/**
+ * Activity type vocabulary. The package stores `type` as free-form
+ * string so hosts can extend; these constants cover the common
+ * channels that automation tooling typically keys off.
+ */
+declare const ACTIVITY_TYPES: readonly ["call", "email", "meeting", "task", "note", "sms", "social", "demo", "other"];
+type ActivityType = (typeof ACTIVITY_TYPES)[number];
+declare const ACTIVITY_STATUSES: readonly ["planned", "in_progress", "completed", "cancelled"];
+type ActivityStatus = (typeof ACTIVITY_STATUSES)[number];
+declare const ACTIVITY_TRANSITIONS: Record<ActivityStatus, readonly ActivityStatus[]>;
+declare function canTransitionActivity(from: ActivityStatus, to: ActivityStatus): boolean;
+/**
+ * Kinds of entity an Activity can reference. Polymorphic linking lets
+ * hosts log a call against a Lead, an Opportunity, a Contact, or a
+ * stand-alone Account.
+ */
+declare const SUBJECT_KINDS: readonly ["lead", "opportunity", "contact", "account"];
+type SubjectKind = (typeof SUBJECT_KINDS)[number];
+//#endregion
+//#region src/models/activity.schema.d.ts
+interface IActivityDocument {
+  _id: mongoose1.Types.ObjectId;
+  organizationId: mongoose1.Types.ObjectId | string;
+  type: ActivityType;
+  status: ActivityStatus;
+  subjectKind: SubjectKind;
+  subjectId: mongoose1.Types.ObjectId | string;
+  title: string;
+  description?: string;
   ownerId?: string;
-  accountId?: string;
-  closingBetween?: {
-    from: Date;
-    to: Date;
-  };
-}
-interface OpportunityRepository {
-  findById(id: string): Promise<Opportunity | null>;
-  list(filter?: OpportunityFilter): Promise<Opportunity[]>;
-  create(o: Omit<Opportunity, 'createdAt' | 'updatedAt'>): Promise<Opportunity>;
-  update(id: string, patch: Partial<Opportunity>): Promise<Opportunity>;
-  delete(id: string): Promise<void>;
-  casStatus(id: string, expected: OpportunityStatus, next: OpportunityStatus, patch?: Partial<Opportunity>): Promise<Opportunity | null>;
-  casStage(id: string, expectedStageId: string, nextStageId: string, patch?: Partial<Opportunity>): Promise<Opportunity | null>;
+  participantIds: string[];
+  dueDate?: Date;
+  completedAt?: Date;
+  externalRef?: string;
+  metadata?: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
 }
+declare function buildActivitySchema(config: SchemaBuildConfig): Schema<IActivityDocument>;
+declare function createActivityModel(connection: Connection, config: SchemaBuildConfig): Model<IActivityDocument>;
 //#endregion
-//#region src/services/opportunity.service.d.ts
-interface OpportunityPipelinePort {
-  findById(id: string): Promise<{
-    id: string;
-    stages: readonly {
-      id: string;
-    }[];
-  } | null>;
-  getStage(pipelineId: string, stageId: string): Promise<{
-    id: string;
-    sequence: number;
-    defaultProbability: number;
-  }>;
-  getFirstStage(pipelineId: string): Promise<{
-    id: string;
-    sequence: number;
-    defaultProbability: number;
-  }>;
-}
-interface OpportunityServiceConfig {
-  repo: OpportunityRepository;
-  pipelines: OpportunityPipelinePort;
-  events?: EventTransport | undefined;
-  /** Optional host-owned outbox. See AccountServiceConfig.outbox. */
-  outbox?: OutboxStore | undefined;
-  clock?: Clock;
-  ids?: IdGenerator;
+//#region src/models/note.schema.d.ts
+interface INoteDocument {
+  _id: mongoose1.Types.ObjectId;
+  organizationId: mongoose1.Types.ObjectId | string;
+  subjectKind: SubjectKind;
+  subjectId: mongoose1.Types.ObjectId | string;
+  body: string;
+  authorId?: string;
+  pinned: boolean;
+  metadata?: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
 }
-interface CreateOpportunityInput {
+declare function buildNoteSchema(config: SchemaBuildConfig): Schema<INoteDocument>;
+declare function createNoteModel(connection: Connection, config: SchemaBuildConfig): Model<INoteDocument>;
+//#endregion
+//#region src/models/loss-reason.schema.d.ts
+interface ILossReasonDocument {
+  _id: mongoose1.Types.ObjectId;
+  organizationId: mongoose1.Types.ObjectId | string;
   name: string;
-  pipelineId: string;
-  /** Starting stage — defaults to the pipeline's first stage. */
-  stageId?: string;
-  accountId?: string;
-  primaryContactId?: string;
-  sourceLeadId?: string;
-  amount?: Money;
-  /** Override the stage default. Defaults to the stage's `defaultProbability`. */
-  probability?: number;
-  expectedCloseAt?: Date;
-  ownerId?: string;
-  tags?: readonly string[];
+  description?: string;
+  isActive: boolean;
+  /** Display ordering in admin UIs. */
+  sequence: number;
   metadata?: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
 }
-interface MoveStageInput {
-  stageId: string;
-  /** Override probability. Defaults to the target stage's `defaultProbability`. */
-  probability?: number;
-  by?: string;
-  note?: string;
-}
-interface CloseInput {
-  amount?: Money;
-  closedAt?: Date;
-  by?: string;
-  note?: string;
-}
-interface LoseInput extends CloseInput {
-  lostReasonId?: string;
-}
+declare function buildLossReasonSchema(config: SchemaBuildConfig): Schema<ILossReasonDocument>;
+declare function createLossReasonModel(connection: Connection, config: SchemaBuildConfig): Model<ILossReasonDocument>;
+//#endregion
+//#region src/enums/email-event-kind.d.ts
 /**
- * Opportunity lifecycle — stage movement + outcome resolution. Stage
- * changes call the pipeline service to validate membership + default
- * probability; status transitions (`won` / `lost` / `abandoned`) are
- * terminal.
+ * Email engagement event kinds, recorded against a Contact / Campaign /
+ * Subscription tuple as the recipient interacts with a sent message.
+ *
+ *   open       — recipient's mail client loaded the tracking pixel.
+ *                Imperfect signal: image-block clients suppress it, some
+ *                clients pre-fetch and inflate counts. Useful in aggregate.
+ *
+ *   click      — recipient followed a tracked link. High-signal: actual
+ *                user action, not background fetch.
+ *
+ *   bounce     — provider reported delivery failed. Pair with the
+ *                `bounce` status on Subscription for permanent suppression.
+ *
+ *   complaint  — recipient hit "spam" / "report" in their inbox. Pair
+ *                with `complained` Subscription status.
+ *
+ *   unsubscribe — recipient hit the unsubscribe link in the email. May
+ *                fire BEFORE the Subscription itself is marked unsubscribed
+ *                (the host can choose to confirm before flipping status).
+ *
+ * Open and click are "engagement signal"; bounce/complaint/unsubscribe are
+ * "suppression signal". The service exposes aggregates over both
+ * categories so consumers can compute open rate, click rate, bounce rate
+ * without filtering kind themselves.
  */
-declare class OpportunityService {
-  private readonly repo;
-  private readonly pipelines;
-  private readonly events;
-  private readonly outbox;
-  private readonly clock;
-  private readonly ids;
-  constructor(config: OpportunityServiceConfig);
-  create(input: CreateOpportunityInput, options?: MutationOptions): Promise<Opportunity>;
-  moveToStage(id: string, input: MoveStageInput, options?: MutationOptions): Promise<Opportunity>;
-  win(id: string, input?: CloseInput, options?: MutationOptions): Promise<Opportunity>;
-  lose(id: string, input?: LoseInput, options?: MutationOptions): Promise<Opportunity>;
-  abandon(id: string, by?: string, note?: string, options?: MutationOptions): Promise<Opportunity>;
-  delete(id: string): Promise<void>;
-  findById(id: string): Promise<Opportunity | null>;
-  list(filter?: Parameters<OpportunityRepository['list']>[0]): Promise<Opportunity[]>;
-  private _require;
-  private _transitionStatus;
-  private _emit;
+declare const EMAIL_EVENT_KINDS: readonly ["open", "click", "bounce", "complaint", "unsubscribe"];
+type EmailEventKind = (typeof EMAIL_EVENT_KINDS)[number];
+/** Engagement (positive signal). */
+//#endregion
+//#region src/models/email-event.schema.d.ts
+declare const EMAIL_EVENT_SUBJECT_KINDS: readonly ["contact", "subscription"];
+type EmailEventSubjectKind = (typeof EMAIL_EVENT_SUBJECT_KINDS)[number];
+interface IEmailEventDocument {
+  _id: mongoose1.Types.ObjectId;
+  organizationId: mongoose1.Types.ObjectId | string;
+  kind: EmailEventKind;
+  subjectKind: EmailEventSubjectKind;
+  subjectId: mongoose1.Types.ObjectId | string;
+  campaignId?: mongoose1.Types.ObjectId | string;
+  messageId?: string;
+  url?: string;
+  userAgent?: string;
+  ip?: string;
+  metadata?: Record<string, unknown>;
+  createdAt: Date;
 }
+declare function buildEmailEventSchema(config: SchemaBuildConfig): Schema<IEmailEventDocument>;
+declare function createEmailEventModel(connection: Connection, config: SchemaBuildConfig): Model<IEmailEventDocument>;
 //#endregion
-//#region src/services/scoring.d.ts
+//#region src/enums/conversation.d.ts
 /**
- * Pluggable lead scorer. Hosts inject whatever rubric they need —
- * firmographic model, in-app signals, ML prediction, external enrichment.
+ * Conversation / Message vocabulary.
  *
- * Stay pure: the scorer must not mutate anything, not hit I/O, and
- * be deterministic given its input. Side-effects belong in the
- * caller — `LeadService.recomputeScore` runs the scorer then persists.
+ * Conversations unify a contact's (or pre-conversion lead's) message
+ * thread across channels (WhatsApp / Telegram / Email / IG-DM / SMS).
+ * The host's webhook adapters write to this surface — the CRM does not
+ * dial outward.
  */
-type LeadScorer = (lead: Lead) => number;
+declare const CONVERSATION_CHANNELS: readonly ["whatsapp", "telegram", "email", "instagram_dm", "sms", "web_chat"];
+type ConversationChannel = (typeof CONVERSATION_CHANNELS)[number];
+declare const CONVERSATION_STATUSES: readonly ["open", "snoozed", "resolved"];
+type ConversationStatus = (typeof CONVERSATION_STATUSES)[number];
+/** Conversations attach to either a Contact or a (yet-unconverted) Lead. */
+declare const CONVERSATION_PARTICIPANT_KINDS: readonly ["contact", "lead"];
+type ConversationParticipantKind = (typeof CONVERSATION_PARTICIPANT_KINDS)[number];
+declare const MESSAGE_DIRECTIONS: readonly ["inbound", "outbound"];
+type MessageDirection = (typeof MESSAGE_DIRECTIONS)[number];
+declare const MESSAGE_DELIVERY_STATUSES: readonly ["queued", "sent", "delivered", "read", "failed"];
+type MessageDeliveryStatus = (typeof MESSAGE_DELIVERY_STATUSES)[number];
+//#endregion
+//#region src/models/conversation.schema.d.ts
+interface IConversationDocument {
+  _id: mongoose1.Types.ObjectId;
+  organizationId: mongoose1.Types.ObjectId | string;
+  channel: ConversationChannel;
+  participantKind: ConversationParticipantKind;
+  participantId: mongoose1.Types.ObjectId | string;
+  /** Channel-side identifier (e.g. WhatsApp wa_id, Telegram chat id). */
+  channelUserId?: string;
+  status: ConversationStatus;
+  /** Last message timestamp — surfaced for inbox sort + idle SLAs. */
+  lastMessageAt?: Date;
+  /** Unread inbound count. Reset to 0 on `markRead`. */
+  unreadCount: number;
+  /** Assignee. Stored as a string so hosts can use either userId or a queue id. */
+  assigneeId?: string;
+  /** Free-form bag — channel-specific settings (preview text, IMAP folder). */
+  metadata?: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
+}
+declare function buildConversationSchema(config: SchemaBuildConfig): Schema<IConversationDocument>;
+declare function createConversationModel(connection: Connection, config: SchemaBuildConfig): Model<IConversationDocument>;
+//#endregion
+//#region src/models/message.schema.d.ts
+interface IMessageAttachment {
+  type: string;
+  url: string;
+  name?: string;
+  size?: number;
+  mimeType?: string;
+}
+interface IMessageDocument {
+  _id: mongoose1.Types.ObjectId;
+  organizationId: mongoose1.Types.ObjectId | string;
+  conversationId: mongoose1.Types.ObjectId | string;
+  direction: MessageDirection;
+  body: string;
+  attachments: IMessageAttachment[];
+  /** Provider-side id — webhook dedup key. */
+  externalMessageId?: string;
+  status: MessageDeliveryStatus;
+  /** Channel id of the sender (phone number, email, telegram id). */
+  senderRef?: string;
+  /** Channel id of the recipient. */
+  recipientRef?: string;
+  /** When the wire said it left / arrived; falls back to createdAt. */
+  sentAt?: Date;
+  metadata?: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
+}
+declare function buildMessageSchema(config: SchemaBuildConfig): Schema<IMessageDocument>;
+declare function createMessageModel(connection: Connection, config: SchemaBuildConfig): Model<IMessageDocument>;
+//#endregion
+//#region src/models/create-models.d.ts
+interface CrmModels {
+  Pipeline: Model<IPipelineDocument>;
+  Lead: Model<ILeadDocument>;
+  Opportunity: Model<IOpportunityDocument>;
+  Contact: Model<IContactDocument>;
+  Account: Model<IAccountDocument>;
+  Campaign: Model<ICampaignDocument>;
+  Subscription: Model<ISubscriptionDocument>;
+  Activity: Model<IActivityDocument>;
+  Note: Model<INoteDocument>;
+  LossReason: Model<ILossReasonDocument>;
+  EmailEvent: Model<IEmailEventDocument>;
+  Conversation: Model<IConversationDocument>;
+  Message: Model<IMessageDocument>;
+}
+/** Mongoose model names this package registers — drives the §21 collision check. */
+declare const CRM_MODEL_NAMES: readonly ["Pipeline", "Lead", "Opportunity", "Contact", "Account", "Campaign", "EmailSubscription", "Activity", "Note", "LossReason", "EmailEvent", "Conversation", "Message"];
+interface CreateModelsOptions extends SchemaBuildConfig {
+  /**
+   * On a model-name collision: `false` (default) throws
+   * `CrmModelCollisionError`; `true` deletes + re-registers (test
+   * fixtures / hot reload only).
+   */
+  forceRecreate?: boolean;
+  /** Mongoose auto-index builds. Default `true` (dev); `false` in prod. */
+  autoIndex?: boolean;
+}
+declare function createCrmModels(connection: Connection, config: CreateModelsOptions): CrmModels;
+//#endregion
+//#region src/repositories/pipeline.repository.d.ts
+interface PipelineRepositoryDeps {
+  events: EventTransport;
+}
+declare class PipelineRepository extends Repository<IPipelineDocument> {
+  private readonly events;
+  constructor(model: Model<IPipelineDocument>, plugins: PluginType[], deps: PipelineRepositoryDeps, pagination?: PaginationConfig);
+  /**
+   * Read a single embedded stage. Used by Opportunity create / move to
+   * validate stage membership + pick up `defaultProbability`.
+   */
+  getStage(pipelineId: string, stageId: string, ctx?: CrmContext): Promise<IStageDocument>;
+  /** First stage by `sequence` ascending. */
+  getFirstStage(pipelineId: string, ctx?: CrmContext): Promise<IStageDocument>;
+  /** Stage immediately after the given one. `null` at terminal stage. */
+  getNextStage(pipelineId: string, stageId: string, ctx?: CrmContext): Promise<IStageDocument | null>;
+  /** Soft-deprecate — existing opps still move; no new ones can be created. */
+  archive(id: string, ctx?: CrmContext): Promise<IPipelineDocument>;
+}
+//#endregion
+//#region src/shared/calculators/scoring.d.ts
+/** Minimal Lead shape the scorer reads. */
+type LeadInput = Pick<ILeadDocument, 'email' | 'phone' | 'companyName' | 'tags' | 'jobTitle'>;
+type LeadScorer = (lead: LeadInput) => number;
 /**
- * Reference implementation. Intentionally simple so hosts read it and
- * understand the shape, then replace it.
+ * Reference implementation. Intentionally simple — hosts read it and
+ * replace it.
  *
  * +20 if email is present
  * +20 if phone is present
  * +20 if companyName is present
  * +10 per populated tag up to 40
- * +10 if jobTitle looks director/manager/head (case-insensitive)
- */
-declare function defaultLeadScorer(lead: Lead): number;
-/**
- * Compose a scoring pipeline — each rule returns an increment
- * (positive or negative). Useful when host logic is a bunch of
- * small, testable rules.
- *
- * @example
- * ```ts
- * const scorer = composeScorers(
- *   (l) => (l.email ? 20 : 0),
- *   (l) => (l.source === 'referral' ? 30 : 0),
- *   (l) => (l.tags?.includes('enterprise') ? 50 : 0),
- * );
- * ```
+ * +10 if jobTitle hints senior (director / manager / head / chief / vp / founder)
  */
+declare function defaultLeadScorer(lead: LeadInput): number;
+/** Compose multiple small rules into one scorer. */
 declare function composeScorers(...rules: readonly LeadScorer[]): LeadScorer;
 //#endregion
-//#region src/services/lead.service.d.ts
-interface LeadAccountWriter {
-  create(input: CreateAccountInput, options?: MutationOptions): Promise<Account>;
-  delete?(id: string): Promise<void>;
-}
-interface LeadContactWriter {
-  create(input: CreateContactInput, options?: MutationOptions): Promise<Contact>;
-  delete?(id: string): Promise<void>;
-}
-interface LeadOpportunityWriter {
-  create(input: CreateOpportunityInput, options?: MutationOptions): Promise<Opportunity>;
-  delete?(id: string): Promise<void>;
-}
-interface LeadServiceConfig {
-  repo: LeadRepository;
-  contacts: LeadContactWriter;
-  accounts: LeadAccountWriter;
-  opportunities: LeadOpportunityWriter;
-  events?: EventTransport | undefined;
-  /** Optional host-owned outbox. See AccountServiceConfig.outbox. */
-  outbox?: OutboxStore | undefined;
-  clock?: Clock;
-  ids?: IdGenerator;
-  /** Override the default scorer (`defaultLeadScorer`). */
+//#region src/repositories/lead.repository.d.ts
+interface LeadRepositoryDeps {
+  events: EventTransport;
+  /** Override the default lead scorer. */
   scorer?: LeadScorer;
-  /** When true (default), `create()` rejects dup emails. */
+  /** Reject `create()` when an email already exists in-tenant (default true). */
   rejectDuplicates?: boolean;
 }
-interface CreateLeadInput {
-  firstName?: string;
-  lastName?: string;
-  fullName?: string;
-  email?: string;
-  phone?: string;
-  companyName?: string;
-  jobTitle?: string;
-  source?: string;
-  campaignRef?: string;
-  ownerId?: string;
-  tags?: readonly string[];
-  metadata?: Record<string, unknown>;
-}
-interface ConvertLeadInput {
-  /** Pipeline the resulting opportunity enters. */
-  pipelineId: string;
-  /** Opportunity name. Defaults to `<lead.companyName> — <lead.fullName>`. */
-  opportunityName?: string;
-  /** Optional deal amount. */
-  amount?: Money;
-  expectedCloseAt?: Date;
+type TransitionExtras = {
   by?: string;
-}
-interface ConvertResult {
-  lead: Lead;
-  contactId: string;
-  accountId?: string;
-  opportunityId: string;
-}
-/**
- * Lead lifecycle + the crown-jewel `convert()` verb that atomically
- * spawns a Contact + Account + Opportunity and transitions the lead
- * to `converted`.
- */
-declare class LeadService {
-  private readonly repo;
-  private readonly contacts;
-  private readonly accounts;
-  private readonly opportunities;
+  note?: string;
+  patch?: Partial<ILeadDocument>;
+};
+declare class LeadRepository extends Repository<ILeadDocument> {
   private readonly events;
-  private readonly outbox;
-  private readonly clock;
-  private readonly ids;
   private readonly scorer;
   private readonly rejectDuplicates;
-  constructor(config: LeadServiceConfig);
-  create(input: CreateLeadInput, options?: MutationOptions): Promise<Lead>;
-  markContacted(id: string, by?: string, note?: string, options?: MutationOptions): Promise<Lead>;
-  qualify(id: string, by?: string, note?: string, options?: MutationOptions): Promise<Lead>;
-  disqualify(id: string, reason: string, by?: string, options?: MutationOptions): Promise<Lead>;
-  nurture(id: string, by?: string, options?: MutationOptions): Promise<Lead>;
-  convert(id: string, input: ConvertLeadInput, options?: MutationOptions): Promise<ConvertResult>;
-  /** Recompute score and persist. Hosts can call on update or on demand. */
-  recomputeScore(id: string, options?: MutationOptions): Promise<Lead>;
-  findById(id: string): Promise<Lead | null>;
-  list(filter?: Parameters<LeadRepository['list']>[0]): Promise<Lead[]>;
-  private _updateScore;
-  private _require;
+  constructor(model: Model<ILeadDocument>, plugins: PluginType[], deps: LeadRepositoryDeps, pagination?: PaginationConfig);
+  /**
+   * Create a Lead. Auto-scores on insert so hosts can route immediately.
+   * Rejects duplicate emails inside the same tenant unless
+   * `rejectDuplicates: false` was set at engine boot.
+   */
+  createLead(input: Partial<ILeadDocument>, ctx?: CrmContext): Promise<ILeadDocument>;
+  markContacted(id: string, extras?: TransitionExtras, ctx?: CrmContext): Promise<ILeadDocument>;
+  qualify(id: string, extras?: TransitionExtras, ctx?: CrmContext): Promise<ILeadDocument>;
+  disqualify(id: string, reason: string, extras?: Omit<TransitionExtras, 'patch'>, ctx?: CrmContext): Promise<ILeadDocument>;
+  nurture(id: string, extras?: TransitionExtras, ctx?: CrmContext): Promise<ILeadDocument>;
+  /**
+   * Merge enrichment payload (3rd-party provider response or manual
+   * patch) into the lead doc, then re-score. Emits `crm:lead.enriched`
+   * with the field set written so subscribers can fan out (e.g. push a
+   * `recompute_segment` job) without re-reading the doc.
+   *
+   * The `provider` tag flows into the event for attribution; the package
+   * is provider-agnostic so the actual enrichment call lives at the host.
+   */
+  enrich(id: string, patch: Partial<ILeadDocument>, extras?: {
+    provider?: string;
+  }, ctx?: CrmContext): Promise<ILeadDocument>;
+  /**
+   * Assign / re-assign the lead's owner. Emits `crm:lead.assigned` with
+   * the previous owner so audit consumers can compute hand-off chains.
+   */
+  assign(id: string, ownerId: string, ctx?: CrmContext): Promise<ILeadDocument>;
+  /**
+   * Recompute + persist the lead's score. Called from `createLead`
+   * automatically; hosts also call this after enrichment writes.
+   */
+  recomputeScore(id: string, ctx?: CrmContext): Promise<ILeadDocument>;
   private _transition;
-  private _emit;
+  /**
+   * Count leads created on or after `since`. Used by dashboard KPI tiles.
+   * Goes through the inherited tenant-scoped `count()` — the plugin
+   * injects `organizationId` (never a manual `if (ctx)` filter, which
+   * silently reads ALL tenants when ctx is absent).
+   */
+  countCreatedSince(since: Date, ctx?: CrmContext): Promise<number>;
+  /** Latest `limit` leads — lightweight projection for the activity feed. */
+  findRecentForFeed(limit: number, ctx?: CrmContext): Promise<ILeadDocument[]>;
 }
 //#endregion
-//#region src/domain/entities/pipeline.d.ts
-/**
- * A Stage in a Pipeline. Stages are ordered (`sequence` ascending).
- * Default win-probability applies at every opportunity-movement unless
- * the caller overrides.
- */
-interface Stage {
-  id: string;
-  name: string;
-  sequence: number;
-  /** Default win probability (0-1) assigned to opportunities entering this stage. */
-  defaultProbability: number;
-  /** Optional UX hint for color-coded kanbans. */
-  color?: string;
-  /** Describes what "reaching this stage" means. */
-  description?: string;
+//#region src/repositories/opportunity.repository.d.ts
+interface OpportunityRepositoryDeps {
+  events: EventTransport;
+  /** Cross-repo reference: read embedded stages from Pipeline. */
+  pipelines: PipelineRepository;
 }
-/**
- * A Pipeline groups ordered Stages for a specific sales motion. Hosts
- * typically have 1-N pipelines (e.g. `new-business`, `expansion`,
- * `partnerships`, `renewals`). Opportunities pin to exactly one
- * pipeline at create time.
- */
-interface Pipeline {
-  id: string;
+interface OpenOpportunityInput {
   name: string;
-  /** Deprecates this pipeline — opportunities can still move within it but no new ones are created. */
-  isArchived: boolean;
-  stages: readonly Stage[];
-  /** Free-form label for the sales team / motion that owns this pipeline. */
-  teamRef?: string;
+  pipelineId: string;
+  /** When omitted, opp enters the pipeline's first stage. */
+  stageId?: string;
+  accountId?: string;
+  primaryContactId?: string;
+  sourceLeadId?: string;
+  amount?: number;
+  currency?: string;
+  /** Override the stage's `defaultProbability`. */
+  probability?: number;
+  expectedCloseAt?: Date;
+  ownerId?: string;
+  tags?: readonly string[];
   metadata?: Record<string, unknown>;
-  createdAt: Date;
-  updatedAt: Date;
 }
-//#endregion
-//#region src/domain/ports/pipeline-repository.port.d.ts
-interface PipelineRepository {
-  findById(id: string): Promise<Pipeline | null>;
-  list(includeArchived?: boolean): Promise<Pipeline[]>;
-  create(p: Omit<Pipeline, 'createdAt' | 'updatedAt'>): Promise<Pipeline>;
-  update(id: string, patch: Partial<Pipeline>): Promise<Pipeline>;
+interface MoveStageInput {
+  stageId: string;
+  by?: string;
+  note?: string;
+  /** Override the target stage's `defaultProbability`. */
+  probability?: number;
 }
-//#endregion
-//#region src/services/pipeline.service.d.ts
-interface PipelineServiceConfig {
-  repo: PipelineRepository;
-  events?: EventTransport | undefined;
-  /** Optional host-owned outbox. See AccountServiceConfig.outbox. */
-  outbox?: OutboxStore | undefined;
-  clock?: Clock;
-  ids?: IdGenerator;
-}
-interface CreatePipelineInput {
-  name: string;
-  stages: readonly Omit<Stage, 'id'>[];
-  teamRef?: string;
-  metadata?: Record<string, unknown>;
+interface CloseInput {
+  by?: string;
+  note?: string;
+  closedAt?: Date;
+  amount?: number;
+  lostReasonId?: string;
 }
-/**
- * Pipeline lifecycle + stage helpers. The service owns stage id
- * generation so callers don't have to — create a pipeline with an
- * array of stage seeds and the service hands back the persisted
- * pipeline with ids assigned.
- */
-declare class PipelineService {
-  private readonly repo;
+declare class OpportunityRepository extends Repository<IOpportunityDocument> {
   private readonly events;
-  private readonly outbox;
-  private readonly clock;
-  private readonly ids;
-  constructor(config: PipelineServiceConfig);
-  create(input: CreatePipelineInput, options?: MutationOptions): Promise<Pipeline>;
-  archive(id: string, options?: MutationOptions): Promise<Pipeline>;
-  getStage(pipelineId: string, stageId: string): Promise<Stage>;
-  /** First stage in the ordered pipeline (minimum `sequence`). */
-  getFirstStage(pipelineId: string): Promise<Stage>;
-  /** Next stage after `stageId` in the ordered pipeline, or `null` at the end. */
-  getNextStage(pipelineId: string, stageId: string): Promise<Stage | null>;
-  findById(id: string): Promise<Pipeline | null>;
-  list(includeArchived?: boolean): Promise<Pipeline[]>;
-  private _require;
-  private _emit;
-}
-//#endregion
-//#region src/services/forecast.d.ts
-interface ForecastRow {
-  /** Bucket key — typically ISO month `YYYY-MM` derived from `expectedCloseAt`. */
-  bucket: string;
-  /** Sum of unweighted `amount`. */
-  committed: number;
-  /** Sum of `amount × probability`. */
-  weighted: number;
-  /** Count of opportunities contributing. */
-  count: number;
-  currency: string;
-}
-interface ForecastOptions {
+  private readonly pipelines;
+  constructor(model: Model<IOpportunityDocument>, plugins: PluginType[], deps: OpportunityRepositoryDeps, pagination?: PaginationConfig);
+  openOpportunity(input: OpenOpportunityInput, ctx?: CrmContext): Promise<IOpportunityDocument>;
   /**
-   * Bucket function — given an opportunity, return a string bucket
-   * key. Default is ISO-month `YYYY-MM`. Custom buckets (quarter,
-   * fiscal-year, custom periods) plug in here.
+   * Atomic stage move. CAS on `(status='open', stageId=current)` so two
+   * concurrent moves can't both win. Emits `stage_advanced` or
+   * `stage_regressed` based on `sequence` ordering of the embedded stages.
    */
-  bucket?: (o: Opportunity) => string;
+  moveToStage(id: string, input: MoveStageInput, ctx?: CrmContext): Promise<IOpportunityDocument>;
+  win(id: string, input?: CloseInput, ctx?: CrmContext): Promise<IOpportunityDocument>;
+  lose(id: string, input?: CloseInput, ctx?: CrmContext): Promise<IOpportunityDocument>;
   /**
-   * Filter opportunities before bucketing. Default includes only
-   * `open` opportunities with `amount` and `expectedCloseAt`.
+   * Re-assign opportunity owner. Mutates `ownerId` only; no status
+   * transition. Emits `crm:opportunity.assigned` with the previous owner.
    */
-  include?: (o: Opportunity) => boolean;
-}
-/**
- * Aggregate opportunities into a forecast table — one row per
- * bucket (month by default). Committed is `Σ amount`; weighted is
- * `Σ amount × probability`.
- *
- * Integer-safe: sums are computed on minor-unit amounts (consistent
- * with `@classytic/primitives/money`'s integer convention). Currency
- * mismatch across a bucket throws — hosts dealing in multi-currency
- * run this once per currency after partitioning.
- */
-declare function forecast(opportunities: readonly Opportunity[], options?: ForecastOptions): ForecastRow[];
-/**
- * Pipeline conversion summary — how opportunities partitioned across
- * stages and final outcome. Useful for "where do deals die?" analysis.
- */
-interface ConversionRow {
-  stageId: string;
-  currentCount: number;
-  wonFromHere: number;
-  lostFromHere: number;
-  conversionRate: number;
+  assign(id: string, ownerId: string, ctx?: CrmContext): Promise<IOpportunityDocument>;
+  /**
+   * Adjust the deal amount on an open opportunity. Rejected after
+   * win/lose/abandon — closed-deal amounts are immutable history.
+   * Emits `crm:opportunity.amount_changed` with the delta so forecast
+   * subscribers can re-bucket.
+   */
+  updateAmount(id: string, amount: number, extras?: {
+    reason?: string;
+    by?: string;
+  }, ctx?: CrmContext): Promise<IOpportunityDocument>;
+  /**
+   * Push `expectedCloseAt` further out. Only valid on open opps —
+   * extending a closed deal is meaningless. The new date must be later
+   * than the current one; pulling the date in is silently accepted
+   * (no event is meaningful there).
+   */
+  extendCloseDate(id: string, newDate: Date, extras?: {
+    reason?: string;
+    by?: string;
+  }, ctx?: CrmContext): Promise<IOpportunityDocument>;
+  abandon(id: string, by?: string, note?: string, ctx?: CrmContext): Promise<IOpportunityDocument>;
+  private _closeStatus;
+  /** Count opportunities with status `open`. Used by dashboard KPI tiles. */
+  countOpen(ctx?: CrmContext): Promise<number>;
+  /**
+   * Sum `amount` on won opportunities updated within `since`.
+   * Goes through the tenant-scoped `findAll()` — the multiTenant plugin
+   * injects `organizationId`, so a missing ctx can't leak other tenants'
+   * revenue (a manual `if (ctx)` filter would).
+   */
+  sumWonSince(since: Date, ctx?: CrmContext): Promise<{
+    total: number;
+    currency?: string;
+  } | null>;
+  /** Latest `limit` opportunities — lightweight projection for the activity feed. */
+  findRecentForFeed(limit: number, ctx?: CrmContext): Promise<IOpportunityDocument[]>;
 }
-declare function pipelineConversion(opportunities: readonly Opportunity[], stageIds: readonly string[]): ConversionRow[];
 //#endregion
-//#region src/domain/entities/loss-reason.d.ts
-/**
- * Standardized reason for closing an opportunity as `lost`. Seeded
- * once by the host; referenced by id on the opportunity. Keeping
- * these as records (vs free-form strings) is what makes lost-reason
- * analytics possible.
- */
-interface LossReason {
-  id: string;
-  name: string;
-  /** Broad category — `price`, `feature-gap`, `timing`, `competitor`, `no-decision`. */
-  category?: string;
-  description?: string;
-  active: boolean;
-  metadata?: Record<string, unknown>;
-  createdAt: Date;
-  updatedAt: Date;
+//#region src/repositories/contact.repository.d.ts
+interface ContactRepositoryDeps {
+  events: EventTransport;
+}
+interface MergeContactInput {
+  /** Surviving contact id. Receives merged fields. */
+  primaryId: string;
+  /** Secondary contact id. Deleted after merge. */
+  secondaryId: string;
+  /**
+   * Per-field strategy. Defaults to `'preferPrimary'` — primary's
+   * non-empty fields win, secondary fills the gaps. Use `'preferSecondary'`
+   * for the reverse. `tags` are always unioned.
+   */
+  strategy?: 'preferPrimary' | 'preferSecondary';
 }
-//#endregion
-//#region src/domain/ports/loss-reason-repository.port.d.ts
-interface LossReasonRepository {
-  findById(id: string): Promise<LossReason | null>;
-  list(activeOnly?: boolean): Promise<LossReason[]>;
-  create(r: Omit<LossReason, 'createdAt' | 'updatedAt'>): Promise<LossReason>;
-  update(id: string, patch: Partial<LossReason>): Promise<LossReason>;
+declare class ContactRepository extends Repository<IContactDocument> {
+  private readonly events;
+  constructor(model: Model<IContactDocument>, plugins: PluginType[], deps: ContactRepositoryDeps, pagination?: PaginationConfig);
+  /**
+   * Create + emit `crm:contact.created`. Hosts call this instead of
+   * `create()` when they want the event side-effect (e.g. webhook fan-out).
+   */
+  createContact(input: Partial<IContactDocument>, ctx?: CrmContext): Promise<IContactDocument>;
+  /**
+   * Merge enrichment payload into the contact. The `patch` is applied
+   * verbatim; deep-merge of `contact.*` channels is the caller's job
+   * (they own the provider response shape).
+   */
+  enrich(id: string, patch: Partial<IContactDocument>, extras?: {
+    provider?: string;
+  }, ctx?: CrmContext): Promise<IContactDocument>;
+  /** Set / re-assign the contact's owner. Atomic; no-op when unchanged. */
+  assign(id: string, ownerId: string, ctx?: CrmContext): Promise<IContactDocument>;
+  /**
+   * Merge two contacts. Secondary's non-conflicting fields are folded
+   * into primary, tags are unioned, then secondary is deleted.
+   *
+   * Hosts wanting transactional safety can pass `ctx.session` —
+   * mongokit threads it through `update` + `delete`.
+   *
+   * Re-pointing related Activities / Notes / Opportunities is the host's
+   * job (they own those relationships) — subscribe to
+   * `crm:contact.merged` and rewrite `subjectId` / `primaryContactId`
+   * from there.
+   */
+  merge(input: MergeContactInput, ctx?: CrmContext): Promise<IContactDocument>;
 }
 //#endregion
-//#region src/domain/ports/outreach.port.d.ts
-/**
- * Optional outreach bridge. When wired, activity transitions can send
- * real emails / SMS / etc. via the host's pipeline. This package does
- * NOT call it automatically — hosts subscribe to `crm:activity.*`
- * events and call `outreach.send()` from their own handler so pacing,
- * retry, and bounce handling live where they belong.
- *
- * The port intentionally stays minimal; implementations forward to
- * SendGrid, Postmark, Twilio, Mailgun, or an in-house SMTP stack.
- */
-interface OutreachSendRequest {
-  channel: 'email' | 'sms' | 'social' | string;
-  toAddress: string;
-  subject?: string;
-  body: string;
-  activityId?: string;
-  /** Host metadata — template id, campaign ref, personalization vars. */
-  metadata?: Record<string, unknown>;
+//#region src/repositories/account.repository.d.ts
+interface AccountRepositoryDeps {
+  events: EventTransport;
 }
-interface OutreachSendResult {
-  /** Opaque ref — typically the provider's message id. */
-  providerMessageId?: string;
-  acceptedAt: Date;
+interface MergeAccountInput {
+  primaryId: string;
+  secondaryId: string;
+  strategy?: 'preferPrimary' | 'preferSecondary';
 }
-interface OutreachPort {
-  send(request: OutreachSendRequest): Promise<OutreachSendResult>;
+declare class AccountRepository extends Repository<IAccountDocument> {
+  private readonly events;
+  constructor(model: Model<IAccountDocument>, plugins: PluginType[], deps: AccountRepositoryDeps, pagination?: PaginationConfig);
+  createAccount(input: Partial<IAccountDocument>, ctx?: CrmContext): Promise<IAccountDocument>;
+  enrich(id: string, patch: Partial<IAccountDocument>, extras?: {
+    provider?: string;
+  }, ctx?: CrmContext): Promise<IAccountDocument>;
+  assign(id: string, ownerId: string, ctx?: CrmContext): Promise<IAccountDocument>;
+  merge(input: MergeAccountInput, ctx?: CrmContext): Promise<IAccountDocument>;
 }
 //#endregion
-//#region src/adapters/in-memory/account-repository.d.ts
-declare class InMemoryAccountRepository implements AccountRepository {
-  private readonly clock;
-  private readonly items;
-  constructor(clock?: Clock);
-  findById(id: string): Promise<Account | null>;
-  findByDomain(domain: string): Promise<Account | null>;
-  list(filter?: AccountFilter): Promise<Account[]>;
-  create(input: Omit<Account, 'createdAt' | 'updatedAt'>): Promise<Account>;
-  update(id: string, patch: Partial<Account>): Promise<Account>;
-  delete(id: string): Promise<void>;
+//#region src/repositories/campaign.repository.d.ts
+interface CampaignRepositoryDeps {
+  events: EventTransport;
+  /** Reject `createCampaign` on duplicate names per-tenant (default true). */
+  rejectDuplicates?: boolean;
 }
-//#endregion
-//#region src/adapters/in-memory/activity-repository.d.ts
-declare class InMemoryActivityRepository implements ActivityRepository {
-  private readonly clock;
-  private readonly items;
-  constructor(clock?: Clock);
-  findById(id: string): Promise<Activity | null>;
-  list(filter?: ActivityFilter): Promise<Activity[]>;
-  create(input: Omit<Activity, 'createdAt' | 'updatedAt'>): Promise<Activity>;
-  update(id: string, patch: Partial<Activity>): Promise<Activity>;
-  casStatus(id: string, expected: ActivityStatus, next: ActivityStatus, patch?: Partial<Activity>): Promise<Activity | null>;
+type ExtrasWithRevenue = {
+  by?: string;
+  note?: string;
+  actualRevenueAmount?: number;
+};
+declare class CampaignRepository extends Repository<ICampaignDocument> {
+  private readonly events;
+  private readonly rejectDuplicates;
+  constructor(model: Model<ICampaignDocument>, plugins: PluginType[], deps: CampaignRepositoryDeps, pagination?: PaginationConfig);
+  createCampaign(input: Partial<ICampaignDocument>, ctx?: CrmContext): Promise<ICampaignDocument>;
+  activate(id: string, by?: string, ctx?: CrmContext): Promise<ICampaignDocument>;
+  pause(id: string, reason?: string, by?: string, ctx?: CrmContext): Promise<ICampaignDocument>;
+  resume(id: string, by?: string, ctx?: CrmContext): Promise<ICampaignDocument>;
+  complete(id: string, extras?: ExtrasWithRevenue, ctx?: CrmContext): Promise<ICampaignDocument>;
+  archive(id: string, by?: string, ctx?: CrmContext): Promise<ICampaignDocument>;
+  private _transition;
 }
 //#endregion
-//#region src/adapters/in-memory/contact-repository.d.ts
-declare class InMemoryContactRepository implements ContactRepository {
-  private readonly clock;
-  private readonly items;
-  constructor(clock?: Clock);
-  findById(id: string): Promise<Contact | null>;
-  findByEmail(email: string): Promise<Contact | null>;
-  list(filter?: ContactFilter): Promise<Contact[]>;
-  create(input: Omit<Contact, 'createdAt' | 'updatedAt'>): Promise<Contact>;
-  update(id: string, patch: Partial<Contact>): Promise<Contact>;
-  delete(id: string): Promise<void>;
+//#region src/repositories/subscription.repository.d.ts
+interface SubscriptionRepositoryDeps {
+  events: EventTransport;
+  /** Default DOI policy when `subscribe` doesn't pass `requireDoubleOptIn`. */
+  defaultRequireDoubleOptIn?: boolean;
 }
-//#endregion
-//#region src/adapters/in-memory/event-transport.d.ts
-type RecordedEvent = DomainEvent;
-declare class InMemoryEventTransport implements EventTransport {
-  readonly name = "crm-in-memory";
-  readonly events: RecordedEvent[];
-  private readonly subscribers;
-  publish(event: DomainEvent): Promise<void>;
-  subscribe(pattern: string, handler: EventHandler): Promise<() => void>;
+interface SubscribeInput {
+  contactId: string;
+  campaignId: string;
+  source?: string;
+  consentIpAddress?: string;
+  consentUserAgent?: string;
+  metadata?: Record<string, unknown>;
+  /** Override the engine-level default. */
+  requireDoubleOptIn?: boolean;
 }
-//#endregion
-//#region src/adapters/in-memory/lead-repository.d.ts
-declare class InMemoryLeadRepository implements LeadRepository {
-  private readonly clock;
-  private readonly items;
-  constructor(clock?: Clock);
-  findById(id: string): Promise<Lead | null>;
-  findByEmail(email: string): Promise<Lead | null>;
-  list(filter?: LeadFilter): Promise<Lead[]>;
-  create(input: Omit<Lead, 'createdAt' | 'updatedAt'>): Promise<Lead>;
-  update(id: string, patch: Partial<Lead>): Promise<Lead>;
-  casStatus(id: string, expected: LeadStatus, next: LeadStatus, patch?: Partial<Lead>): Promise<Lead | null>;
+declare class SubscriptionRepository extends Repository<ISubscriptionDocument> {
+  private readonly events;
+  private readonly defaultRequireDoubleOptIn;
+  constructor(model: Model<ISubscriptionDocument>, plugins: PluginType[], deps: SubscriptionRepositoryDeps, pagination?: PaginationConfig);
+  subscribe(input: SubscribeInput, ctx?: CrmContext): Promise<ISubscriptionDocument>;
+  confirm(token: string, ctx?: CrmContext): Promise<ISubscriptionDocument>;
+  unsubscribe(token: string, reason?: string, ctx?: CrmContext): Promise<ISubscriptionDocument>;
+  markBounced(id: string, reason?: string, ctx?: CrmContext): Promise<ISubscriptionDocument>;
+  markComplained(id: string, ctx?: CrmContext): Promise<ISubscriptionDocument>;
+  private _transition;
 }
 //#endregion
-//#region src/adapters/in-memory/loss-reason-repository.d.ts
-declare class InMemoryLossReasonRepository implements LossReasonRepository {
-  private readonly clock;
-  private readonly items;
-  constructor(clock?: Clock);
-  findById(id: string): Promise<LossReason | null>;
-  list(activeOnly?: boolean): Promise<LossReason[]>;
-  create(input: Omit<LossReason, 'createdAt' | 'updatedAt'>): Promise<LossReason>;
-  update(id: string, patch: Partial<LossReason>): Promise<LossReason>;
+//#region src/repositories/activity.repository.d.ts
+interface ActivityRepositoryDeps {
+  events: EventTransport;
 }
-//#endregion
-//#region src/adapters/in-memory/note-repository.d.ts
-declare class InMemoryNoteRepository implements NoteRepository {
-  private readonly clock;
-  private readonly items;
-  constructor(clock?: Clock);
-  findById(id: string): Promise<Note | null>;
-  listBySubject(subjectKind: SubjectKind, subjectId: string): Promise<Note[]>;
-  create(input: Omit<Note, 'createdAt' | 'updatedAt'>): Promise<Note>;
-  update(id: string, patch: Partial<Note>): Promise<Note>;
-  delete(id: string): Promise<void>;
+declare class ActivityRepository extends Repository<IActivityDocument> {
+  private readonly events;
+  constructor(model: Model<IActivityDocument>, plugins: PluginType[], deps: ActivityRepositoryDeps, pagination?: PaginationConfig);
+  plan(input: Partial<IActivityDocument>, ctx?: CrmContext): Promise<IActivityDocument>;
+  start(id: string, ctx?: CrmContext): Promise<IActivityDocument>;
+  complete(id: string, completedAt?: Date, ctx?: CrmContext): Promise<IActivityDocument>;
+  cancel(id: string, reason?: string, ctx?: CrmContext): Promise<IActivityDocument>;
+  /**
+   * Push an activity's `dueDate`. Allowed on planned / in_progress only;
+   * rescheduling a completed or cancelled activity makes no sense.
+   * Emits `crm:activity.rescheduled` with the previous date for audit.
+   */
+  reschedule(id: string, newDueDate: Date, extras?: {
+    reason?: string;
+    by?: string;
+  }, ctx?: CrmContext): Promise<IActivityDocument>;
+  /**
+   * Record the outcome of an activity (call result, email engagement,
+   * meeting confirmation). Stored under `metadata.outcome` so it stays
+   * polymorphic — the shape is the channel's concern, not this package's.
+   *
+   * Does NOT transition status — call `complete()` separately when the
+   * outcome implies completion. This split lets agents log partial
+   * outcomes (e.g. "left voicemail") without forcing terminal state.
+   */
+  recordOutcome(id: string, outcome: Record<string, unknown>, ctx?: CrmContext): Promise<IActivityDocument>;
+  private _transition;
+  /** Count `planned` activities with `dueDate` before `asOf`. Dashboard KPI. */
+  countOverduePlanned(asOf: Date, ctx?: CrmContext): Promise<number>;
+  /** Latest `limit` activities — lightweight projection for the activity feed. */
+  findRecentForFeed(limit: number, ctx?: CrmContext): Promise<IActivityDocument[]>;
 }
 //#endregion
-//#region src/adapters/in-memory/opportunity-repository.d.ts
-declare class InMemoryOpportunityRepository implements OpportunityRepository {
-  private readonly clock;
-  private readonly items;
-  constructor(clock?: Clock);
-  findById(id: string): Promise<Opportunity | null>;
-  list(filter?: OpportunityFilter): Promise<Opportunity[]>;
-  create(input: Omit<Opportunity, 'createdAt' | 'updatedAt'>): Promise<Opportunity>;
-  update(id: string, patch: Partial<Opportunity>): Promise<Opportunity>;
-  delete(id: string): Promise<void>;
-  casStatus(id: string, expected: OpportunityStatus, next: OpportunityStatus, patch?: Partial<Opportunity>): Promise<Opportunity | null>;
-  casStage(id: string, expectedStageId: string, nextStageId: string, patch?: Partial<Opportunity>): Promise<Opportunity | null>;
+//#region src/repositories/note.repository.d.ts
+interface NoteRepositoryDeps {
+  events: EventTransport;
 }
-//#endregion
-//#region src/adapters/in-memory/pipeline-repository.d.ts
-declare class InMemoryPipelineRepository implements PipelineRepository {
-  private readonly clock;
-  private readonly items;
-  constructor(clock?: Clock);
-  findById(id: string): Promise<Pipeline | null>;
-  list(includeArchived?: boolean): Promise<Pipeline[]>;
-  create(input: Omit<Pipeline, 'createdAt' | 'updatedAt'>): Promise<Pipeline>;
-  update(id: string, patch: Partial<Pipeline>): Promise<Pipeline>;
+declare class NoteRepository extends Repository<INoteDocument> {
+  private readonly events;
+  constructor(model: Model<INoteDocument>, plugins: PluginType[], deps: NoteRepositoryDeps, pagination?: PaginationConfig);
+  addNote(input: Partial<INoteDocument>, ctx?: CrmContext): Promise<INoteDocument>;
 }
 //#endregion
-//#region src/adapters/in-memory/outreach-port.d.ts
-declare class NullOutreachPort implements OutreachPort {
-  private counter;
-  send(_request: OutreachSendRequest): Promise<OutreachSendResult>;
-}
-interface RecordedOutreach extends OutreachSendRequest, OutreachSendResult {}
-declare class InMemoryOutreachPort implements OutreachPort {
-  private readonly nowMs;
-  readonly sent: RecordedOutreach[];
-  private counter;
-  constructor(nowMs?: () => number);
-  send(request: OutreachSendRequest): Promise<OutreachSendResult>;
+//#region src/repositories/loss-reason.repository.d.ts
+interface LossReasonRepositoryDeps {
+  events: EventTransport;
+}
+declare class LossReasonRepository extends Repository<ILossReasonDocument> {
+  private readonly events;
+  constructor(model: Model<ILossReasonDocument>, plugins: PluginType[], deps: LossReasonRepositoryDeps, pagination?: PaginationConfig);
+  /** Hide from pickers without breaking historical FKs. */
+  archive(id: string, ctx?: CrmContext): Promise<ILossReasonDocument>;
 }
 //#endregion
-//#region src/adapters/in-memory/id-generator.d.ts
-declare const cryptoIdGenerator: IdGenerator;
-declare function createSequentialIdGenerator(prefix?: string): IdGenerator;
-//#endregion
-//#region src/domain/errors.d.ts
-/**
- * CRM error vocabulary. Hosts catch `CrmError` at API edges.
- */
-declare class CrmError extends Error {
-  readonly code: string;
-  readonly details?: Record<string, unknown>;
-  constructor(code: string, message: string, details?: Record<string, unknown>);
-}
-declare class NotFoundError extends CrmError {
-  constructor(kind: string, id: string);
-}
-declare class InvalidLeadTransitionError extends CrmError {
-  constructor(details: {
-    from: string;
-    to: string;
-    leadId: string;
-  });
+//#region src/repositories/email-event.repository.d.ts
+interface EmailEventRepositoryDeps {
+  events: EventTransport;
 }
-declare class InvalidOpportunityTransitionError extends CrmError {
-  constructor(details: {
-    from: string;
-    to: string;
-    opportunityId: string;
-  });
+interface RecordEmailEventInput {
+  subjectKind: EmailEventSubjectKind;
+  subjectId: string;
+  campaignId?: string;
+  messageId?: string;
+  url?: string;
+  userAgent?: string;
+  ip?: string;
+  metadata?: Record<string, unknown>;
 }
-declare class InvalidActivityTransitionError extends CrmError {
-  constructor(details: {
-    from: string;
-    to: string;
-    activityId: string;
-  });
+declare class EmailEventRepository extends Repository<IEmailEventDocument> {
+  private readonly events;
+  constructor(model: Model<IEmailEventDocument>, plugins: PluginType[], deps: EmailEventRepositoryDeps, pagination?: PaginationConfig);
+  recordOpen(input: RecordEmailEventInput, ctx?: CrmContext): Promise<IEmailEventDocument>;
+  recordClick(input: RecordEmailEventInput, ctx?: CrmContext): Promise<IEmailEventDocument>;
+  recordBounce(input: RecordEmailEventInput, ctx?: CrmContext): Promise<IEmailEventDocument>;
+  recordComplaint(input: RecordEmailEventInput, ctx?: CrmContext): Promise<IEmailEventDocument>;
+  recordUnsubscribe(input: RecordEmailEventInput, ctx?: CrmContext): Promise<IEmailEventDocument>;
+  private _record;
 }
-declare class StageNotInPipelineError extends CrmError {
-  constructor(details: {
-    pipelineId: string;
-    stageId: string;
-  });
+//#endregion
+//#region src/repositories/conversation.repository.d.ts
+interface ConversationRepositoryDeps {
+  events: EventTransport;
+}
+interface OpenConversationInput {
+  channel: ConversationChannel;
+  participantKind: ConversationParticipantKind;
+  participantId: string;
+  channelUserId?: string;
+  assigneeId?: string;
+  metadata?: Record<string, unknown>;
 }
-declare class LeadAlreadyConvertedError extends CrmError {
-  constructor(leadId: string);
+declare class ConversationRepository extends Repository<IConversationDocument> {
+  private readonly events;
+  constructor(model: Model<IConversationDocument>, plugins: PluginType[], deps: ConversationRepositoryDeps, pagination?: PaginationConfig);
+  openConversation(input: OpenConversationInput, ctx?: CrmContext): Promise<IConversationDocument>;
+  assign(id: string, assigneeId: string, ctx?: CrmContext): Promise<IConversationDocument>;
+  resolve(id: string, ctx?: CrmContext): Promise<IConversationDocument>;
+  reopen(id: string, ctx?: CrmContext): Promise<IConversationDocument>;
+  /** Reset unread badge. Pure UI affordance, no event. */
+  markRead(id: string, ctx?: CrmContext): Promise<IConversationDocument>;
+  /**
+   * Bump `lastMessageAt` and (for inbound) increment `unreadCount`.
+   * Called by `MessageRepository` when a message is recorded — not part
+   * of the public surface. Returns the conversation for the caller's
+   * follow-up writes.
+   */
+  touch(id: string, args: {
+    direction: 'inbound' | 'outbound';
+    sentAt: Date;
+  }, ctx?: CrmContext): Promise<IConversationDocument | null>;
+  private _setStatus;
 }
-declare class DuplicateLeadError extends CrmError {
-  constructor(details: {
-    email?: string;
-    phone?: string;
-  });
+//#endregion
+//#region src/repositories/message.repository.d.ts
+interface MessageRepositoryDeps {
+  events: EventTransport;
+  conversations: ConversationRepository;
 }
-declare class EmptyPipelineError extends CrmError {
-  constructor(pipelineId: string);
+interface RecordMessageInput {
+  conversationId: string;
+  body: string;
+  attachments?: IMessageAttachment[];
+  externalMessageId?: string;
+  senderRef?: string;
+  recipientRef?: string;
+  sentAt?: Date;
+  metadata?: Record<string, unknown>;
+}
+declare class MessageRepository extends Repository<IMessageDocument> {
+  private readonly events;
+  private readonly conversations;
+  constructor(model: Model<IMessageDocument>, plugins: PluginType[], deps: MessageRepositoryDeps, pagination?: PaginationConfig);
+  recordInbound(input: RecordMessageInput, ctx?: CrmContext): Promise<IMessageDocument>;
+  recordOutbound(input: RecordMessageInput, ctx?: CrmContext): Promise<IMessageDocument>;
+  /** Wire delivery callback (e.g. WhatsApp `status` webhook). */
+  updateStatus(id: string, status: MessageDeliveryStatus, ctx?: CrmContext): Promise<IMessageDocument>;
+  private _record;
+  /** Latest `limit` messages — lightweight projection for the activity feed. */
+  findRecentForFeed(limit: number, ctx?: CrmContext): Promise<IMessageDocument[]>;
 }
 //#endregion
-//#region src/events/event-constants.d.ts
-/** PACKAGE_RULES rule 12: `package:resource.verb`. */
-declare const CRM_EVENTS: {
-  readonly LEAD_CREATED: "crm:lead.created";
-  readonly LEAD_STATUS_CHANGED: "crm:lead.status_changed";
-  readonly LEAD_SCORED: "crm:lead.scored";
-  readonly LEAD_CONVERTED: "crm:lead.converted";
-  readonly LEAD_DISQUALIFIED: "crm:lead.disqualified";
-  readonly ACCOUNT_CREATED: "crm:account.created";
-  readonly ACCOUNT_UPDATED: "crm:account.updated";
-  readonly CONTACT_CREATED: "crm:contact.created";
-  readonly CONTACT_UPDATED: "crm:contact.updated";
-  readonly OPPORTUNITY_CREATED: "crm:opportunity.created";
-  readonly OPPORTUNITY_STAGE_ADVANCED: "crm:opportunity.stage_advanced";
-  readonly OPPORTUNITY_STAGE_REGRESSED: "crm:opportunity.stage_regressed";
-  readonly OPPORTUNITY_WON: "crm:opportunity.won";
-  readonly OPPORTUNITY_LOST: "crm:opportunity.lost";
-  readonly OPPORTUNITY_ABANDONED: "crm:opportunity.abandoned";
-  readonly PIPELINE_CREATED: "crm:pipeline.created";
-  readonly PIPELINE_ARCHIVED: "crm:pipeline.archived";
-  readonly ACTIVITY_PLANNED: "crm:activity.planned";
-  readonly ACTIVITY_COMPLETED: "crm:activity.completed";
-  readonly ACTIVITY_CANCELLED: "crm:activity.cancelled";
-  readonly NOTE_ADDED: "crm:note.added";
-};
-type CrmEventName = (typeof CRM_EVENTS)[keyof typeof CRM_EVENTS];
-//#endregion
-//#region src/events/event-catalog.d.ts
-interface CrmEventSchema {
-  type: 'object';
-  properties?: Record<string, {
-    type?: string;
-    format?: string;
-    [key: string]: unknown;
-  }>;
-  required?: string[];
-  [key: string]: unknown;
+//#region src/engine/engine-types.d.ts
+interface CrmLogger {
+  info?(msg: string, meta?: Record<string, unknown>): void;
+  warn?(msg: string, meta?: Record<string, unknown>): void;
+  error?(msg: string, meta?: Record<string, unknown>): void;
+  debug?(msg: string, meta?: Record<string, unknown>): void;
+}
+interface CrmConfig {
+  /** Mongoose connection — package creates models on this connection. */
+  connection: Connection;
+  /**
+   * Tenant column shape. `'objectId'` (default) matches Better Auth orgs
+   * and unlocks `$lookup` / `.populate()`; `'string'` matches UUID hosts.
+   * Threaded into both schemas and `multiTenantPlugin` so they stay in
+   * sync (PACKAGE_RULES §9.2).
+   */
+  tenantFieldType?: TenantFieldType;
+  /**
+   * When `true` (default), wire `multiTenantPlugin` on every repository
+   * with `required: true`. Set `false` only for fixtures / smoke tests
+   * that intentionally drop the scope.
+   */
+  multiTenant?: boolean;
+  /** Arc-compatible event transport. Default: in-process bus. */
+  eventTransport?: EventTransport;
+  /** Logger surface used by the in-process bus + repositories. */
+  logger?: CrmLogger;
+  /** Pagination defaults for every repository (mongokit). */
+  pagination?: PaginationConfig;
+  /** Extra mongokit plugins applied to every repository (after defaults). */
+  plugins?: PluginType[];
+  /**
+   * On a Mongoose model-name collision (another engine / hot reload owns
+   * the name): `false` (default) throws `CrmModelCollisionError`; `true`
+   * deletes + re-registers. Test fixtures / hot reload only (§21).
+   */
+  forceRecreate?: boolean;
+  /**
+   * Mongoose auto-index builds. Default `true` (dev). Set `false` in
+   * production and run `engine.syncIndexes()` from a deploy script so
+   * cold-boot index builds don't blow Fastify's plugin timeout (§35).
+   */
+  autoIndex?: boolean;
+  /**
+   * Skip the boot-time `transactions` capability requirement, downgrading
+   * it to a warning. Set only when the host never calls
+   * `LeadService.convert()` inside a transaction (standalone Mongo).
+   */
+  allowNonTransactional?: boolean;
+}
+interface ResolvedCrmConfig extends SchemaBuildConfig {
+  connection: Connection;
+  tenantFieldType: TenantFieldType;
+  multiTenant: boolean;
+  forceRecreate: boolean;
+  autoIndex: boolean;
+  logger?: CrmLogger;
+  pagination?: PaginationConfig;
+  plugins: PluginType[];
+}
+interface CrmRepositories {
+  pipeline: PipelineRepository;
+  lead: LeadRepository;
+  opportunity: OpportunityRepository;
+  contact: ContactRepository;
+  account: AccountRepository;
+  campaign: CampaignRepository;
+  subscription: SubscriptionRepository;
+  activity: ActivityRepository;
+  note: NoteRepository;
+  lossReason: LossReasonRepository;
+  emailEvent: EmailEventRepository;
+  conversation: ConversationRepository;
+  message: MessageRepository;
+}
+interface CrmEngine {
+  /** Repositories ARE the API surface (PACKAGE_RULES §1). */
+  readonly repositories: Readonly<CrmRepositories>;
+  /** Arc-compatible event transport. */
+  readonly events: EventTransport;
+  /** Mongoose models — for arc adapter wiring. */
+  readonly models: Readonly<CrmModels>;
+  /** Resolved configuration (frozen). */
+  readonly config: Readonly<ResolvedCrmConfig>;
+  /**
+   * Build/align every model's indexes against its schema. Call once per
+   * deploy when booted with `autoIndex: false` (§35). Idempotent.
+   */
+  syncIndexes(): Promise<void>;
+  /** Release resources. Safe to call multiple times. */
+  dispose(): Promise<void>;
 }
-interface CrmEventDefinition<TSchema extends z.ZodType = z.ZodType> {
-  readonly name: string;
-  readonly version: number;
-  readonly description?: string;
-  readonly schema: CrmEventSchema;
-  readonly zodSchema: TSchema;
-  create(payload: z.infer<TSchema>, meta?: Partial<DomainEvent['meta']>): DomainEvent<z.infer<TSchema>>;
-  readonly __payload?: z.infer<TSchema>;
-}
-type CrmEventPayloadOf<D> = D extends CrmEventDefinition<infer S> ? z.infer<S> : never;
-declare const leadCreatedSchema: z.ZodObject<{
-  leadId: z.ZodString;
-  email: z.ZodOptional<z.ZodString>;
-  score: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-declare const leadStatusChangedSchema: z.ZodObject<{
-  leadId: z.ZodString;
-  from: z.ZodString;
-  to: z.ZodString;
-}, z.core.$strip>;
-declare const leadScoredSchema: z.ZodObject<{
-  leadId: z.ZodString;
-  score: z.ZodNumber;
-}, z.core.$strip>;
-declare const leadConvertedSchema: z.ZodObject<{
-  leadId: z.ZodString;
-  contactId: z.ZodString;
-  accountId: z.ZodOptional<z.ZodString>;
-  opportunityId: z.ZodString;
-}, z.core.$strip>;
-declare const leadDisqualifiedSchema: z.ZodObject<{
-  leadId: z.ZodString;
-  reason: z.ZodString;
-}, z.core.$strip>;
-declare const accountCreatedSchema: z.ZodObject<{
-  accountId: z.ZodString;
-}, z.core.$strip>;
-declare const accountUpdatedSchema: z.ZodObject<{
-  accountId: z.ZodString;
-}, z.core.$strip>;
-declare const contactCreatedSchema: z.ZodObject<{
-  contactId: z.ZodString;
-  email: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-declare const contactUpdatedSchema: z.ZodObject<{
-  contactId: z.ZodString;
-}, z.core.$strip>;
-declare const opportunityCreatedSchema: z.ZodObject<{
-  opportunityId: z.ZodString;
-  pipelineId: z.ZodString;
-  stageId: z.ZodString;
-}, z.core.$strip>;
-declare const opportunityStageAdvancedSchema: z.ZodObject<{
-  opportunityId: z.ZodString;
-  from: z.ZodObject<{
-    stageId: z.ZodString;
-    sequence: z.ZodNumber;
-  }, z.core.$strip>;
-  to: z.ZodObject<{
-    stageId: z.ZodString;
-    sequence: z.ZodNumber;
-  }, z.core.$strip>;
-}, z.core.$strip>;
-declare const opportunityStageRegressedSchema: z.ZodObject<{
-  opportunityId: z.ZodString;
-  from: z.ZodObject<{
-    stageId: z.ZodString;
-    sequence: z.ZodNumber;
-  }, z.core.$strip>;
-  to: z.ZodObject<{
-    stageId: z.ZodString;
-    sequence: z.ZodNumber;
-  }, z.core.$strip>;
-}, z.core.$strip>;
-declare const opportunityWonSchema: z.ZodObject<{
-  opportunityId: z.ZodString;
-  amount: z.ZodOptional<z.ZodObject<{
-    amount: z.ZodNumber;
-    currency: z.ZodString;
-  }, z.core.$strip>>;
-}, z.core.$strip>;
-declare const opportunityLostSchema: z.ZodObject<{
-  opportunityId: z.ZodString;
-  lostReasonId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-declare const opportunityAbandonedSchema: z.ZodObject<{
-  opportunityId: z.ZodString;
-}, z.core.$strip>;
-declare const pipelineCreatedSchema: z.ZodObject<{
-  pipelineId: z.ZodString;
-}, z.core.$strip>;
-declare const pipelineArchivedSchema: z.ZodObject<{
-  pipelineId: z.ZodString;
-}, z.core.$strip>;
-declare const activityPlannedSchema: z.ZodObject<{
-  activityId: z.ZodString;
-  type: z.ZodString;
-  subjectKind: z.ZodEnum<{
-    lead: "lead";
-    opportunity: "opportunity";
-    contact: "contact";
-    account: "account";
-  }>;
-  subjectId: z.ZodString;
-}, z.core.$strip>;
-declare const activityCompletedSchema: z.ZodObject<{
-  activityId: z.ZodString;
-  completedAt: z.ZodISODateTime;
-}, z.core.$strip>;
-declare const activityCancelledSchema: z.ZodObject<{
-  activityId: z.ZodString;
-  reason: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-declare const noteAddedSchema: z.ZodObject<{
-  noteId: z.ZodString;
-  subjectKind: z.ZodEnum<{
-    lead: "lead";
-    opportunity: "opportunity";
-    contact: "contact";
-    account: "account";
-  }>;
-  subjectId: z.ZodString;
-}, z.core.$strip>;
-type LeadCreatedPayload = z.infer<typeof leadCreatedSchema>;
-type LeadStatusChangedPayload = z.infer<typeof leadStatusChangedSchema>;
-type LeadScoredPayload = z.infer<typeof leadScoredSchema>;
-type LeadConvertedPayload = z.infer<typeof leadConvertedSchema>;
-type LeadDisqualifiedPayload = z.infer<typeof leadDisqualifiedSchema>;
-type AccountCreatedPayload = z.infer<typeof accountCreatedSchema>;
-type AccountUpdatedPayload = z.infer<typeof accountUpdatedSchema>;
-type ContactCreatedPayload = z.infer<typeof contactCreatedSchema>;
-type ContactUpdatedPayload = z.infer<typeof contactUpdatedSchema>;
-type OpportunityCreatedPayload = z.infer<typeof opportunityCreatedSchema>;
-type OpportunityStageAdvancedPayload = z.infer<typeof opportunityStageAdvancedSchema>;
-type OpportunityStageRegressedPayload = z.infer<typeof opportunityStageRegressedSchema>;
-type OpportunityWonPayload = z.infer<typeof opportunityWonSchema>;
-type OpportunityLostPayload = z.infer<typeof opportunityLostSchema>;
-type OpportunityAbandonedPayload = z.infer<typeof opportunityAbandonedSchema>;
-type PipelineCreatedPayload = z.infer<typeof pipelineCreatedSchema>;
-type PipelineArchivedPayload = z.infer<typeof pipelineArchivedSchema>;
-type ActivityPlannedPayload = z.infer<typeof activityPlannedSchema>;
-type ActivityCompletedPayload = z.infer<typeof activityCompletedSchema>;
-type ActivityCancelledPayload = z.infer<typeof activityCancelledSchema>;
-type NoteAddedPayload = z.infer<typeof noteAddedSchema>;
-declare const LeadCreated: CrmEventDefinition<z.ZodObject<{
-  leadId: z.ZodString;
-  email: z.ZodOptional<z.ZodString>;
-  score: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>>;
-declare const LeadStatusChanged: CrmEventDefinition<z.ZodObject<{
-  leadId: z.ZodString;
-  from: z.ZodString;
-  to: z.ZodString;
-}, z.core.$strip>>;
-declare const LeadScored: CrmEventDefinition<z.ZodObject<{
-  leadId: z.ZodString;
-  score: z.ZodNumber;
-}, z.core.$strip>>;
-declare const LeadConverted: CrmEventDefinition<z.ZodObject<{
-  leadId: z.ZodString;
-  contactId: z.ZodString;
-  accountId: z.ZodOptional<z.ZodString>;
-  opportunityId: z.ZodString;
-}, z.core.$strip>>;
-declare const LeadDisqualified: CrmEventDefinition<z.ZodObject<{
-  leadId: z.ZodString;
-  reason: z.ZodString;
-}, z.core.$strip>>;
-declare const AccountCreated: CrmEventDefinition<z.ZodObject<{
-  accountId: z.ZodString;
-}, z.core.$strip>>;
-declare const AccountUpdated: CrmEventDefinition<z.ZodObject<{
-  accountId: z.ZodString;
-}, z.core.$strip>>;
-declare const ContactCreated: CrmEventDefinition<z.ZodObject<{
-  contactId: z.ZodString;
-  email: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>>;
-declare const ContactUpdated: CrmEventDefinition<z.ZodObject<{
-  contactId: z.ZodString;
-}, z.core.$strip>>;
-declare const OpportunityCreated: CrmEventDefinition<z.ZodObject<{
-  opportunityId: z.ZodString;
-  pipelineId: z.ZodString;
-  stageId: z.ZodString;
-}, z.core.$strip>>;
-declare const OpportunityStageAdvanced: CrmEventDefinition<z.ZodObject<{
-  opportunityId: z.ZodString;
-  from: z.ZodObject<{
-    stageId: z.ZodString;
-    sequence: z.ZodNumber;
-  }, z.core.$strip>;
-  to: z.ZodObject<{
-    stageId: z.ZodString;
-    sequence: z.ZodNumber;
-  }, z.core.$strip>;
-}, z.core.$strip>>;
-declare const OpportunityStageRegressed: CrmEventDefinition<z.ZodObject<{
-  opportunityId: z.ZodString;
-  from: z.ZodObject<{
-    stageId: z.ZodString;
-    sequence: z.ZodNumber;
-  }, z.core.$strip>;
-  to: z.ZodObject<{
-    stageId: z.ZodString;
-    sequence: z.ZodNumber;
-  }, z.core.$strip>;
-}, z.core.$strip>>;
-declare const OpportunityWon: CrmEventDefinition<z.ZodObject<{
-  opportunityId: z.ZodString;
-  amount: z.ZodOptional<z.ZodObject<{
-    amount: z.ZodNumber;
-    currency: z.ZodString;
-  }, z.core.$strip>>;
-}, z.core.$strip>>;
-declare const OpportunityLost: CrmEventDefinition<z.ZodObject<{
-  opportunityId: z.ZodString;
-  lostReasonId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>>;
-declare const OpportunityAbandoned: CrmEventDefinition<z.ZodObject<{
-  opportunityId: z.ZodString;
-}, z.core.$strip>>;
-declare const PipelineCreated: CrmEventDefinition<z.ZodObject<{
-  pipelineId: z.ZodString;
-}, z.core.$strip>>;
-declare const PipelineArchived: CrmEventDefinition<z.ZodObject<{
-  pipelineId: z.ZodString;
-}, z.core.$strip>>;
-declare const ActivityPlanned: CrmEventDefinition<z.ZodObject<{
-  activityId: z.ZodString;
-  type: z.ZodString;
-  subjectKind: z.ZodEnum<{
-    lead: "lead";
-    opportunity: "opportunity";
-    contact: "contact";
-    account: "account";
-  }>;
-  subjectId: z.ZodString;
-}, z.core.$strip>>;
-declare const ActivityCompleted: CrmEventDefinition<z.ZodObject<{
-  activityId: z.ZodString;
-  completedAt: z.ZodISODateTime;
-}, z.core.$strip>>;
-declare const ActivityCancelled: CrmEventDefinition<z.ZodObject<{
-  activityId: z.ZodString;
-  reason: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>>;
-declare const NoteAdded: CrmEventDefinition<z.ZodObject<{
-  noteId: z.ZodString;
-  subjectKind: z.ZodEnum<{
-    lead: "lead";
-    opportunity: "opportunity";
-    contact: "contact";
-    account: "account";
-  }>;
-  subjectId: z.ZodString;
-}, z.core.$strip>>;
 /**
- * Every CRM event defined in the package — pass to Arc's `EventRegistry`.
- * Hosts wire ONE array; the whole `crm:*` namespace becomes introspectable
- * via OpenAPI and auto-validated at publish time when
- * `eventPlugin({ validateMode: 'reject' })` is set.
+ * Operation context threaded through every domain verb. Extends
+ * primitives' `OperationContext` and narrows `IdLike` to types Mongoose
+ * stores cleanly. Host-specific extras go through the inherited
+ * `metadata?` field — keep the typed surface tight.
  */
-declare const crmEventDefinitions: ReadonlyArray<CrmEventDefinition>;
+interface CrmContext extends OperationContext {
+  organizationId?: string | mongoose1.Types.ObjectId;
+  actorId?: string | mongoose1.Types.ObjectId;
+  /** Mongo transaction session (passed through to mongokit). */
+  session?: unknown;
+}
+type _ModelTypes = Model<unknown>;
+//#endregion
+//#region src/events/helpers.d.ts
+declare function createEvent$1<T>(type: string, payload: T, ctx?: CrmContext, meta?: Partial<EventMeta>): DomainEvent<T>;
+//#endregion
+//#region src/events/in-process-bus.d.ts
+declare class InProcessCrmBus implements EventTransport {
+  readonly name = "in-process-crm";
+  private subs;
+  private logger?;
+  constructor(options?: {
+    logger?: CrmLogger;
+  });
+  publish(event: DomainEvent): Promise<void>;
+  subscribe(pattern: string, handler: EventHandler): Promise<() => void>;
+  close(): Promise<void>;
+}
 //#endregion
-export { ACTIVITY_STATUSES, ACTIVITY_TRANSITIONS, ACTIVITY_TYPES, type Account, AccountCreated, type AccountCreatedPayload, type AccountFilter, type AccountRepository, AccountService, type AccountServiceConfig, AccountUpdated, type AccountUpdatedPayload, type Activity, ActivityCancelled, type ActivityCancelledPayload, ActivityCompleted, type ActivityCompletedPayload, type ActivityFilter, ActivityPlanned, type ActivityPlannedPayload, type ActivityRepository, ActivityService, type ActivityServiceConfig, type ActivityStatus, type ActivityType, CRM_EVENTS, type Clock, type CloseInput, type Contact, ContactCreated, type ContactCreatedPayload, type ContactFilter, type ContactRepository, ContactService, type ContactServiceConfig, ContactUpdated, type ContactUpdatedPayload, type ConversionRow, type ConvertLeadInput, type ConvertResult, type CreateAccountInput, type CreateActivityInput, type CreateContactInput, type CreateLeadInput, type CreateNoteInput, type CreateOpportunityInput, type CreatePipelineInput, CrmError, type CrmEventDefinition, type CrmEventName, type CrmEventPayloadOf, type CrmEventSchema, DuplicateLeadError, EmptyPipelineError, type ForecastOptions, type ForecastRow, type IdGenerator, InMemoryAccountRepository, InMemoryActivityRepository, InMemoryContactRepository, InMemoryEventTransport, InMemoryLeadRepository, InMemoryLossReasonRepository, InMemoryNoteRepository, InMemoryOpportunityRepository, InMemoryOutreachPort, InMemoryPipelineRepository, InvalidActivityTransitionError, InvalidLeadTransitionError, InvalidOpportunityTransitionError, LEAD_STATUSES, LEAD_TRANSITIONS, type Lead, LeadAlreadyConvertedError, LeadConverted, type LeadConvertedPayload, LeadCreated, type LeadCreatedPayload, LeadDisqualified, type LeadDisqualifiedPayload, type LeadFilter, type LeadRepository, LeadScored, type LeadScoredPayload, type LeadScorer, LeadService, type LeadServiceConfig, type LeadStatus, LeadStatusChanged, type LeadStatusChangedPayload, type LeadStatusEntry, type LoseInput, type LossReason, type LossReasonRepository, type MoveStageInput, NotFoundError, type Note, NoteAdded, type NoteAddedPayload, type NoteRepository, NullOutreachPort, OPPORTUNITY_STATUSES, OPPORTUNITY_TRANSITIONS, type Opportunity, OpportunityAbandoned, type OpportunityAbandonedPayload, OpportunityCreated, type OpportunityCreatedPayload, type OpportunityFilter, OpportunityLost, type OpportunityLostPayload, type OpportunityRepository, OpportunityService, type OpportunityServiceConfig, OpportunityStageAdvanced, type OpportunityStageAdvancedPayload, OpportunityStageRegressed, type OpportunityStageRegressedPayload, type OpportunityStatus, type OpportunityStatusEntry, OpportunityWon, type OpportunityWonPayload, type OutreachPort, type OutreachSendRequest, type OutreachSendResult, type Pipeline, PipelineArchived, type PipelineArchivedPayload, PipelineCreated, type PipelineCreatedPayload, type PipelineRepository, PipelineService, type PipelineServiceConfig, type RecordedEvent, type RecordedOutreach, SUBJECT_KINDS, type Stage, StageNotInPipelineError, type SubjectKind, canTransitionActivity, canTransitionLead, canTransitionOpportunity, composeScorers, createSequentialIdGenerator, crmEventDefinitions, cryptoIdGenerator, defaultLeadScorer, forecast, pipelineConversion, systemClock };
-//# sourceMappingURL=index.d.ts.map
+export { IMessageAttachment as $, ContactUpdated as $n, CAMPAIGN_TRANSITIONS as $t, AccountRepository as A, SchemaBuildConfig as An, PipelineArchived as Ar, buildActivitySchema as At, OpportunityRepositoryDeps as B, ActivityOutcomeRecorded as Bn, ISubscriptionDocument as Bt, ActivityRepository as C, LEAD_TRANSITIONS as Cn, OpportunityAssigned as Cr, ILossReasonDocument as Ct, SubscriptionRepositoryDeps as D, IStageDocument as Dn, OpportunityStageAdvanced as Dr, buildNoteSchema as Dt, SubscriptionRepository as E, IPipelineDocument as En, OpportunityLost as Er, INoteDocument as Et, MergeContactInput as F, AccountEnriched as Fn, SubscriptionCreated as Fr, ActivityStatus as Ft, composeScorers as G, CampaignCompleted as Gn, SUBSCRIPTION_TRANSITIONS as Gt, LeadRepositoryDeps as H, ActivityRescheduled as Hn, buildSubscriptionSchema as Ht, CloseInput as I, AccountMerged as In, SubscriptionUnsubscribed as Ir, ActivityType as It, PipelineRepositoryDeps as J, CampaignResumed as Jn, ICampaignDocument as Jt, defaultLeadScorer as K, CampaignCreated as Kn, SubscriptionStatus as Kt, MoveStageInput as L, AccountUpdated as Ln, crmEventDefinitions as Lr, SUBJECT_KINDS as Lt, MergeAccountInput as M, tenantFieldDef as Mn, SubscriptionBounced as Mr, ACTIVITY_STATUSES as Mt, ContactRepository as N, AccountAssigned as Nn, SubscriptionComplained as Nr, ACTIVITY_TRANSITIONS as Nt, CampaignRepository as O, buildPipelineSchema as On, OpportunityStageRegressed as Or, createNoteModel as Ot, ContactRepositoryDeps as P, AccountCreated as Pn, SubscriptionConfirmed as Pr, ACTIVITY_TYPES as Pt, createCrmModels as Q, ContactMerged as Qn, CAMPAIGN_STATUSES as Qt, OpenOpportunityInput as R, ActivityCancelled as Rn, CRM_EVENTS as Rr, SubjectKind as Rt, NoteRepositoryDeps as S, LEAD_STATUSES as Sn, OpportunityAmountChanged as Sr, EmailEventKind as St, SubscribeInput as T, canTransitionLead as Tn, OpportunityExtended as Tr, createLossReasonModel as Tt, LeadInput as U, CampaignActivated as Un, createSubscriptionModel as Ut, LeadRepository as V, ActivityPlanned as Vn, ISubscriptionStatusEntry as Vt, LeadScorer as W, CampaignArchived as Wn, SUBSCRIPTION_STATUSES as Wt, CreateModelsOptions as X, ContactCreated as Xn, buildCampaignSchema as Xt, CRM_MODEL_NAMES as Y, ContactAssigned as Yn, ICampaignStatusEntry as Yt, CrmModels as Z, ContactEnriched as Zn, createCampaignModel as Zt, EmailEventRepositoryDeps as _, canTransitionOpportunity as _n, LeadStatusChanged as _r, EmailEventSubjectKind as _t, CrmEngine as a, IContactDocument as an, CrmEventSchema as ar, createConversationModel as at, LossReasonRepositoryDeps as b, buildLeadSchema as bn, NoteAdded as br, createEmailEventModel as bt, ResolvedCrmConfig as c, buildContactSchema as cn, EmailEventComplained as cr, CONVERSATION_STATUSES as ct, MessageRepositoryDeps as d, IOpportunityStatusEntry as dn, LeadAssigned as dr, ConversationStatus as dt, CampaignStatus as en, ConversationAssigned as er, IMessageDocument as et, RecordMessageInput as f, buildOpportunitySchema as fn, LeadConverted as fr, MESSAGE_DELIVERY_STATUSES as ft, EmailEventRepository as g, OpportunityStatus as gn, LeadScored as gr, EMAIL_EVENT_SUBJECT_KINDS as gt, OpenConversationInput as h, OPPORTUNITY_TRANSITIONS as hn, LeadEnriched as hr, MessageDirection as ht, CrmContext as i, createAccountModel as in, CrmEventDefinition as ir, buildConversationSchema as it, AccountRepositoryDeps as j, TenantFieldType as jn, PipelineCreated as jr, createActivityModel as jt, CampaignRepositoryDeps as k, createPipelineModel as kn, OpportunityWon as kr, IActivityDocument as kt, _ModelTypes as l, createContactModel as ln, EmailEventOpened as lr, ConversationChannel as lt, ConversationRepositoryDeps as m, OPPORTUNITY_STATUSES as mn, LeadDisqualified as mr, MessageDeliveryStatus as mt, createEvent$1 as n, IAccountDocument as nn, ConversationReopened as nr, createMessageModel as nt, CrmLogger as o, IContactInfoEmbedded as on, EmailEventBounced as or, CONVERSATION_CHANNELS as ot, ConversationRepository as p, createOpportunityModel as pn, LeadCreated as pr, MESSAGE_DIRECTIONS as pt, PipelineRepository as q, CampaignPaused as qn, canTransitionSubscription as qt, CrmConfig as r, buildAccountSchema as rn, ConversationResolved as rr, IConversationDocument as rt, CrmRepositories as s, IContactName as sn, EmailEventClicked as sr, CONVERSATION_PARTICIPANT_KINDS as st, InProcessCrmBus as t, canTransitionCampaign as tn, ConversationCreated as tr, buildMessageSchema as tt, MessageRepository as u, IOpportunityDocument as un, EmailEventUnsubscribed as ur, ConversationParticipantKind as ut, RecordEmailEventInput as v, ILeadDocument as vn, MessageReceived as vr, IEmailEventDocument as vt, ActivityRepositoryDeps as w, LeadStatus as wn, OpportunityCreated as wr, buildLossReasonSchema as wt, NoteRepository as x, createLeadModel as xn, OpportunityAbandoned as xr, EMAIL_EVENT_KINDS as xt, LossReasonRepository as y, ILeadStatusEntry as yn, MessageSent as yr, buildEmailEventSchema as yt, OpportunityRepository as z, ActivityCompleted as zn, CrmEventName as zr, canTransitionActivity as zt };