@leadpoet/client 0.1.3 → 0.1.5

package/types/shared/outreach-audience-segments.d.ts

@@ -0,0 +1,135 @@
+import { z } from "zod";
+import { type AudienceContactFacts, type AudienceFilters, type AudienceSeniority } from "./outreach-audience-filters";
+/**
+ * Seniority from title words alone. Null without a title, or when the title
+ * names neither a level nor an individual contributor's job, so a seniority
+ * filter excludes the contact instead of guessing.
+ */
+export declare function contactSeniorityForTitle(title: unknown): AudienceSeniority | null;
+export interface AudienceFactSources {
+    title: unknown;
+    contact: {
+        country?: unknown;
+        state?: unknown;
+    };
+    /** The linked company, or the contact's own company fields without one. Null hides company facts. */
+    company: {
+        industry?: unknown;
+        sub_industry?: unknown;
+        employee_count?: unknown;
+        hq_country?: unknown;
+        hq_state?: unknown;
+    } | null;
+    signals: readonly string[];
+}
+/** Location is the contact's own, else the company's HQ, never a mix. */
+export declare function audienceContactFacts(sources: AudienceFactSources): AudienceContactFacts;
+export declare const AUDIENCE_FACET_KEYS: readonly ["departments", "seniorities", "countries", "states", "industries", "sub_industries", "company_sizes", "signals"];
+export type AudienceFacetKey = (typeof AUDIENCE_FACET_KEYS)[number];
+export declare const audienceFacetsSchema: z.ZodObject<{
+    total: z.ZodNumber;
+    dimensions: z.ZodArray<z.ZodObject<{
+        key: z.ZodEnum<["departments", "seniorities", "countries", "states", "industries", "sub_industries", "company_sizes", "signals"]>;
+        options: z.ZodArray<z.ZodObject<{
+            value: z.ZodString;
+            label: z.ZodString;
+            count: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            value: string;
+            label: string;
+            count: number;
+        }, {
+            value: string;
+            label: string;
+            count: number;
+        }>, "many">;
+        /** Contacts with no value here; an active filter excludes them. */
+        missing: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        options: {
+            value: string;
+            label: string;
+            count: number;
+        }[];
+        key: "signals" | "departments" | "seniorities" | "industries" | "company_sizes" | "countries" | "states" | "sub_industries";
+        missing: number;
+    }, {
+        options: {
+            value: string;
+            label: string;
+            count: number;
+        }[];
+        key: "signals" | "departments" | "seniorities" | "industries" | "company_sizes" | "countries" | "states" | "sub_industries";
+        missing: number;
+    }>, "many">;
+    segments: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        count: z.ZodNumber;
+        filters: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        label: string;
+        count: number;
+        filters: Record<string, string[]>;
+    }, {
+        id: string;
+        label: string;
+        count: number;
+        filters: Record<string, string[]>;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    total: number;
+    dimensions: {
+        options: {
+            value: string;
+            label: string;
+            count: number;
+        }[];
+        key: "signals" | "departments" | "seniorities" | "industries" | "company_sizes" | "countries" | "states" | "sub_industries";
+        missing: number;
+    }[];
+    segments: {
+        id: string;
+        label: string;
+        count: number;
+        filters: Record<string, string[]>;
+    }[];
+}, {
+    total: number;
+    dimensions: {
+        options: {
+            value: string;
+            label: string;
+            count: number;
+        }[];
+        key: "signals" | "departments" | "seniorities" | "industries" | "company_sizes" | "countries" | "states" | "sub_industries";
+        missing: number;
+    }[];
+    segments: {
+        id: string;
+        label: string;
+        count: number;
+        filters: Record<string, string[]>;
+    }[];
+}>;
+export type AudienceFacets = z.infer<typeof audienceFacetsSchema>;
+export type AudienceSegment = AudienceFacets["segments"][number];
+/** Each contact's filterable values for one dimension; empty means missing. */
+export declare function audienceFacetValues(key: AudienceFacetKey, facts: AudienceContactFacts): Array<{
+    value: string;
+    label: string;
+}>;
+/**
+ * Counts per filter value across the contacts given, before filters, plus up
+ * to four suggested groups worth their own messaging. Suggestions come only
+ * from the facts counted here, so applying one returns its count from the
+ * same contacts. The picker passes only contacts that can be added.
+ * `segmentFits` leaves out a group that could not be added as a campaign's
+ * whole audience, so the next group is suggested instead.
+ */
+export declare function audienceFacets(contacts: readonly AudienceContactFacts[], options?: {
+    segmentFits?: (filters: AudienceFilters) => boolean;
+}): AudienceFacets;
+/** A suggested group as filters; the rest of the current filters are dropped. */
+export declare function audienceSegmentFilters(segment: AudienceSegment): AudienceFilters;

