@classytic/crm 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1420 @@
+import { DomainEvent, EventHandler, EventTransport } from "@classytic/primitives/events";
+import { z } from "zod";
+import { OutboxStore } from "@classytic/primitives/outbox";
+import { ContactInfo, PersonName } from "@classytic/primitives/person";
+import { Money } from "@classytic/primitives/money";
+
+//#region src/domain/entities/account.d.ts
+/**
+ * An account (company / organization). Contacts, Opportunities, and
+ * Activities can reference it.
+ */
+interface Account {
+  id: string;
+  name: string;
+  /** Domain / website — used by host deduplication pipelines. */
+  domain?: string;
+  industry?: string;
+  /** Employee-count bucket, e.g. `1-10`, `11-50`. Free-form for flexibility. */
+  sizeBucket?: string;
+  annualRevenue?: {
+    amount: number;
+    currency: string;
+  };
+  ownerId?: string;
+  tags?: readonly string[];
+  metadata?: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
+}
+//#endregion
+//#region src/domain/ports/account-repository.port.d.ts
+interface AccountFilter {
+  ownerId?: string;
+  industry?: string;
+  domain?: string;
+  tags?: readonly string[];
+}
+interface AccountRepository {
+  findById(id: string): Promise<Account | null>;
+  findByDomain(domain: string): Promise<Account | null>;
+  list(filter?: AccountFilter): Promise<Account[]>;
+  create(a: Omit<Account, 'createdAt' | 'updatedAt'>): Promise<Account>;
+  update(id: string, patch: Partial<Account>): Promise<Account>;
+  delete(id: string): Promise<void>;
+}
+//#endregion
+//#region src/domain/ports/clock.port.d.ts
+interface Clock {
+  now(): Date;
+}
+declare const systemClock: Clock;
+//#endregion
+//#region src/domain/ports/id-generator.port.d.ts
+interface IdGenerator {
+  next(): string;
+}
+//#endregion
+//#region src/services/mutation-options.d.ts
+/**
+ * Options passed to every service mutation. All fields optional — hosts
+ * opt into the behaviours they need.
+ */
+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;
+}
+//#endregion
+//#region src/services/account.service.d.ts
+interface AccountServiceConfig {
+  repo: AccountRepository;
+  events?: EventTransport | undefined;
+  /**
+   * Optional host-owned outbox. See `emitCrmEvent` for the dispatch contract:
+   * outbox save (session-bound when `options.session` is passed) is issued
+   * before the transport publish so durable at-least-once delivery works
+   * even when the transport is down.
+   */
+  outbox?: OutboxStore | undefined;
+  clock?: Clock;
+  ids?: IdGenerator;
+}
+interface CreateAccountInput {
+  name: string;
+  domain?: string;
+  industry?: string;
+  sizeBucket?: string;
+  annualRevenue?: {
+    amount: number;
+    currency: string;
+  };
+  ownerId?: string;
+  tags?: readonly string[];
+  metadata?: Record<string, unknown>;
+}
+declare class AccountService {
+  private readonly repo;
+  private readonly events;
+  private readonly outbox;
+  private readonly clock;
+  private readonly ids;
+  constructor(config: AccountServiceConfig);
+  create(input: CreateAccountInput, options?: MutationOptions): Promise<Account>;
+  update(id: string, patch: Partial<Account>, options?: MutationOptions): Promise<Account>;
+  delete(id: string): Promise<void>;
+  findById(id: string): Promise<Account | null>;
+  findByDomain(domain: string): Promise<Account | null>;
+  list(filter?: Parameters<AccountRepository['list']>[0]): Promise<Account[]>;
+  private _require;
+  private _emit;
+}
+//#endregion
+//#region src/domain/enums/activity.d.ts
+/**
+ * Activity type vocabulary. The package stores `type` as free-form
+ * string so hosts can extend; these constants cover the common
+ * channels that automation tooling typically keys off.
+ */
+declare const ACTIVITY_TYPES: readonly ["call", "email", "meeting", "task", "note", "sms", "social", "demo", "other"];
+type ActivityType = (typeof ACTIVITY_TYPES)[number];
+declare const ACTIVITY_STATUSES: readonly ["planned", "in_progress", "completed", "cancelled"];
+type ActivityStatus = (typeof ACTIVITY_STATUSES)[number];
+declare const ACTIVITY_TRANSITIONS: Record<ActivityStatus, readonly ActivityStatus[]>;
+declare function canTransitionActivity(from: ActivityStatus, to: ActivityStatus): boolean;
+/**
+ * Kinds of entity an Activity can reference. Polymorphic linking lets
+ * hosts log a call against a Lead, an Opportunity, a Contact, or a
+ * stand-alone Account.
+ */
+declare const SUBJECT_KINDS: readonly ["lead", "opportunity", "contact", "account"];
+type SubjectKind = (typeof SUBJECT_KINDS)[number];
+//#endregion
+//#region src/domain/entities/activity.d.ts
+/**
+ * An activity is a polymorphic record of outreach / task / event
+ * attached to any CRM entity. `subjectKind` + `subjectId` define the
+ * link — this is how hosts build automation atop the package (subscribe
+ * to `crm:activity.*` events, filter by `subjectKind`, react).
+ */
+interface Activity {
+  id: string;
+  type: ActivityType | string;
+  status: ActivityStatus;
+  subjectKind: SubjectKind;
+  subjectId: string;
+  subject?: string;
+  body?: string;
+  /** When the activity is / was scheduled to happen. */
+  scheduledAt?: Date;
+  completedAt?: Date;
+  cancelledAt?: Date;
+  /** User-level ownership (call made by / task assigned to). */
+  ownerId?: string;
+  participantIds?: readonly string[];
+  /**
+   * Optional external ref — e.g. Calendar event id, email thread id,
+   * call-recording url. Host-owned semantics.
+   */
+  externalRef?: string;
+  metadata?: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
+}
+//#endregion
+//#region src/domain/entities/note.d.ts
+/**
+ * A free-text note on a CRM entity. Separate from Activity because
+ * notes aren't status-tracked — they're typed once and stay; they're
+ * also the cheapest "activity log" entry to create.
+ */
+interface Note {
+  id: string;
+  subjectKind: SubjectKind;
+  subjectId: string;
+  body: string;
+  authorId?: string;
+  /** Supports @-mentions, Markdown, etc. — host-interpreted. */
+  format?: 'plain' | 'markdown';
+  metadata?: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
+}
+//#endregion
+//#region src/domain/ports/activity-repository.port.d.ts
+interface ActivityFilter {
+  subjectKind?: SubjectKind;
+  subjectId?: string;
+  status?: ActivityStatus | readonly ActivityStatus[];
+  ownerId?: string;
+  scheduledBetween?: {
+    from: Date;
+    to: Date;
+  };
+}
+interface ActivityRepository {
+  findById(id: string): Promise<Activity | null>;
+  list(filter?: ActivityFilter): Promise<Activity[]>;
+  create(a: Omit<Activity, 'createdAt' | 'updatedAt'>): Promise<Activity>;
+  update(id: string, patch: Partial<Activity>): Promise<Activity>;
+  casStatus(id: string, expected: ActivityStatus, next: ActivityStatus, patch?: Partial<Activity>): Promise<Activity | null>;
+}
+//#endregion
+//#region src/domain/ports/note-repository.port.d.ts
+interface NoteRepository {
+  findById(id: string): Promise<Note | null>;
+  listBySubject(subjectKind: SubjectKind, subjectId: string): Promise<Note[]>;
+  create(n: Omit<Note, 'createdAt' | 'updatedAt'>): Promise<Note>;
+  update(id: string, patch: Partial<Note>): Promise<Note>;
+  delete(id: string): Promise<void>;
+}
+//#endregion
+//#region src/services/activity.service.d.ts
+interface ActivityServiceConfig {
+  repo: ActivityRepository;
+  notes: NoteRepository;
+  events?: EventTransport | undefined;
+  /** Optional host-owned outbox. See AccountServiceConfig.outbox. */
+  outbox?: OutboxStore | undefined;
+  clock?: Clock;
+  ids?: IdGenerator;
+}
+interface CreateActivityInput {
+  type: ActivityType | string;
+  subjectKind: SubjectKind;
+  subjectId: string;
+  subject?: string;
+  body?: string;
+  scheduledAt?: Date;
+  ownerId?: string;
+  participantIds?: readonly string[];
+  externalRef?: string;
+  metadata?: Record<string, unknown>;
+}
+interface CreateNoteInput {
+  subjectKind: SubjectKind;
+  subjectId: string;
+  body: string;
+  authorId?: string;
+  format?: 'plain' | 'markdown';
+  metadata?: Record<string, unknown>;
+}
+/**
+ * Polymorphic activity / note service. Activities have a lifecycle
+ * (`planned → in_progress → completed | cancelled`); notes are
+ * immutable-ish (create + update body, no status).
+ */
+declare class ActivityService {
+  private readonly repo;
+  private readonly noteRepo;
+  private readonly events;
+  private readonly outbox;
+  private readonly clock;
+  private readonly ids;
+  constructor(config: ActivityServiceConfig);
+  plan(input: CreateActivityInput, options?: MutationOptions): Promise<Activity>;
+  start(id: string, options?: MutationOptions): Promise<Activity>;
+  complete(id: string, completedAt?: Date, options?: MutationOptions): Promise<Activity>;
+  cancel(id: string, reason?: string, options?: MutationOptions): Promise<Activity>;
+  addNote(input: CreateNoteInput, options?: MutationOptions): Promise<Note>;
+  listBySubject(subjectKind: SubjectKind, subjectId: string): Promise<Activity[]>;
+  listNotesBySubject(subjectKind: SubjectKind, subjectId: string): Promise<Note[]>;
+  findById(id: string): Promise<Activity | null>;
+  private _transition;
+  private _emit;
+}
+//#endregion
+//#region src/domain/entities/contact.d.ts
+/**
+ * A person — the atom of a CRM. Contacts may belong to an Account,
+ * but can also exist stand-alone (independent consultants, consumers).
+ *
+ * Structured `name` + `contact` come from `@classytic/primitives/person`.
+ * Hosts projecting over a commerce Customer record embed the same shapes —
+ * no translation needed at the boundary.
+ */
+interface Contact {
+  id: string;
+  name: PersonName;
+  contact: ContactInfo;
+  jobTitle?: string;
+  accountId?: string;
+  ownerId?: string;
+  /** Free-form tags for segmentation. */
+  tags?: readonly string[];
+  /** Host-owned arbitrary payload (social handles, custom fields, etc.). */
+  metadata?: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
+}
+//#endregion
+//#region src/domain/ports/contact-repository.port.d.ts
+interface ContactFilter {
+  accountId?: string;
+  ownerId?: string;
+  email?: string;
+  tags?: readonly string[];
+}
+interface ContactRepository {
+  findById(id: string): Promise<Contact | null>;
+  findByEmail(email: string): Promise<Contact | null>;
+  list(filter?: ContactFilter): Promise<Contact[]>;
+  create(c: Omit<Contact, 'createdAt' | 'updatedAt'>): Promise<Contact>;
+  update(id: string, patch: Partial<Contact>): Promise<Contact>;
+  delete(id: string): Promise<void>;
+}
+//#endregion
+//#region src/services/contact.service.d.ts
+interface ContactServiceConfig {
+  repo: ContactRepository;
+  events?: EventTransport | undefined;
+  /** Optional host-owned outbox. See AccountServiceConfig.outbox. */
+  outbox?: OutboxStore | undefined;
+  clock?: Clock;
+  ids?: IdGenerator;
+}
+interface CreateContactInput {
+  name: PersonName;
+  contact?: ContactInfo;
+  jobTitle?: string;
+  accountId?: string;
+  ownerId?: string;
+  tags?: readonly string[];
+  metadata?: Record<string, unknown>;
+}
+declare class ContactService {
+  private readonly repo;
+  private readonly events;
+  private readonly outbox;
+  private readonly clock;
+  private readonly ids;
+  constructor(config: ContactServiceConfig);
+  create(input: CreateContactInput, options?: MutationOptions): Promise<Contact>;
+  update(id: string, patch: Partial<Contact>, options?: MutationOptions): Promise<Contact>;
+  delete(id: string): Promise<void>;
+  findById(id: string): Promise<Contact | null>;
+  findByEmail(email: string): Promise<Contact | null>;
+  list(filter?: Parameters<ContactRepository['list']>[0]): Promise<Contact[]>;
+  private _require;
+  private _emit;
+}
+//#endregion
+//#region src/domain/enums/lead-status.d.ts
+/**
+ * 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/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;
+}
+interface LeadStatusEntry {
+  status: LeadStatus;
+  occurredAt: Date;
+  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;
+  /**
+   * Win probability (0-1). Defaults to the stage's probability at
+   * every stage move; host can override for hand-tuned forecasts.
+   */
+  probability: number;
+  /** When the deal is expected to close. Drives forecast grouping. */
+  expectedCloseAt?: Date;
+  /** Populated on win/lose. */
+  closedAt?: Date;
+  lostReasonId?: string;
+  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>;
+}
+//#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;
+}
+interface CreateOpportunityInput {
+  name: string;
+  pipelineId: string;
+  /** Starting stage — defaults to the pipeline's first stage. */
+  stageId?: string;
+  accountId?: string;
+  primaryContactId?: string;
+  sourceLeadId?: string;
+  amount?: Money;
+  /** Override the stage default. Defaults to the stage's `defaultProbability`. */
+  probability?: number;
+  expectedCloseAt?: Date;
+  ownerId?: string;
+  tags?: readonly string[];
+  metadata?: Record<string, unknown>;
+}
+interface MoveStageInput {
+  stageId: string;
+  /** Override probability. Defaults to the target stage's `defaultProbability`. */
+  probability?: number;
+  by?: string;
+  note?: string;
+}
+interface CloseInput {
+  amount?: Money;
+  closedAt?: Date;
+  by?: string;
+  note?: string;
+}
+interface LoseInput extends CloseInput {
+  lostReasonId?: string;
+}
+/**
+ * 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;
+  private readonly pipelines;
+  private readonly events;
+  private readonly outbox;
+  private readonly clock;
+  private readonly ids;
+  constructor(config: OpportunityServiceConfig);
+  create(input: CreateOpportunityInput, options?: MutationOptions): Promise<Opportunity>;
+  moveToStage(id: string, input: MoveStageInput, options?: MutationOptions): Promise<Opportunity>;
+  win(id: string, input?: CloseInput, options?: MutationOptions): Promise<Opportunity>;
+  lose(id: string, input?: LoseInput, options?: MutationOptions): Promise<Opportunity>;
+  abandon(id: string, by?: string, note?: string, options?: MutationOptions): Promise<Opportunity>;
+  delete(id: string): Promise<void>;
+  findById(id: string): Promise<Opportunity | null>;
+  list(filter?: Parameters<OpportunityRepository['list']>[0]): Promise<Opportunity[]>;
+  private _require;
+  private _transitionStatus;
+  private _emit;
+}
+//#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;
+//#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. */
+  rejectDuplicates?: boolean;
+}
+interface CreateLeadInput {
+  firstName?: string;
+  lastName?: string;
+  fullName?: string;
+  email?: string;
+  phone?: string;
+  companyName?: string;
+  jobTitle?: string;
+  source?: string;
+  campaignRef?: string;
+  ownerId?: string;
+  tags?: readonly string[];
+  metadata?: Record<string, unknown>;
+}
+interface ConvertLeadInput {
+  /** Pipeline the resulting opportunity enters. */
+  pipelineId: string;
+  /** Opportunity name. Defaults to `<lead.companyName> — <lead.fullName>`. */
+  opportunityName?: string;
+  /** Optional deal amount. */
+  amount?: Money;
+  expectedCloseAt?: Date;
+  by?: string;
+}
+interface ConvertResult {
+  lead: Lead;
+  contactId: string;
+  accountId?: string;
+  opportunityId: string;
+}
+/**
+ * Lead lifecycle + the crown-jewel `convert()` verb that atomically
+ * spawns a Contact + Account + Opportunity and transitions the lead
+ * to `converted`.
+ */
+declare class LeadService {
+  private readonly repo;
+  private readonly contacts;
+  private readonly accounts;
+  private readonly opportunities;
+  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;
+  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;
+}
+/**
+ * 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;
+}
+//#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>;
+}
+//#endregion
+//#region src/services/pipeline.service.d.ts
+interface PipelineServiceConfig {
+  repo: PipelineRepository;
+  events?: EventTransport | undefined;
+  /** Optional host-owned outbox. See AccountServiceConfig.outbox. */
+  outbox?: OutboxStore | undefined;
+  clock?: Clock;
+  ids?: IdGenerator;
+}
+interface CreatePipelineInput {
+  name: string;
+  stages: readonly Omit<Stage, 'id'>[];
+  teamRef?: string;
+  metadata?: Record<string, unknown>;
+}
+/**
+ * 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;
+  private readonly events;
+  private readonly outbox;
+  private readonly clock;
+  private readonly ids;
+  constructor(config: PipelineServiceConfig);
+  create(input: CreatePipelineInput, options?: MutationOptions): Promise<Pipeline>;
+  archive(id: string, options?: MutationOptions): Promise<Pipeline>;
+  getStage(pipelineId: string, stageId: string): Promise<Stage>;
+  /** First stage in the ordered pipeline (minimum `sequence`). */
+  getFirstStage(pipelineId: string): Promise<Stage>;
+  /** Next stage after `stageId` in the ordered pipeline, or `null` at the end. */
+  getNextStage(pipelineId: string, stageId: string): Promise<Stage | null>;
+  findById(id: string): Promise<Pipeline | null>;
+  list(includeArchived?: boolean): Promise<Pipeline[]>;
+  private _require;
+  private _emit;
+}
+//#endregion
+//#region src/services/forecast.d.ts
+interface ForecastRow {
+  /** Bucket key — typically ISO month `YYYY-MM` derived from `expectedCloseAt`. */
+  bucket: string;
+  /** Sum of unweighted `amount`. */
+  committed: number;
+  /** Sum of `amount × probability`. */
+  weighted: number;
+  /** Count of opportunities contributing. */
+  count: number;
+  currency: string;
+}
+interface ForecastOptions {
+  /**
+   * 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.
+   */
+  bucket?: (o: Opportunity) => string;
+  /**
+   * Filter opportunities before bucketing. Default includes only
+   * `open` opportunities with `amount` and `expectedCloseAt`.
+   */
+  include?: (o: Opportunity) => boolean;
+}
+/**
+ * Aggregate opportunities into a forecast table — one row per
+ * bucket (month by default). Committed is `Σ amount`; weighted is
+ * `Σ amount × probability`.
+ *
+ * Integer-safe: sums are computed on minor-unit amounts (consistent
+ * with `@classytic/primitives/money`'s integer convention). Currency
+ * mismatch across a bucket throws — hosts dealing in multi-currency
+ * run this once per currency after partitioning.
+ */
+declare function forecast(opportunities: readonly Opportunity[], options?: ForecastOptions): ForecastRow[];
+/**
+ * Pipeline conversion summary — how opportunities partitioned across
+ * stages and final outcome. Useful for "where do deals die?" analysis.
+ */
+interface ConversionRow {
+  stageId: string;
+  currentCount: number;
+  wonFromHere: number;
+  lostFromHere: number;
+  conversionRate: number;
+}
+declare function pipelineConversion(opportunities: readonly Opportunity[], stageIds: readonly string[]): ConversionRow[];
+//#endregion
+//#region src/domain/entities/loss-reason.d.ts
+/**
+ * Standardized reason for closing an opportunity as `lost`. Seeded
+ * once by the host; referenced by id on the opportunity. Keeping
+ * these as records (vs free-form strings) is what makes lost-reason
+ * analytics possible.
+ */
+interface LossReason {
+  id: string;
+  name: string;
+  /** Broad category — `price`, `feature-gap`, `timing`, `competitor`, `no-decision`. */
+  category?: string;
+  description?: string;
+  active: boolean;
+  metadata?: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
+}
+//#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>;
+}
+//#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>;
+}
+interface OutreachSendResult {
+  /** Opaque ref — typically the provider's message id. */
+  providerMessageId?: string;
+  acceptedAt: Date;
+}
+interface OutreachPort {
+  send(request: OutreachSendRequest): Promise<OutreachSendResult>;
+}
+//#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>;
+}
+//#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>;
+}
+//#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>;
+}
+//#endregion
+//#region src/adapters/in-memory/event-transport.d.ts
+type RecordedEvent = DomainEvent;
+declare class InMemoryEventTransport implements EventTransport {
+  readonly name = "crm-in-memory";
+  readonly events: RecordedEvent[];
+  private readonly subscribers;
+  publish(event: DomainEvent): Promise<void>;
+  subscribe(pattern: string, handler: EventHandler): Promise<() => void>;
+}
+//#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;
+//#endregion
+//#region src/domain/errors.d.ts
+/**
+ * CRM error vocabulary. Hosts catch `CrmError` at API edges.
+ */
+declare class CrmError extends Error {
+  readonly code: string;
+  readonly details?: Record<string, unknown>;
+  constructor(code: string, message: string, details?: Record<string, unknown>);
+}
+declare class NotFoundError extends CrmError {
+  constructor(kind: string, id: string);
+}
+declare class InvalidLeadTransitionError extends CrmError {
+  constructor(details: {
+    from: string;
+    to: string;
+    leadId: string;
+  });
+}
+declare class InvalidOpportunityTransitionError extends CrmError {
+  constructor(details: {
+    from: string;
+    to: string;
+    opportunityId: string;
+  });
+}
+declare class InvalidActivityTransitionError extends CrmError {
+  constructor(details: {
+    from: string;
+    to: string;
+    activityId: string;
+  });
+}
+declare class StageNotInPipelineError extends CrmError {
+  constructor(details: {
+    pipelineId: string;
+    stageId: string;
+  });
+}
+declare class LeadAlreadyConvertedError extends CrmError {
+  constructor(leadId: string);
+}
+declare class DuplicateLeadError extends CrmError {
+  constructor(details: {
+    email?: string;
+    phone?: string;
+  });
+}
+declare class EmptyPipelineError extends CrmError {
+  constructor(pipelineId: string);
+}
+//#endregion
+//#region src/events/event-constants.d.ts
+/** PACKAGE_RULES rule 12: `package:resource.verb`. */
+declare const CRM_EVENTS: {
+  readonly LEAD_CREATED: "crm:lead.created";
+  readonly LEAD_STATUS_CHANGED: "crm:lead.status_changed";
+  readonly LEAD_SCORED: "crm:lead.scored";
+  readonly LEAD_CONVERTED: "crm:lead.converted";
+  readonly LEAD_DISQUALIFIED: "crm:lead.disqualified";
+  readonly ACCOUNT_CREATED: "crm:account.created";
+  readonly ACCOUNT_UPDATED: "crm:account.updated";
+  readonly CONTACT_CREATED: "crm:contact.created";
+  readonly CONTACT_UPDATED: "crm:contact.updated";
+  readonly OPPORTUNITY_CREATED: "crm:opportunity.created";
+  readonly OPPORTUNITY_STAGE_ADVANCED: "crm:opportunity.stage_advanced";
+  readonly OPPORTUNITY_STAGE_REGRESSED: "crm:opportunity.stage_regressed";
+  readonly OPPORTUNITY_WON: "crm:opportunity.won";
+  readonly OPPORTUNITY_LOST: "crm:opportunity.lost";
+  readonly OPPORTUNITY_ABANDONED: "crm:opportunity.abandoned";
+  readonly PIPELINE_CREATED: "crm:pipeline.created";
+  readonly PIPELINE_ARCHIVED: "crm:pipeline.archived";
+  readonly ACTIVITY_PLANNED: "crm:activity.planned";
+  readonly ACTIVITY_COMPLETED: "crm:activity.completed";
+  readonly ACTIVITY_CANCELLED: "crm:activity.cancelled";
+  readonly NOTE_ADDED: "crm:note.added";
+};
+type CrmEventName = (typeof CRM_EVENTS)[keyof typeof CRM_EVENTS];
+//#endregion
+//#region src/events/event-catalog.d.ts
+interface CrmEventSchema {
+  type: 'object';
+  properties?: Record<string, {
+    type?: string;
+    format?: string;
+    [key: string]: unknown;
+  }>;
+  required?: string[];
+  [key: string]: unknown;
+}
+interface CrmEventDefinition<TSchema extends z.ZodType = z.ZodType> {
+  readonly name: string;
+  readonly version: number;
+  readonly description?: string;
+  readonly schema: CrmEventSchema;
+  readonly zodSchema: TSchema;
+  create(payload: z.infer<TSchema>, meta?: Partial<DomainEvent['meta']>): DomainEvent<z.infer<TSchema>>;
+  readonly __payload?: z.infer<TSchema>;
+}
+type CrmEventPayloadOf<D> = D extends CrmEventDefinition<infer S> ? z.infer<S> : never;
+declare const leadCreatedSchema: z.ZodObject<{
+  leadId: z.ZodString;
+  email: z.ZodOptional<z.ZodString>;
+  score: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const leadStatusChangedSchema: z.ZodObject<{
+  leadId: z.ZodString;
+  from: z.ZodString;
+  to: z.ZodString;
+}, z.core.$strip>;
+declare const leadScoredSchema: z.ZodObject<{
+  leadId: z.ZodString;
+  score: z.ZodNumber;
+}, z.core.$strip>;
+declare const leadConvertedSchema: z.ZodObject<{
+  leadId: z.ZodString;
+  contactId: z.ZodString;
+  accountId: z.ZodOptional<z.ZodString>;
+  opportunityId: z.ZodString;
+}, z.core.$strip>;
+declare const leadDisqualifiedSchema: z.ZodObject<{
+  leadId: z.ZodString;
+  reason: z.ZodString;
+}, z.core.$strip>;
+declare const accountCreatedSchema: z.ZodObject<{
+  accountId: z.ZodString;
+}, z.core.$strip>;
+declare const accountUpdatedSchema: z.ZodObject<{
+  accountId: z.ZodString;
+}, z.core.$strip>;
+declare const contactCreatedSchema: z.ZodObject<{
+  contactId: z.ZodString;
+  email: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const contactUpdatedSchema: z.ZodObject<{
+  contactId: z.ZodString;
+}, z.core.$strip>;
+declare const opportunityCreatedSchema: z.ZodObject<{
+  opportunityId: z.ZodString;
+  pipelineId: z.ZodString;
+  stageId: z.ZodString;
+}, z.core.$strip>;
+declare const opportunityStageAdvancedSchema: z.ZodObject<{
+  opportunityId: z.ZodString;
+  from: z.ZodObject<{
+    stageId: z.ZodString;
+    sequence: z.ZodNumber;
+  }, z.core.$strip>;
+  to: z.ZodObject<{
+    stageId: z.ZodString;
+    sequence: z.ZodNumber;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+declare const opportunityStageRegressedSchema: z.ZodObject<{
+  opportunityId: z.ZodString;
+  from: z.ZodObject<{
+    stageId: z.ZodString;
+    sequence: z.ZodNumber;
+  }, z.core.$strip>;
+  to: z.ZodObject<{
+    stageId: z.ZodString;
+    sequence: z.ZodNumber;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+declare const opportunityWonSchema: z.ZodObject<{
+  opportunityId: z.ZodString;
+  amount: z.ZodOptional<z.ZodObject<{
+    amount: z.ZodNumber;
+    currency: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const opportunityLostSchema: z.ZodObject<{
+  opportunityId: z.ZodString;
+  lostReasonId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const opportunityAbandonedSchema: z.ZodObject<{
+  opportunityId: z.ZodString;
+}, z.core.$strip>;
+declare const pipelineCreatedSchema: z.ZodObject<{
+  pipelineId: z.ZodString;
+}, z.core.$strip>;
+declare const pipelineArchivedSchema: z.ZodObject<{
+  pipelineId: z.ZodString;
+}, z.core.$strip>;
+declare const activityPlannedSchema: z.ZodObject<{
+  activityId: z.ZodString;
+  type: z.ZodString;
+  subjectKind: z.ZodEnum<{
+    lead: "lead";
+    opportunity: "opportunity";
+    contact: "contact";
+    account: "account";
+  }>;
+  subjectId: z.ZodString;
+}, z.core.$strip>;
+declare const activityCompletedSchema: z.ZodObject<{
+  activityId: z.ZodString;
+  completedAt: z.ZodISODateTime;
+}, z.core.$strip>;
+declare const activityCancelledSchema: z.ZodObject<{
+  activityId: z.ZodString;
+  reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const noteAddedSchema: z.ZodObject<{
+  noteId: z.ZodString;
+  subjectKind: z.ZodEnum<{
+    lead: "lead";
+    opportunity: "opportunity";
+    contact: "contact";
+    account: "account";
+  }>;
+  subjectId: z.ZodString;
+}, z.core.$strip>;
+type LeadCreatedPayload = z.infer<typeof leadCreatedSchema>;
+type LeadStatusChangedPayload = z.infer<typeof leadStatusChangedSchema>;
+type LeadScoredPayload = z.infer<typeof leadScoredSchema>;
+type LeadConvertedPayload = z.infer<typeof leadConvertedSchema>;
+type LeadDisqualifiedPayload = z.infer<typeof leadDisqualifiedSchema>;
+type AccountCreatedPayload = z.infer<typeof accountCreatedSchema>;
+type AccountUpdatedPayload = z.infer<typeof accountUpdatedSchema>;
+type ContactCreatedPayload = z.infer<typeof contactCreatedSchema>;
+type ContactUpdatedPayload = z.infer<typeof contactUpdatedSchema>;
+type OpportunityCreatedPayload = z.infer<typeof opportunityCreatedSchema>;
+type OpportunityStageAdvancedPayload = z.infer<typeof opportunityStageAdvancedSchema>;
+type OpportunityStageRegressedPayload = z.infer<typeof opportunityStageRegressedSchema>;
+type OpportunityWonPayload = z.infer<typeof opportunityWonSchema>;
+type OpportunityLostPayload = z.infer<typeof opportunityLostSchema>;
+type OpportunityAbandonedPayload = z.infer<typeof opportunityAbandonedSchema>;
+type PipelineCreatedPayload = z.infer<typeof pipelineCreatedSchema>;
+type PipelineArchivedPayload = z.infer<typeof pipelineArchivedSchema>;
+type ActivityPlannedPayload = z.infer<typeof activityPlannedSchema>;
+type ActivityCompletedPayload = z.infer<typeof activityCompletedSchema>;
+type ActivityCancelledPayload = z.infer<typeof activityCancelledSchema>;
+type NoteAddedPayload = z.infer<typeof noteAddedSchema>;
+declare const LeadCreated: CrmEventDefinition<z.ZodObject<{
+  leadId: z.ZodString;
+  email: z.ZodOptional<z.ZodString>;
+  score: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>>;
+declare const LeadStatusChanged: CrmEventDefinition<z.ZodObject<{
+  leadId: z.ZodString;
+  from: z.ZodString;
+  to: z.ZodString;
+}, z.core.$strip>>;
+declare const LeadScored: CrmEventDefinition<z.ZodObject<{
+  leadId: z.ZodString;
+  score: z.ZodNumber;
+}, z.core.$strip>>;
+declare const LeadConverted: CrmEventDefinition<z.ZodObject<{
+  leadId: z.ZodString;
+  contactId: z.ZodString;
+  accountId: z.ZodOptional<z.ZodString>;
+  opportunityId: z.ZodString;
+}, z.core.$strip>>;
+declare const LeadDisqualified: CrmEventDefinition<z.ZodObject<{
+  leadId: z.ZodString;
+  reason: z.ZodString;
+}, z.core.$strip>>;
+declare const AccountCreated: CrmEventDefinition<z.ZodObject<{
+  accountId: z.ZodString;
+}, z.core.$strip>>;
+declare const AccountUpdated: CrmEventDefinition<z.ZodObject<{
+  accountId: z.ZodString;
+}, z.core.$strip>>;
+declare const ContactCreated: CrmEventDefinition<z.ZodObject<{
+  contactId: z.ZodString;
+  email: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const ContactUpdated: CrmEventDefinition<z.ZodObject<{
+  contactId: z.ZodString;
+}, z.core.$strip>>;
+declare const OpportunityCreated: CrmEventDefinition<z.ZodObject<{
+  opportunityId: z.ZodString;
+  pipelineId: z.ZodString;
+  stageId: z.ZodString;
+}, z.core.$strip>>;
+declare const OpportunityStageAdvanced: CrmEventDefinition<z.ZodObject<{
+  opportunityId: z.ZodString;
+  from: z.ZodObject<{
+    stageId: z.ZodString;
+    sequence: z.ZodNumber;
+  }, z.core.$strip>;
+  to: z.ZodObject<{
+    stageId: z.ZodString;
+    sequence: z.ZodNumber;
+  }, z.core.$strip>;
+}, z.core.$strip>>;
+declare const OpportunityStageRegressed: CrmEventDefinition<z.ZodObject<{
+  opportunityId: z.ZodString;
+  from: z.ZodObject<{
+    stageId: z.ZodString;
+    sequence: z.ZodNumber;
+  }, z.core.$strip>;
+  to: z.ZodObject<{
+    stageId: z.ZodString;
+    sequence: z.ZodNumber;
+  }, z.core.$strip>;
+}, z.core.$strip>>;
+declare const OpportunityWon: CrmEventDefinition<z.ZodObject<{
+  opportunityId: z.ZodString;
+  amount: z.ZodOptional<z.ZodObject<{
+    amount: z.ZodNumber;
+    currency: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>>;
+declare const OpportunityLost: CrmEventDefinition<z.ZodObject<{
+  opportunityId: z.ZodString;
+  lostReasonId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const OpportunityAbandoned: CrmEventDefinition<z.ZodObject<{
+  opportunityId: z.ZodString;
+}, z.core.$strip>>;
+declare const PipelineCreated: CrmEventDefinition<z.ZodObject<{
+  pipelineId: z.ZodString;
+}, z.core.$strip>>;
+declare const PipelineArchived: CrmEventDefinition<z.ZodObject<{
+  pipelineId: z.ZodString;
+}, z.core.$strip>>;
+declare const ActivityPlanned: CrmEventDefinition<z.ZodObject<{
+  activityId: z.ZodString;
+  type: z.ZodString;
+  subjectKind: z.ZodEnum<{
+    lead: "lead";
+    opportunity: "opportunity";
+    contact: "contact";
+    account: "account";
+  }>;
+  subjectId: z.ZodString;
+}, z.core.$strip>>;
+declare const ActivityCompleted: CrmEventDefinition<z.ZodObject<{
+  activityId: z.ZodString;
+  completedAt: z.ZodISODateTime;
+}, z.core.$strip>>;
+declare const ActivityCancelled: CrmEventDefinition<z.ZodObject<{
+  activityId: z.ZodString;
+  reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+declare const NoteAdded: CrmEventDefinition<z.ZodObject<{
+  noteId: z.ZodString;
+  subjectKind: z.ZodEnum<{
+    lead: "lead";
+    opportunity: "opportunity";
+    contact: "contact";
+    account: "account";
+  }>;
+  subjectId: z.ZodString;
+}, z.core.$strip>>;
+/**
+ * Every CRM event defined in the package — pass to Arc's `EventRegistry`.
+ * Hosts wire ONE array; the whole `crm:*` namespace becomes introspectable
+ * via OpenAPI and auto-validated at publish time when
+ * `eventPlugin({ validateMode: 'reject' })` is set.
+ */
+declare const crmEventDefinitions: ReadonlyArray<CrmEventDefinition>;
+//#endregion
+export { ACTIVITY_STATUSES, ACTIVITY_TRANSITIONS, ACTIVITY_TYPES, type Account, AccountCreated, type AccountCreatedPayload, type AccountFilter, type AccountRepository, AccountService, type AccountServiceConfig, AccountUpdated, type AccountUpdatedPayload, type Activity, ActivityCancelled, type ActivityCancelledPayload, ActivityCompleted, type ActivityCompletedPayload, type ActivityFilter, ActivityPlanned, type ActivityPlannedPayload, type ActivityRepository, ActivityService, type ActivityServiceConfig, type ActivityStatus, type ActivityType, CRM_EVENTS, type Clock, type CloseInput, type Contact, ContactCreated, type ContactCreatedPayload, type ContactFilter, type ContactRepository, ContactService, type ContactServiceConfig, ContactUpdated, type ContactUpdatedPayload, type ConversionRow, type ConvertLeadInput, type ConvertResult, type CreateAccountInput, type CreateActivityInput, type CreateContactInput, type CreateLeadInput, type CreateNoteInput, type CreateOpportunityInput, type CreatePipelineInput, CrmError, type CrmEventDefinition, type CrmEventName, type CrmEventPayloadOf, type CrmEventSchema, DuplicateLeadError, EmptyPipelineError, type ForecastOptions, type ForecastRow, type IdGenerator, InMemoryAccountRepository, InMemoryActivityRepository, InMemoryContactRepository, InMemoryEventTransport, InMemoryLeadRepository, InMemoryLossReasonRepository, InMemoryNoteRepository, InMemoryOpportunityRepository, InMemoryOutreachPort, InMemoryPipelineRepository, InvalidActivityTransitionError, InvalidLeadTransitionError, InvalidOpportunityTransitionError, LEAD_STATUSES, LEAD_TRANSITIONS, type Lead, LeadAlreadyConvertedError, LeadConverted, type LeadConvertedPayload, LeadCreated, type LeadCreatedPayload, LeadDisqualified, type LeadDisqualifiedPayload, type LeadFilter, type LeadRepository, LeadScored, type LeadScoredPayload, type LeadScorer, LeadService, type LeadServiceConfig, type LeadStatus, LeadStatusChanged, type LeadStatusChangedPayload, type LeadStatusEntry, type LoseInput, type LossReason, type LossReasonRepository, type MoveStageInput, NotFoundError, type Note, NoteAdded, type NoteAddedPayload, type NoteRepository, NullOutreachPort, OPPORTUNITY_STATUSES, OPPORTUNITY_TRANSITIONS, type Opportunity, OpportunityAbandoned, type OpportunityAbandonedPayload, OpportunityCreated, type OpportunityCreatedPayload, type OpportunityFilter, OpportunityLost, type OpportunityLostPayload, type OpportunityRepository, OpportunityService, type OpportunityServiceConfig, OpportunityStageAdvanced, type OpportunityStageAdvancedPayload, OpportunityStageRegressed, type OpportunityStageRegressedPayload, type OpportunityStatus, type OpportunityStatusEntry, OpportunityWon, type OpportunityWonPayload, type OutreachPort, type OutreachSendRequest, type OutreachSendResult, type Pipeline, PipelineArchived, type PipelineArchivedPayload, PipelineCreated, type PipelineCreatedPayload, type PipelineRepository, PipelineService, type PipelineServiceConfig, type RecordedEvent, type RecordedOutreach, SUBJECT_KINDS, type Stage, StageNotInPipelineError, type SubjectKind, canTransitionActivity, canTransitionLead, canTransitionOpportunity, composeScorers, createSequentialIdGenerator, crmEventDefinitions, cryptoIdGenerator, defaultLeadScorer, forecast, pipelineConversion, systemClock };
+//# sourceMappingURL=index.d.ts.map