@wirecat/cli-core 0.586.0 → 0.588.0

package/dist/store/sqlite/deals.d.ts

@@ -1,31 +1,61 @@
-import { type DealRole, type DealStatus } from "../../domain/deals.js";
-import { type FinanceReview } from "../../domain/finance.js";
-import { type Decider } from "../decisions.js";
+import { type DealKind, type DealRole, type DealStatus, type StageOutcome } from "../../domain/deals.js";
 import { type ProposedByFilter } from "./actors.js";
-import { type Party, type Reviewed, type Written } from "./finance.js";
+import { type Party } from "./finance.js";
 import { type Author } from "./memories.js";
 import type { StoreContext } from "./open.js";
 export interface PipelineStage {
     name: string;
     position: number;
-    /** Open deals standing in it, the owner's and agents' not rejected. */
+    outcome: StageOutcome;
+    externalId: string | null;
+    /** Open deals or leads standing in it now. */
     open: number;
 }
 export interface Pipeline {
+    id: string;
+    ref: string;
     name: string;
+    kind: DealKind;
+    /** The CRM account it was copied from; `null` for the owner's or an agent's own. */
+    account: {
+        provider: string;
+        account: string;
+    } | null;
+    externalId: string | null;
     stages: PipelineStage[];
     createdAt: string;
 }
+export interface FunnelStage extends PipelineStage {
+    /** Rows that got this far: entered this stage or a later one that is not lost, or were won. */
+    reached: number;
+    /** `reached` of the next stage that is not lost over this stage's, 0–1; `null` for the last or an empty one. */
+    conversion: number | null;
+}
+/** A pipeline with its funnel, counted from `pipeline_stage_changes`. */
+export interface PipelineReport extends Omit<Pipeline, "stages"> {
+    stages: FunnelStage[];
+    totals: {
+        items: number;
+        open: number;
+        won: number;
+        lost: number;
+        winRate: number | null;
+    };
+    /** `YYYY-MM-DD`: only rows made since that day are counted; `null` for all. */
+    since: string | null;
+}
 export interface DealPerson extends Party {
     role: DealRole;
 }