package/types/shared/outreach-enums.d.ts

@@ -0,0 +1,22 @@
+export declare const OUTREACH_MODES: readonly ["copilot", "autopilot"];
+export type OutreachMode = (typeof OUTREACH_MODES)[number];
+export declare const OUTREACH_AUTOPILOT_SCOPES: readonly ["recommended", "all"];
+export type OutreachAutopilotScope = (typeof OUTREACH_AUTOPILOT_SCOPES)[number];
+export declare const OUTREACH_STRATEGY_GOALS: readonly ["meeting", "question", "referral", "website_traffic", "resource", "sample"];
+export type OutreachStrategyGoal = (typeof OUTREACH_STRATEGY_GOALS)[number];
+export declare const OUTREACH_EVIDENCE_TIERS: readonly ["signal_led", "role_problem_hypothesis", "insufficient"];
+export type OutreachEvidenceTier = (typeof OUTREACH_EVIDENCE_TIERS)[number];
+export declare const OUTREACH_RELATIONSHIP_STATES: readonly ["none", "existing_contact", "existing_company", "open_deal", "ambiguous", "unknown"];
+export type OutreachRelationshipState = (typeof OUTREACH_RELATIONSHIP_STATES)[number];
+export declare const OUTREACH_ACTIONS: readonly ["research_more", "draft", "queue_send", "wait", "review", "stop"];
+export type OutreachAction = (typeof OUTREACH_ACTIONS)[number];
+export declare const OUTREACH_SHADOW_VERDICTS: readonly ["would_send", "would_review", "would_no_send", "would_wait"];
+export type OutreachShadowVerdict = (typeof OUTREACH_SHADOW_VERDICTS)[number];
+export declare const OUTREACH_HUMAN_ACTIONS: readonly ["approved", "edited_approved", "denied", "skipped", "suppressed", "expired"];
+export type OutreachHumanAction = (typeof OUTREACH_HUMAN_ACTIONS)[number];
+export declare const OUTREACH_DIVERGENCE_CLASSES: readonly ["agree_send", "agree_hold", "content_divergence", "false_accept_style", "false_accept_safety", "false_reject"];
+export type OutreachDivergenceClass = (typeof OUTREACH_DIVERGENCE_CLASSES)[number];
+export declare const OUTREACH_REPLY_CLASSIFICATIONS: readonly ["opt_out", "bounce", "out_of_office", "automated", "positive", "question", "objection", "referral", "not_now", "negative", "ambiguous"];
+export type OutreachReplyClassification = (typeof OUTREACH_REPLY_CLASSIFICATIONS)[number];
+export declare const OUTREACH_OUTCOME_TYPES: readonly ["qualified_positive_reply", "question_substantive_response", "referral_qualified_person_named", "resource_requested", "resource_meaningfully_used", "sample_accepted", "meeting_requested", "meeting_accepted", "meeting_booked", "meeting_held", "meeting_qualified_held", "qualified_meeting_booked", "poor_fit_meeting", "qualified_meeting_held", "opportunity_created", "opportunity_qualified", "opportunity_disqualified", "opportunity_won", "opportunity_lost", "website_meaningful_visit", "meeting_no_show", "meeting_cancelled", "meeting_disqualified", "complaint", "hard_bounce", "opt_out", "negative_reply", "unsupported_claim_incident"];
+export type OutreachOutcomeType = (typeof OUTREACH_OUTCOME_TYPES)[number];

package/types/shared/outreach-v2-contract.d.ts

