@classytic/crm 0.1.1 → 0.3.0

package/dist/index.d.ts

@@ -1,145 +1,305 @@
-import { DomainEvent, EventHandler, EventTransport } from "@classytic/primitives/events";
+import { t as __exportAll } from "./chunk.js";
+import * as mongoose0 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 * as _classytic_primitives_state_machine0 from "@classytic/primitives/state-machine";
 import { z } from "zod";
-import { OutboxStore } from "@classytic/primitives/outbox";
-import { ContactInfo, PersonName } from "@classytic/primitives/person";
-import { Money } from "@classytic/primitives/money";
+import { StatusChangeEntry, StatusHistory, appendStatus, lastTransitionTo, latestEntry, timeInStatus } from "@classytic/primitives/status-history";
+import { OperationContext } from "@classytic/primitives/context";
 
-//#region src/domain/entities/account.d.ts
+//#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;
+}
 /**
- * An account (company / organization). Contacts, Opportunities, and
- * Activities can reference it.
+ * Tenant-column schema definition. Use this anywhere a model has
+ * `organizationId` — never write the raw type in a schema file.
  */
-interface Account {
-  id: string;
+declare function tenantFieldDef(config: SchemaBuildConfig): SchemaDefinitionProperty;
+//#endregion
+//#region src/models/pipeline.schema.d.ts
+/** Mongoose document shape for a single embedded stage. */
+interface IStageDocument {
+  _id: mongoose0.Types.ObjectId;
   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[];
+  /** 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;
+}
+/** Mongoose document shape for a Pipeline. */
+interface IPipelineDocument {
+  _id: mongoose0.Types.ObjectId;
+  organizationId: mongoose0.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/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/enums/lead-status.d.ts
+/**
+ * Lead lifecycle — from initial inquiry through conversion.
+ *
+ *   new          — just captured (web form, import, referral)
+ *   contacted    — SDR has reached out
+ *   qualified    — meets ICP / BANT
+ *   converted    — turned into Contact + Account + Opportunity
+ *   disqualified — rejected (bad fit, spam, duplicate)
+ *   nurturing    — not ready now; parked for later outreach
+ */
+declare const LEAD_STATUSES: readonly ["new", "contacted", "qualified", "converted", "disqualified", "nurturing"];
+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/ports/clock.port.d.ts
-interface Clock {
-  now(): Date;
+//#region src/models/lead.schema.d.ts
+interface ILeadStatusEntry {
+  status: LeadStatus;
+  occurredAt: Date;
+  by?: string;
+  note?: string;
 }
-declare const systemClock: Clock;
-//#endregion
-//#region src/domain/ports/id-generator.port.d.ts
-interface IdGenerator {
-  next(): string;
+interface ILeadDocument {
+  _id: mongoose0.Types.ObjectId;
+  organizationId: mongoose0.Types.ObjectId | string;
+  fullName: string;
+  firstName?: string;
+  lastName?: string;
+  email?: string;
+  phone?: string;
+  companyName?: string;
+  jobTitle?: string;
+  source?: string;
+  campaignRef?: string;
+  score: number;
+  status: LeadStatus;
+  statusHistory: ILeadStatusEntry[];
+  ownerId?: string;
+  tags: string[];
+  convertedContactId?: mongoose0.Types.ObjectId | string;
+  convertedAccountId?: mongoose0.Types.ObjectId | string;
+  convertedOpportunityId?: mongoose0.Types.ObjectId | string;
+  convertedAt?: Date;
+  disqualifyReason?: string;
+  metadata?: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
 }
+declare function buildLeadSchema(config: SchemaBuildConfig): Schema<ILeadDocument>;
+declare function createLeadModel(connection: Connection, config: SchemaBuildConfig): Model<ILeadDocument>;
 //#endregion
-//#region src/services/mutation-options.d.ts
+//#region src/enums/opportunity-status.d.ts
 /**
- * Options passed to every service mutation. All fields optional — hosts
- * opt into the behaviours they need.
+ * Top-level opportunity status. Movement through pipeline STAGES
+ * happens while status is `open`; `won` / `lost` are terminal
+ * outcomes. Re-opening a lost deal is a host-level decision —
+ * convention is to clone the opportunity rather than revive the
+ * terminal record.
  */
-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 const OPPORTUNITY_STATUSES: readonly ["open", "won", "lost", "abandoned"];
+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/models/opportunity.schema.d.ts
+interface IOpportunityStatusEntry {
+  status: OpportunityStatus;
+  stageId?: string;
+  occurredAt: Date;
+  by?: string;
+  note?: string;
 }
+interface IOpportunityDocument {
+  _id: mongoose0.Types.ObjectId;
+  organizationId: mongoose0.Types.ObjectId | string;
+  name: string;
+  accountId?: mongoose0.Types.ObjectId | string;
+  primaryContactId?: mongoose0.Types.ObjectId | string;
+  pipelineId: mongoose0.Types.ObjectId | string;
+  stageId: string;
+  status: OpportunityStatus;
+  statusHistory: IOpportunityStatusEntry[];
+  amount?: number;
+  currency: string;
+  probability: number;
+  expectedCloseAt?: Date;
+  closedAt?: Date;
+  lostReasonId?: mongoose0.Types.ObjectId | string;
+  ownerId?: string;
+  sourceLeadId?: mongoose0.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/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;
+//#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;
+}
+interface IContactDocument {
+  _id: mongoose0.Types.ObjectId;
+  organizationId: mongoose0.Types.ObjectId | string;
+  name: IContactName;
+  contact: IContactInfoEmbedded;
+  jobTitle?: string;
+  accountId?: mongoose0.Types.ObjectId | string;
+  ownerId?: string;
+  tags: string[];
+  metadata?: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
 }
-interface CreateAccountInput {
+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: mongoose0.Types.ObjectId;
+  organizationId: mongoose0.Types.ObjectId | string;
   name: string;
   domain?: string;
   industry?: string;
   sizeBucket?: string;
-  annualRevenue?: {
-    amount: number;
-    currency: string;
-  };
+  annualRevenueAmount?: number;
+  annualRevenueCurrency: string;
   ownerId?: string;
-  tags?: readonly string[];
+  tags: string[];
   metadata?: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
 }
-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;
+declare function buildAccountSchema(config: SchemaBuildConfig): Schema<IAccountDocument>;
+declare function createAccountModel(connection: Connection, config: SchemaBuildConfig): Model<IAccountDocument>;
+//#endregion
+//#region src/enums/campaign-status.d.ts
+/**
+ * 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
+ */
+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: mongoose0.Types.ObjectId;
+  organizationId: mongoose0.Types.ObjectId | string;
+  name: 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;
+  tags: string[];
+  metadata?: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
+}
+declare function buildCampaignSchema(config: SchemaBuildConfig): Schema<ICampaignDocument>;
+declare function createCampaignModel(connection: Connection, config: SchemaBuildConfig): Model<ICampaignDocument>;
 //#endregion
-//#region src/domain/enums/activity.d.ts
+//#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;
+}
+interface ISubscriptionDocument {
+  _id: mongoose0.Types.ObjectId;
+  organizationId: mongoose0.Types.ObjectId | string;
+  contactId: mongoose0.Types.ObjectId | string;
+  campaignId: mongoose0.Types.ObjectId | string;
+  status: SubscriptionStatus;
+  statusHistory: ISubscriptionStatusEntry[];
+  source?: string;
+  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/enums/activity.d.ts
 /**
  * Activity type vocabulary. The package stores `type` as free-form
  * string so hosts can extend; these constants cover the common
@@ -159,414 +319,218 @@ declare function canTransitionActivity(from: ActivityStatus, to: ActivityStatus)
 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;
+//#region src/models/activity.schema.d.ts
+interface IActivityDocument {
+  _id: mongoose0.Types.ObjectId;
+  organizationId: mongoose0.Types.ObjectId | string;
+  type: ActivityType;
   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). */
+  subjectId: mongoose0.Types.ObjectId | string;
+  title: string;
+  description?: string;
   ownerId?: string;
-  participantIds?: readonly string[];
-  /**
-   * Optional external ref — e.g. Calendar event id, email thread id,
-   * call-recording url. Host-owned semantics.
-   */
+  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/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;
+//#region src/models/note.schema.d.ts
+interface INoteDocument {
+  _id: mongoose0.Types.ObjectId;
+  organizationId: mongoose0.Types.ObjectId | string;
   subjectKind: SubjectKind;
-  subjectId: string;
+  subjectId: mongoose0.Types.ObjectId | string;
   body: string;
   authorId?: string;
-  /** Supports @-mentions, Markdown, etc. — host-interpreted. */
-  format?: 'plain' | 'markdown';
+  pinned: boolean;
   metadata?: Record<string, unknown>;
   createdAt: Date;
   updatedAt: Date;
 }
+declare function buildNoteSchema(config: SchemaBuildConfig): Schema<INoteDocument>;
+declare function createNoteModel(connection: Connection, config: SchemaBuildConfig): Model<INoteDocument>;
 //#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';
+//#region src/models/loss-reason.schema.d.ts
+interface ILossReasonDocument {
+  _id: mongoose0.Types.ObjectId;
+  organizationId: mongoose0.Types.ObjectId | string;
+  name: string;
+  description?: string;
+  isActive: boolean;
+  /** Display ordering in admin UIs. */
+  sequence: number;
   metadata?: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
 }
-/**
- * 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;
-}
+declare function buildLossReasonSchema(config: SchemaBuildConfig): Schema<ILossReasonDocument>;
+declare function createLossReasonModel(connection: Connection, config: SchemaBuildConfig): Model<ILossReasonDocument>;
 //#endregion
-//#region src/domain/entities/contact.d.ts
+//#region src/enums/email-event-kind.d.ts
 /**
- * A person — the atom of a CRM. Contacts may belong to an Account,
- * but can also exist stand-alone (independent consultants, consumers).
+ * 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.
  *
- * 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.
+ *   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.
  */
-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.). */
+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: mongoose0.Types.ObjectId;
+  organizationId: mongoose0.Types.ObjectId | string;
+  kind: EmailEventKind;
+  subjectKind: EmailEventSubjectKind;
+  subjectId: mongoose0.Types.ObjectId | string;
+  campaignId?: mongoose0.Types.ObjectId | string;
+  messageId?: string;
+  url?: string;
+  userAgent?: string;
+  ip?: string;
   metadata?: Record<string, unknown>;
   createdAt: Date;
-  updatedAt: Date;
 }
+declare function buildEmailEventSchema(config: SchemaBuildConfig): Schema<IEmailEventDocument>;
+declare function createEmailEventModel(connection: Connection, config: SchemaBuildConfig): Model<IEmailEventDocument>;
 //#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>;
-}
+//#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>;
+}
+declare function createCrmModels(connection: Connection, config: SchemaBuildConfig): CrmModels;
 //#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>;