-export interface Deal extends Reviewed {
+export interface Deal {
     id: string;
     ref: string;
+    kind: DealKind;
     title: string;
-    /** One line with stage, amount and status, as a list or the review inbox prints it. */
+    /** One line with stage, amount and status, as a list prints it. */
     summary: string;
     pipeline: string;
+    pipelineName: string;
     stage: string;
     status: DealStatus;
     organization: Party | null;
@@ -36,14 +66,44 @@ export interface Deal extends Reviewed {
     closeDate: string | null;
     /** `YYYY-MM-DD`: the day it was won or lost. */
     closedDate: string | null;
-    /** Why it was won or lost, as the owner said when closing it. */
+    /** Why it was won or lost, as given when closing it. */
     closedReason: string | null;
+    rank: number | null;
+    /** A lead's deal, once it became one. */
+    deal: string | null;
+    account: {
+        provider: string;
+        account: string;
+    } | null;
+    externalId: string | null;
     people: DealPerson[];
+    author: {
+        type: "person" | "bot";
+        id: string;
+        name: string | null;
+        kind: "agent" | "rule" | null;
+    };
+    model: string | null;
+    source: string;
+    reason: string | null;
+    evidence: string[];
+    project: string | null;
+    projectName: string | null;
+    createdAt: string;
+    updatedAt: string;
 }
-export interface DealInput extends Written {
+export interface DealInput {
+    /** Who writes it; the owner and an agent write alike, and only the author is kept. */
+    by: Author;
+    /** `deal` when left out. */
+    kind?: DealKind;
     title: string;
-    /** A stage's name; `pipeline` names its pipeline when more than one has a stage of that name. */
-    stage: string;
+    /**
+     * A stage's name, in `pipeline` when given, else in the only pipeline of the kind that has it. A lead may leave it
+     * out when there is one lead pipeline: it starts in that pipeline's first stage.
+     */
+    stage?: string;
+    /** `pipeline:<id>`, or a name only one pipeline of the kind has. */
     pipeline?: string;
     organization?: string;
     /** A decimal string in `currency`; give both or neither. */
@@ -54,51 +114,90 @@ export interface DealInput extends Written {
         person: string;
         role: DealRole;
     }[];
+    project?: string;
+    /** Where an agent's row came from, such as `agent`; the owner's is always `owner`. */
+    source?: string;
+    reason?: string;
+    evidence?: string[];
 }
 export interface DealFilter {
+    /** `deal` when left out. */
+    kind?: DealKind;
     status?: DealStatus;
-    /** A stage's or pipeline's name, in any letter case. */
+    /** A stage's name, in any letter case. */
     stage?: string;
+    /** `pipeline:<id>`, or a name only one pipeline of the kind has. */
     pipeline?: string;
     project?: string;
     organization?: string;
-    review?: FinanceReview;
     proposedBy?: ProposedByFilter;
     /** 1–500, 100 by default; newest written first. */
     limit?: number;
 }
+export interface PipelineInput {
+    name: string;
+    /** `deal` when left out. */
+    kind?: DealKind;
+    /** In order; a bare name is an open stage. */
+    stages: (string | {
+        name: string;
+        outcome?: StageOutcome;
+    })[];
+    by: Author;
+}
 /**
- * The owner's sales pipelines and the deals in them. The owner's deal is confirmed at once; an agent's waits as
- * proposed for him, and only he decides it. Only the owner makes a pipeline, moves a deal or closes it.
+ * Sales pipelines and the deals and leads in them. The owner and his agents write alike: nothing waits for review,
+ * and memo's permission settings are where writes are limited. Every stage a row enters is kept, by triggers, so a
+ * pipeline's report counts conversion between stages.
  */
 export interface DealsStore {
-    addPipeline(input: {
-        name: string;
-        stages: string[];
-        by: Author;
-    }): Promise<Pipeline>;
-    pipelines(): Promise<Pipeline[]>;
+    addPipeline(input: PipelineInput): Promise<Pipeline>;
+    pipelines(filter?: {
+        kind?: DealKind;
+    }): Promise<Pipeline[]>;
+    /** One pipeline by `pipeline:<id>` or a name only one pipeline has, with its funnel. */
+    pipeline(reference: string, options?: {
+        kind?: DealKind;
+        since?: string;
+    }): Promise<PipelineReport>;
     add(input: DealInput): Promise<Deal>;
+    /** `deal:<id>` or `lead:<id>`; a bare id is a deal. */
     get(reference: string): Promise<Deal>;
     list(filter?: DealFilter): Promise<Deal[]>;
-    /** To another stage of the deal's own pipeline. */
+    /** To another stage of its own pipeline; a stage whose outcome is won or lost closes it, an open one reopens it. */
     move(reference: string, input: {
         stage: string;
         by: Author;
     }): Promise<Deal>;
-    /** `date` is the day it closed, today when left out. */
+    /** Won or lost, on `date` (today when left out); it moves to its pipeline's stage of that outcome when there is one. */
     close(reference: string, input: {
         status: Exclude<DealStatus, "open">;
         date?: string;
         reason?: string;
         by: Author;
     }): Promise<Deal>;
-    confirm(reference: string, by: Decider, reason?: string): Promise<Deal>;
-    reject(reference: string, by: Decider, reason?: string): Promise<Deal>;
 }
-type DealOperations = {
-    [K in keyof DealsStore]: DealsStore[K] extends (...args: infer A) => Promise<infer R> ? (...args: A) => R : never;
+export declare const dealOperationsOver: (context: StoreContext) => {
+    addPipeline: ({ name, kind, stages, by }: PipelineInput) => Pipeline;
+    pipelines: (filter?: {
+        kind?: DealKind;
+    }) => Pipeline[];
+    pipeline: (reference: string, options?: {
+        kind?: DealKind;
+        since?: string;
+    }) => PipelineReport;
+    add: (input: DealInput) => Deal;
+    get: (reference: string) => Deal;
+    list: (filter?: DealFilter) => Deal[];
+    move: (reference: string, { stage, by }: {
+        stage: string;
+        by: Author;
+    }) => Deal;
+    close: (reference: string, { status, date, reason, by }: {
+        status: Exclude<DealStatus, "open">;
+        date?: string;
+        reason?: string;
+        by: Author;
+    }) => Deal;
 };
-export declare const dealOperationsOver: (context: StoreContext) => DealOperations;
 export declare const dealsStoreOver: (context: StoreContext) => DealsStore;
-export {};