@@ -0,0 +1,253 @@
+import { OUTREACH_ACTIONS, OUTREACH_SHADOW_VERDICTS, OUTREACH_DIVERGENCE_CLASSES, OUTREACH_HUMAN_ACTIONS, OUTREACH_EVIDENCE_TIERS, OUTREACH_RELATIONSHIP_STATES, OUTREACH_REPLY_CLASSIFICATIONS, OUTREACH_OUTCOME_TYPES, OUTREACH_MODES, OUTREACH_AUTOPILOT_SCOPES, type OutreachAction, type OutreachShadowVerdict, type OutreachDivergenceClass, type OutreachHumanAction, type OutreachEvidenceTier, type OutreachRelationshipState, type OutreachMode, type OutreachAutopilotScope, type OutreachReplyClassification, type OutreachOutcomeType } from "./outreach-enums";
+export { OUTREACH_ACTIONS, OUTREACH_SHADOW_VERDICTS, OUTREACH_DIVERGENCE_CLASSES, OUTREACH_HUMAN_ACTIONS, OUTREACH_EVIDENCE_TIERS, OUTREACH_RELATIONSHIP_STATES, OUTREACH_REPLY_CLASSIFICATIONS, OUTREACH_OUTCOME_TYPES, OUTREACH_MODES, OUTREACH_AUTOPILOT_SCOPES, };
+export type { OutreachAction, OutreachShadowVerdict, OutreachDivergenceClass, OutreachHumanAction, OutreachEvidenceTier, OutreachRelationshipState, OutreachMode, OutreachAutopilotScope, OutreachReplyClassification, OutreachOutcomeType, };
+/** Product outreach links must resolve to a public HTTPS host. */
+export declare function isPublicOutboundHttpsUrl(value: string): boolean;
+export interface OutreachRequestDeliveryState {
+    status?: string | null;
+    request_kind?: string | null;
+}
+export declare function isOutreachDeliveredRequest(request: OutreachRequestDeliveryState): boolean;
+export declare const OUTREACH_V2_FLAGS: readonly ["OUTREACH_V2_UI", "OUTREACH_V2_ENGINE", "OUTREACH_V2_AUTOPILOT", "OUTREACH_V2_EXTERNAL_RECIPIENTS", "OUTREACH_V2_LINKEDIN_ASSIST", "OUTREACH_V2_LINKEDIN_TRANSPORT", "OUTREACH_V2_LINKEDIN_EXTERNAL_RECIPIENTS"];
+export type OutreachV2Flag = (typeof OUTREACH_V2_FLAGS)[number];
+export declare const OUTREACH_DENY_REASONS: readonly ["too_generic", "too_salesy", "unnatural_tone", "repeated_pitch", "did_not_answer", "wrong_angle", "wrong_proof", "too_long", "cta_too_strong", "unsupported_claim", "wrong_person", "timing_after_reply", "relationship_conflict", "compliance_issue", "custom"];
+export type OutreachDenyReason = (typeof OUTREACH_DENY_REASONS)[number];
+export declare const OUTREACH_DRAFT_EDIT_KINDS: readonly ["light", "shortened", "lengthened", "rewritten"];
+export type OutreachDraftEditKind = (typeof OUTREACH_DRAFT_EDIT_KINDS)[number];
+export declare const OUTREACH_SAFETY_DENY_REASONS: readonly OutreachDenyReason[];
+export declare function isSafetyDenyReason(reason: string | null | undefined): boolean;
+export declare const OUTREACH_V2_ERROR_CODES: readonly ["TENANT_MISMATCH", "NOT_ELIGIBLE", "DESTINATION_ACTIVE", "IDENTITY_AMBIGUOUS", "SUPPRESSED", "REPLY_RECEIVED", "COOLDOWN_ACTIVE", "RELATIONSHIP_BLOCKED", "COMPANY_PACING", "EVIDENCE_INSUFFICIENT", "EVIDENCE_UNTRUSTED", "PROOF_EXPIRED", "INJECTION_DETECTED", "QUALITY_FAILED", "ACCOUNT_UNAVAILABLE", "HEALTH_STALE", "CAP_REACHED", "COST_CAP_REACHED", "AUTOPILOT_NOT_AUTHORIZED", "VERSION_CONFLICT", "ALREADY_AUTHORIZED", "AUTHORIZATION_EXPIRED", "PROVIDER_RETRYABLE", "PROVIDER_TERMINAL"];
+export type OutreachV2ErrorCode = (typeof OUTREACH_V2_ERROR_CODES)[number];
+export declare const OUTREACH_V2_EVENT_CODES: readonly ["strategy_launched", "strategy_paused", "strategy_resumed", "strategy_mode_changed", "strategy_safety_reverted", "member_admitted", "member_rejected", "action_decided", "verdict_frozen", "verdict_revealed", "divergence_classified", "generation_passed", "generation_failed", "claim_validation_passed", "claim_validation_failed", "review_action", "send_authorized", "send_queued", "send_attempted", "send_succeeded", "send_failed", "send_blocked_by_recheck", "reply_detected", "reply_classified", "suppression_created", "outcome_derived", "outcome_corrected", "breaker_opened", "breaker_closed", "strategy_review_generated", "strategy_review_applied", "voice_profile_updated"];
+export type OutreachV2EventCode = (typeof OUTREACH_V2_EVENT_CODES)[number];
+export declare const OUTREACH_V2_JOB_KINDS: readonly ["prepare_approval", "plan_enrollment", "send_message", "reconcile_send", "classify_reply", "strategy_review", "recommendation_refresh"];
+export type OutreachV2JobKind = (typeof OUTREACH_V2_JOB_KINDS)[number];
+export interface SendMessageJobPayload {
+    message_id: string;
+    authorized_content_hash: string;
+}
+export interface SendGateContext {
+    mode: OutreachMode;
+    autopilotScope: OutreachAutopilotScope;
+    safetyReverted: boolean;
+    /** Cohort key of the enrollment (tier × touch), per §9.3. */
+    cohort: OutreachCohortKey;
+    /** Is this cohort currently ledger-recommended? */
+    cohortRecommended: boolean;
+    /** Deterministic eligibility result codes that currently fail (empty = pass). */
+    eligibilityFailures: string[];
+    /** Independent claim gate passed (§8.3). */
+    claimsEntailed: boolean;
+    /** Explicit candidate readiness; omitted by historical callers. */
+    autopilotQualityReady?: boolean;
+    /** Whether the editorial judge must pass before the send can proceed. */
+    editorialEvaluation?: "required" | "not_required";
+    /** Judge outcome. */
+    judgeScore: number | null;
+    judgeBlockingReasons: string[];
+    /** Versioned Autopilot threshold in force. */
+    autopilotJudgeThreshold: number;
+    /** Account health is fresh + sendable, caps clear. */
+    accountReady: boolean;
+    complianceComplete: boolean;
+    quietHoursClear: boolean;
+    intendedSendAt: string | null;
+}
+export interface SendGateEvaluation {
+    verdict: OutreachShadowVerdict;
+    reasonCodes: string[];
+    judgeScore: number | null;
+    riskClass: string | null;
+    intendedSendAt: string | null;
+    /** True only when verdict is would_send AND mode/scope authorize execution. */
+    execute: boolean;
+}
+export interface OutreachCohortKey {
+    evidenceTier: OutreachEvidenceTier;
+    /** 1 = first touch; 2 = any follow-up. Coarse on purpose. */
+    touchClass: 1 | 2;
+}
+export declare function cohortKeyString(key: OutreachCohortKey): string;
+export interface CohortRecommendationDefaults {
+    /** Sample: the last N would_send verdicts... */
+    sampleSize: number;
+    /** ...none older than this many days. */
+    recencyDays: number;
+    maxFalseAcceptSafety: number;
+    maxFalseAcceptStyleRate: number;
+    maxEditRate: number;
+}
+export declare const OUTREACH_RECOMMENDATION_DEFAULTS: CohortRecommendationDefaults;
+export declare const OUTREACH_STYLE_DIMENSIONS: readonly ["style", "angle", "cta", "opening", "subject", "tier"];
+export type OutreachStyleDimension = (typeof OUTREACH_STYLE_DIMENSIONS)[number];
+/** `learning` = not enough delivered to say anything; `on_par` = measured, no
+ *  detectable difference. Neither is ever rendered as a win or a loss. */
+export type OutreachStyleVerdict = "working" | "on_par" | "underperforming" | "learning";
+export interface OutreachStyleRow {
+    key: string;
+    /** Raw enum parts; the client owns human labels. */
+    parts: string[];
+    delivered: number;
+    replies: number;
+    reply_rate: number;
+    qualified: number;
+    qualified_rate: number;
+    opt_outs: number;
+    verdict: OutreachStyleVerdict;
+    /** Delivered messages still needed before this row can earn a verdict. */
+    needed: number;
+}
+export interface OutreachStyleBoard {
+    window_days: number;
+    min_delivered: number;
+    baseline: {
+        delivered: number;
+        replies: number;
+        reply_rate: number;
+        qualified: number;
+        qualified_rate: number;
+    };
+    boards: Record<OutreachStyleDimension, OutreachStyleRow[]>;
+}
+export interface OutreachStyleBoardDefaults {
+    windowDays: number;
+    /** Verdict floor. Below this a row reads "learning", never a rate call. */
+    minDelivered: number;
+    /** Wilson z. 1.645 = 90% two-sided — the usual working confidence for a
+     *  readout that informs a human decision rather than gating a send. */
+    z: number;
+}
+export declare const OUTREACH_STYLE_BOARD_DEFAULTS: OutreachStyleBoardDefaults;
+export declare const OUTREACH_V2_DEFAULTS: {
+    readonly maxTouches: 3;
+    readonly campaignWindowDays: 21;
+    readonly minTouchSpacingHours: 72;
+    readonly cooldownDays: 90;
+    readonly evidenceTtlDays: 30;
+    readonly approvalTtlDays: 7;
+    /** Ramp cap for newly enabled Autopilot strategies (§9.3). Ten days at the
+     *  same daily cap is the compensating control for the 40-sample
+     *  recommendation window: ~2x the supervised volume before full rate. */
+    readonly autopilotRampDailyCap: 20;
+    readonly autopilotRampDays: 10;
+    /** Per-company pacing (§7.4). */
+    readonly companyConcurrencyCap: 2;
+    readonly companyFirstTouchSpacingHours: 24;
+    readonly negativeReplyPropagation: true;
+    /** Versioned Autopilot judge threshold (never silently lowered, §8.3). */
+    readonly autopilotJudgeThreshold: 0.8;
+    readonly copilotJudgeThreshold: 0.6;
+    /** Reply SLA target inside coverage hours (§5.5), minutes. */
+    readonly replySlaMinutes: 15;
+    /** OOO auto-resume buffer (§5.5), hours. */
+    readonly oooResumeBufferHours: 24;
+    /** Each weekly review reads two weeks, so a typical campaign clears the
+     *  sample floor by its second review. */
+    readonly strategyReviewWindowDays: 14;
+    /** No review before a campaign has run this long: one week is too thin. */
+    readonly strategyReviewMinCampaignDays: 10;
+    readonly strategyReviewEveryNDelivered: 100;
+    /** Minimum cell size before a Strategy Review may cite a slice (§5.8). */
+    readonly strategyReviewMinSample: 20;
+};
+export declare function classifyDivergence(input: {
+    verdict: OutreachShadowVerdict | null;
+    humanAction: OutreachHumanAction;
+    denyReason?: string | null;
+}): OutreachDivergenceClass | null;
+export declare const OUTREACH_AUDIENCE_PUBLICATION_GATE_VERSION = "direct-bridge-ready-v1";
+export interface QualifiedAudienceMemberImport {
+    lead_id: string;
+    canonical_person_id?: string | null;
+    company_id?: string | null;
+    evidence_tier: OutreachEvidenceTier;
+    qualification_evidence_ids?: string[];
+    destinations: {
+        email?: string | null;
+        linkedin?: string | null;
+    };
+    relationship_state?: OutreachRelationshipState;
+    membership_reason?: string | null;
+}
+export interface QualifiedAudienceSnapshotImport {
+    source_type: "saved_snapshot" | "pipeline_filter" | "explicit_selection";
+    source_id?: string | null;
+    source_version?: string | null;
+    qualification_definition_version?: string;
+    publication_gate_version?: string;
+    fresh_until?: string | null;
+    members: QualifiedAudienceMemberImport[];
+}
+export interface OutreachProofClaim {
+    id: string;
+    text: string;
+    type: "customer_result" | "metric" | "capability" | "social_proof";
+    customer_ref?: string | null;
+    attested_at?: string | null;
+    valid_until?: string | null;
+    status: "active" | "expired" | "retired";
+}
+/**
+ * A claim a message may cite: active, approved no later than `now` and not
+ * past its date. An unreadable date counts as not current. The claim writer
+ * and the agent's GTM context share this one rule.
+ */
+export declare function isCurrentAttestedClaim(claim: {
+    status?: string | null;
+    attested_at?: string | null;
+    valid_until?: string | null;
+}, now: Date): boolean;
+export interface OutreachVoiceProfileContract {
+    rules: string[];
+    examples: string[];
+    version: number;
+    sender_name?: string | null;
+    sender_role?: string | null;
+    sender_company?: string | null;
+    sign_off?: string | null;
+    cta_style?: string | null;
+    website_cta?: {
+        url: string | null;
+        description?: string | null;
+        action_label?: string | null;
+    };
+    /** Optional per-sending-account overlays — deferred (§21), shape reserved. */
+    sender_overrides?: Record<string, {
+        rules?: string[];
+        examples?: string[];
+    }>;
+}
+export interface OutreachComplianceProfile {
+    legal_entity?: string | null;
+    postal_address?: string | null;
+    opt_out_method?: string | null;
+    /** Campaign render input only: the sender's own opt-out sentence. */
+    opt_out_text?: string | null;
+    regions?: string[];
+}
+export declare function complianceProfileComplete(c: OutreachComplianceProfile | null | undefined): boolean;
+export declare const OUTREACH_EVIDENCE_TYPES: readonly ["funding", "hiring", "job_post", "product_launch", "tech_stack", "exec_move", "news", "content", "intent", "role", "company_fact"];
+export type OutreachEvidenceType = (typeof OUTREACH_EVIDENCE_TYPES)[number];
+export declare const OUTREACH_CTA_TYPES: readonly ["soft_interest", "question", "resource_offer", "meeting_ask", "referral_ask", "website_visit"];
+export type OutreachCtaType = (typeof OUTREACH_CTA_TYPES)[number];
+export declare const OUTREACH_ANGLES: readonly ["signal_observation", "role_problem_hypothesis", "proof_led", "referral_ask"];
+export type OutreachAngle = (typeof OUTREACH_ANGLES)[number];
+export interface OutreachMessageAttributes {
+    /** Composer contract that produced the persisted subject/body bytes. */
+    message_composition_policy_version?: string;
+    /** Free prose from the generator — unique per message, for the reviewer. */
+    angle: OutreachAngle | string;
+    /** The sliceable class derived from proof/CTA/tier. Analysis groups on this;
+     *  grouping on `angle` yields one row per message and never earns a verdict. */
+    angle_class?: OutreachAngle | string;
+    cta_type: OutreachCtaType | string;
+    proof_claim_ids?: string[];
+    opening_style?: "observation" | "question" | "direct" | string;
+    subject_style?: "topic" | "question" | "name_drop" | "plain" | string;
+    /** Coarse, deterministic job family. This is never a personality inference. */
+    role_family?: "executive" | "sales" | "marketing" | "operations" | "product_technical" | "other" | string;
+    evidence_tier?: "signal_led" | "role_problem_hypothesis" | "insufficient" | string;
+    /** Human edits remain visible in reporting but are excluded from automatic promotion. */
+    human_edited?: boolean;
+}
+export declare function canonicalMessageContent(subject: string | null, body: string): string;