+//#region src/repositories/pipeline.repository.d.ts
+interface PipelineRepositoryDeps {
+  events: EventTransport;
 }
-declare class ContactService {
-  private readonly repo;
+declare class PipelineRepository extends Repository<IPipelineDocument> {
   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;
+  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/domain/enums/lead-status.d.ts
+//#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;
 /**
- * Lead lifecycle — from initial inquiry through conversion.
+ * Reference implementation. Intentionally simple — hosts read it and
+ * replace it.
  *
- *   new          — just captured (web form, import, referral)
- *   contacted    — SDR has reached out
- *   qualified    — meets ICP / BANT
- *   converted    — turned into Contact + Account + Opportunity
- *   disqualified — rejected (bad fit, spam, duplicate)
- *   nurturing    — not ready now; parked for later outreach
+ * +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 hints senior (director / manager / head / chief / vp / founder)
  */
-declare const LEAD_STATUSES: readonly ["new", "contacted", "qualified", "converted", "disqualified", "nurturing"];
-type LeadStatus = (typeof LEAD_STATUSES)[number];
-declare const LEAD_TRANSITIONS: Record<LeadStatus, readonly LeadStatus[]>;
-declare function canTransitionLead(from: LeadStatus, to: LeadStatus): boolean;
+declare function defaultLeadScorer(lead: LeadInput): number;
+/** Compose multiple small rules into one scorer. */
+declare function composeScorers(...rules: readonly LeadScorer[]): LeadScorer;
 //#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. */
-  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;
-  status: LeadStatus;
-  statusHistory: readonly LeadStatusEntry[];
-  ownerId?: string;
-  tags?: readonly string[];
-  /** On successful `convert`, links to the resulting records. */
-  convertedContactId?: string;
-  convertedAccountId?: string;
-  convertedOpportunityId?: string;
-  convertedAt?: Date;
-  /** Disqualification detail. */
-  disqualifyReason?: string;
-  metadata?: Record<string, unknown>;
-  createdAt: Date;
-  updatedAt: Date;
+//#region src/repositories/lead.repository.d.ts
+interface LeadRepositoryDeps {
+  events: EventTransport;
+  /** Override the default lead scorer. */
+  scorer?: LeadScorer;
+  /** Reject `create()` when an email already exists in-tenant (default true). */
+  rejectDuplicates?: boolean;
 }
-interface LeadStatusEntry {
-  status: LeadStatus;
-  occurredAt: Date;
+type TransitionExtras = {
   by?: string;
   note?: string;
-}
-//#endregion
-//#region src/domain/enums/opportunity-status.d.ts
-/**
- * Top-level opportunity status. Movement through pipeline STAGES
- * happens while status is `open`; `won` / `lost` are terminal
- * outcomes. Re-opening a lost deal is a host-level decision —
- * convention is to clone the opportunity rather than revive the
- * terminal record.
- */
-declare const OPPORTUNITY_STATUSES: readonly ["open", "won", "lost", "abandoned"];
-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
-/**
- * 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.
- */
-interface Opportunity {
-  id: 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;
+  patch?: Partial<ILeadDocument>;
+};
+declare class LeadRepository extends Repository<ILeadDocument> {
+  private readonly events;
+  private readonly scorer;
+  private readonly rejectDuplicates;
+  constructor(model: Model<ILeadDocument>, plugins: PluginType[], deps: LeadRepositoryDeps, pagination?: PaginationConfig);
   /**
-   * Win probability (0-1). Defaults to the stage's probability at
-   * every stage move; host can override for hand-tuned forecasts.
+   * 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.
    */
-  probability: number;
-  /** When the deal is expected to close. Drives forecast grouping. */
-  expectedCloseAt?: Date;
-  /** Populated on win/lose. */
-  closedAt?: Date;
-  lostReasonId?: string;
-  ownerId?: string;
-  sourceLeadId?: string;
-  tags?: readonly string[];
-  metadata?: Record<string, unknown>;
-  createdAt: Date;
-  updatedAt: Date;
-}
-interface OpportunityStatusEntry {
-  status: OpportunityStatus;
-  stageId?: string;
-  occurredAt: Date;
-  by?: string;
-  note?: string;
-}
-//#endregion
-//#region src/domain/ports/lead-repository.port.d.ts
-interface LeadFilter {
-  status?: LeadStatus | readonly LeadStatus[];
-  ownerId?: string;
-  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>;
-}
-//#endregion
-//#region src/domain/ports/opportunity-repository.port.d.ts
-interface OpportunityFilter {
-  status?: OpportunityStatus | readonly OpportunityStatus[];
-  pipelineId?: string;
-  stageId?: 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>;
+  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>;
+  /**
+   * 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;
 }
 //#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/repositories/opportunity.repository.d.ts
+interface OpportunityRepositoryDeps {
+  events: EventTransport;
+  /** Cross-repo reference: read embedded stages from Pipeline. */
+  pipelines: PipelineRepository;
 }
-interface CreateOpportunityInput {
+interface OpenOpportunityInput {
   name: string;
   pipelineId: string;
-  /** Starting stage — defaults to the pipeline's first stage. */
+  /** When omitted, opp enters 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`. */
+  amount?: number;
+  currency?: string;
+  /** Override the stage's `defaultProbability`. */
   probability?: number;
   expectedCloseAt?: Date;
   ownerId?: string;
@@ -575,493 +539,408 @@ interface CreateOpportunityInput {
 }
 interface MoveStageInput {
   stageId: string;
-  /** Override probability. Defaults to the target stage's `defaultProbability`. */
-  probability?: number;
   by?: string;
   note?: string;
+  /** Override the target stage's `defaultProbability`. */
+  probability?: number;
 }
 interface CloseInput {
-  amount?: Money;
-  closedAt?: Date;
   by?: string;
   note?: string;
-}
-interface LoseInput extends CloseInput {
+  closedAt?: Date;
+  amount?: number;
   lostReasonId?: string;
 }
-/**
- * Opportunity lifecycle — stage movement + outcome resolution. Stage
- * changes call the pipeline service to validate membership + default
- * probability; status transitions (`won` / `lost` / `abandoned`) are
- * terminal.
- */
-declare class OpportunityService {
-  private readonly repo;
+declare class OpportunityRepository extends Repository<IOpportunityDocument> {
+  private readonly events;
   private readonly pipelines;
+  constructor(model: Model<IOpportunityDocument>, plugins: PluginType[], deps: OpportunityRepositoryDeps, pagination?: PaginationConfig);
+  openOpportunity(input: OpenOpportunityInput, ctx?: CrmContext): Promise<IOpportunityDocument>;
+  /**
+   * 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.
+   */
+  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>;
+  abandon(id: string, by?: string, note?: string, ctx?: CrmContext): Promise<IOpportunityDocument>;
+  private _closeStatus;
+}
+//#endregion
+//#region src/repositories/contact.repository.d.ts
+interface ContactRepositoryDeps {
+  events: EventTransport;
+}
+declare class ContactRepository extends Repository<IContactDocument> {
   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;
+  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>;
 }
 //#endregion
-//#region src/services/scoring.d.ts
-/**
- * Pluggable lead scorer. Hosts inject whatever rubric they need —
- * firmographic model, in-app signals, ML prediction, external enrichment.
- *
- * 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.
- */
-type LeadScorer = (lead: Lead) => number;
-/**
- * Reference implementation. Intentionally simple so hosts read it and
- * understand the shape, then 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),
- * );
- * ```
- */
-declare function composeScorers(...rules: readonly LeadScorer[]): LeadScorer;
+//#region src/repositories/account.repository.d.ts
+interface AccountRepositoryDeps {
+  events: EventTransport;
+}
+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>;
+}
 //#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`). */
-  scorer?: LeadScorer;
-  /** When true (default), `create()` rejects dup emails. */
+//#region src/repositories/campaign.repository.d.ts
+interface CampaignRepositoryDeps {
+  events: EventTransport;
+  /** Reject `createCampaign` on duplicate names per-tenant (default true). */
   rejectDuplicates?: boolean;
 }
-interface CreateLeadInput {
-  firstName?: string;
-  lastName?: string;
-  fullName?: string;
-  email?: string;
-  phone?: string;
-  companyName?: string;
-  jobTitle?: string;
+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/repositories/subscription.repository.d.ts
+interface SubscriptionRepositoryDeps {
+  events: EventTransport;
+  /** Default DOI policy when `subscribe` doesn't pass `requireDoubleOptIn`. */
+  defaultRequireDoubleOptIn?: boolean;
+}
+interface SubscribeInput {
+  contactId: string;
+  campaignId: string;
   source?: string;
-  campaignRef?: string;
-  ownerId?: string;
-  tags?: readonly string[];
+  consentIpAddress?: string;
+  consentUserAgent?: string;
   metadata?: Record<string, unknown>;
+  /** Override the engine-level default. */
+  requireDoubleOptIn?: boolean;
 }
-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;
-  by?: string;
+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;
 }
-interface ConvertResult {
-  lead: Lead;
-  contactId: string;
-  accountId?: string;
-  opportunityId: string;
+//#endregion
+//#region src/repositories/activity.repository.d.ts
+interface ActivityRepositoryDeps {
+  events: EventTransport;
 }
-/**
- * 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;
+declare class ActivityRepository extends Repository<IActivityDocument> {
   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<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>;
   private _transition;
-  private _emit;
 }
 //#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/note.repository.d.ts
+interface NoteRepositoryDeps {
+  events: EventTransport;
+}
+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/repositories/loss-reason.repository.d.ts
+interface LossReasonRepositoryDeps {
+  events: EventTransport;
 }
-/**
- * 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;
-  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;
-  metadata?: Record<string, unknown>;
-  createdAt: Date;
-  updatedAt: Date;
+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/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>;
+//#region src/repositories/email-event.repository.d.ts
+interface EmailEventRepositoryDeps {
+  events: EventTransport;
 }
-//#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;
+interface RecordEmailEventInput {
+  subjectKind: EmailEventSubjectKind;
+  subjectId: string;
+  campaignId?: string;
+  messageId?: string;
+  url?: string;
+  userAgent?: string;
+  ip?: string;
   metadata?: Record<string, unknown>;
 }
-/**
- * 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 EmailEventRepository extends Repository<IEmailEventDocument> {
   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;
+  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;
 }
 //#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 {
+//#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;
   /**
-   * 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.
+   * 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).
    */
-  bucket?: (o: Opportunity) => string;
+  tenantFieldType?: TenantFieldType;
   /**
-   * Filter opportunities before bucketing. Default includes only
-   * `open` opportunities with `amount` and `expectedCloseAt`.
+   * When `true` (default), wire `multiTenantPlugin` on every repository
+   * with `required: true`. Set `false` only for fixtures / smoke tests
+   * that intentionally drop the scope.
    */
-  include?: (o: Opportunity) => boolean;
+  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[];
+}
+interface ResolvedCrmConfig extends SchemaBuildConfig {
+  connection: Connection;
+  tenantFieldType: TenantFieldType;
+  multiTenant: 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;
+}
+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>;
+  /** Release resources. Safe to call multiple times. */
+  dispose(): Promise<void>;
 }
 /**
- * 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.
+ * 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.
  */
-interface ConversionRow {
-  stageId: string;
-  currentCount: number;
-  wonFromHere: number;
-  lostFromHere: number;
-  conversionRate: number;
+interface CrmContext extends OperationContext {
+  organizationId?: string | mongoose0.Types.ObjectId;
+  actorId?: string | mongoose0.Types.ObjectId;
+  /** Mongo transaction session (passed through to mongokit). */
+  session?: unknown;
 }
-declare function pipelineConversion(opportunities: readonly Opportunity[], stageIds: readonly string[]): ConversionRow[];
+type _ModelTypes = Model<unknown>;
 //#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/engine/create-crm.d.ts
+declare function createCrm(config: CrmConfig): Promise<CrmEngine>;
 //#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>;
+//#region src/repositories/create-repositories.d.ts
+interface CreateCrmRepositoriesDeps {
+  events: EventTransport;
+  config: ResolvedCrmConfig;
 }
+declare function createCrmRepositories(models: CrmModels, deps: CreateCrmRepositoriesDeps): CrmRepositories;
 //#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/services/lead.service.d.ts
+interface ConvertLeadInput {
+  pipelineId: string;
+  /** Defaults to `<companyName> — <source>` / `<fullName> — New`. */
+  opportunityName?: string;
+  /** Stored flat on the opportunity (`amount` + `currency`). */
+  amount?: number;
+  currency?: string;
+  expectedCloseAt?: Date;
+  by?: string;
 }
-interface OutreachSendResult {
-  /** Opaque ref — typically the provider's message id. */
-  providerMessageId?: string;
-  acceptedAt: Date;
+interface ConvertResult {
+  lead: ILeadDocument;
+  contact: IContactDocument;
+  account?: IAccountDocument;
+  opportunity: IOpportunityDocument;
+  /** @deprecated use contact._id */
+  contactId: string;
+  /** @deprecated use account._id */
+  accountId?: string;
+  /** @deprecated use opportunity._id */
+  opportunityId: string;
 }
-interface OutreachPort {
-  send(request: OutreachSendRequest): Promise<OutreachSendResult>;
+interface LeadServiceDeps {
+  lead: LeadRepository;
+  contact: ContactRepository;
+  account: AccountRepository;
+  opportunity: OpportunityRepository;
+  events: EventTransport;
 }
-//#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>;
+declare class LeadService {
+  private readonly leads;
+  private readonly contacts;
+  private readonly accounts;
+  private readonly opportunities;
+  private readonly events;
+  constructor(deps: LeadServiceDeps);
+  /**
+   * Construct from an already-built CrmEngine — the host's preferred path.
+   * Avoids manually wiring four repositories.
+   */
+  static fromEngine(engine: CrmEngine): LeadService;
+  /**
+   * Convert a Lead into Account + Contact + Opportunity, then transition
+   * the lead. Wrap the call in `connection.transaction()` and pass the
+   * session via `ctx.session` for atomicity — all four writes commit or
+   * roll back together.
+   *
+   * Best-effort compensation: if a downstream write fails, already-
+   * created docs are deleted in reverse order. The reverse delete may
+   * itself fail (e.g. transient DB issues) — when transactions are
+   * active, prefer that path; compensation is the no-transaction
+   * fallback.
+   */
+  convert(leadId: string, input: ConvertLeadInput, ctx?: CrmContext): Promise<ConvertResult>;
+  /**
+   * The state-machine hop from whichever status the lead is in to
+   * `converted`. We do this directly (instead of calling
+   * `LeadRepository.qualify` first then a hypothetical `complete`)
+   * because the conversion is "this lead is done" regardless of where
+   * it started — bypassing the `qualified` waypoint is intentional when
+   * a Lead is converted directly from `new` (importers, webhooks).
+   */
+  private _markConverted;
 }
 //#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>;
-}
+//#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";
+};
+type CrmEventName = (typeof CRM_EVENTS)[keyof typeof CRM_EVENTS];
 //#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/events/helpers.d.ts
+declare function createEvent<T>(type: string, payload: T, ctx?: CrmContext, meta?: Partial<EventMeta>): DomainEvent<T>;
 //#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;
+//#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
-//#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>;
-}
-//#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>;
-}
-//#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>;
-}
-//#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>;
-}
-//#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>;
-}
-//#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>;
-}
-//#endregion
-//#region src/adapters/in-memory/id-generator.d.ts
-declare const cryptoIdGenerator: IdGenerator;
-declare function createSequentialIdGenerator(prefix?: string): IdGenerator;
+//#region src/core/state-machines.d.ts
+/**
+ * Declarative state machines for every CRM aggregate that has lifecycle
+ * transitions. Single source of truth for what `from -> to` moves are
+ * legal — the repositories' domain verbs (`qualify`, `convert`, `win`,
+ * `lose`, `confirm`, `unsubscribe`, ...) call `assertTransition` before
+ * they touch Mongo.
+ *
+ * Per PACKAGE_RULES §30: "State machines map to Arc Actions". The host
+ * exposes each domain verb as an arc Action (`POST /:id/action` with
+ * `{ action: 'qualify' }`); the verb's implementation lives on the
+ * Repository class and uses these machines internally.
+ *
+ * Built on `@classytic/primitives/state-machine` so the same shape lights
+ * up across kits (mongokit's `claim()` pairing, sqlitekit follow-ups).
+ */
+declare const LEAD_MACHINE: _classytic_primitives_state_machine0.StateMachine<"new" | "contacted" | "qualified" | "converted" | "disqualified" | "nurturing">;
+declare const OPPORTUNITY_MACHINE: _classytic_primitives_state_machine0.StateMachine<"open" | "won" | "lost" | "abandoned">;
+declare const CAMPAIGN_MACHINE: _classytic_primitives_state_machine0.StateMachine<"draft" | "active" | "paused" | "completed" | "archived">;
+declare const SUBSCRIPTION_MACHINE: _classytic_primitives_state_machine0.StateMachine<"pending" | "confirmed" | "unsubscribed" | "bounced" | "complained">;
+declare const ACTIVITY_MACHINE: _classytic_primitives_state_machine0.StateMachine<"completed" | "planned" | "in_progress" | "cancelled">;
 //#endregion