package/types/shared/plan-entitlements.d.ts

@@ -0,0 +1,75 @@
+/**
+ * What each plan includes beyond its monthly credits. The database holds the
+ * same numbers (public.plan_outreach_account_limit_v1,
+ * public.plan_outreach_sender_total_v1,
+ * public.plan_included_contacts_per_company_v1,
+ * public.plan_ai_action_allowance_v1 and public.plan_workspace_daily_limit_v1)
+ * and enforces them; supabase/tests/plan_entitlements_test.sql,
+ * ai_action_allowance_test.sql and workspace_daily_limits_test.sql keep the
+ * two equal. Staff can
+ * raise one workspace above its plan, never lower it below.
+ */
+export type PlanEntitlementTier = "free" | "launch" | "growth" | "accelerate" | "scale";
+export type PlanEntitlements = {
+    emailInboxes: number;
+    linkedinAccounts: number;
+    /**
+     * Senders in total across both channels, or null when each channel has its
+     * own allowance. Free has one: an email inbox or a LinkedIn account.
+     * Add-ons and staff raises come on top.
+     */
+    sendersTotal: number | null;
+    contactsPerAccount: number;
+    /** AI-written contact sequences a calendar month (UTC); unused ones lapse. */
+    aiActionsPerMonth: number;
+    /**
+     * Small AI requests that use no AI action (reply suggestions, AI search,
+     * account summaries and the like), per aiRequestWindow. null: not limited.
+     */
+    aiRequests: number | null;
+    /** A UTC day, or a UTC week from Monday. */
+    aiRequestWindow: "day" | "week";
+    /** Find a person lookups, hit or miss, in any 24 hours. */
+    findPersonPerDay: number;
+    /**
+     * People in the workspace: its owner, each teammate and each pending
+     * invitation. 1 means the owner works alone, with no team.
+     */
+    teamSeats: number;
+    /** Whether the workspace can buy seats on top, a seat a month each. */
+    extraTeamSeats: boolean;
+};
+export declare const PLAN_ENTITLEMENTS: Record<PlanEntitlementTier, PlanEntitlements>;
+export declare function planEntitlements(plan: string | null | undefined): PlanEntitlements;
+export type SenderChannel = "email" | "linkedin";
+export type SenderChannelState = {
+    addon: number;
+    base: number;
+    connected: number;
+};
+/**
+ * The add-ons a channel cannot drop below, given the add-ons chosen for the
+ * other channel: removing a paid slot a connected sender uses would leave the
+ * workspace over its limit. With a shared sender total (Free's one inbox or
+ * LinkedIn account) the plan's sender covers either channel, so a channel's
+ * share is what the total leaves after the other channel's senders that its
+ * add-ons do not pay for, as public.outreach_account_limit_v1 computes for a
+ * plan whose per-channel allowance equals its total (Free's does). An add-on
+ * increase on the other channel counts only once paid, so it never covers a
+ * removal here.
+ */
+export declare function minimumSenderAddon(channel: SenderChannel, channels: Record<SenderChannel, SenderChannelState>, senderTotal: number | null, otherTarget: number): number;
+/**
+ * The bought seats a workspace cannot drop below: removing a paid seat that a
+ * teammate or a pending invitation uses would leave the team over its limit.
+ * Seats that count nothing (a lapsed subscription's) can always be removed,
+ * and so can every seat on a plan that sells none, such as after a downgrade
+ * from Accelerate. Nobody is removed either way, so a team that plan does not
+ * include never has to keep paying for its seats.
+ */
+export declare function minimumTeamSeatAddon(seats: {
+    plan: string | null | undefined;
+    planSeats: number;
+    addonSeats: number;
+    seatsUsed: number;
+}): number;

package/types/shared/plan-features.d.ts

@@ -0,0 +1,50 @@
+export declare const plural: (count: number, one: string, many: string) => string;
+/** What one AI action buys, as the metering counts it, for the pricing page and /pricing.md. */
+export declare const AI_ACTION_DEFINITION = "One AI action writes one personalized outreach sequence for one contact in a campaign, follow-ups included, or gives one sales assistant answer or scheduled run.";
+/**
+ * Credits Signals charges for each watched account a week. Mirrors
+ * `ACCOUNT_MONITORING_WEEKLY_CREDITS` in `account-monitoring.ts`, which this
+ * file can't import without zod; a spec keeps them equal.
+ */
+export declare const SIGNALS_WEEKLY_CREDITS = 2;
+/** What Signals watches, for the pricing page and /pricing.md. */
+export declare const SIGNALS_DESCRIPTION = "Signals checks the accounts you choose and their contacts every week, and alerts you to new job postings, funding, company news, new technology and role changes.";
+/** Signals as a plan item. It names its cost, because no plan includes Signals without credits. */
+export declare const SIGNALS_FEATURE: string;
+export declare const PLAN_FEATURES: {
+    readonly free: readonly ["Company & contact pipeline", "Email & LinkedIn outreach", string, string, "Personalized sequences & follow-ups", "Reply & campaign tracking", "AI pipeline search", string, "HubSpot, Slack & webhooks", "Excel (.xlsx) export"];
+    readonly launch: readonly ["Everything in Free", string, string, string, "Verified, intent-scored accounts", "25+ buying signal sources", "Company & role targeting", "Email support"];
+    readonly accelerate: readonly ["Everything in Free", string, string, string, string, "Verified, intent-scored accounts", "25+ buying signal sources", "Company & role targeting", "Onboarding & priority email support"];
+    readonly scale: readonly ["Everything in Free", "Verified, intent-scored accounts", "25+ buying signal sources", "Company & role targeting", "Custom LinkedIn & email account limits", "Custom team size", "Onboarding & priority email support", "Dedicated account manager", "Custom integrations"];
+};
+/**
+ * Mirrors the request credit costs in `request-credit-budget.ts` and
+ * `company-request-contacts.ts`, which this file can't import without zod; a
+ * spec keeps them equal.
+ */
+export declare const SOLUTION_CREDIT_COSTS: {
+    readonly account: 10;
+    readonly extraContact: 5;
+    readonly mobileNumber: 1;
+};
+/** Accounts with one contact each that a month's credits buy. */
+export declare const accountsPerMonth: (monthlyCredits: number) => number;
+/**
+ * Add-ons at their lowest step. Senders and packs are sold on every plan,
+ * Free included; an extra team seat only on a plan with `extraTeamSeats`.
+ * Mirrors `SENDER_ADDONS`, `TEAM_SEAT_ADDON` and the pack definitions in
+ * `server/billing/catalog.ts`; a spec keeps them equal.
+ */
+export declare const ADD_ON_PRICES: {
+    readonly emailInboxMonthlyUsd: 10;
+    readonly linkedinAccountMonthlyUsd: 40;
+    readonly teamSeatMonthlyUsd: 20;
+    readonly aiPack: {
+        readonly actions: 200;
+        readonly usd: 10;
+    };
+    readonly leadPack: {
+        readonly credits: 100;
+        readonly usd: 60;
+    };
+};