-//#region src/domain/errors.d.ts
+//#region src/core/errors.d.ts
 /**
  * CRM error vocabulary. Hosts catch `CrmError` at API edges.
  */
@@ -1112,309 +991,585 @@ declare class DuplicateLeadError extends CrmError {
 declare class EmptyPipelineError extends CrmError {
   constructor(pipelineId: string);
 }
+declare class InvalidCampaignTransitionError extends CrmError {
+  constructor(details: {
+    from: string;
+    to: string;
+    campaignId: string;
+  });
+}
+declare class DuplicateCampaignError extends CrmError {
+  constructor(name: string);
+}
+declare class InvalidSubscriptionTransitionError extends CrmError {
+  constructor(details: {
+    from: string;
+    to: string;
+    subscriptionId: string;
+  });
+}
+declare class DuplicateSubscriptionError extends CrmError {
+  constructor(details: {
+    contactId: string;
+    campaignId: string;
+  });
+}
+declare class InvalidConfirmationTokenError extends CrmError {
+  constructor();
+}
+declare class InvalidUnsubscribeTokenError extends CrmError {
+  constructor();
+}
 //#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];
+//#region src/shared/calculators/forecast.d.ts
+type OpportunityForecast = Pick<IOpportunityDocument, 'amount' | 'currency' | 'probability' | 'status' | 'expectedCloseAt' | 'stageId' | 'statusHistory'>;
+interface ForecastRow {
+  /** Bucket key — ISO month `YYYY-MM` by default. */
+  bucket: string;
+  /** Σ amount. */
+  committed: number;
+  /** Σ amount × probability. */
+  weighted: number;
+  /** Number of opportunities in the bucket. */
+  count: number;
+  currency: string;
+}
+interface ForecastOptions {
+  /** Bucket function. Default: ISO month from `expectedCloseAt`. */
+  bucket?: (o: OpportunityForecast) => string;
+  /** Filter before bucketing. Default: open + has amount + has expectedCloseAt. */
+  include?: (o: OpportunityForecast) => boolean;
+}
+/**
+ * Aggregate opportunities into a forecast table — one row per bucket.
+ * Currency mismatch within a bucket throws — partition by currency
+ * upstream when multi-currency.
+ */
+declare function forecast(opportunities: readonly OpportunityForecast[], options?: ForecastOptions): ForecastRow[];
+interface ConversionRow {
+  stageId: string;
+  currentCount: number;
+  wonFromHere: number;
+  lostFromHere: number;
+  conversionRate: number;
+}
+/**
+ * "Where do deals die?" summary — opportunities partitioned across
+ * stages with current count + won/lost-from-here.
+ */
+declare function pipelineConversion(opportunities: readonly OpportunityForecast[], stageIds: readonly string[]): ConversionRow[];
 //#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;
-}
-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>;
+//#region src/validators/common.d.ts
+declare const objectIdLike: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+declare const metadataSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+declare const tagsSchema: z.ZodOptional<z.ZodArray<z.ZodString>>;
+declare const moneyAmountSchema: z.ZodNumber;
+declare const currencyCodeSchema: z.ZodString;
+//#endregion
+//#region src/validators/pipeline.schema.d.ts
+declare const stageInputSchema: z.ZodObject<{
+  name: z.ZodString;
+  sequence: z.ZodNumber;
+  defaultProbability: z.ZodNumber;
+  color: z.ZodOptional<z.ZodString>;
+  description: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-declare const leadStatusChangedSchema: z.ZodObject<{
-  leadId: z.ZodString;
-  from: z.ZodString;
-  to: z.ZodString;
+declare const createPipelineSchema: z.ZodObject<{
+  name: z.ZodString;
+  stages: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    sequence: z.ZodNumber;
+    defaultProbability: z.ZodNumber;
+    color: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>>;
+  teamRef: z.ZodOptional<z.ZodString>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>;
-declare const leadScoredSchema: z.ZodObject<{
-  leadId: z.ZodString;
-  score: z.ZodNumber;
+declare const updatePipelineSchema: z.ZodObject<{
+  name: z.ZodOptional<z.ZodString>;
+  stages: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    sequence: z.ZodNumber;
+    defaultProbability: z.ZodNumber;
+    color: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>>>;
+  teamRef: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+  metadata: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
 }, z.core.$strip>;
-declare const leadConvertedSchema: z.ZodObject<{
-  leadId: z.ZodString;
-  contactId: z.ZodString;
-  accountId: z.ZodOptional<z.ZodString>;
-  opportunityId: z.ZodString;
+declare const stageInputSchemaExport: z.ZodObject<{
+  name: z.ZodString;
+  sequence: z.ZodNumber;
+  defaultProbability: z.ZodNumber;
+  color: z.ZodOptional<z.ZodString>;
+  description: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-declare const leadDisqualifiedSchema: z.ZodObject<{
-  leadId: z.ZodString;
-  reason: z.ZodString;
+declare const pipelineFilterSchema: z.ZodObject<{
+  isArchived: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;
+  teamRef: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-declare const accountCreatedSchema: z.ZodObject<{
-  accountId: z.ZodString;
+type CreatePipelineDto = z.infer<typeof createPipelineSchema>;
+type UpdatePipelineDto = z.infer<typeof updatePipelineSchema>;
+type StageInputDto = z.infer<typeof stageInputSchema>;
+//#endregion
+//#region src/validators/lead.schema.d.ts
+declare const createLeadSchema: z.ZodObject<{
+  fullName: z.ZodOptional<z.ZodString>;
+  firstName: z.ZodOptional<z.ZodString>;
+  lastName: z.ZodOptional<z.ZodString>;
+  email: z.ZodOptional<z.ZodString>;
+  phone: z.ZodOptional<z.ZodString>;
+  companyName: z.ZodOptional<z.ZodString>;
+  jobTitle: z.ZodOptional<z.ZodString>;
+  source: z.ZodOptional<z.ZodString>;
+  campaignRef: z.ZodOptional<z.ZodString>;
+  ownerId: z.ZodOptional<z.ZodString>;
+  tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>;
-declare const accountUpdatedSchema: z.ZodObject<{
-  accountId: z.ZodString;
+declare const updateLeadSchema: z.ZodObject<{
+  fullName: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+  firstName: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+  lastName: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+  email: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+  phone: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+  companyName: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+  jobTitle: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+  source: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+  campaignRef: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+  ownerId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+  tags: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+  metadata: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
 }, z.core.$strip>;
-declare const contactCreatedSchema: z.ZodObject<{
-  contactId: z.ZodString;
+declare const leadFilterSchema: z.ZodObject<{
+  status: z.ZodOptional<z.ZodEnum<{
+    new: "new";
+    contacted: "contacted";
+    qualified: "qualified";
+    converted: "converted";
+    disqualified: "disqualified";
+    nurturing: "nurturing";
+  }>>;
+  ownerId: z.ZodOptional<z.ZodString>;
   email: z.ZodOptional<z.ZodString>;
+  tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  source: z.ZodOptional<z.ZodString>;
+  campaignRef: z.ZodOptional<z.ZodString>;
+  scoreMin: z.ZodOptional<z.ZodNumber>;
+  scoreMax: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
-declare const contactUpdatedSchema: z.ZodObject<{
-  contactId: z.ZodString;
+declare const convertLeadSchema: z.ZodObject<{
+  pipelineId: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+  opportunityName: z.ZodOptional<z.ZodString>;
+  amount: z.ZodOptional<z.ZodNumber>;
+  currency: z.ZodOptional<z.ZodString>;
+  expectedCloseAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+  by: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-declare const opportunityCreatedSchema: z.ZodObject<{
-  opportunityId: z.ZodString;
-  pipelineId: z.ZodString;
+type CreateLeadDto = z.infer<typeof createLeadSchema>;
+type UpdateLeadDto = z.infer<typeof updateLeadSchema>;
+type ConvertLeadDto = z.infer<typeof convertLeadSchema>;
+type LeadFilterDto = z.infer<typeof leadFilterSchema>;
+//#endregion
+//#region src/validators/opportunity.schema.d.ts
+declare const openOpportunitySchema: z.ZodObject<{
+  name: z.ZodString;
+  pipelineId: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+  stageId: z.ZodOptional<z.ZodString>;
+  accountId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+  primaryContactId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+  sourceLeadId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+  amount: z.ZodOptional<z.ZodNumber>;
+  currency: z.ZodOptional<z.ZodString>;
+  probability: z.ZodOptional<z.ZodNumber>;
+  expectedCloseAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+  ownerId: z.ZodOptional<z.ZodString>;
+  tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+declare const moveStageSchema: z.ZodObject<{
   stageId: z.ZodString;
+  by: z.ZodOptional<z.ZodString>;
+  note: z.ZodOptional<z.ZodString>;
+  probability: z.ZodOptional<z.ZodNumber>;
 }, 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>;
+declare const closeWinSchema: z.ZodObject<{
+  by: z.ZodOptional<z.ZodString>;
+  note: z.ZodOptional<z.ZodString>;
+  closedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+  amount: z.ZodOptional<z.ZodNumber>;
 }, 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;
+declare const closeLossSchema: z.ZodObject<{
+  by: z.ZodOptional<z.ZodString>;
+  note: z.ZodOptional<z.ZodString>;
+  closedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+  lostReasonId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+}, z.core.$strip>;
+declare const opportunityFilterSchema: z.ZodObject<{
+  status: z.ZodOptional<z.ZodEnum<{
+    open: "open";
+    won: "won";
+    lost: "lost";
+    abandoned: "abandoned";
+  }>>;
+  pipelineId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+  stageId: z.ZodOptional<z.ZodString>;
+  ownerId: z.ZodOptional<z.ZodString>;
+  accountId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+  expectedCloseFrom: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+  expectedCloseTo: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+}, z.core.$strip>;
+type OpenOpportunityDto = z.infer<typeof openOpportunitySchema>;
+type MoveStageDto = z.infer<typeof moveStageSchema>;
+type CloseWinDto = z.infer<typeof closeWinSchema>;
+type CloseLossDto = z.infer<typeof closeLossSchema>;
+type OpportunityFilterDto = z.infer<typeof opportunityFilterSchema>;
+//#endregion
+//#region src/validators/contact.schema.d.ts
+declare const createContactSchema: z.ZodObject<{
+  name: z.ZodObject<{
+    given: z.ZodString;
+    family: z.ZodDefault<z.ZodString>;
+    middle: z.ZodOptional<z.ZodString>;
+    prefix: z.ZodOptional<z.ZodString>;
+    suffix: z.ZodOptional<z.ZodString>;
+    preferred: z.ZodOptional<z.ZodString>;
   }, z.core.$strip>;
+  contact: z.ZodDefault<z.ZodObject<{
+    email: z.ZodOptional<z.ZodString>;
+    personalEmail: z.ZodOptional<z.ZodString>;
+    phone: z.ZodOptional<z.ZodString>;
+    alternatePhone: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  jobTitle: z.ZodOptional<z.ZodString>;
+  accountId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+  ownerId: z.ZodOptional<z.ZodString>;
+  tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>;
-declare const opportunityWonSchema: z.ZodObject<{
-  opportunityId: z.ZodString;
-  amount: z.ZodOptional<z.ZodObject<{
-    amount: z.ZodNumber;
-    currency: z.ZodString;
+declare const updateContactSchema: z.ZodObject<{
+  name: z.ZodOptional<z.ZodObject<{
+    given: z.ZodString;
+    family: z.ZodDefault<z.ZodString>;
+    middle: z.ZodOptional<z.ZodString>;
+    prefix: z.ZodOptional<z.ZodString>;
+    suffix: z.ZodOptional<z.ZodString>;
+    preferred: z.ZodOptional<z.ZodString>;
   }, z.core.$strip>>;
+  contact: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+    email: z.ZodOptional<z.ZodString>;
+    personalEmail: z.ZodOptional<z.ZodString>;
+    phone: z.ZodOptional<z.ZodString>;
+    alternatePhone: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>>;
+  jobTitle: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+  accountId: z.ZodOptional<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>>;
+  ownerId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+  tags: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+  metadata: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strip>;
+declare const contactFilterSchema: z.ZodObject<{
+  accountId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+  ownerId: z.ZodOptional<z.ZodString>;
+  email: z.ZodOptional<z.ZodString>;
+  tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type CreateContactDto = z.infer<typeof createContactSchema>;
+type UpdateContactDto = z.infer<typeof updateContactSchema>;
+//#endregion
+//#region src/validators/account.schema.d.ts
+declare const createAccountSchema: z.ZodObject<{
+  name: z.ZodString;
+  domain: z.ZodOptional<z.ZodString>;
+  industry: z.ZodOptional<z.ZodString>;
+  sizeBucket: z.ZodOptional<z.ZodString>;
+  annualRevenueAmount: z.ZodOptional<z.ZodNumber>;
+  annualRevenueCurrency: z.ZodOptional<z.ZodString>;
+  ownerId: z.ZodOptional<z.ZodString>;
+  tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+declare const updateAccountSchema: z.ZodObject<{
+  name: z.ZodOptional<z.ZodString>;
+  domain: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+  industry: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+  sizeBucket: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+  annualRevenueAmount: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+  annualRevenueCurrency: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+  ownerId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+  tags: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+  metadata: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strip>;
+declare const accountFilterSchema: z.ZodObject<{
+  domain: z.ZodOptional<z.ZodString>;
+  industry: z.ZodOptional<z.ZodString>;
+  ownerId: z.ZodOptional<z.ZodString>;
+  tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type CreateAccountDto = z.infer<typeof createAccountSchema>;
+type UpdateAccountDto = z.infer<typeof updateAccountSchema>;
+//#endregion
+//#region src/validators/campaign.schema.d.ts
+declare const createCampaignSchema: z.ZodObject<{
+  name: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+  utmSource: z.ZodOptional<z.ZodString>;
+  utmMedium: z.ZodOptional<z.ZodString>;
+  utmCampaign: z.ZodOptional<z.ZodString>;
+  startDate: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+  endDate: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+  budgetAmount: z.ZodOptional<z.ZodNumber>;
+  expectedRevenueAmount: z.ZodOptional<z.ZodNumber>;
+  currency: z.ZodOptional<z.ZodString>;
+  ownerId: z.ZodOptional<z.ZodString>;
+  tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+declare const updateCampaignSchema: z.ZodObject<{
+  name: z.ZodOptional<z.ZodString>;
+  description: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+  utmSource: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+  utmMedium: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+  utmCampaign: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+  startDate: z.ZodOptional<z.ZodOptional<z.ZodCoercedDate<unknown>>>;
+  endDate: z.ZodOptional<z.ZodOptional<z.ZodCoercedDate<unknown>>>;
+  budgetAmount: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+  expectedRevenueAmount: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+  currency: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+  ownerId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+  tags: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+  metadata: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strip>;
+declare const completeCampaignSchema: z.ZodObject<{
+  by: z.ZodOptional<z.ZodString>;
+  note: z.ZodOptional<z.ZodString>;
+  actualRevenueAmount: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const campaignFilterSchema: z.ZodObject<{
+  status: z.ZodOptional<z.ZodEnum<{
+    draft: "draft";
+    active: "active";
+    paused: "paused";
+    completed: "completed";
+    archived: "archived";
+  }>>;
+  ownerId: z.ZodOptional<z.ZodString>;
+  tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  startDateFrom: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+  startDateTo: z.ZodOptional<z.ZodCoercedDate<unknown>>;
 }, z.core.$strip>;
-declare const opportunityLostSchema: z.ZodObject<{
-  opportunityId: z.ZodString;
-  lostReasonId: z.ZodOptional<z.ZodString>;
+type CreateCampaignDto = z.infer<typeof createCampaignSchema>;
+type UpdateCampaignDto = z.infer<typeof updateCampaignSchema>;
+type CompleteCampaignDto = z.infer<typeof completeCampaignSchema>;
+//#endregion
+//#region src/validators/subscription.schema.d.ts
+declare const subscribeSchema: z.ZodObject<{
+  contactId: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+  campaignId: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+  source: z.ZodOptional<z.ZodString>;
+  consentIpAddress: z.ZodOptional<z.ZodString>;
+  consentUserAgent: z.ZodOptional<z.ZodString>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  requireDoubleOptIn: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
-declare const opportunityAbandonedSchema: z.ZodObject<{
-  opportunityId: z.ZodString;
+declare const confirmSubscriptionSchema: z.ZodObject<{
+  token: z.ZodString;
 }, z.core.$strip>;
-declare const pipelineCreatedSchema: z.ZodObject<{
-  pipelineId: z.ZodString;
+declare const unsubscribeSchema: z.ZodObject<{
+  token: z.ZodString;
+  reason: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-declare const pipelineArchivedSchema: z.ZodObject<{
-  pipelineId: z.ZodString;
+declare const subscriptionFilterSchema: z.ZodObject<{
+  status: z.ZodOptional<z.ZodEnum<{
+    pending: "pending";
+    confirmed: "confirmed";
+    unsubscribed: "unsubscribed";
+    bounced: "bounced";
+    complained: "complained";
+  }>>;
+  contactId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+  campaignId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
 }, z.core.$strip>;
-declare const activityPlannedSchema: z.ZodObject<{
-  activityId: z.ZodString;
-  type: z.ZodString;
+type SubscribeDto = z.infer<typeof subscribeSchema>;
+type ConfirmSubscriptionDto = z.infer<typeof confirmSubscriptionSchema>;
+type UnsubscribeDto = z.infer<typeof unsubscribeSchema>;
+//#endregion
+//#region src/validators/activity.schema.d.ts
+declare const planActivitySchema: z.ZodObject<{
+  type: z.ZodEnum<{
+    call: "call";
+    email: "email";
+    meeting: "meeting";
+    task: "task";
+    note: "note";
+    sms: "sms";
+    social: "social";
+    demo: "demo";
+    other: "other";
+  }>;
   subjectKind: z.ZodEnum<{
     lead: "lead";
     opportunity: "opportunity";
     contact: "contact";
     account: "account";
   }>;
-  subjectId: z.ZodString;
+  subjectId: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+  title: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+  ownerId: z.ZodOptional<z.ZodString>;
+  participantIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  dueDate: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+  externalRef: z.ZodOptional<z.ZodString>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>;
-declare const activityCompletedSchema: z.ZodObject<{
-  activityId: z.ZodString;
-  completedAt: z.ZodISODateTime;
+declare const updateActivitySchema: z.ZodObject<{
+  type: z.ZodOptional<z.ZodEnum<{
+    call: "call";
+    email: "email";
+    meeting: "meeting";
+    task: "task";
+    note: "note";
+    sms: "sms";
+    social: "social";
+    demo: "demo";
+    other: "other";
+  }>>;
+  subjectKind: z.ZodOptional<z.ZodEnum<{
+    lead: "lead";
+    opportunity: "opportunity";
+    contact: "contact";
+    account: "account";
+  }>>;
+  subjectId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+  title: z.ZodOptional<z.ZodString>;
+  description: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+  ownerId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+  participantIds: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+  dueDate: z.ZodOptional<z.ZodOptional<z.ZodCoercedDate<unknown>>>;
+  externalRef: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+  metadata: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
 }, z.core.$strip>;
-declare const activityCancelledSchema: z.ZodObject<{
-  activityId: z.ZodString;
+declare const cancelActivitySchema: z.ZodObject<{
   reason: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-declare const noteAddedSchema: z.ZodObject<{
-  noteId: z.ZodString;
-  subjectKind: z.ZodEnum<{
+declare const activityFilterSchema: z.ZodObject<{
+  type: z.ZodOptional<z.ZodEnum<{
+    call: "call";
+    email: "email";
+    meeting: "meeting";
+    task: "task";
+    note: "note";
+    sms: "sms";
+    social: "social";
+    demo: "demo";
+    other: "other";
+  }>>;
+  status: z.ZodOptional<z.ZodEnum<{
+    completed: "completed";
+    planned: "planned";
+    in_progress: "in_progress";
+    cancelled: "cancelled";
+  }>>;
+  subjectKind: z.ZodOptional<z.ZodEnum<{
     lead: "lead";
     opportunity: "opportunity";
     contact: "contact";
     account: "account";
-  }>;
-  subjectId: z.ZodString;
+  }>>;
+  subjectId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+  ownerId: z.ZodOptional<z.ZodString>;
+  dueDateFrom: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+  dueDateTo: z.ZodOptional<z.ZodCoercedDate<unknown>>;
 }, 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;
+type PlanActivityDto = z.infer<typeof planActivitySchema>;
+type CancelActivityDto = z.infer<typeof cancelActivitySchema>;
+//#endregion
+//#region src/validators/note.schema.d.ts
+declare const addNoteSchema: z.ZodObject<{
   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<{
+  subjectId: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+  body: z.ZodString;
+  authorId: z.ZodOptional<z.ZodString>;
+  pinned: z.ZodOptional<z.ZodBoolean>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+declare const updateNoteSchema: z.ZodObject<{
+  body: z.ZodOptional<z.ZodString>;
+  pinned: z.ZodOptional<z.ZodBoolean>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+declare const noteFilterSchema: z.ZodObject<{
+  subjectKind: z.ZodOptional<z.ZodEnum<{
     lead: "lead";
     opportunity: "opportunity";
     contact: "contact";
     account: "account";
+  }>>;
+  subjectId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+  authorId: z.ZodOptional<z.ZodString>;
+  pinned: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;
+}, z.core.$strip>;
+type AddNoteDto = z.infer<typeof addNoteSchema>;
+type UpdateNoteDto = z.infer<typeof updateNoteSchema>;
+//#endregion
+//#region src/validators/loss-reason.schema.d.ts
+declare const createLossReasonSchema: z.ZodObject<{
+  name: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+  isActive: z.ZodOptional<z.ZodBoolean>;
+  sequence: z.ZodOptional<z.ZodNumber>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+declare const updateLossReasonSchema: z.ZodObject<{
+  name: z.ZodOptional<z.ZodString>;
+  description: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+  isActive: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+  sequence: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+  metadata: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strip>;
+declare const lossReasonFilterSchema: z.ZodObject<{
+  isActive: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;
+}, z.core.$strip>;
+type CreateLossReasonDto = z.infer<typeof createLossReasonSchema>;
+type UpdateLossReasonDto = z.infer<typeof updateLossReasonSchema>;
+//#endregion
+//#region src/validators/email-event.schema.d.ts
+declare const recordEmailEventSchema: z.ZodObject<{
+  subjectKind: z.ZodEnum<{
+    contact: "contact";
+    subscription: "subscription";
   }>;
-  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.
- */
-declare const crmEventDefinitions: ReadonlyArray<CrmEventDefinition>;
+  subjectId: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+  campaignId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+  messageId: z.ZodOptional<z.ZodString>;
+  url: z.ZodOptional<z.ZodString>;
+  userAgent: z.ZodOptional<z.ZodString>;
+  ip: z.ZodOptional<z.ZodString>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+declare const emailEventFilterSchema: z.ZodObject<{
+  kind: z.ZodOptional<z.ZodEnum<{
+    open: "open";
+    click: "click";
+    bounce: "bounce";
+    complaint: "complaint";
+    unsubscribe: "unsubscribe";
+  }>>;
+  subjectKind: z.ZodOptional<z.ZodEnum<{
+    contact: "contact";
+    subscription: "subscription";
+  }>>;
+  subjectId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+  campaignId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+  messageId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type RecordEmailEventDto = z.infer<typeof recordEmailEventSchema>;
 //#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 };
+export { ACTIVITY_MACHINE, ACTIVITY_STATUSES, ACTIVITY_TRANSITIONS, ACTIVITY_TYPES, AccountRepository, AccountRepositoryDeps, ActivityRepository, ActivityRepositoryDeps, type ActivityStatus, type ActivityType, CAMPAIGN_MACHINE, CAMPAIGN_STATUSES, CAMPAIGN_TRANSITIONS, CRM_EVENTS, CampaignRepository, CampaignRepositoryDeps, type CampaignStatus, CloseInput, ContactRepository, ContactRepositoryDeps, ConversionRow, ConvertLeadInput, ConvertResult, CreateCrmRepositoriesDeps, CrmConfig, CrmContext, CrmEngine, CrmError, CrmEventName, CrmLogger, CrmModels, CrmRepositories, DuplicateCampaignError, DuplicateLeadError, DuplicateSubscriptionError, EMAIL_EVENT_KINDS, EMAIL_EVENT_SUBJECT_KINDS, type EmailEventKind, EmailEventRepository, EmailEventRepositoryDeps, EmailEventSubjectKind, EmptyPipelineError, ForecastOptions, ForecastRow, type IAccountDocument, type IActivityDocument, type ICampaignDocument, ICampaignStatusEntry, type IContactDocument, IContactInfoEmbedded, IContactName, type IEmailEventDocument, type ILeadDocument, ILeadStatusEntry, type ILossReasonDocument, type INoteDocument, type IOpportunityDocument, IOpportunityStatusEntry, type IPipelineDocument, IStageDocument, type ISubscriptionDocument, ISubscriptionStatusEntry, InProcessCrmBus, InvalidActivityTransitionError, InvalidCampaignTransitionError, InvalidConfirmationTokenError, InvalidLeadTransitionError, InvalidOpportunityTransitionError, InvalidSubscriptionTransitionError, InvalidUnsubscribeTokenError, LEAD_MACHINE, LEAD_STATUSES, LEAD_TRANSITIONS, LeadAlreadyConvertedError, LeadInput, LeadRepository, LeadRepositoryDeps, LeadScorer, LeadService, LeadServiceDeps, type LeadStatus, LossReasonRepository, LossReasonRepositoryDeps, MoveStageInput, NotFoundError, NoteRepository, NoteRepositoryDeps, OPPORTUNITY_MACHINE, OPPORTUNITY_STATUSES, OPPORTUNITY_TRANSITIONS, OpenOpportunityInput, OpportunityForecast, OpportunityRepository, OpportunityRepositoryDeps, type OpportunityStatus, PipelineRepository, PipelineRepositoryDeps, RecordEmailEventInput, ResolvedCrmConfig, SUBJECT_KINDS, SUBSCRIPTION_MACHINE, SUBSCRIPTION_STATUSES, SUBSCRIPTION_TRANSITIONS, SchemaBuildConfig, StageNotInPipelineError, type StatusChangeEntry, type StatusHistory, type SubjectKind, SubscribeInput, SubscriptionRepository, SubscriptionRepositoryDeps, type SubscriptionStatus, TenantFieldType, _ModelTypes, appendStatus, buildAccountSchema, buildActivitySchema, buildCampaignSchema, buildContactSchema, buildEmailEventSchema, buildLeadSchema, buildLossReasonSchema, buildNoteSchema, buildOpportunitySchema, buildPipelineSchema, buildSubscriptionSchema, canTransitionActivity, canTransitionCampaign, canTransitionLead, canTransitionOpportunity, canTransitionSubscription, composeScorers, createAccountModel, createActivityModel, createCampaignModel, createContactModel, createCrm, createCrmModels, createCrmRepositories, createEmailEventModel, createEvent, createLeadModel, createLossReasonModel, createNoteModel, createOpportunityModel, createPipelineModel, createSubscriptionModel, defaultLeadScorer, forecast, lastTransitionTo, latestEntry, pipelineConversion, tenantFieldDef, timeInStatus, index_d_exports as validators };
 //# sourceMappingURL=index.d.ts.map