package/types/shared/request-credit-constants.d.ts

@@ -0,0 +1,13 @@
+export declare const COMPANY_REQUEST_CREDIT_COST = 10;
+export declare const COMPANY_REQUEST_MIN_COMPANIES = 10;
+export declare const COMPANY_REQUEST_MAX_COMPANIES = 100;
+/** Lead Search: credits for each contact a search delivers (Gavin, Nov 11 2026). Nothing charges it yet. */
+export declare const LEAD_SEARCH_CONTACT_CREDIT_COST = 2;
+export declare const COMPANY_REQUEST_MIN_CREDITS: number;
+export declare const COMPANY_REQUEST_MAX_CREDITS: number;
+/**
+ * Find a person holds this many credits per lookup and keeps them only when a
+ * verified email is found. start_find_person_lookup holds the same amount.
+ */
+export declare const FIND_PERSON_CREDIT_COST = 1;
+export declare const FIND_PERSON_CREDIT_LABEL: string;

package/types/shared/website-fact-language.d.ts

@@ -0,0 +1,9 @@
+/** True when a sentence's English function words outnumber common Spanish, French, German,
+ * Nordic and Italian ones. */
+export declare function websiteFactReadsAsEnglish(text: string): boolean;
+/**
+ * True when a fact a person entered is clearly in another language: its non-English function words
+ * outnumber English ones, or most of its letters are not Latin. Unlike the scan's check, a short
+ * English fact without function words ("Search answers in under fifty milliseconds.") passes.
+ */
+export declare function websiteFactIsNotEnglish(text: string): boolean;