// AUTO-GENERATED by scripts/generate-app-sdk.ts — do NOT edit by hand.
// Types for the `window.dench` App SDK injected into every Dench App iframe.
//
//   /// <reference types="@dench.com/cli/app-sdk" />
//   /** @type {import("@dench.com/cli/app-sdk").Dench} */
//   const dench = window.dench;
//
// There is NO runtime package: the SDK is already on window.dench.

/* eslint-disable */

// ── Operation request/response types (from cli/lib/api-schemas.ts) ──────

export interface ApiRequests {
  /** List workspace-shared reusable setups and ready revisions (metadata only). — `dench env list` — GET /api/v1/environments */
  "environments.list": {
    limit?: number;
    cursor?: string;
  };
  /** Inspect a saved setup, its manifest, and an optional immutable revision. — `dench env show` — GET /api/v1/environments/{name} */
  "environments.get": {
    name: string;
    revision?: string;
  };
  /** Reserve an owner-bound source upload. Prefix the uploaded bytes with the returned proof before saving. — `dench env save` — POST /api/v1/environments/uploads */
  "environments.upload": {
    kind: "source";
    size: number;
    sha256: string;
  };
  /** Publish an explicitly saved source and manifest for one-time preparation. Returns pending/building until verified; does not run the task. — `dench env save` — POST /api/v1/environments/{name} */
  "environments.save": {
    name: string;
    manifest: {
      version: 1;
      name: string;
      purpose: string;
      files: string[];
      prepare: string[];
      verify: string[];
      env?: Record<string, string>;
      secretEnv?: Record<string, string>;
      secretFiles?: {
        path: string;
        secret: string;
        mutable?: boolean;
      }[];
      statePaths?: string[];
      portable?: boolean;
    };
    uploadId: string;
    storageId: string;
    sha256: string;
  };
  /** Retire a saved setup from new selection; retain immutable revisions and active job evidence. — `dench env delete` — DELETE /api/v1/environments/{name} */
  "environments.delete": {
    name: string;
  };
  /** List workspace-shared credential names, kinds and versions; never values. — `dench secrets list` — GET /api/v1/secrets */
  "secrets.list": {
    limit?: number;
    cursor?: string;
  };
  /** Encrypt a workspace credential. Use CLI stdin or the secure chat form; return metadata only. Do not put values in chat, manifests or scripts. — `dench secrets set` — PUT /api/v1/secrets/{name} */
  "secrets.set": {
    name: string;
    kind: "env" | "file";
    value: string;
    expectedVersion?: number;
  };
  /** Revoke a workspace credential for future resolution, optionally checking its version. — `dench secrets delete` — DELETE /api/v1/secrets/{name} */
  "secrets.delete": {
    name: string;
    expectedVersion?: number;
  };
  /** Create an idempotent empty campaign draft with the caller's available sender pools. Does not launch or send. — `dench campaign draft` — POST /api/v1/campaigns/drafts */
  "campaigns.drafts.create": {
    /** Your stable id for this request, 8-64 characters. Retrying with the same id returns the same draft instead of creating another. */
    clientRequestId: string;
    name?: string;
    /** IANA timezone, e.g. America/Los_Angeles. Sets a Mon-Fri 9-18 send window in it; without one the draft has no send window. */
    timezone?: string;
    /** Mailboxes to send from instead of your own running ones. Checked as the draft is created: one you can't use creates nothing. */
    emailMailboxAccountIds?: string[];
    /** LinkedIn accounts to send from instead of your own running ones. Checked as the draft is created. */
    linkedinAccountIds?: string[];
  };
  /** Search people by filters without adding CRM records or campaign recipients. Search credits apply; this is not a free provider preview. — `dench campaign search` — POST /api/v1/campaigns/audience/search */
  "campaigns.audience.search": {
    sequenceId?: string;
    filters: {
      linkedinUrl?: string;
      fullName?: string;
      firstName?: string;
      lastName?: string;
      /** Current-title text only. For profile or work descriptions, use profileKeywords. Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
      keywords?: string;
      companyDomain?: string;
      companyName?: string;
      /** Current job titles (free text). Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
      titles?: Array<string | {
        value: string;
        exclude?: boolean;
        exactMatch?: boolean;
      }>;
      /** Past job titles (free text). */
      pastTitles?: Array<string | {
        value: string;
        exclude?: boolean;
        exactMatch?: boolean;
      }>;
      personNames?: Array<string | {
        value: string;
        exclude?: boolean;
        exactMatch?: boolean;
      }>;
      /** Seniority in any past role, independent of pastCompanyNames/pastTitles. Current seniority vocabulary plus Founding Team. Founder includes Co-Founder; C-level and Founding Team do not imply founder. Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
      pastSeniorities?: Array<string | {
        value: string;
        exclude?: boolean;
        exactMatch?: boolean;
      }>;
      /** Text in headline/about or any current/past work description. OR includes, global exclusions. Always loose text matching; missing evidence does not match. */
      profileKeywords?: Array<string | {
        value: string;
        exclude?: boolean;
        exactMatch?: boolean;
      }>;
      /** Current employer business focus/model (e.g. SaaS, B2B, Cloud), from description/tagline/business tags; distinct from legal companyTypes. Same employer as other current-job filters. Always loose text matching. May need another filter to retrieve candidates. */
      companyKeywords?: Array<string | {
        value: string;
        exclude?: boolean;
        exactMatch?: boolean;
      }>;
      /** Exact enum: Owner, Founder, C-level, Partner, VP, Head, Director, Manager, Senior. */
      seniorities?: Array<string | {
        value: string;
        exclude?: boolean;
        exactMatch?: boolean;
      }>;
      /** Exact enum, e.g. Sales, Marketing, Software. Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
      jobFunctions?: Array<string | {
        value: string;
        exclude?: boolean;
        exactMatch?: boolean;
      }>;
      /** Exact enum, e.g. SDR/BDR, Demand Generation. Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
      subFunctions?: Array<string | {
        value: string;
        exclude?: boolean;
        exactMatch?: boolean;
      }>;
      /** Exact enum, e.g. Software Development. Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
      industries?: Array<string | {
        value: string;
        exclude?: boolean;
        exactMatch?: boolean;
      }>;
      /** Person locations — cities, states, countries, or metros (free text). Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
      locations?: Array<string | {
        value: string;
        exclude?: boolean;
        exactMatch?: boolean;
      }>;
      /** Exact buckets: 1-10, 11-50, 51-200, 201-500, 501-1000, 1001-5000, 5001-10000, 10001+. */
      headcountRanges?: Array<string | {
        value: string;
        exclude?: boolean;
        exactMatch?: boolean;
      }>;
      companyNames?: Array<string | {
        value: string;
        exclude?: boolean;
        exactMatch?: boolean;
      }>;
      pastCompanyNames?: Array<string | {
        value: string;
        exclude?: boolean;
        exactMatch?: boolean;
      }>;
      companyDomains?: Array<string | {
        value: string;
        exclude?: boolean;
        exactMatch?: boolean;
      }>;
      /** Company HQ locations — cities, states, countries, or metros (free text). Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
      companyHeadquarters?: Array<string | {
        value: string;
        exclude?: boolean;
        exactMatch?: boolean;
      }>;
      /** Exact enum: Partnership, Nonprofit, Educational, Privately Held, Public Company, Self-Owned, Self-Employed, Government Agency. */
      companyTypes?: Array<string | {
        value: string;
        exclude?: boolean;
        exactMatch?: boolean;
      }>;
      /** Universities attended (free text). Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
      universities?: Array<string | {
        value: string;
        exclude?: boolean;
        exactMatch?: boolean;
      }>;
      /** Profile skills (free text). Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
      skills?: Array<string | {
        value: string;
        exclude?: boolean;
        exactMatch?: boolean;
      }>;
      /** Spoken languages, e.g. English, German. Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
      languages?: Array<string | {
        value: string;
        exclude?: boolean;
        exactMatch?: boolean;
      }>;
      yearsInRole?: {
        min?: number;
        max?: number;
      };
      yearsAtCompany?: {
        min?: number;
        max?: number;
      };
      daysSinceJobChange?: {
        min?: number;
        max?: number;
      };
      /** Company founded-year range, e.g. {min: 2015, max: 2024}. */
      foundedYears?: {
        min?: number;
        max?: number;
      };
      /** Match free-text filters as whole strings. Default false: titles ['Founder'] also returns 'Co-Founder' and 'Founder & CEO'. Set true to narrow. Domains, LinkedIn URLs, enum filters and numeric ranges are always exact; keywords is always a loose text probe. */
      exactMatch?: boolean;
      preferCache?: boolean;
    };
    limit?: number;
    pageToken?: string;
  };
  /** Search and add up to 50 people to an existing campaign. New identities become Leads. Search credits apply; use nextPageToken for another page. — `dench campaign add --search` — POST /api/v1/campaigns/{sequenceId}/people/search */
  "campaigns.people.addFromSearch": {
    sequenceId: string;
    filters: {
      linkedinUrl?: string;
      fullName?: string;
      firstName?: string;
      lastName?: string;
      /** Current-title text only. For profile or work descriptions, use profileKeywords. Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
      keywords?: string;
      companyDomain?: string;
      companyName?: string;
      /** Current job titles (free text). Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
      titles?: Array<string | {
        value: string;
        exclude?: boolean;
        exactMatch?: boolean;
      }>;
      /** Past job titles (free text). */
      pastTitles?: Array<string | {
        value: string;
        exclude?: boolean;
        exactMatch?: boolean;
      }>;
      personNames?: Array<string | {
        value: string;
        exclude?: boolean;
        exactMatch?: boolean;
      }>;
      /** Seniority in any past role, independent of pastCompanyNames/pastTitles. Current seniority vocabulary plus Founding Team. Founder includes Co-Founder; C-level and Founding Team do not imply founder. Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
      pastSeniorities?: Array<string | {
        value: string;
        exclude?: boolean;
        exactMatch?: boolean;
      }>;
      /** Text in headline/about or any current/past work description. OR includes, global exclusions. Always loose text matching; missing evidence does not match. */
      profileKeywords?: Array<string | {
        value: string;
        exclude?: boolean;
        exactMatch?: boolean;
      }>;
      /** Current employer business focus/model (e.g. SaaS, B2B, Cloud), from description/tagline/business tags; distinct from legal companyTypes. Same employer as other current-job filters. Always loose text matching. May need another filter to retrieve candidates. */
      companyKeywords?: Array<string | {
        value: string;
        exclude?: boolean;
        exactMatch?: boolean;
      }>;
      /** Exact enum: Owner, Founder, C-level, Partner, VP, Head, Director, Manager, Senior. */
      seniorities?: Array<string | {
        value: string;
        exclude?: boolean;
        exactMatch?: boolean;
      }>;
      /** Exact enum, e.g. Sales, Marketing, Software. Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
      jobFunctions?: Array<string | {
        value: string;
        exclude?: boolean;
        exactMatch?: boolean;
      }>;
      /** Exact enum, e.g. SDR/BDR, Demand Generation. Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
      subFunctions?: Array<string | {
        value: string;
        exclude?: boolean;
        exactMatch?: boolean;
      }>;
      /** Exact enum, e.g. Software Development. Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
      industries?: Array<string | {
        value: string;
        exclude?: boolean;
        exactMatch?: boolean;
      }>;
      /** Person locations — cities, states, countries, or metros (free text). Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
      locations?: Array<string | {
        value: string;
        exclude?: boolean;
        exactMatch?: boolean;
      }>;
      /** Exact buckets: 1-10, 11-50, 51-200, 201-500, 501-1000, 1001-5000, 5001-10000, 10001+. */
      headcountRanges?: Array<string | {
        value: string;
        exclude?: boolean;
        exactMatch?: boolean;
      }>;
      companyNames?: Array<string | {
        value: string;
        exclude?: boolean;
        exactMatch?: boolean;
      }>;
      pastCompanyNames?: Array<string | {
        value: string;
        exclude?: boolean;
        exactMatch?: boolean;
      }>;
      companyDomains?: Array<string | {
        value: string;
        exclude?: boolean;
        exactMatch?: boolean;
      }>;
      /** Company HQ locations — cities, states, countries, or metros (free text). Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
      companyHeadquarters?: Array<string | {
        value: string;
        exclude?: boolean;
        exactMatch?: boolean;
      }>;
      /** Exact enum: Partnership, Nonprofit, Educational, Privately Held, Public Company, Self-Owned, Self-Employed, Government Agency. */
      companyTypes?: Array<string | {
        value: string;
        exclude?: boolean;
        exactMatch?: boolean;
      }>;
      /** Universities attended (free text). Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
      universities?: Array<string | {
        value: string;
        exclude?: boolean;
        exactMatch?: boolean;
      }>;
      /** Profile skills (free text). Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
      skills?: Array<string | {
        value: string;
        exclude?: boolean;
        exactMatch?: boolean;
      }>;
      /** Spoken languages, e.g. English, German. Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
      languages?: Array<string | {
        value: string;
        exclude?: boolean;
        exactMatch?: boolean;
      }>;
      yearsInRole?: {
        min?: number;
        max?: number;
      };
      yearsAtCompany?: {
        min?: number;
        max?: number;
      };
      daysSinceJobChange?: {
        min?: number;
        max?: number;
      };
      /** Company founded-year range, e.g. {min: 2015, max: 2024}. */
      foundedYears?: {
        min?: number;
        max?: number;
      };
      /** Match free-text filters as whole strings. Default false: titles ['Founder'] also returns 'Co-Founder' and 'Founder & CEO'. Set true to narrow. Domains, LinkedIn URLs, enum filters and numeric ranges are always exact; keywords is always a loose text probe. */
      exactMatch?: boolean;
      preferCache?: boolean;
    };
    limit?: number;
    pageToken?: string;
    checkDuplicatesAcrossWorkspace?: boolean;
  };
  /** Add up to 50 selected recipients without another search. Deduplicates, applies suppression, and preserves the campaign's launch state. — `dench campaign add --people-file` — POST /api/v1/campaigns/{sequenceId}/people/batch */
  "campaigns.people.addBatch": {
    sequenceId: string;
    recipients: {
      email?: string;
      linkedinProfileUrl?: string;
      displayName?: string;
      /** Merge values keyed by name, e.g. {"Company":"Acme"} for {{Company}}. */
      personalization?: Record<string, unknown>;
    }[];
    newRecordsObject?: "lead" | "people";
    checkDuplicatesAcrossWorkspace?: boolean;
  };
  /** Read a campaign's saved signal source, targeting and schedule. — `dench campaign sources get` — GET /api/v1/campaigns/{sequenceId}/sources */
  "campaigns.sources.get": {
    sequenceId: string;
  };
  /** Read signal choices, suggested terms and current source configuration. — `dench campaign sources signals` — GET /api/v1/campaigns/{sequenceId}/sources/signals */
  "campaigns.sources.signals": {
    sequenceId: string;
  };
  /** Update source cadence, pause/resume, targeting, signals or terms. Active sources may perform billable future work. — `dench campaign sources set` — PATCH /api/v1/campaigns/{sequenceId}/sources */
  "campaigns.sources.update": {
    sequenceId: string;
    status?: "active" | "paused";
    cadence?: "daily" | "weekly" | "monthly";
    findMoreMatching?: boolean;
    /** auto: new people a signal finds start the sequence on their own. manual: they wait for approval. */
    approvalMode?: "auto" | "manual";
    targeting?: {
      titles: string[];
      locations: string[];
      companySizes: string[];
      industries: string[];
      excludes: string[];
      companies?: string[];
      companyTypes?: string[];
    };
    signal?: {
      signal: "post_engagement" | "keyword" | "hiring" | "funding" | "launch" | "new_leader" | "voice_engagement" | "company_engagement" | "brand_engagement" | "lookalike";
      enabled: boolean;
    };
    terms?: {
      signal: "post_engagement" | "keyword" | "hiring" | "voice_engagement" | "company_engagement" | "brand_engagement";
      values: string[];
    };
  };
  /** Preview a signal source using its current audience. Provider credits may apply; does not enroll people. — `dench campaign sources preview` — POST /api/v1/campaigns/{sequenceId}/sources/preview */
  "campaigns.sources.preview": {
    sequenceId: string;
    signal: "post_engagement" | "keyword" | "hiring" | "funding" | "launch" | "new_leader" | "voice_engagement" | "company_engagement" | "brand_engagement" | "lookalike";
    terms?: string[];
  };
  /** Run a live campaign's signals now instead of waiting for the schedule (Run now). Provider credits apply; limited to 6 runs an hour. — `dench campaign sources run` — POST /api/v1/campaigns/{sequenceId}/sources/run */
  "campaigns.sources.run": {
    sequenceId: string;
  };
  /** Read the Sources tab: each signal's status, last and next run, people found and anything needing attention. — `dench campaign sources overview` — GET /api/v1/campaigns/{sequenceId}/sources/overview */
  "campaigns.sources.overview": {
    sequenceId: string;
  };
  /** List people a signal found who are waiting for approval (manual approval mode). — `dench campaign sources pending` — GET /api/v1/campaigns/{sequenceId}/sources/pending */
  "campaigns.sources.pending": {
    sequenceId: string;
  };
  /** Approve people waiting for review (they start the sequence) or reject them. — `dench campaign sources approve|reject` — POST /api/v1/campaigns/{sequenceId}/sources/review */
  "campaigns.sources.review": {
    sequenceId: string;
    enrollmentIds: string[];
    decision: "approve" | "reject";
  };
  /** Today's queue: who the campaign plans to contact today, warmest first, within the senders' limits. — `dench campaign queue` — GET /api/v1/campaigns/{sequenceId}/queue */
  "campaigns.queue": {
    sequenceId: string;
  };
  /** Read the company profile and suggested campaign audience. — `dench campaign builder profile` — GET /api/v1/campaigns/builder/profile */
  "campaigns.builder.profile": Record<string, unknown>;
  /** Save a signal campaign's audience, signals and terms idempotently. Does not start a build. — `dench campaign builder save` — POST /api/v1/campaigns/builder/drafts */
  "campaigns.builder.save": {
    /** Your stable id for this request, 8-64 characters. Retrying with the same id returns the same draft instead of creating another. */
    clientRequestId: string;
    targeting: {
      titles: string[];
      locations: string[];
      companySizes: string[];
      industries: string[];
      excludes: string[];
      companies?: string[];
      companyTypes?: string[];
    };
    signals: Array<"post_engagement" | "keyword" | "hiring" | "funding" | "launch" | "new_leader" | "voice_engagement" | "company_engagement" | "brand_engagement" | "lookalike">;
    signalTerms?: {
      /** Post topics, phrased as what the buyer does ("using AI for outbound"), not bare product names. */
      post_engagement?: string[];
      keyword?: string[];
      /** Roles being hired for. */
      hiring?: string[];
      /** LinkedIn profile URLs of market voices whose posts to watch. */
      voice_engagement?: string[];
      /** LinkedIn company page URLs of companies and competitors. */
      company_engagement?: string[];
      /** The sender's own LinkedIn company page URL. */
      brand_engagement?: string[];
      /** Topic signals searched by their exact keywords only (no drafted phrases). */
      exact?: Array<"post_engagement" | "keyword">;
    };
    /** Also add people who match the audience without a signal. */
    findMoreMatching?: boolean;
    name?: string;
    /** How people come in: buying signals, people like one best lead, a pasted list or CSV, CRM records, or a people search. */
    source?: "signals" | "lookalike" | "existing" | "crm" | "search";
    screen?: "source" | "signals" | "lookalike" | "target" | "messages" | "outreach" | "review";
    /** For source lookalike: the edited result of builder lookalike, with signals ["lookalike"]. */
    lookalike?: {
      seed: {
        name: string;
        linkedinUrl: string;
        title?: string;
        companyName?: string;
        companyDomain?: string;
        avatarUrl?: string;
      };
      title: string;
      similarRoles: boolean;
      roles: string[];
      location?: string;
      industry?: string;
      relatedIndustries: boolean;
      industries: string[];
      companySizes: string[];
      companies: {
        name: string;
        domain: string;
      }[];
    };
  };
  /** Read signal build progress, preview people, messages and errors. — `dench campaign builder get` — GET /api/v1/campaigns/builder/drafts/{draftId} */
  "campaigns.builder.get": {
    draftId: string;
  };
  /** Start the same billable signal/audience/message build used by the UI; poll the draft for progress. — `dench campaign builder build` — POST /api/v1/campaigns/builder/drafts/{draftId}/build */
  "campaigns.builder.build": {
    draftId: string;
  };
  /** Create a campaign from a reviewed signal draft. Does not launch the campaign. — `dench campaign builder create` — POST /api/v1/campaigns/builder/drafts/{draftId}/create */
  "campaigns.builder.create": {
    draftId: string;
    name?: string;
    timezone?: string;
    /** Save paused: signals wait to run until launch. */
    paused?: boolean;
  };
  /** Edit or reset one preview person's opening line before creating the campaign. — `dench campaign builder opener` — PUT /api/v1/campaigns/builder/drafts/{draftId}/people/{leadId}/opener */
  "campaigns.builder.opener": {
    draftId: string;
    leadId: string;
    opener: string;
  };
  /** List saved, unfinished campaign drafts that can be resumed. — `dench campaign builder drafts` — GET /api/v1/campaigns/builder/drafts */
  "campaigns.builder.drafts": Record<string, unknown>;
  /** Read a saved draft's setup (source, name, targeting, signals, terms, lookalike) to resume it. — `dench campaign builder resume` — GET /api/v1/campaigns/builder/drafts/{draftId}/setup */
  "campaigns.builder.resume": {
    draftId: string;
  };
  /** Discard a saved draft that has not become a campaign. — `dench campaign builder discard` — DELETE /api/v1/campaigns/builder/drafts/{draftId} */
  "campaigns.builder.discard": {
    draftId: string;
  };
  /** Save a draft's Outreach and Review choices: AI or manual steps, the brief, the steps, who sends and when, and auto or manual approval. — `dench campaign builder outreach` — PATCH /api/v1/campaigns/builder/drafts/{draftId}/outreach */
  "campaigns.builder.outreach": {
    draftId: string;
    /** ai: generate the sequence from the brief. manual: write steps. */
    outreachMode?: "ai" | "manual";
    brief?: {
      /** What a reply should lead to, e.g. a demo. */
      goal: string;
      /** The problem the product solves for them. */
      helpWith: string;
      tone: "conversational" | "warm" | "direct" | "formal";
      channels: "both" | "email" | "linkedin";
    };
    steps?: Array<{
      type: "email" | "wait" | "linkedin_connection" | "linkedin_message";
      /** Hours to wait, 1 to 1440. Required on a wait step. */
      waitHours?: number;
      emailSubject?: string;
      /** Plain text only; draft steps keep no HTML body. */
      emailTextBody?: string;
      emailReplyToPrevious?: boolean;
      onlyIf?: "always" | "connected" | "not_connected";
      linkedinMessageBody?: string;
      linkedinMessageMode?: "skip_if_not_connected" | "wait_until_connected";
      connectionTimeoutHours?: number;
    }>;
    sending?: {
      emailMailboxAccountIds: string[];
      linkedinAccountIds: string[];
      timezone: string;
      startHour: number;
      endHour: number;
      /** 0 is Sunday, 6 is Saturday. */
      weekdays: number[];
      dailySendCap?: number;
    };
    /** auto: new people a signal finds start the sequence on their own. manual: they wait for approval. */
    approvalMode?: "auto" | "manual";
  };
  /** Generate the draft's sequence from a brief (goal, problem, tone, channels), as Generate sequence does. AI credits apply. — `dench campaign builder sequence` — POST /api/v1/campaigns/builder/drafts/{draftId}/sequence */
  "campaigns.builder.sequence": {
    draftId: string;
    brief: {
      /** What a reply should lead to, e.g. a demo. */
      goal: string;
      /** The problem the product solves for them. */
      helpWith: string;
      tone: "conversational" | "warm" | "direct" | "formal";
      channels: "both" | "email" | "linkedin";
    };
  };
  /** Set up a lookalike from the best lead's LinkedIn URL (role, similar roles, place, industry, similar companies), suggest roles again, or re-scope to a company. Nothing is saved. Provider credits apply. — `dench campaign builder lookalike` — POST /api/v1/campaigns/builder/lookalike */
  "campaigns.builder.lookalike": {
    /** The best lead's LinkedIn profile URL. */
    linkedinUrl?: string;
    /** Suggest similar roles and related industries again. */
    suggest?: {
      title: string;
      industry?: string;
    };
    /** Re-scope the lookalike to a different company. */
    rescope?: {
      seed: {
        name: string;
        linkedinUrl: string;
        title?: string;
        companyName?: string;
        companyDomain?: string;
        avatarUrl?: string;
      };
      company: string;
      title?: string;
      location?: string;
    };
  };
  /** Suggest market voices (LinkedIn experts) for the campaign's topics, to watch with voice_engagement. AI credits apply. — `dench campaign builder voices` — POST /api/v1/campaigns/builder/voices */
  "campaigns.builder.voices": {
    topics?: string[];
    market?: string;
  };
  /** Turn an audience description into targeting filters. AI credits apply. — `dench campaign builder autofill` — POST /api/v1/campaigns/builder/autofill */
  "campaigns.builder.autofill": {
    description: string;
  };
  /** Estimate audience or weekly signal volume using the UI's cached estimator. Provider credits may apply. — `dench campaign builder estimate` — POST /api/v1/campaigns/builder/estimate */
  "campaigns.builder.estimate": {
    kind: "people" | "week";
    targeting: {
      titles: string[];
      locations: string[];
      companySizes: string[];
      industries: string[];
      excludes: string[];
      companies?: string[];
      companyTypes?: string[];
    };
    signals?: Array<"post_engagement" | "keyword" | "hiring" | "funding" | "launch" | "new_leader" | "voice_engagement" | "company_engagement" | "brand_engagement" | "lookalike">;
    signalTerms?: {
      /** Post topics, phrased as what the buyer does ("using AI for outbound"), not bare product names. */
      post_engagement?: string[];
      keyword?: string[];
      /** Roles being hired for. */
      hiring?: string[];
      /** LinkedIn profile URLs of market voices whose posts to watch. */
      voice_engagement?: string[];
      /** LinkedIn company page URLs of companies and competitors. */
      company_engagement?: string[];
      /** The sender's own LinkedIn company page URL. */
      brand_engagement?: string[];
      /** Topic signals searched by their exact keywords only (no drafted phrases). */
      exact?: Array<"post_engagement" | "keyword">;
    };
  };
  /** List all CLI/API operations and parity classifications. — `dench help` — GET /api/v1/commands */
  "commands.list": Record<string, unknown>;
  /** Create an agent sign-in request. — `dench signin` — POST /api/v1/auth/signin-requests */
  "auth.signin.create": {
    codeHash: string;
    sessionTokenHash: string;
    agentName: string;
    /** Agent kind, normalized to snake_case. */
    agentKind: string;
    /** Whether to join an existing workspace or create a new one. */
    intent: "join_existing" | "create_workspace";
    /** Required when intent is create_workspace. */
    proposedOrganizationName?: string;
    requestedOrganizationSelector?: string;
    userAgent?: string;
  };
  /** Poll an agent sign-in request until approval. — `dench signin` — POST /api/v1/auth/signin-requests/{requestId}/poll */
  "auth.signin.poll": {
    codeHash: string;
    sessionTokenHash: string;
  };
  /** Start the email OTP sign-in flow. — `dench signin --email` — POST /api/v1/auth/otp/start */
  "auth.otp.start": {
    /** Email to send the code to. */
    email: string;
  };
  /** Verify an email OTP sign-in code. — `dench signin --email` — POST /api/v1/auth/otp/verify */
  "auth.otp.verify": {
    email: string;
    /** 6+ digit code from the email. */
    code: string;
    agentName: string;
    agentKind: string;
    /** sha256 hex of the local session token. */
    sessionTokenHash: string;
    /** Whether to join an existing workspace or create a new one. */
    intent: "join_existing" | "create_workspace";
    proposedOrganizationName?: string;
    organizationSelector?: string;
    userAgent?: string;
  };
  /** Finalize an email OTP sign-in session. — `dench signin --email` — POST /api/v1/auth/otp/finalize */
  "auth.otp.finalize": {
    authToken: string;
    /** Provide this OR newOrganizationName. */
    organizationId?: string;
    newOrganizationName?: string;
  };
  /** Read selected scoped workspace documents and a compact context index without writes. — `dench context --sections` — GET /api/v1/context/sections */
  "workspace.context.sections": {
    organizationId?: string;
    sections?: Array<"identity" | "organisation" | "user" | "memory" | "rules" | "tools">;
  };
  /** Return the current Dench workspace context for the bearer. — `dench context` — GET /api/v1/context */
  "workspace.context": Record<string, unknown>;
  /** Return the current workspace's standing instructions for external agents. — `dench context --instructions` — GET /api/v1/context/instructions */
  "workspace.instructions": {
    organizationId?: string;
  };
  /** Return workspace and agent status. — `dench status` — GET /api/v1/status */
  "workspace.status": Record<string, unknown>;
  /** List agents visible in the workspace status payload. — `dench agents` — GET /api/v1/agents */
  "workspace.agents": Record<string, unknown>;
  /** List approval requests visible in the workspace status payload. — `dench approvals` — GET /api/v1/approvals */
  "workspace.approvals.list": Record<string, unknown>;
  /** List artifacts for the authenticated workspace. — `dench artifacts` — GET /api/v1/artifacts */
  "workspace.artifacts.list": {
    limit?: number;
  };
  /** List draft suggested-work artifacts. — `dench suggested-work` — GET /api/v1/suggested-work */
  "workspace.suggestedWork.list": {
    limit?: number;
  };
  /** List saved searches (find-result lists) in the workspace, newest first. — `dench lists` — GET /api/v1/lists */
  "lists.list": {
    search?: string;
    cursor?: string;
    limit?: number;
  };
  /** Read saved rows with current enrichment results and original indices; cursor-paged, without repeating a search. — `dench lists rows` — GET /api/v1/lists/{artifactId}/rows */
  "lists.rows": {
    artifactId: string;
    cursor?: string;
    limit?: number;
    enrichment?: "all" | "enriched" | "in_progress" | "no_contacts" | "failed" | "not_enriched";
  };
  /** Buy contact details for 1–100 saved profiles and save them to the list. Skips fields already found, looked up empty, or in flight. Requires a signed-in member or their personal agent. — `dench lists enrich` — POST /api/v1/lists/{artifactId}/enrich */
  "lists.enrich": {
    artifactId: string;
    rows: Record<string, unknown>[];
    /** email is work email. */
    fields: Array<"email" | "phone" | "personal_email">;
  };
  /** Explicitly import selected saved profiles, optionally filtered by enrichment, with a configured Lead status. Reuses CRM records; never sends outreach or triggers conversion. — `dench artifacts import` — POST /api/v1/lists/{artifactId}/import */
  "lists.import": {
    artifactId: string;
    to: "lead" | "company" | "job_posting";
    rowIndexes?: number[];
    status?: string;
    enrichment?: "all" | "enriched" | "in_progress" | "no_contacts" | "failed" | "not_enriched";
    viewName?: string;
    pin?: boolean;
  };
  /** Get one saved search / list by artifact id. — `dench lists show` — GET /api/v1/lists/{artifactId} */
  "lists.get": Record<string, unknown>;
  /** Save find results as a named list (rows + filters become a workspace artifact). — `dench lists save` — POST /api/v1/lists */
  "lists.save": {
    /** Use find_people, find_companies or find_jobs for a prospect list. */
    createdFrom: "find_people" | "find_companies" | "find_jobs" | "mixed" | "watch_fire" | "generate_image";
    /** Name of the new list. */
    title: string;
    /** True makes the list visible in Find. Omitted saves an unlisted draft that can still be read or added to a campaign by id. */
    saved?: boolean;
    /** Original search filters to retain with the list. Saving does not run a search. */
    filters?: unknown;
    /** Complete person records from a search, including existing contact details and custom fields. */
    people?: Record<string, unknown>[];
    /** Complete company records from a search. */
    companies?: Record<string, unknown>[];
    /** Complete job records from a search. */
    jobs?: Record<string, unknown>[];
  };
  /** Update a saved list in place (title, filters, and/or replacement rows). — `dench lists update` — PATCH /api/v1/lists/{artifactId} */
  "lists.update": {
    /** The existing list id. */
    artifactId: string;
    title?: string;
    /** Replacement filter metadata; does not run a new search. */
    filters?: unknown;
    /** Replacement people. Omit to preserve existing rows; an empty array clears them. */
    people?: Record<string, unknown>[];
    /** Replacement companies. Omit to preserve existing rows. */
    companies?: Record<string, unknown>[];
    /** Replacement jobs. Omit to preserve existing rows. */
    jobs?: Record<string, unknown>[];
  };
  /** Rename a saved search / list. — `dench lists rename` — POST /api/v1/lists/{artifactId}/rename */
  "lists.rename": Record<string, unknown>;
  /** Delete a saved search / list, its exported CSV/JSONL files, and any linked watch. — `dench lists delete` — DELETE /api/v1/lists/{artifactId} */
  "lists.delete": Record<string, unknown>;
  /** Read durable enrichment activity (legacy review metadata remains readable). Use lists rows for current saved profiles and contacts. — `dench lists reviews` — GET /api/v1/lists/{artifactId}/reviews */
  "lists.prospects.reviews": {
    artifactId: string;
    limit?: number;
    cursor?: string;
  };
  /** Suggest ICP fit for one profile. Never changes a human review decision. — `dench lists assess` — POST /api/v1/lists/{artifactId}/assess */
  "lists.prospects.assess": {
    artifactId: string;
    row: Record<string, unknown>;
    suggestion: {
      fit: "likely_fit" | "unlikely_fit" | "unknown";
      /** AI relevance to the saved ICP, not conversion probability. */
      score?: number;
      reason: string;
    };
  };
  /** Search durable workspace memory. — `dench memory search` — GET /api/v1/memory/search */
  "memory.search": {
    /** Full-text query. */
    query: string;
    limit?: number;
  };
  /** Save a durable workspace memory fact. — `dench memory save` — POST /api/v1/memory */
  "memory.save": {
    /** Stable memory key. */
    key: string;
    /** Memory classification. */
    kind: "fact" | "decision" | "preference" | "goal" | "tool_note" | "other" | "convention" | "project_context" | "agent_lesson" | "docs_knowledge" | "open_goal";
    /** Memory body. No secrets or scratch notes. */
    text: string;
    tags?: string[];
    /** Sensitivity tier; `sensitive` memories land in needs-review. */
    sensitivity?: "normal" | "broad" | "sensitive";
    /** Who can see the memory. Defaults to `user`. */
    visibility?: "user" | "org";
    projectId?: string;
    sourceQuote?: string;
    confidence?: number;
    importance?: number;
  };
  /** Request human approval. — `dench approval request` — POST /api/v1/approvals */
  "approval.request": {
    /** What needs human approval. */
    title: string;
    reason?: string;
    /** Risk level. */
    risk: "low" | "medium" | "high";
  };
  /** Record an approval decision. — `dench approval approve|reject` — POST /api/v1/approvals/{approvalId}/decision */
  "approval.decide": {
    approvalId: string;
    /** Human decision for an approval request. */
    decision: "approved" | "rejected";
    /** Required when the requesting agent records its own decision. */
    evidence?: string;
  };
  /** Get billing and AI credit status. — `dench billing status` — GET /api/v1/billing/status */
  "billing.status": Record<string, unknown>;
  /** Create an AI credit top-up checkout link. — `dench billing topup` — POST /api/v1/billing/topup */
  "billing.topup": {
    /** Idempotency key (1-200 of [A-Za-z0-9:_-]). */
    requestId: string;
    /** USD amount, $5 to $1000. */
    amountUsd: number;
  };
  /** Create a workspace upgrade checkout link. — `dench upgrade` — POST /api/v1/billing/upgrade */
  "billing.upgrade": {
    tier?: "pro" | "max" | "cloud" | "desktop" | "api";
    billingCycle?: "monthly" | "yearly";
    requestId?: string;
    /** Internal return path beginning with /. */
    returnPath?: string;
  };
  /** List past chat threads. — `dench chat list` — GET /api/v1/chat/threads */
  "chat.list": {
    titleQuery?: string;
    limit?: number;
    includeArchived?: boolean;
    includeAutomated?: boolean;
  };
  /** Search past chat messages. — `dench chat search` — GET /api/v1/chat/search */
  "chat.search": {
    /** Full-text query across past messages. */
    query: string;
    limit?: number;
    excludeThreadId?: string;
    includeAutomated?: boolean;
  };
  /** Read a past chat thread. — `dench chat read` — GET /api/v1/chat/threads/{threadId} */
  "chat.read": {
    threadId: string;
    limit?: number;
    /** Message text as a person sees it: text parts only, without reasoning or tool calls. */
    visibleTextOnly?: boolean;
  };
  /** Read the parent-child chat thread hierarchy. — `dench chat tree` — GET /api/v1/chat/tree */
  "chat.tree": {
    /** Filter threads by title. */
    titleQuery?: string;
    limit?: number;
    includeArchived?: boolean;
    /** Include routine-spawned threads. Defaults false. */
    includeAutomated?: boolean;
  };
  /** Rename one or more chat threads. — `dench chat rename` — PATCH /api/v1/chat/threads */
  "chat.rename": {
    items: {
      threadId: string;
      title: string;
    }[];
  };
  /** Delete one or more chat threads. — `dench chat delete` — DELETE /api/v1/chat/threads */
  "chat.delete": {
    threadIds: string[];
    includeAutomated?: boolean;
  };
  /** Start a new chat-turn workflow. — `dench chat new` — POST /api/v1/chat/threads */
  "chat.new": {
    environment?: string;
    /** The user message that starts the turn. */
    prompt: string;
    model?: string;
    fileContextPath?: string;
    visibility?: "private" | "shared";
    /** Bypass approval gates for this turn. */
    yolo?: boolean;
    title?: string;
  };
  /** Send a message to an existing chat thread. — `dench chat send` — POST /api/v1/chat/threads/{threadId}/messages */
  "chat.send": {
    threadId: string;
    /** The message to append. */
    prompt: string;
    model?: string;
    yolo?: boolean;
  };
  /** Follow a live chat response stream. — `dench chat follow` — GET /api/v1/chat/threads/{threadId}/stream */
  "chat.follow": {
    threadId: string;
  };
  /** List CRM objects. — `dench crm objects list [--with-references]` — GET /api/v1/crm/objects */
  "crm.objects.list": {
    /** Include bounded navigation references. Array reads return {data, references, referenceCoverage}; existing result envelopes keep their fields. */
    withReferences?: boolean;
  };
  /** List names, display labels, visibility and workspace counts without internal state. — `dench crm objects list --compact` — GET /api/v1/crm/catalog/objects */
  "crm.objects.listCompact": Record<string, unknown>;
  /** Get a CRM object. — `dench crm objects get` — GET /api/v1/crm/objects/{name} */
  "crm.objects.get": {
    name: string;
  };
  /** Create a CRM object. — `dench crm objects create` — POST /api/v1/crm/objects */
  "crm.objects.create": {
    /** Object name (lowercased, singular). */
    name: string;
    description?: string;
    /** Default view rendered for the object. */
    defaultView?: "table" | "kanban" | "calendar" | "timeline" | "gallery" | "list";
    /** Hugeicons (or legacy Lucide) icon name, e.g. user-multiple, target-01. */
    icon?: string;
    /** Fields to add after the built-in Notes, in column order. The object and its fields are created in one transaction: if any field is rejected, nothing is created. */
    fields?: Array<{
      name: string;
      /** Defaults to text. */
      type?: "text" | "email" | "phone" | "url" | "number" | "boolean" | "date" | "richtext" | "file" | "user" | "enum" | "relation" | "tags" | "action";
      required?: boolean;
      defaultValue?: string;
      /** Target object for `relation` fields. */
      relatedObjectName?: string;
      /** Relation cardinality for a `relation` field. */
      relationshipType?: "many_to_one" | "many_to_many";
      /** Options for `enum` fields. */
      enumValues?: string[];
      /** Hex colors aligned to enumValues. */
      enumColors?: string[];
      /** Allow multi-select enum. */
      enumMultiple?: boolean;
      description?: string;
      /** Index for filter/search/sort. */
      indexed?: boolean;
    }>;
  };
  /** Update a CRM object. — `dench crm objects update` — PATCH /api/v1/crm/objects/{name} */
  "crm.objects.update": {
    name: string;
    description?: string;
    /** Default view rendered for the object. */
    defaultView?: "table" | "kanban" | "calendar" | "timeline" | "gallery" | "list";
    icon?: string;
    viewSettings?: Record<string, unknown>;
    savedViews?: Record<string, unknown>[];
    /** Who can see the object's records: every workspace member, only the record's owner, or the owner plus the members listed on the record. Admins only (a signed-in admin; an org-scoped key cannot change it). Records created before the switch have no owner and are hidden from everyone until one is set; switch back to workspace to see them again. */
    visibility?: "workspace" | "owner_only" | "owner_plus_members";
  };
  /** Rename a CRM object. — `dench crm objects rename` — POST /api/v1/crm/objects/{from}/rename */
  "crm.objects.rename": {
    /** Current object name (path). */
    from: string;
    /** New object name. */
    to: string;
  };
  /** Delete a CRM object. — `dench crm objects delete` — DELETE /api/v1/crm/objects/{name} */
  "crm.objects.delete": {
    name: string;
  };
  /** Hide a CRM object's workspace sidebar row for the whole workspace. Not a delete — the table keeps working. Admin-only. — `dench crm objects archive` — POST /api/v1/crm/objects/{name}/archive */
  "crm.objects.archive": {
    name: string;
  };
  /** Restore a CRM object's workspace sidebar row. Admin-only. — `dench crm objects unarchive` — POST /api/v1/crm/objects/{name}/unarchive */
  "crm.objects.unarchive": {
    name: string;
  };
  /** List the saved views on a CRM object (plus the active view). — `dench crm views list` — GET /api/v1/crm/objects/{objectName}/views */
  "crm.views.list": {
    objectName: string;
  };
  /** Get one saved view's definition by name. — `dench crm views get` — GET /api/v1/crm/objects/{objectName}/views/{viewName} */
  "crm.views.get": {
    objectName: string;
    viewName: string;
  };
  /** Materialize a saved view's rows (applies its filters/sort/pins), paginated. — `dench crm views entries` — GET /api/v1/crm/objects/{objectName}/views/{viewName}/entries */
  "crm.views.entries": {
    objectName: string;
    viewName: string;
    page?: number;
    pageSize?: number;
    /** Personal scope: "me" (the signed-in member / the human behind an agent session), "unassigned", or a member userId or email. Adds one has_any / is_empty rule on the object's assignee user field; rows, totalCount, sums and analytics all follow it. Never saved onto the view. */
    assignedTo?: string;
    /** Which `user` field "assigned" means. Default: the analytics owner role, else the task `Assignee`, else a user field named like owner/assignee, else the first user field. */
    assigneeField?: string;
  };
  /** Create a saved view (named filters/sort/columns combo) on a CRM object. — `dench crm views create` — POST /api/v1/crm/objects/{objectName}/views */
  "crm.views.create": {
    objectName: string;
    view: {
      /** View name (upsert key; shows in the view dropdown). */
      name: string;
      /** Default view rendered for the object. */
      view_type?: "table" | "kanban" | "calendar" | "timeline" | "gallery" | "list";
      /** FilterGroup, e.g. {"id":"g1","conjunction":"and","rules":[{"id":"r1","field":"Status","operator":"is","value":"Hot"}]}. Date rules support operator "date_preset" with value "today", "yesterday", "this_week", "last_week", "this_month", "last_month", "this_quarter", "last_quarter", "this_year", or "last_year", plus "relative_past"/"relative_next" with relativeAmount + relativeUnit (days|weeks|months|quarters|years). Rules may target the system timestamps "created_at" / "updated_at", e.g. {"field":"created_at","operator":"relative_past","relativeAmount":7,"relativeUnit":"days"}. */
      filters?: Record<string, unknown>;
      sort?: Array<{
        /** Field name to sort by. */
        field: string;
        direction: "asc" | "desc";
      }>;
      /** Visible-column ordering. Omit to keep the default set. */
      columns?: string[];
      /** View-type settings (kanbanField, calendarDateField, timelineStartField, …). */
      settings?: Record<string, unknown>;
      /** Pinned-list mode: show EXACTLY these entry ids (mutually exclusive with filters). */
      pinnedEntryIds?: string[];
      [key: string]: unknown;
    };
    /** Overwrite an existing view with the same name. */
    replaceExisting?: boolean;
    /** Also switch the object's active view to this one. */
    setActive?: boolean;
  };
  /** Replace a saved view's definition (upsert by name). — `dench crm views update` — PATCH /api/v1/crm/objects/{objectName}/views/{viewName} */
  "crm.views.update": {
    objectName: string;
    /** Name of the view to replace (path). */
    viewName: string;
    /** Full replacement definition; the path viewName is used as the name. */
    view?: {
      /** View name (upsert key; shows in the view dropdown). */
      name?: string;
      /** Default view rendered for the object. */
      view_type?: "table" | "kanban" | "calendar" | "timeline" | "gallery" | "list";
      /** FilterGroup, e.g. {"id":"g1","conjunction":"and","rules":[{"id":"r1","field":"Status","operator":"is","value":"Hot"}]}. Date rules support operator "date_preset" with value "today", "yesterday", "this_week", "last_week", "this_month", "last_month", "this_quarter", "last_quarter", "this_year", or "last_year", plus "relative_past"/"relative_next" with relativeAmount + relativeUnit (days|weeks|months|quarters|years). Rules may target the system timestamps "created_at" / "updated_at", e.g. {"field":"created_at","operator":"relative_past","relativeAmount":7,"relativeUnit":"days"}. */
      filters?: Record<string, unknown>;
      sort?: Array<{
        /** Field name to sort by. */
        field: string;
        direction: "asc" | "desc";
      }>;
      /** Visible-column ordering. Omit to keep the default set. */
      columns?: string[];
      /** View-type settings (kanbanField, calendarDateField, timelineStartField, …). */
      settings?: Record<string, unknown>;
      /** Pinned-list mode: show EXACTLY these entry ids (mutually exclusive with filters). */
      pinnedEntryIds?: string[];
      [key: string]: unknown;
    };
    setActive?: boolean;
  };
  /** Rename a saved view in place — keeps its filters, pins, and sidebar slot. — `dench crm views rename` — POST /api/v1/crm/objects/{objectName}/views/{viewName}/rename */
  "crm.views.rename": Record<string, unknown>;
  /** Delete a saved view by name (idempotent). — `dench crm views delete` — DELETE /api/v1/crm/objects/{objectName}/views/{viewName} */
  "crm.views.delete": {
    objectName: string;
    viewName: string;
  };
  /** Move a pinned view's sidebar row into the Archived flyout. Admin-only. — `dench crm views archive` — POST /api/v1/crm/objects/{objectName}/views/{viewName}/archive */
  "crm.views.archive": {
    objectName: string;
    viewName: string;
  };
  /** Restore a view's sidebar row (re-asserts its pin). Admin-only. — `dench crm views unarchive` — POST /api/v1/crm/objects/{objectName}/views/{viewName}/unarchive */
  "crm.views.unarchive": {
    objectName: string;
    viewName: string;
  };
  /** Describe the workspace sidebar: Library rows in tree order (with their groups), the home-level Pinned strip, what is hidden and why, and whether the caller is an admin. — `dench crm sidebar list` — GET /api/v1/crm/sidebar */
  "crm.sidebar.list": Record<string, unknown>;
  /** Reposition one Library row (or group) among the Library's top-level slots. Does not add a home-level Pinned tab. Workspace-shared; admin-only. — `dench crm sidebar move` — POST /api/v1/crm/sidebar/move */
  "crm.sidebar.move": {
    /** Nav id from `sidebar list`, e.g. crm-object:task. */
    navId: string;
    /** Where to land among the visible rows; N is 1-based. */
    position: "top" | "bottom" | number;
  };
  /** Create a named sidebar group (e.g. "Hiring") in the workspace-shared Library. Open to any member. — `dench crm sidebar group create` — POST /api/v1/crm/sidebar/groups */
  "crm.sidebar.groups.create": Record<string, unknown>;
  /** Rename a sidebar group. Open to any member. — `dench crm sidebar group rename` — POST /api/v1/crm/sidebar/groups/rename */
  "crm.sidebar.groups.rename": Record<string, unknown>;
  /** Dissolve a sidebar group; its rows return to the top level in its slot. Open to any member. — `dench crm sidebar group delete` — POST /api/v1/crm/sidebar/groups/delete */
  "crm.sidebar.groups.delete": Record<string, unknown>;
  /** Move a sidebar row into a group (groupId set) or back to the top level (groupId null). Open to any member. — `dench crm sidebar group add` — POST /api/v1/crm/sidebar/groups/move */
  "crm.sidebar.groups.move-item": Record<string, unknown>;
  /** Pin (pinned true) or unpin a Library row — or a whole group — on the home-level Pinned shortcut strip (the "tab on the left"). Does not move the row inside Library. Workspace-shared; open to any member. — `dench crm sidebar pin` — POST /api/v1/crm/sidebar/pins */
  "crm.sidebar.pins.set": Record<string, unknown>;
  /** List fields for a CRM object, including read-only calculation metadata. — `dench crm fields list` — GET /api/v1/crm/objects/{objectName}/fields */
  "crm.fields.list": {
    objectName: string;
  };
  /** List field names, types and effective constraints without indexing or enrichment internals. — `dench crm fields list --compact` — GET /api/v1/crm/catalog/objects/{objectName}/fields */
  "crm.fields.listCompact": {
    objectName: string;
  };
  /** Create a CRM field or read-only campaign activity boolean column. — `dench crm fields create` — POST /api/v1/crm/objects/{objectName}/fields */
  "crm.fields.create": {
    objectName: string;
    name: string;
    /** Defaults to boolean with calculation, otherwise text. Calculations require boolean. */
    type?: "text" | "email" | "phone" | "url" | "number" | "boolean" | "date" | "richtext" | "file" | "user" | "enum" | "relation" | "tags" | "action";
    required?: boolean;
    defaultValue?: string;
    /** Target object for `relation` fields. */
    relatedObjectName?: string;
    /** Relation cardinality for a `relation` field. */
    relationshipType?: "many_to_one" | "many_to_many";
    /** Options for `enum` fields. */
    enumValues?: string[];
    /** Hex colors aligned to enumValues. */
    enumColors?: string[];
    /** Allow multi-select enum. */
    enumMultiple?: boolean;
    description?: string;
    /** Index for filter/search/sort. */
    indexed?: boolean;
    /** Enrichment binding that lets the field auto-fill from a provider. */
    enrichment?: {
      category: "people" | "company";
      key: string;
      apolloPath: string;
      inputFieldName?: string;
    };
    /** Read-only campaign activity boolean on people or lead (through Contact), not an expression. Cannot be required, indexed, enriched or have a default value. */
    calculation?: {
      kind: "campaign_activity";
      metric: "email_opened" | "email_clicked" | "replied" | "linkedin_connected";
      /** Same-workspace multichannel campaign ID readable by the viewer. Omit for any accessible multichannel campaign. */
      campaignId?: string;
    };
  };
  /** Update a CRM field or change/explicitly clear an existing campaign calculation. — `dench crm fields update` — PATCH /api/v1/crm/objects/{objectName}/fields/{fieldName} */
  "crm.fields.update": {
    objectName: string;
    fieldName: string;
    /** Rename the field. */
    name?: string;
    description?: string;
    required?: boolean;
    /** Full replacement of options. */
    enumValues?: string[];
    enumColors?: string[];
    enumMultiple?: boolean;
    indexed?: boolean;
    /** Enrichment binding that lets the field auto-fill from a provider. */
    enrichment?: {
      category: "people" | "company";
      key: string;
      apolloPath: string;
      inputFieldName?: string;
    };
    clearEnrichment?: boolean;
    /** Replace an existing calculation's metric/source. Stored fields cannot be converted; create a new column instead. */
    calculation?: {
      kind: "campaign_activity";
      metric: "email_opened" | "email_clicked" | "replied" | "linkedin_connected";
      /** Same-workspace multichannel campaign ID readable by the viewer. Omit for any accessible multichannel campaign. */
      campaignId?: string;
    };
    /** Explicitly remove an existing calculation, leaving an editable boolean. Does not snapshot calculated values. Mutually exclusive with calculation. */
    clearCalculation?: boolean;
  };
  /** Delete a CRM field. — `dench crm fields delete` — DELETE /api/v1/crm/objects/{objectName}/fields/{fieldName} */
  "crm.fields.delete": {
    objectName: string;
    fieldName: string;
  };
  /** Reorder CRM fields. — `dench crm fields reorder` — POST /api/v1/crm/objects/{objectName}/fields/reorder */
  "crm.fields.reorder": {
    objectName: string;
    /** Field names in desired order. */
    orderedFieldNames: string[];
  };
  /** Reorder enum values. — `dench crm fields enum-reorder` — POST /api/v1/crm/objects/{objectName}/fields/{fieldName}/enum/reorder */
  "crm.fields.enum.reorder": {
    objectName: string;
    fieldName: string;
    /** Exact permutation of existing options. */
    orderedValues: string[];
  };
  /** Add an enum value. — `dench crm fields enum-add` — POST /api/v1/crm/objects/{objectName}/fields/{fieldName}/enum */
  "crm.fields.enum.add": {
    objectName: string;
    fieldName: string;
    /** Option value to add. */
    value: string;
    /** Hex color for the option. */
    color?: string;
    /** 0-based insert index; defaults to append. */
    position?: number;
  };
  /** Remove an enum value. — `dench crm fields enum-remove` — DELETE /api/v1/crm/objects/{objectName}/fields/{fieldName}/enum/{value} */
  "crm.fields.enum.remove": {
    objectName: string;
    fieldName: string;
    value: string;
  };
  /** Rename an enum value. — `dench crm fields enum-rename` — POST /api/v1/crm/objects/{objectName}/fields/{fieldName}/enum/{oldValue}/rename */
  "crm.fields.enum.rename": {
    objectName: string;
    fieldName: string;
    /** Existing option value (path). */
    oldValue: string;
    /** New option value; migrates entries + statuses. */
    newValue: string;
  };
  /** Set an enum color. — `dench crm fields enum-set-color` — POST /api/v1/crm/objects/{objectName}/fields/{fieldName}/enum/{value}/color */
  "crm.fields.enum.color": {
    objectName: string;
    fieldName: string;
    value: string;
    /** Hex color, e.g. #22c55e. */
    color: string;
  };
  /** List CRM entries. — `dench crm entries list [--with-references]` — GET /api/v1/crm/objects/{objectName}/entries */
  "crm.entries.list": {
    /** Include bounded navigation references. Array reads return {data, references, referenceCoverage}; existing result envelopes keep their fields. */
    withReferences?: boolean;
    objectName: string;
    limit?: number;
    /** Personal scope: "me" (the signed-in member / the human behind an agent session), "unassigned", or a member userId or email. Adds one has_any / is_empty rule on the object's assignee user field; rows, totalCount, sums and analytics all follow it. Never saved onto the view. */
    assignedTo?: string;
    /** Which `user` field "assigned" means. Default: the analytics owner role, else the task `Assignee`, else a user field named like owner/assignee, else the first user field. */
    assigneeField?: string;
  };
  /** Get a CRM entry. — `dench crm entries get` — GET /api/v1/crm/objects/{objectName}/entries/{entryId} */
  "crm.entries.get": {
    objectName: string;
    entryId: string;
  };
  /** Queue a full, paged pull of the record's email history from every connected mailbox; the ledger fills as pages land. — `dench crm entries sync-history` — POST /api/v1/crm/objects/{objectName}/entries/{entryId}/sync-history */
  "crm.entries.syncHistory": Record<string, unknown>;
  /** Has Dench read this record's email history? One row per address per mailbox. — `dench crm entries sync-history --status` — GET /api/v1/crm/objects/{objectName}/entries/{entryId}/sync-history */
  "crm.entries.syncHistoryStatus": Record<string, unknown>;
  /** Status of the account's research dossier — the delimited `dench:dossier` section Dench keeps in the record's Notes: status, when it was written, how many dated updates followed, the last error. — `dench crm entries dossier` — GET /api/v1/crm/entries/{entryId}/dossier */
  "crm.entries.dossier.get": Record<string, unknown>;
  /** Research the account again and append a fresh dossier section to its Notes (needs a Website / Domain on the record). — `dench crm entries dossier --regenerate` — POST /api/v1/crm/entries/{entryId}/dossier/regenerate */
  "crm.entries.dossier.regenerate": Record<string, unknown>;
  /** Whether the caller hides their own emails / messages with this record from the workspace (directly, or through its account), and whether they own a connection the toggle applies to. — `dench crm privacy status` — GET /api/v1/crm/entries/{entryId}/privacy */
  "crm.privacy.get": Record<string, unknown>;
  /** Hide (`hidden: true`) or show the caller's own emails / messages with this record to the workspace. An account covers every contact and opportunity linked to it; existing ledger rows are restamped and the shared Brief regenerates. — `dench crm privacy hide|show` — PUT /api/v1/crm/entries/{entryId}/privacy */
  "crm.privacy.set": {
    entryId: string;
    hidden: boolean;
  };
  /** List account-detection verdicts — why a domain (or personal address) did or did not become an account: verdict, counterparty type, probabilities, evidence threads, the rows created. `kind` picks the creator: `detections` (email + sweep), `linkedin` (the LinkedIn resolver's rows) or `all` (default). Newest first. — `dench crm detections list` — GET /api/v1/crm/detections */
  "crm.detections.list": Record<string, unknown>;
  /** Undo what the ingestion jobs created since a timestamp (admin): `kind` = `detections` (accounts + contacts from the email detector and the sweep), `linkedin` (the LinkedIn resolver's contacts + accounts; their conversations are unlinked and parked), `email-tasks` (auto-created tasks and cases) or `all` (default). Deletes only rows no human has touched and marks the verdicts / decisions rolled_back so they are never re-created. `dryRun` lists what would go; per-kind counts in `kinds`. — `dench crm detections undo` — POST /api/v1/crm/detections/undo */
  "crm.detections.undo": {
    /** Only verdicts / decisions at or after this ms timestamp. */
    since: number;
    /** Which creator's rows to undo. Default `all`. */
    kind?: "detections" | "linkedin" | "email-tasks" | "all";
    dryRun?: boolean;
    limit?: number;
  };
  /** List a CRM entry's audit history. — `dench crm history` — GET /api/v1/crm/objects/{objectName}/entries/{entryId}/history */
  "crm.entries.history": Record<string, unknown>;
  /** List a CRM entry's activity ledger (comments, notes, field changes, emails, meetings, Slack, LinkedIn) in one timeline, newest first by default. — `dench crm activity` — GET /api/v1/crm/objects/{objectName}/entries/{entryId}/activity */
  "crm.activity.list": Record<string, unknown>;
  /** The record's generated Brief: health, who owes the next move, open threads, commitments, risks, next step. Read this before the ledger. — `dench crm brief` — GET /api/v1/crm/objects/{objectName}/entries/{entryId}/brief */
  "crm.brief.get": Record<string, unknown>;
  /** Read-only source diagnostics: accessible evidence, association reasons, last Brief source manifest, generation queue, and your mailbox delivery health. Bounded, cursor-paged snapshot; does not certify complete history. — `dench crm context` — GET /api/v1/crm/objects/{objectName}/entries/{entryId}/context */
  "crm.context.get": Record<string, unknown>;
  /** Rebuild a record's Brief from the current timeline. — `dench crm brief --regenerate` — POST /api/v1/crm/objects/{objectName}/entries/{entryId}/brief/regenerate */
  "crm.brief.regenerate": Record<string, unknown>;
  /** Bounded per-source counts of a CRM entry's activity ledger. — `dench crm activity` — GET /api/v1/crm/objects/{objectName}/entries/{entryId}/activity/count */
  "crm.activity.count": Record<string, unknown>;
  /** List a CRM entry's notes (titled, document-style comments), newest first. — `dench crm notes list` — GET /api/v1/crm/objects/{objectName}/entries/{entryId}/notes */
  "crm.notes.list": Record<string, unknown>;
  /** Add a titled note to a CRM entry's activity timeline (markdown body). Research goes here, never into the Notes document. — `dench crm notes create` — POST /api/v1/crm/objects/{objectName}/entries/{entryId}/notes */
  "crm.notes.create": Record<string, unknown>;
  /** List comments on a CRM entry (roots newest first, with preview replies). — `dench crm comments list` — GET /api/v1/crm/objects/{objectName}/entries/{entryId}/comments */
  "crm.comments.list": {
    objectName: string;
    entryId: string;
    limit?: number;
    /** continueCursor from the prior page. */
    cursor?: string;
    /** Preview replies per root (default 2). */
    replies?: number;
  };
  /** List every reply under a root comment, oldest first. — `dench crm comments replies` — GET /api/v1/crm/comments/{commentId}/replies */
  "crm.comments.replies": {
    /** Root comment id. */
    commentId: string;
    limit?: number;
    cursor?: string;
  };
  /** Get one comment with its entry label. — `dench crm comments get` — GET /api/v1/crm/comments/{commentId} */
  "crm.comments.get": {
    commentId: string;
  };
  /** Comment on a CRM entry (markdown). Mention members with [@Name](/?member=<userId>); mention Dench with [@Dench](/?member=dench) or mentionDench. — `dench crm comments create` — POST /api/v1/crm/objects/{objectName}/entries/{entryId}/comments */
  "crm.comments.create": {
    objectName: string;
    entryId: string;
    /** Markdown. Mention a member with [@Name](/?member=<userId>); mention Dench with [@Dench](/?member=dench). */
    body: string;
    /** Reply under this comment (any depth). */
    parentCommentId?: string;
    /** Extra members to notify without writing mention links. */
    mentionUserIds?: string[];
    /** Summon Dench to reply in the thread. */
    mentionDench?: boolean;
  };
  /** Edit a comment you wrote. — `dench crm comments update` — PATCH /api/v1/crm/comments/{commentId} */
  "crm.comments.update": {
    commentId: string;
    body: string;
  };
  /** Delete a comment (kept as a tombstone when it has replies). — `dench crm comments delete` — DELETE /api/v1/crm/comments/{commentId} */
  "crm.comments.delete": {
    commentId: string;
  };
  /** Toggle an emoji reaction on a comment. — `dench crm comments react` — PUT /api/v1/crm/comments/{commentId}/reactions/{emoji} */
  "crm.comments.react": {
    commentId: string;
    /** A single emoji, e.g. 👍. */
    emoji: string;
  };
  /** Whether you follow a CRM entry's activity. — `dench crm watch status` — GET /api/v1/crm/objects/{objectName}/entries/{entryId}/watch */
  "crm.watch.get": {
    objectName: string;
    entryId: string;
  };
  /** Follow or unfollow a CRM entry's activity. — `dench crm watch` — PUT /api/v1/crm/objects/{objectName}/entries/{entryId}/watch */
  "crm.watch.set": {
    objectName: string;
    entryId: string;
    /** Defaults to true; false unfollows. */
    watching?: boolean;
  };
  /** Page assigned tasks in priority order (or completed tasks by recency). — `dench crm tasks mine --page` — POST /api/v1/crm/tasks/assigned/page */
  "crm.tasks.pageAssigned": Record<string, unknown>;
  /** Page all tasks linked to a record, including subtasks. — `dench crm tasks list --page` — POST /api/v1/crm/objects/{objectName}/entries/{entryId}/tasks/page */
  "crm.tasks.pageForEntry": Record<string, unknown>;
  /** Start or resume preparation of exact task ordering and progress. — `dench crm tasks prepare` — POST /api/v1/crm/tasks/prepare */
  "crm.tasks.prepare": Record<string, unknown>;
  /** Your open tasks (plus ones completed today). — `dench crm tasks mine` — GET /api/v1/crm/tasks/mine */
  "crm.tasks.mine": {
    limit?: number;
    /** Only tasks at this priority — one of the workspace's Priority options ("high"; case-insensitive). */
    priority?: string;
  };
  /** Tasks linked to a CRM entry. — `dench crm tasks list` — GET /api/v1/crm/objects/{objectName}/entries/{entryId}/tasks */
  "crm.tasks.forEntry": {
    objectName: string;
    entryId: string;
  };
  /** Create a task linked to a CRM entry. — `dench crm tasks create` — POST /api/v1/crm/objects/{objectName}/entries/{entryId}/tasks */
  "crm.tasks.createForEntry": {
    objectName: string;
    entryId: string;
    name: string;
    assigneeUserId?: string;
    /** YYYY-MM-DD */
    dueDateKey?: string;
    /** One of the workspace's Priority options (default Low | Medium | High; case-insensitive). */
    priority?: string;
  };
  /** Mark a task done. — `dench crm tasks complete` — POST /api/v1/crm/tasks/{entryId}/complete */
  "crm.tasks.complete": {
    entryId: string;
  };
  /** Reopen a completed task. — `dench crm tasks reopen` — POST /api/v1/crm/tasks/{entryId}/reopen */
  "crm.tasks.reopen": {
    entryId: string;
  };
  /** Set or clear a task's priority. — `dench crm tasks priority` — PUT /api/v1/crm/tasks/{entryId}/priority */
  "crm.tasks.setPriority": {
    entryId: string;
    /** One of the workspace's Priority options ("high"; case-insensitive), or null to clear. */
    priority: string | null;
  };
  /** A task's subtasks. — `dench crm tasks subtasks` — GET /api/v1/crm/tasks/{entryId}/subtasks */
  "crm.tasks.subtasks.list": {
    entryId: string;
  };
  /** Create a subtask under a task (inherits the parent's record relations). — `dench crm tasks create-subtask` — POST /api/v1/crm/tasks/{entryId}/subtasks */
  "crm.tasks.subtasks.create": {
    /** The parent task. */
    entryId: string;
    name: string;
    assigneeUserId?: string;
    /** YYYY-MM-DD */
    dueDateKey?: string;
    priority?: string;
  };
  /** Nest a task under a parent, or promote it (parentEntryId: null). — `dench crm tasks parent` — PUT /api/v1/crm/tasks/{entryId}/parent */
  "crm.tasks.setParent": {
    entryId: string;
    /** The parent task, or null to promote to a top-level task. */
    parentEntryId: string | null;
  };
  /** Delete a task and its subtasks, or keep them as tasks. — `dench crm tasks delete` — DELETE /api/v1/crm/tasks/{entryId} */
  "crm.tasks.delete": {
    entryId: string;
    /** What happens to its subtasks: delete them too (default) or keep them as tasks. */
    subtasks?: "delete" | "keep";
  };
  /** How a task repeats (rule, RRULE, trigger, ends, next due). — `dench crm tasks repeat` — GET /api/v1/crm/tasks/{entryId}/repeat */
  "crm.tasks.repeat.get": {
    entryId: string;
  };
  /** Make a task repeat, or change how it repeats (JSON rule or RRULE). An undated task gets its due date anchored on the first matching day from today. — `dench crm tasks repeat` — PUT /api/v1/crm/tasks/{entryId}/repeat */
  "crm.tasks.repeat.set": {
    entryId: string;
    /** Structured rule; alternative to `rrule`. */
    rule?: {
      freq: "daily";
      interval: number;
    } | {
      freq: "weekly";
      interval: number;
      byWeekday: Array<"mo" | "tu" | "we" | "th" | "fr" | "sa" | "su">;
    } | {
      freq: "monthly";
      interval: number;
      /** 1–31, or -1 for the last day of the month. */
      byMonthDay?: number;
      bySetPos?: {
        /** 1–4, or -1 for the last week. */
        ordinal: number;
        weekday: "mo" | "tu" | "we" | "th" | "fr" | "sa" | "su";
      };
    } | {
      freq: "yearly";
      interval: number;
      month: number;
      day: number;
    };
    /** RFC 5545 subset: FREQ, INTERVAL, BYDAY (ordinal allowed for MONTHLY, e.g. 2TU / -1FR), BYMONTHDAY, BYMONTH, COUNT, UNTIL. Bare FREQ=MONTHLY / YEARLY / WEEKLY take the day from the task's due date. */
    rrule?: string;
    /** When the next occurrence is created: after this one is done (default) or on schedule regardless. */
    trigger?: "after_completion" | "on_schedule";
    ends?: {
      kind: "never";
    } | {
      kind: "count";
      count: number;
    } | {
      kind: "until";
      dateKey: string;
    };
    options?: {
      skipWeekends?: boolean;
      keepAssignee?: boolean;
      copyNotes?: boolean;
      copySubtasks?: boolean;
    };
  };
  /** Stop a task repeating (past occurrences are kept). — `dench crm tasks repeat --off` — DELETE /api/v1/crm/tasks/{entryId}/repeat */
  "crm.tasks.repeat.clear": {
    entryId: string;
  };
  /** Skip the current occurrence: the next one is created now. — `dench crm tasks repeat --skip` — POST /api/v1/crm/tasks/{entryId}/repeat/skip */
  "crm.tasks.repeat.skip": {
    entryId: string;
  };
  /** Pause a repeating task. — `dench crm tasks repeat --pause` — POST /api/v1/crm/tasks/{entryId}/repeat/pause */
  "crm.tasks.repeat.pause": {
    entryId: string;
  };
  /** Resume a paused repeating task. — `dench crm tasks repeat --resume` — POST /api/v1/crm/tasks/{entryId}/repeat/resume */
  "crm.tasks.repeat.resume": {
    entryId: string;
  };
  /** Every repeating-task series in the workspace. — `dench crm tasks series` — GET /api/v1/crm/tasks/series */
  "crm.tasks.series.list": {
    status?: "active" | "paused" | "ended";
  };
  /** Every occurrence (task) of one series. — `dench crm tasks series <seriesId> --occurrences` — GET /api/v1/crm/tasks/series/{seriesId}/occurrences */
  "crm.tasks.series.occurrences": {
    seriesId: string;
  };
  /** Create a CRM entry. — `dench crm entries create` — POST /api/v1/crm/objects/{objectName}/entries */
  "crm.entries.create": {
    objectName: string;
    /** Field-name -> value map. For `user` fields use one member userId or a userId array; preserve every assignee. */
    data: Record<string, unknown>;
  };
  /** Create many CRM entries. — `dench crm entries create-many` — POST /api/v1/crm/objects/{objectName}/entries/batch */
  "crm.entries.createMany": {
    objectName: string;
    /** Up to 200 field maps. */
    entries: Record<string, unknown>[];
  };
  /** Update a CRM entry. — `dench crm entries update` — PATCH /api/v1/crm/objects/{objectName}/entries/{entryId} */
  "crm.entries.update": {
    objectName: string;
    entryId: string;
    /** Field-name -> value map. For `user` fields use one member userId or a userId array; preserve every assignee. */
    data: Record<string, unknown>;
  };
  /** Update many CRM entries. — `dench crm entries update-many` — PATCH /api/v1/crm/objects/{objectName}/entries/batch */
  "crm.entries.updateMany": {
    /** Object the entries belong to. */
    objectName: string;
    /** Per-entry partial updates (entryId or id + data). */
    updates: {
      entryId?: string;
      id?: string;
      /** Field-name -> value map. For `user` fields use one member userId or a userId array; preserve every assignee. */
      data: Record<string, unknown>;
    }[];
  };
  /** Delete a CRM entry. — `dench crm entries delete` — DELETE /api/v1/crm/objects/{objectName}/entries/{entryId} */
  "crm.entries.delete": {
    objectName?: string;
    entryId: string;
  };
  /** Bulk delete CRM entries. — `dench crm entries bulk-delete` — POST /api/v1/crm/objects/{objectName}/entries/delete */
  "crm.entries.bulkDelete": {
    objectName?: string;
    entryIds: string[];
  };
  /** Get a CRM cell value. — `dench crm cells get` — GET /api/v1/crm/objects/{objectName}/entries/{entryId}/fields/{fieldName} */
  "crm.cells.get": {
    objectName: string;
    entryId: string;
    fieldName: string;
  };
  /** Set a CRM cell value. — `dench crm cells set` — PUT /api/v1/crm/objects/{objectName}/entries/{entryId}/fields/{fieldName} */
  "crm.cells.set": {
    objectName: string;
    entryId: string;
    fieldName: string;
    /** Cell value. Enum=option string, tags=string array, user=one member userId or a userId array, relation=related entry id, boolean=true/false. */
    value: unknown;
  };
  /** Set many CRM cell values. — `dench crm cells set-many` — POST /api/v1/crm/cells/batch */
  "crm.cells.setMany": {
    cells: {
      objectName: string;
      entryId: string;
      fieldName: string;
      /** Cell value. Enum=option string, tags=string array, user=one member userId or a userId array, relation=related entry id, boolean=true/false. */
      value: unknown;
    }[];
  };
  /** Append to a CRM cell. — `dench crm cells append` — POST /api/v1/crm/objects/{objectName}/entries/{entryId}/fields/{fieldName}/append */
  "crm.cells.append": {
    objectName: string;
    entryId: string;
    fieldName: string;
    /** Cell value. Enum=option string, tags=string array, user=one member userId or a userId array, relation=related entry id, boolean=true/false. */
    value: unknown;
  };
  /** Query CRM entries. — `dench crm query [--with-references]` — POST /api/v1/crm/query */
  "crm.query": {
    /** Include bounded navigation references. Array reads return {data, references, referenceCoverage}; existing result envelopes keep their fields. */
    withReferences?: boolean;
    objectName: string;
    /** Query DSL. Bare equality only; use dslJson for $-operators. */
    dsl?: {
      filter?: Record<string, unknown>;
      select?: string[];
      /** e.g. -Score,Name (- = desc). */
      sort?: string;
      limit?: number;
    };
    /** JSON string of the DSL when filters use operators like $gt/$in/$contains/$and/$or. Date fields and the system timestamps created_at/updated_at also accept $datePreset ("today", "yesterday", "this_week", "last_week", "this_month", "last_month", "this_quarter", "last_quarter", "this_year", "last_year"), and $inLast/$inNext rolling windows (a day count like 7, or {"amount":2,"unit":"weeks"} with unit days|weeks|months|quarters|years). Example: {"filter":{"updated_at":{"$datePreset":"this_month"}}}. */
    dslJson?: string;
    /** Personal scope: "me" (the signed-in member / the human behind an agent session), "unassigned", or a member userId or email. Adds one has_any / is_empty rule on the object's assignee user field; rows, totalCount, sums and analytics all follow it. Never saved onto the view. */
    assignedTo?: string;
    /** Which `user` field "assigned" means. Default: the analytics owner role, else the task `Assignee`, else a user field named like owner/assignee, else the first user field. */
    assigneeField?: string;
  };
  /** Scan CRM entries with a resumable cursor. Empty filtered pages can have more results. — `dench crm query --page` — POST /api/v1/crm/query/page */
  "crm.queryPage": {
    objectName: string;
    dsl?: Record<string, unknown>;
    dslJson?: string;
    /** Personal scope: "me" (the signed-in member / the human behind an agent session), "unassigned", or a member userId or email. Adds one has_any / is_empty rule on the object's assignee user field; rows, totalCount, sums and analytics all follow it. Never saved onto the view. */
    assignedTo?: string;
    /** Which `user` field "assigned" means. Default: the analytics owner role, else the task `Assignee`, else a user field named like owner/assignee, else the first user field. */
    assigneeField?: string;
    /** Include bounded navigation references. Array reads return {data, references, referenceCoverage}; existing result envelopes keep their fields. */
    withReferences?: boolean;
    paginationOpts: {
      numItems: number;
      cursor: string | null;
    };
  };
  /** Run CRM SQL-compatible query. — `dench crm sql` — POST /api/v1/crm/sql */
  "crm.sql": {
    objectName: string;
    dsl?: Record<string, unknown>;
    dslJson?: string;
  };
  /** Aggregate CRM entries. — `dench crm aggregate` — POST /api/v1/crm/aggregate */
  "crm.aggregate": {
    objectName: string;
    /** Field to bucket by. */
    fieldName: string;
    /** Number field to total per bucket (e.g. Amount grouped by Stage). Exact at any table size. */
    sumField?: string;
  };
  /** Search CRM entries. — `dench crm search [--with-references]` — GET /api/v1/crm/search */
  "crm.search": {
    /** Include bounded navigation references. Array reads return {data, references, referenceCoverage}; existing result envelopes keep their fields. */
    withReferences?: boolean;
    /** Full-text query. */
    text: string;
    /** Omit to search org-wide. */
    objectName?: string;
    limit?: number;
  };
  /** Search bounded pages of readable CRM entries, optionally projecting cells. Always follow continueCursor until isDone. — `dench crm search --page` — GET /api/v1/crm/search/page */
  "crm.search.page": {
    /** Include bounded navigation references. Array reads return {data, references, referenceCoverage}; existing result envelopes keep their fields. */
    withReferences?: boolean;
    /** Full-text query over readable entries. */
    text: string;
    objectName?: string;
    select?: string[];
    /** Defaults to strict. Explicit modes require objectName and select. Compact recovers unknown selected names with bounded canonical columns and explicit selectionFallback metadata in the same response. Does not guess aliases. */
    selectionMode?: "strict" | "compact";
    limit?: number;
    /** Use the preceding continueCursor, with the same query and projection. */
    cursor?: string;
  };
  /** List CRM statuses. — `dench crm statuses list` — GET /api/v1/crm/objects/{objectName}/statuses */
  "crm.statuses.list": {
    objectName: string;
  };
  /** Set CRM statuses. — `dench crm statuses set` — PUT /api/v1/crm/objects/{objectName}/statuses */
  "crm.statuses.set": {
    objectName: string;
    statuses: {
      name: string;
      /** Hex color. */
      color: string;
      sortOrder?: number;
      isDefault?: boolean;
    }[];
  };
  /** Apply a CRM batch. — `dench crm batch` — POST /api/v1/crm/batch */
  "crm.batch": {
    /** Include bounded navigation references. Array reads return {data, references, referenceCoverage}; existing result envelopes keep their fields. */
    withReferences?: boolean;
    ops: Array<{
      type: "entries.create";
      objectName: string;
      /** Field-name -> value map. For `user` fields use one member userId or a userId array; preserve every assignee. */
      data: Record<string, unknown>;
    } | {
      type: "entries.update";
      entryId: string;
      /** Field-name -> value map. For `user` fields use one member userId or a userId array; preserve every assignee. */
      data: Record<string, unknown>;
    } | {
      type: "entries.delete";
      entryId: string;
    }>;
    idempotencyKey?: string;
  };
  /** Begin a CRM transaction. — `dench crm transaction begin` — POST /api/v1/crm/transactions */
  "crm.transaction.begin": Record<string, unknown>;
  /** Add an operation to a CRM transaction. — `dench crm transaction add` — POST /api/v1/crm/transactions/{txnId}/operations */
  "crm.transaction.add": {
    txnId: string;
    /** A single CRM batch/transaction operation. */
    op: {
      type: "entries.create";
      objectName: string;
      /** Field-name -> value map. For `user` fields use one member userId or a userId array; preserve every assignee. */
      data: Record<string, unknown>;
    } | {
      type: "entries.update";
      entryId: string;
      /** Field-name -> value map. For `user` fields use one member userId or a userId array; preserve every assignee. */
      data: Record<string, unknown>;
    } | {
      type: "entries.delete";
      entryId: string;
    };
  };
  /** Commit a CRM transaction. — `dench crm transaction commit` — POST /api/v1/crm/transactions/{txnId}/commit */
  "crm.transaction.commit": {
    txnId: string;
  };
  /** Abort a CRM transaction. — `dench crm transaction abort` — POST /api/v1/crm/transactions/{txnId}/abort */
  "crm.transaction.abort": {
    txnId: string;
  };
  /** Inspect a CRM transaction. — `dench crm transaction inspect` — GET /api/v1/crm/transactions/{txnId} */
  "crm.transaction.inspect": {
    txnId: string;
  };
  /** List CRM documents. — `dench crm docs list` — GET /api/v1/crm/docs */
  "crm.docs.list": Record<string, unknown>;
  /** Create a CRM document. — `dench crm docs create` — POST /api/v1/crm/docs */
  "crm.docs.create": {
    title: string;
    filePath: string;
    icon?: string;
    coverImage?: string;
    parentId?: string;
    parentObjectName?: string;
    entryId?: string;
  };
  /** Link a CRM document. — `dench crm docs link` — POST /api/v1/crm/docs/link */
  "crm.docs.link": {
    filePath: string;
    objectName?: string;
    entryId?: string;
  };
  /** Delete a CRM document page; its workspace file stays and nested pages move up. — `dench crm docs delete` — DELETE /api/v1/crm/docs/{documentId} */
  "crm.docs.delete": {
    /** The id crm docs create returned. */
    documentId: string;
  };
  /** List CRM actions. — `dench crm actions list` — GET /api/v1/crm/actions */
  "crm.actions.list": {
    entryId: string;
  };
  /** Create or upsert an action button on a named action column (fieldName is the column header; a column can hold multiple buttons — reuse fieldName to add more). — `dench crm actions create` — POST /api/v1/crm/actions */
  "crm.actions.create": {
    objectName: string;
    fieldName: string;
    actionId?: string;
    label?: string;
    variant?: string;
    icon?: string;
    confirmMessage?: string;
    recipe?: unknown[];
    script?: string;
    scriptPath?: string;
    [key: string]: unknown;
  };
  /** Update an action button on a CRM field. — `dench crm actions edit` — PATCH /api/v1/crm/actions/{actionId} */
  "crm.actions.update": {
    actionId: string;
    objectName: string;
    fieldName: string;
    label?: string;
    variant?: string;
    icon?: string;
    confirmMessage?: string;
    recipe?: unknown[];
    script?: string;
    scriptPath?: string;
    [key: string]: unknown;
  };
  /** Delete an action button from a CRM field. — `dench crm actions delete` — DELETE /api/v1/crm/actions/{actionId} */
  "crm.actions.delete": {
    actionId: string;
    objectName: string;
    fieldName?: string;
    fieldId?: string;
    deleteFieldIfEmpty?: boolean;
    [key: string]: unknown;
  };
  /** Run a CRM action on one or more entries. — `dench crm actions run` — POST /api/v1/crm/actions/{actionId}/runs */
  "crm.actions.run": {
    actionId: string;
    objectName: string;
    fieldId: string;
    entryIds: string[];
    prompts?: Record<string, string>;
  };
  /** List workspace members for CRM user fields. — `dench members list` — GET /api/v1/members */
  "crm.members.list": Record<string, unknown>;
  /** Live presence (online / away / offline) for workspace members. — `dench members presence` — GET /api/v1/members/presence */
  "members.presence": {
    /** Comma-separated user ids; omit for every member. */
    userIds?: string;
  };
  /** A member's profile: name, email, tagline, role, timezone, presence, open task count. — `dench members get` — GET /api/v1/members/{userId} */
  "members.get": {
    userId: string;
  };
  /** A member's recent comments and record changes across the CRM, newest first. — `dench members activity` — GET /api/v1/members/{userId}/activity */
  "members.activity": {
    userId: string;
    limit?: number;
    /** Comma-separated subset of comments,changes. */
    kinds?: string;
  };
  /** Open tasks assigned to a member (plus ones completed today). — `dench members tasks` — GET /api/v1/members/{userId}/tasks */
  "members.tasks": {
    userId: string;
    limit?: number;
    todayStartMs?: number;
  };
  /** Your own member profile. — `dench members me` — GET /api/v1/me/profile */
  "me.profile.get": Record<string, unknown>;
  /** Update your name, tagline, avatar URL, or timezone. — `dench members me --name … --tagline … --timezone …` — PATCH /api/v1/me/profile */
  "me.profile.update": {
    name?: string;
    /** Empty string clears. */
    tagline?: string;
    /** http(s) image URL; empty string clears the avatar. */
    imageUrl?: string;
    /** IANA zone; null returns to browser detection. */
    timezone?: string | null;
  };
  /** Get a one-time URL to POST an avatar image to; then PUT /me/avatar with the returned storageId. — `dench members me --avatar <file>` — POST /api/v1/me/avatar/upload-url */
  "me.avatar.uploadUrl": Record<string, unknown>;
  /** Set your avatar from an uploaded storageId. — `dench members me --avatar <file>` — PUT /api/v1/me/avatar */
  "me.avatar.set": {
    /** storageId returned by the upload POST. */
    storageId: string;
  };
  /** Remove your avatar. — `dench members me --clear-avatar` — DELETE /api/v1/me/avatar */
  "me.avatar.clear": Record<string, unknown>;
  /** Generate a CRM report. — `dench crm reports generate` — POST /api/v1/crm/reports */
  "crm.reports.generate": {
    objectName: string;
    /** Chart type for the generated report. */
    type: "pie" | "bar" | "line" | "table";
    groupByField: string;
    /** Aggregation metric. Defaults to `count`. */
    metric?: "count" | "sum" | "avg" | "min" | "max";
    /** Number field to sum/avg per bucket (e.g. Amount grouped by Stage). Defaults to the group field itself. */
    metricField?: string;
  };
  /** Read an object's analytics dashboard: panels, field roles, the strip's collapsed flag, the named view's own dashboard (if any), and the fields panels may bucket on (synthetic $createdAt / $location last). — `dench crm analytics get` — GET /api/v1/crm/objects/{objectName}/analytics */
  "crm.analytics.get": {
    objectName: string;
    /** Also return this saved view's own dashboard (viewAnalytics) when it has one. */
    viewName?: string;
  };
  /** Compute chart-ready results (buckets / series / values) for the stored dashboard, a subset of its panels, or ad-hoc panel definitions — optionally scoped to a saved view, a period preset (with the previous interval as previousValue) and extra filters. Same query the strip renders from. — `dench crm analytics compute` — POST /api/v1/crm/objects/{objectName}/analytics/compute */
  "crm.analytics.compute": {
    objectName: string;
    /** Compute the saved view's own dashboard instead of the object's (ignored when the view inherits). */
    viewName?: string;
    /** Only these stored panels. */
    panelIds?: string[];
    /** Ad-hoc panel definitions to compute instead of the stored dashboard (nothing is persisted). id/title/metric/sortOrder are filled in when omitted. */
    panels?: Array<{
      /** Stable id (template panels use `tpl:<template>:<slug>`). */
      id?: string;
      title?: string;
      type: "stat" | "bar" | "line" | "area" | "donut" | "funnel" | "leaderboard" | "forecast" | "map";
      metric?: "count" | "sum" | "avg" | "min" | "max";
      /** Numeric field for sum/avg/min/max. Ignored for count. */
      metricField?: string;
      /** Bucketing field (enum/user/relation/boolean/text, or $location). On a time-series panel it splits the series into one line per value. */
      groupBy?: string;
      /** Date field for line/area/forecast bucketing (or $createdAt). */
      dateField?: string;
      dateBucket?: "day" | "week" | "month" | "quarter";
      /** Panel-scoped FilterGroup, same shape as saved-view filters. */
      filters?: Record<string, unknown>;
      /** Deprecated; ignored for layout. Use `span`. */
      size?: "sm" | "md" | "lg";
      /** Card width on the 6-track dashboard grid: 2 = a third, 3 = half, 4 = two thirds, 6 = full row. Defaults: funnel 4; map and leaderboard 2; bar/donut grouped by a user field 2, by anything else 4; trends 3. */
      span?: 2 | 3 | 4 | 6;
      /** Hide from the strip above the table; still shown in the full analytics view. */
      hidden?: boolean;
      sortOrder?: number;
      /** Role-driven derived metric; when set the panel computes from fieldRoles instead of metric/groupBy. */
      derived?: "conversion_rate" | "win_rate" | "won_amount" | "lost_amount" | "open_pipeline" | "pipeline_forecast" | "mrr" | "arr";
    }>;
    /** Period preset. Scopes every panel by a date_preset on the object's closeDate role (else $createdAt) and fills previousValue from the previous calendar interval. "all" = no scope. */
    period?: "all" | "this_week" | "this_month" | "last_month" | "this_quarter" | "last_quarter" | "this_year";
    /** FilterGroup applied to every panel (e.g. the view's rules). Forces the bounded scan path. */
    extraFilters?: Record<string, unknown>;
    /** FilterGroup for the comparison window; every panel's value over it comes back as previousValue. Derived automatically from `period`. */
    compareFilters?: Record<string, unknown>;
    /** Preview an unsaved role mapping. */
    fieldRolesOverride?: {
      /** Numeric field holding the deal value ("Amount") — the "Value field" in the setup sheet. */
      amount?: string;
      /** Enum field driving the pipeline ("Stage" / "Status") — the "Progress field". */
      stage?: string;
      /** `stage` options that count as won (closed, successful). */
      wonValues?: string[];
      /** `stage` options that count as lost (closed, gone). */
      lostValues?: string[];
      /** `stage` options that count as converted (a lead reached "Qualified"). */
      convertedValues?: string[];
      /** Date field for time bucketing, forecasts and the period pill (falls back to $createdAt). */
      closeDate?: string;
      /** User field naming who owns each record ("Owner"). Rankings on it default to a narrow card and draw member faces. */
      owner?: string;
      /** Place-name field maps plot. May be a relation path like "Account.HQ Location" (one hop through a relation). */
      location?: string;
      /** How a won amount recurs: annual treats Amount as ARR, monthly as MRR, one_time disables MRR/ARR panels. */
      recurrence?: "monthly" | "annual" | "one_time";
      /** Chance of closing per OPEN stage, 0..1, for the weighted forecast. Unlisted stages are spaced evenly; won = 1, lost = 0. */
      stageProbabilities?: Record<string, number>;
    };
    /** Personal scope: "me" (the signed-in member / the human behind an agent session), "unassigned", or a member userId or email. Adds one has_any / is_empty rule on the object's assignee user field; rows, totalCount, sums and analytics all follow it. Never saved onto the view. */
    assignedTo?: string;
    /** Which `user` field "assigned" means. Default: the analytics owner role, else the task `Assignee`, else a user field named like owner/assignee, else the first user field. */
    assigneeField?: string;
    /** Click-to-filter chips, same as the strip: each scopes every panel EXCEPT those whose dimensions include `dimension`. */
    drillFilters?: {
      /** The bare field the click came from — a panel's groupBy or dateField, or `$location` for a map. Panels drawn along it keep their full picture; every other panel is scoped. */
      dimension: string;
      /** FilterGroup selecting the clicked bucket. */
      filter: Record<string, unknown>;
    }[];
  };
  /** Create or update one panel (upsert by id). With viewName the write lands on that saved view's own dashboard, forking a copy if it was still inheriting the object's. — `dench crm analytics save` — PUT /api/v1/crm/objects/{objectName}/analytics/panels/{panelId} */
  "crm.analytics.save": {
    objectName: string;
    /** Panel id (path); becomes panel.id. */
    panelId: string;
    /** The panel definition to upsert. */
    panel: {
      title: string;
      type: "stat" | "bar" | "line" | "area" | "donut" | "funnel" | "leaderboard" | "forecast" | "map";
      metric: "count" | "sum" | "avg" | "min" | "max";
      /** Numeric field for sum/avg/min/max. Ignored for count. */
      metricField?: string;
      /** Bucketing field (enum/user/relation/boolean/text, or $location). On a time-series panel it splits the series into one line per value. */
      groupBy?: string;
      /** Date field for line/area/forecast bucketing (or $createdAt). */
      dateField?: string;
      dateBucket?: "day" | "week" | "month" | "quarter";
      /** Panel-scoped FilterGroup, same shape as saved-view filters. */
      filters?: Record<string, unknown>;
      /** Deprecated; ignored for layout. Use `span`. */
      size?: "sm" | "md" | "lg";
      /** Card width on the 6-track dashboard grid: 2 = a third, 3 = half, 4 = two thirds, 6 = full row. Defaults: funnel 4; map and leaderboard 2; bar/donut grouped by a user field 2, by anything else 4; trends 3. */
      span?: 2 | 3 | 4 | 6;
      /** Hide from the strip above the table; still shown in the full analytics view. */
      hidden?: boolean;
      sortOrder: number;
      /** Role-driven derived metric; when set the panel computes from fieldRoles instead of metric/groupBy. */
      derived?: "conversion_rate" | "win_rate" | "won_amount" | "lost_amount" | "open_pipeline" | "pipeline_forecast" | "mrr" | "arr";
      id?: string;
    };
    /** Write the saved view's own dashboard (forks a copy if it was inheriting). */
    viewName?: string;
  };
  /** Edit part of one stored panel: only the keys in `patch` change (title, type, metric, metricField, groupBy, dateField, dateBucket, filters, derived, span, hidden, sortOrder); null clears an optional key. What the card's ⋮ menu writes. — `dench crm analytics update` — PATCH /api/v1/crm/objects/{objectName}/analytics/panels/{panelId} */
  "crm.analytics.update": {
    objectName: string;
    /** Stored panel id (path). */
    panelId: string;
    /** Partial panel edit: only the keys present change; null clears an optional key; hidden: false is stored as absent. */
    patch: {
      title?: string;
      type?: "stat" | "bar" | "line" | "area" | "donut" | "funnel" | "leaderboard" | "forecast" | "map";
      metric?: "count" | "sum" | "avg" | "min" | "max";
      metricField?: string | null;
      groupBy?: string | null;
      dateField?: string | null;
      dateBucket?: "day" | "week" | "month" | "quarter" | null;
      filters?: Record<string, unknown> | null;
      /** Width in tracks; null restores the chart kind's default. */
      span?: 2 | 3 | 4 | 6 | null;
      /** Hide from the strip above the table; still shown in the full analytics view. */
      hidden?: boolean;
      sortOrder?: number;
      derived?: "conversion_rate" | "win_rate" | "won_amount" | "lost_amount" | "open_pipeline" | "pipeline_forecast" | "mrr" | "arr" | null;
    };
    /** Edit the saved view's own dashboard (forks a copy if it was inheriting). */
    viewName?: string;
  };
  /** Take a chart off the strip above the table (hidden: true). It stays in the full analytics view, counted by the strip's “+N more”. — `dench crm analytics hide` — POST /api/v1/crm/objects/{objectName}/analytics/panels/{panelId}/hide */
  "crm.analytics.hide": {
    objectName: string;
    panelId: string;
    viewName?: string;
  };
  /** Bring a hidden chart back onto the strip (hidden: false). — `dench crm analytics show` — POST /api/v1/crm/objects/{objectName}/analytics/panels/{panelId}/show */
  "crm.analytics.show": {
    objectName: string;
    panelId: string;
    viewName?: string;
  };
  /** Set a card's width on the 6-track dashboard grid: span 2 (third), 3 (half), 4 (two thirds), 6 (full), or null for the chart kind's default. — `dench crm analytics resize` — POST /api/v1/crm/objects/{objectName}/analytics/panels/{panelId}/resize */
  "crm.analytics.resize": {
    objectName: string;
    panelId: string;
    /** 2 = third, 3 = half, 4 = two thirds, 6 = full row; null = the chart kind's default. */
    span: 2 | 3 | 4 | 6 | null;
    viewName?: string;
  };
  /** Delete one panel (idempotent). Template panels are tombstoned so a re-install never resurrects them. — `dench crm analytics delete` — DELETE /api/v1/crm/objects/{objectName}/analytics/panels/{panelId} */
  "crm.analytics.delete": {
    objectName: string;
    panelId: string;
    viewName?: string;
  };
  /** Persist the full panel order. panelIds must name every stored panel of the targeted dashboard. — `dench crm analytics reorder` — POST /api/v1/crm/objects/{objectName}/analytics/reorder */
  "crm.analytics.reorder": {
    objectName: string;
    /** Every stored panel id of the targeted dashboard, in order. */
    panelIds: string[];
    viewName?: string;
  };
  /** Set the object's analytics setup — the field roles shared by every chart and view (amount, stage, won/lost/converted values, stageProbabilities, closeDate, recurrence, owner, location). Replaces the mapping; with merge: true only the keys given change and null clears one. — `dench crm analytics roles` — PUT /api/v1/crm/objects/{objectName}/analytics/roles */
  "crm.analytics.roles": {
    objectName: string;
    /** Field roles as an edit: the same keys; null clears one. Applied onto the stored mapping with merge: true, otherwise replaces it. */
    fieldRoles: {
      /** Numeric field holding the deal value ("Amount") — the "Value field" in the setup sheet. */
      amount?: string | null;
      /** Enum field driving the pipeline ("Stage" / "Status") — the "Progress field". */
      stage?: string | null;
      /** `stage` options that count as won (closed, successful). */
      wonValues?: string[] | null;
      /** `stage` options that count as lost (closed, gone). */
      lostValues?: string[] | null;
      /** `stage` options that count as converted (a lead reached "Qualified"). */
      convertedValues?: string[] | null;
      /** Date field for time bucketing, forecasts and the period pill (falls back to $createdAt). */
      closeDate?: string | null;
      /** User field naming who owns each record ("Owner"). Rankings on it default to a narrow card and draw member faces. */
      owner?: string | null;
      /** Place-name field maps plot. May be a relation path like "Account.HQ Location" (one hop through a relation). */
      location?: string | null;
      /** How a won amount recurs: annual treats Amount as ARR, monthly as MRR, one_time disables MRR/ARR panels. */
      recurrence?: "monthly" | "annual" | "one_time" | null;
      /** Chance of closing per OPEN stage, 0..1, for the weighted forecast. Unlisted stages are spaced evenly; won = 1, lost = 0. */
      stageProbabilities?: Record<string, number> | null;
    };
    /** true: change only the keys given (null clears one). Default replaces the whole mapping. */
    merge?: boolean;
  };
  /** Collapse the analytics strip above the object's table (team-shared, like saved views). — `dench crm analytics collapse` — POST /api/v1/crm/objects/{objectName}/analytics/collapse */
  "crm.analytics.collapse": {
    objectName: string;
  };
  /** Expand the analytics strip above the object's table. — `dench crm analytics expand` — POST /api/v1/crm/objects/{objectName}/analytics/expand */
  "crm.analytics.expand": {
    objectName: string;
  };
  /** Give a saved view its own dashboard (mode "own": starts as a copy of the object's panels) or hand it back to the object's shared one (mode "shared"). — `dench crm analytics scope` — POST /api/v1/crm/objects/{objectName}/views/{viewName}/analytics/scope */
  "crm.analytics.scope": {
    objectName: string;
    viewName: string;
    /** "own": the view gets its own dashboard (a copy of the object's panels); "shared": it shows the object's again. */
    mode: "own" | "shared";
  };
  /** Request enrichment for one CRM cell. — `dench crm enrich cell` — POST /api/v1/crm/enrich/cell */
  "crm.enrich.cell": {
    objectName: string;
    entryId: string;
    fieldName: string;
  };
  /** Request enrichment for a CRM object. — `dench crm enrich object` — POST /api/v1/crm/enrich/object */
  "crm.enrich.object": {
    objectName: string;
    fieldName: string;
    /** Only enrich empty cells. Defaults true. */
    missingOnly?: boolean;
  };
  /** Search for people through the enrichment gateway. `companyDomains` takes up to 1000 domains (e.g. a resolved company list; `dench leads find --company-list <id|view>` resolves one for you) — the gateway fans large lists out as sequential vendor-safe chunks behind one `nextPageToken` stream. — `dench crm people search` — POST /api/v1/enrichment/people/search */
  "crm.people.search": {
    linkedinUrl?: string;
    fullName?: string;
    firstName?: string;
    lastName?: string;
    /** Current-title text only. For profile or work descriptions, use profileKeywords. Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
    keywords?: string;
    companyDomain?: string;
    companyName?: string;
    /** Current job titles (free text). Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
    titles?: Array<string | {
      value: string;
      exclude?: boolean;
      exactMatch?: boolean;
    }>;
    /** Past job titles (free text). */
    pastTitles?: Array<string | {
      value: string;
      exclude?: boolean;
      exactMatch?: boolean;
    }>;
    personNames?: Array<string | {
      value: string;
      exclude?: boolean;
      exactMatch?: boolean;
    }>;
    /** Seniority in any past role, independent of pastCompanyNames/pastTitles. Current seniority vocabulary plus Founding Team. Founder includes Co-Founder; C-level and Founding Team do not imply founder. Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
    pastSeniorities?: Array<string | {
      value: string;
      exclude?: boolean;
      exactMatch?: boolean;
    }>;
    /** Text in headline/about or any current/past work description. OR includes, global exclusions. Always loose text matching; missing evidence does not match. */
    profileKeywords?: Array<string | {
      value: string;
      exclude?: boolean;
      exactMatch?: boolean;
    }>;
    /** Current employer business focus/model (e.g. SaaS, B2B, Cloud), from description/tagline/business tags; distinct from legal companyTypes. Same employer as other current-job filters. Always loose text matching. May need another filter to retrieve candidates. */
    companyKeywords?: Array<string | {
      value: string;
      exclude?: boolean;
      exactMatch?: boolean;
    }>;
    /** Exact enum: Owner, Founder, C-level, Partner, VP, Head, Director, Manager, Senior. */
    seniorities?: Array<string | {
      value: string;
      exclude?: boolean;
      exactMatch?: boolean;
    }>;
    /** Exact enum, e.g. Sales, Marketing, Software. Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
    jobFunctions?: Array<string | {
      value: string;
      exclude?: boolean;
      exactMatch?: boolean;
    }>;
    /** Exact enum, e.g. SDR/BDR, Demand Generation. Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
    subFunctions?: Array<string | {
      value: string;
      exclude?: boolean;
      exactMatch?: boolean;
    }>;
    /** Exact enum, e.g. Software Development. Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
    industries?: Array<string | {
      value: string;
      exclude?: boolean;
      exactMatch?: boolean;
    }>;
    /** Person locations — cities, states, countries, or metros (free text). Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
    locations?: Array<string | {
      value: string;
      exclude?: boolean;
      exactMatch?: boolean;
    }>;
    /** Exact buckets: 1-10, 11-50, 51-200, 201-500, 501-1000, 1001-5000, 5001-10000, 10001+. */
    headcountRanges?: Array<string | {
      value: string;
      exclude?: boolean;
      exactMatch?: boolean;
    }>;
    companyNames?: Array<string | {
      value: string;
      exclude?: boolean;
      exactMatch?: boolean;
    }>;
    pastCompanyNames?: Array<string | {
      value: string;
      exclude?: boolean;
      exactMatch?: boolean;
    }>;
    companyDomains?: Array<string | {
      value: string;
      exclude?: boolean;
      exactMatch?: boolean;
    }>;
    /** Company HQ locations — cities, states, countries, or metros (free text). Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
    companyHeadquarters?: Array<string | {
      value: string;
      exclude?: boolean;
      exactMatch?: boolean;
    }>;
    /** Exact enum: Partnership, Nonprofit, Educational, Privately Held, Public Company, Self-Owned, Self-Employed, Government Agency. */
    companyTypes?: Array<string | {
      value: string;
      exclude?: boolean;
      exactMatch?: boolean;
    }>;
    /** Universities attended (free text). Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
    universities?: Array<string | {
      value: string;
      exclude?: boolean;
      exactMatch?: boolean;
    }>;
    /** Profile skills (free text). Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
    skills?: Array<string | {
      value: string;
      exclude?: boolean;
      exactMatch?: boolean;
    }>;
    /** Spoken languages, e.g. English, German. Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
    languages?: Array<string | {
      value: string;
      exclude?: boolean;
      exactMatch?: boolean;
    }>;
    yearsInRole?: {
      min?: number;
      max?: number;
    };
    yearsAtCompany?: {
      min?: number;
      max?: number;
    };
    daysSinceJobChange?: {
      min?: number;
      max?: number;
    };
    /** Company founded-year range, e.g. {min: 2015, max: 2024}. */
    foundedYears?: {
      min?: number;
      max?: number;
    };
    /** Match free-text filters as whole strings. Default false: titles ['Founder'] also returns 'Co-Founder' and 'Founder & CEO'. Set true to narrow. Domains, LinkedIn URLs, enum filters and numeric ranges are always exact; keywords is always a loose text probe. */
    exactMatch?: boolean;
    limit?: number;
    offset?: number;
    /** Opaque token from a previous response's metadata.nextPageToken. */
    pageToken?: string;
    preferCache?: boolean;
  };
  /** Search for companies through the enrichment gateway (also `dench companies find`). — `dench crm companies search` — POST /api/v1/enrichment/company/search */
  "crm.companies.search": {
    domain?: string;
    name?: string;
    linkedinUrl?: string;
    keywords?: string;
    /** Exact enum, e.g. Software Development. Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
    industries?: string[];
    /** Cities, states, countries, or metros (free text). Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
    locations?: string[];
    /** Exact buckets: 1-10, 11-50, 51-200, 201-500, 501-1000, 1001-5000, 5001-10000, 10001+. */
    headcountRanges?: string[];
    /** Match free-text filters (name, locations, keywords) as whole strings. Default false. Domain, linkedinUrl and enum filters are always exact. */
    exactMatch?: boolean;
    limit?: number;
    offset?: number;
    /** Opaque token from a previous response's metadata.nextPageToken. */
    pageToken?: string;
    preferCache?: boolean;
  };
  /** Search job postings through Dench find. `companyDomains` takes up to 1000 domains (chunked automatically); `dench jobs find --company-list <id|view>` resolves a saved company list into it. — `dench jobs find` — POST /api/v1/enrichment/jobs/search */
  "enrichment.jobs.search": {
    /** Job titles (free text). Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
    titles?: string[];
    /** Cities, states, countries, or metros (free text). Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
    locations?: string[];
    companyDomain?: string;
    companyName?: string;
    companyLinkedinUrl?: string;
    keywords?: string;
    postedAfter?: string;
    /** Inclusive posting end date (YYYY-MM-DD); includes the whole UTC day. */
    postedBefore?: string;
    limit?: number;
    /** Opaque token from a previous response's metadata.nextPageToken. */
    pageToken?: string;
    preferCache?: boolean;
  };
  /** Look up one person profile. — `dench crm enrich cell` — POST /api/v1/enrichment/person */
  "enrichment.person": {
    linkedinURL?: string;
    linkedinID?: string;
    email?: string;
    [key: string]: unknown;
  };
  /** Look up one company profile. — `dench crm enrich cell` — POST /api/v1/enrichment/company */
  "enrichment.company": {
    website?: string;
    linkedinURL?: string;
    linkedinID?: string;
    [key: string]: unknown;
  };
  /** Look up verified emails and phones for people. — `dench crm enrich cell` — POST /api/v1/enrichment/person/contact */
  "enrichment.person.contact": {
    contacts: Record<string, unknown>[];
    [key: string]: unknown;
  };
  /** Look up up to 100 people or company profiles without buying emails or phones. Pass kind (people|companies) and lookups; results preserve inputIndex. People require linkedinUrl or email; companies require domain or linkedinUrl. — `dench crm enrich profiles` — POST /api/v1/enrichment/profiles/bulk */
  "enrichment.profiles.bulk": {
    kind: "people" | "companies";
    /** Input order is preserved. Does not purchase contact data or write CRM records. */
    lookups: Array<{
      linkedinUrl: string;
    } | {
      email: string;
    } | {
      domain: string;
    }>;
  };
  /** Read company employees, founders, funding, investors, acquisitions, or investments. Pass domain or linkedinUrl, kind, limit (1–100), and optional pageToken. Does not import CRM records or buy contacts. — `dench companies related` — POST /api/v1/enrichment/company/related */
  "enrichment.company.related": {
    /** Company domain. Provide exactly one of domain or linkedinUrl. */
    domain?: string;
    /** Company LinkedIn URL. Omit when domain is provided. */
    linkedinUrl?: string;
    kind: "employees" | "founders" | "funding" | "investors" | "acquisitions" | "investments";
    /** Records per page; defaults to 25. Keep unchanged when using pageToken. */
    limit?: number;
    /** Opaque metadata.nextPageToken from this same company, kind, and page size. */
    pageToken?: string;
  };
  /** Preview how many records a find would return. — `dench leads find --limit 1` — POST /api/v1/enrichment/search/preview */
  "enrichment.search.preview": {
    kind?: "people" | "companies" | "jobs";
    [key: string]: unknown;
  };
  /** List one-click CRM templates (objects + automations + sample rows) with per-workspace installed flags. — `dench crm templates list` — GET /api/v1/crm/templates */
  "crm.templates.list": Record<string, unknown>;
  /** Install a CRM template. Idempotent: re-installs top up missing pieces and never duplicate objects, automations, or sample rows. — `dench crm templates install` — POST /api/v1/crm/templates/{templateId}/install */
  "crm.templates.install": Record<string, unknown>;
  /** Delete a CRM template's sample rows (tagged "Sample"); schema, views, and automations stay. — `dench crm templates remove-sample-data` — POST /api/v1/crm/templates/{templateId}/remove-sample-data */
  "crm.templates.removeSampleData": Record<string, unknown>;
  /** List deterministic CRM automations (rules that fire inside entry writes, e.g. qualified prospect → opportunity). — `dench crm automations list` — GET /api/v1/crm/automations */
  "crm.automations.list": Record<string, unknown>;
  /** Enable or disable a CRM automation. — `dench crm automations enable|disable` — PATCH /api/v1/crm/automations/{automationId} */
  "crm.automations.setEnabled": Record<string, unknown>;
  /** List meetings, newest first, with status and participants. — `dench meetings list` — GET /api/v1/meetings */
  "meetings.list": {
    limit?: number;
    /** continueCursor from the prior page. */
    cursor?: string;
  };
  /** Read a meeting's transcript, in order, one page at a time. — `dench meetings transcript get` — GET /api/v1/meetings/{meetingEntryId}/transcript */
  "meetings.transcript.list": {
    meetingEntryId: string;
    limit?: number;
    cursor?: string;
  };
  /** Append up to 500 transcript segments to a meeting (speakers with an email link to existing people). — `dench meetings transcript set` — POST /api/v1/meetings/{meetingEntryId}/transcript */
  "meetings.transcript.append": {
    meetingEntryId: string;
    segments: Array<{
      /** Ordinal; omitted continues after the last row. */
      seq?: number;
      speakerName?: string | null;
      /** Links the speaker to an existing person by exact email. */
      speakerEmail?: string | null;
      startMs?: number;
      endMs?: number;
      text: string;
    }>;
  };
  /** Delete a batch of a meeting's transcript segments; repeat until `done` before re-appending. — `dench meetings transcript clear` — DELETE /api/v1/meetings/{meetingEntryId}/transcript */
  "meetings.transcript.clear": {
    meetingEntryId: string;
  };
  /** List a meeting's action items. — `dench meetings action-items list` — GET /api/v1/meetings/{meetingEntryId}/action-items */
  "meetings.actionItems.list": {
    meetingEntryId: string;
  };
  /** Add action items to a meeting; `replace: true` swaps the whole list. — `dench meetings action-items set` — POST /api/v1/meetings/{meetingEntryId}/action-items */
  "meetings.actionItems.add": {
    meetingEntryId: string;
    items: Array<{
      text: string;
      ownerName?: string | null;
      done?: boolean;
    }>;
    /** Delete the existing list first. */
    replace?: boolean;
  };
  /** Tick or untick one action item. — `dench meetings action-items done` — PATCH /api/v1/meetings/action-items/{itemId} */
  "meetings.actionItems.setDone": {
    itemId: string;
    done: boolean;
  };
  /** Delete one action item. — `dench meetings action-items delete` — DELETE /api/v1/meetings/action-items/{itemId} */
  "meetings.actionItems.delete": {
    itemId: string;
  };
  /** Who was in the meeting, merged with the linked calendar invite. — `dench meetings participants list` — GET /api/v1/meetings/{meetingEntryId}/participants */
  "meetings.participants.list": {
    meetingEntryId: string;
  };
  /** Record attendees by name/email; known members and existing people are linked, nobody is created. — `dench meetings participants set` — PUT /api/v1/meetings/{meetingEntryId}/participants */
  "meetings.participants.set": {
    meetingEntryId: string;
    participants: Array<{
      name?: string | null;
      email?: string | null;
      isHost?: boolean;
    }>;
    /** Drop attendees not in this list. Default merges. */
    replace?: boolean;
  };
  /** Whether a meeting is shared with the whole workspace, and whether you may change that. — `dench meetings share` — GET /api/v1/meetings/{meetingEntryId}/sharing */
  "meetings.sharing.get": {
    meetingEntryId: string;
  };
  /** Share one meeting with the workspace, or take it back to owner + invitees. — `dench meetings share --workspace` — PUT /api/v1/meetings/{meetingEntryId}/sharing */
  "meetings.sharing.set": {
    meetingEntryId: string;
    /** true opens the meeting to every workspace member; false returns it to the owner plus the members who were on the invite. */
    shared: boolean;
  };
  /** Start Dench Emailing Service sender verification. — `dench email identity verify` — POST /api/v1/email/identities/verify */
  "email.identity.verify": {
    /** Identity scope. `domain` verifies via DNS (DKIM); `email` verifies a single mailbox via a confirmation email. */
    type: "domain" | "email";
    /** Domain (example.com) or mailbox (founder@example.com). */
    identity: string;
    /** Optional provider configuration set override. */
    configurationSetName?: string;
  };
  /** Create a durable Dench email sending identity record. — `dench email identity verify` — POST /api/v1/email/sending-identities */
  "email.identity.create": {
    /** Identity scope. `domain` verifies via DNS (DKIM); `email` verifies a single mailbox via a confirmation email. */
    type: "domain" | "email";
    /** Lowercase domain; required when type is `domain`. */
    domain?: string;
    /** Sender mailbox, e.g. founder@example.com. */
    fromEmail: string;
    /** Default display name for the sender. */
    fromName?: string;
    replyToEmail?: string;
    configurationSetName?: string;
  };
  /** Refresh a Dench Emailing Service sender verification status. — `dench email identity status --identity-id` — POST /api/v1/email/sending-identities/{identityId}/status */
  "email.identity.refresh": {
    /** Sending identity id. */
    identityId: string;
  };
  /** Begin the full Dench sender verification flow for a sending identity. — `dench email identity verify` — POST /api/v1/email/sending-identities/{identityId}/verify */
  "email.identity.beginVerification": {
    /** Sending identity id from `POST /email/sending-identities`. */
    identityId: string;
  };
  /** Read Dench Emailing Service sender verification status. — `dench email identity status` — GET /api/v1/email/identities/{identity}/status */
  "email.identity.status": {
    /** Email address or domain to check. */
    identity: string;
  };
  /** List the workspace's email sending identities. — `dench email identity list` — GET /api/v1/email/sending-identities */
  "email.identity.list": {
    /** Filter identities by domain. */
    domain?: string;
  };
  /** Fetch DNS records (DKIM/SPF/DMARC) for a pending domain sender verification. — `dench email identity dns` — GET /api/v1/email/sending-identities/{identityId}/dns */
  "email.identity.dns": {
    /** Sending identity id. */
    identityId: string;
  };
  /** Soft-disable a sender (or every sender on a domain) for the workspace; sends are blocked until restored. — `dench email identity disable` — POST /api/v1/email/sending-identities/{identity}/disable */
  "email.identity.disable": {
    /** Identity id, sender email, or domain (disables every sender on the domain). */
    identity: string;
  };
  /** Restore a previously disabled sender for the workspace. — `dench email identity restore` — POST /api/v1/email/sending-identities/{identity}/restore */
  "email.identity.restore": {
    /** Identity id, sender email, or domain. */
    identity: string;
  };
  /** Permanently delete a sender (or every sender on a domain) from the workspace; re-adding it requires verification from scratch. — `dench email identity delete` — DELETE /api/v1/email/sending-identities/{identity} */
  "email.identity.delete": {
    /** Identity id, sender email, or domain (deletes every sender on the domain). Permanent: re-adding requires re-verification. */
    identity: string;
  };
  /** Search authorized synced mailbox headers with bounded cursor pagination. isDone covers stored records, not provider completeness. — `dench email inbox search` — GET /api/v1/email/inbox/search */
  "email.inbox.search": {
    limit?: number;
    cursor?: string;
    mailbox?: string;
    from?: string;
    to?: string;
    subject?: string;
    /** Words that must all appear in the subject, sender or recipients (case-insensitive). */
    query?: string;
    /** Inclusive Unix milliseconds; missing sentAt falls back to createdAt. */
    after?: number;
    /** Exclusive Unix milliseconds. */
    before?: number;
    direction?: "inbound" | "outbound";
  };
  /** Read a bounded page of synced headers using an exact thread handle from inbox search; bodies remain on demand. — `dench email inbox thread` — GET /api/v1/email/inbox/threads/{threadHandle} */
  "email.inbox.thread": {
    limit?: number;
    cursor?: string;
    threadHandle: string;
  };
  /** Read a bounded stored body using an exact message handle from inbox search; rechecks mailbox and record privacy. — `dench email inbox message` — GET /api/v1/email/inbox/messages/{messageHandle} */
  "email.inbox.message": {
    messageHandle: string;
    format?: "text" | "html";
    maxBytes?: number;
  };
  /** Create an editable Dench email draft and synchronize its selected native mailbox asynchronously. Use a stable requestId for retries. — `dench email draft create` — POST /api/v1/email/drafts */
  "email.drafts.create": {
    organizationId?: string;
    threadId?: string;
    mailbox?: string;
    requestId: string;
    to?: {
      email: string;
      name?: string;
    }[];
    cc?: {
      email: string;
      name?: string;
    }[];
    bcc?: {
      email: string;
      name?: string;
    }[];
    subject?: string;
    htmlBody?: string;
    textBody?: string;
    attachments?: {
      storageId: string;
      name: string;
      contentType: string;
      size: number;
    }[];
  };
  /** Read an email draft, eligible senders and provider sync status. — `dench email draft show` — GET /api/v1/email/drafts/{draftId} */
  "email.drafts.get": {
    draftId: string;
  };
  /** List native mailboxes this caller may use. — `dench email draft senders` — GET /api/v1/email/drafts/senders */
  "email.drafts.senders": {
    organizationId?: string;
  };
  /** Save draft content using expectedRevision; sender changes require a new draft after provider binding. — `dench email draft update` — PATCH /api/v1/email/drafts/{draftId} */
  "email.drafts.update": {
    draftId: string;
    expectedRevision: number;
    patch: {
      mailboxAccountId?: string;
      to?: {
        email: string;
        name?: string;
      }[];
      cc?: {
        email: string;
        name?: string;
      }[];
      bcc?: {
        email: string;
        name?: string;
      }[];
      subject?: string;
      htmlBody?: string;
      textBody?: string;
      attachments?: {
        storageId: string;
        name: string;
        contentType: string;
        size: number;
      }[];
    };
  };
  /** Send the current Dench draft revision through its native mailbox. Repeated requests share a durable receipt. — `dench email draft send` — POST /api/v1/email/drafts/{draftId}/send */
  "email.drafts.send": {
    draftId: string;
    expectedRevision: number;
    requestId?: string;
  };
  /** Upload attachment bytes authorized against this draft before adding its storage reference. — `dench email draft attach` — POST /api/v1/email/drafts/{draftId}/attachments */
  "email.drafts.upload": {
    draftId: string;
    name: string;
    contentType: string;
    contentBase64: string;
  };
  /** Load the selected mailbox signature for explicit visible insertion. — `dench email draft signature` — GET /api/v1/email/drafts/{draftId}/signature */
  "email.drafts.signature": {
    draftId: string;
  };
  /** Send through a native Gmail or Outlook mailbox with a durable request receipt. Only use for an explicit send request. — `dench email send [--mailbox <id/email>]` — POST /api/v1/email/native/send */
  "email.native.send": {
    organizationId?: string;
    threadId?: string;
    mailbox?: string;
    requestId: string;
    to: {
      email: string;
      name?: string;
    }[];
    cc?: {
      email: string;
      name?: string;
    }[];
    bcc?: {
      email: string;
      name?: string;
    }[];
    subject?: string;
    htmlBody?: string;
    textBody?: string;
    attachments?: {
      storageId: string;
      name: string;
      contentType: string;
      size: number;
    }[];
  };
  /** Send one raw email (no campaign): to/cc/bcc, custom from-name and reply-to, optional reply threading via replyToMessageId. — `dench email send --from <verified-email>` — POST /api/v1/email/send */
  "email.send": {
    /** Verified sender mailbox. */
    fromEmail: string;
    /** Display name override. */
    fromName?: string;
    /** Primary recipients. to+cc+bcc is capped at 50. */
    to: {
      /** Recipient email address. */
      email: string;
      /** Optional display name. */
      name?: string;
    }[];
    cc?: {
      /** Recipient email address. */
      email: string;
      /** Optional display name. */
      name?: string;
    }[];
    bcc?: {
      /** Recipient email address. */
      email: string;
      /** Optional display name. */
      name?: string;
    }[];
    replyToEmail?: string;
    subject: string;
    /** HTML body. Provide htmlBody and/or textBody. */
    htmlBody?: string;
    textBody?: string;
    /** Dench messageId or RFC 5322 Message-ID to thread this send as a reply. */
    replyToMessageId?: string;
    configurationSetName?: string;
  };
  /** Read a raw email message's status and open/click counters. — `dench email message status` — GET /api/v1/email/messages/{messageId} */
  "email.message.get": {
    /** Raw email message id. */
    messageId: string;
  };
  /** List recent raw email messages for the workspace. — `dench email message list` — GET /api/v1/email/messages */
  "email.message.list": {
    limit?: number;
    /** Raw email message lifecycle status. */
    status?: "queued" | "sent" | "failed" | "delivered" | "opened" | "clicked" | "bounced" | "complained";
  };
  /** Create a managed email campaign template. — `dench email template create` — POST /api/v1/email/templates */
  "email.template.create": {
    name: string;
    /** Supports {{variable}} placeholders. */
    subject: string;
    /** HTML body with {{variable}} placeholders. */
    htmlBody: string;
    textBody?: string;
    /** Template lifecycle status. Defaults to `active`. */
    status?: "draft" | "active" | "archived";
  };
  /** Preview a managed email campaign template. — `dench email template preview` — POST /api/v1/email/templates/{templateId}/preview */
  "email.template.preview": {
    templateId: string;
    /** Personalization data for {{variable}} placeholders. */
    data?: Record<string, unknown>;
  };
  /** Create a managed email campaign draft from a connected inbox or verified sender. — `dench email campaign create` — POST /api/v1/email/campaigns */
  "email.campaign.create": {
    name: string;
    /** Sending identity id OR a verified from-email. */
    identityId: string;
    templateId: string;
    /** Epoch ms to start sending; omit to send on submit. */
    scheduledAt?: number;
    maxRecipients?: number;
    batchSize?: number;
    metadata?: Record<string, unknown>;
  };
  /** Read campaign status and counters. — `dench email campaign status` — GET /api/v1/email/campaigns/{campaignId} */
  "email.campaign.get": {
    campaignId: string;
  };
  /** Add recipients to a managed email campaign. — `dench email campaign recipients add` — POST /api/v1/email/campaigns/{campaignId}/recipients */
  "email.campaign.recipients.add": {
    campaignId: string;
    /** Up to 500 recipients per call. */
    recipients: {
      /** Recipient email address. */
      email: string;
      displayName?: string;
      /** Optional CRM people entry to link the send to. */
      personEntryId?: string;
      companyEntryId?: string;
      /** Values for {{variable}} placeholders in the template. */
      personalization?: Record<string, unknown>;
    }[];
  };
  /** Preview rendered messages for a campaign sample. — `dench email campaign preview` — POST /api/v1/email/campaigns/{campaignId}/preview */
  "email.campaign.preview": {
    campaignId: string;
    /** Number of rendered previews to return (default 5). */
    sample?: number;
  };
  /** Submit a campaign for approval or sending. — `dench email campaign submit` — POST /api/v1/email/campaigns/{campaignId}/submit */
  "email.campaign.submit": {
    campaignId: string;
    /** Approval request id when workspace policy requires human sign-off. */
    approvalId?: string;
  };
  /** Pause a sending email campaign. — `dench email campaign pause` — POST /api/v1/email/campaigns/{campaignId}/pause */
  "email.campaign.pause": {
    campaignId: string;
  };
  /** Resume a paused email campaign. — `dench email campaign resume` — POST /api/v1/email/campaigns/{campaignId}/resume */
  "email.campaign.resume": {
    campaignId: string;
  };
  /** Cancel an email campaign. — `dench email campaign cancel` — POST /api/v1/email/campaigns/{campaignId}/cancel */
  "email.campaign.cancel": {
    campaignId: string;
  };
  /** List managed email campaigns (paginated, optional status filter). — `dench email campaign list` — GET /api/v1/email/campaigns */
  "email.campaign.list": {
    limit?: number;
    cursor?: string;
    status?: string;
  };
  /** List a campaign's recipients (paginated, optional status filter). — `dench email campaign recipients list` — GET /api/v1/email/campaigns/{campaignId}/recipients */
  "email.campaign.recipients.list": {
    campaignId: string;
    limit?: number;
    cursor?: string;
    status?: string;
    /** Default true: attach each recipient's CRM record. */
    includePeople?: boolean;
  };
  /** Add campaign recipients from a CRM object: pick the object, the email field, and the entry ids. — `dench email campaign recipients add-from-object` — POST /api/v1/email/campaigns/{campaignId}/recipients/from-object */
  "email.campaign.recipients.addFromObject": Record<string, unknown>;
  /** Create a follow-up sequence from a connected inbox or verified sender. — `dench email sequence create` — POST /api/v1/email/sequences */
  "email.sequence.create": Record<string, unknown>;
  /** Update a sequence's name, sender, or reply/stop settings. — `dench email sequence update` — POST /api/v1/email/sequences/{sequenceId} */
  "email.sequence.update": Record<string, unknown>;
  /** Activate a sequence so its enrollments begin sending. — `dench email sequence activate` — POST /api/v1/email/sequences/{sequenceId}/activate */
  "email.sequence.activate": Record<string, unknown>;
  /** Deactivate a sequence (pause sending, revert to draft). — `dench email sequence deactivate` — POST /api/v1/email/sequences/{sequenceId}/deactivate */
  "email.sequence.deactivate": Record<string, unknown>;
  /** Archive a sequence (stops all sending). — `dench email sequence archive` — POST /api/v1/email/sequences/{sequenceId}/archive */
  "email.sequence.archive": Record<string, unknown>;
  /** List the workspace's follow-up sequences. — `dench email sequence list` — GET /api/v1/email/sequences */
  "email.sequence.list": Record<string, unknown>;
  /** Read a sequence with its ordered steps. — `dench email sequence status` — GET /api/v1/email/sequences/{sequenceId} */
  "email.sequence.get": Record<string, unknown>;
  /** Add a step (subject, body, and wait delay) to a sequence. — `dench email sequence steps add` — POST /api/v1/email/sequences/{sequenceId}/steps */
  "email.sequence.step.add": Record<string, unknown>;
  /** Update a sequence step's subject, body, or delay. — `dench email sequence steps update` — POST /api/v1/email/sequences/steps/{stepId} */
  "email.sequence.step.update": Record<string, unknown>;
  /** Remove a step from a sequence. — `dench email sequence steps remove` — POST /api/v1/email/sequences/steps/{stepId}/remove */
  "email.sequence.step.remove": Record<string, unknown>;
  /** Reorder a sequence's steps. — `dench email sequence steps reorder` — POST /api/v1/email/sequences/{sequenceId}/steps/reorder */
  "email.sequence.step.reorder": Record<string, unknown>;
  /** Enroll explicit recipients into a sequence. — `dench email sequence enroll` — POST /api/v1/email/sequences/{sequenceId}/enroll */
  "email.sequence.enroll": Record<string, unknown>;
  /** Enroll people from a CRM object: pick the object, the email field, and the entry ids. — `dench email sequence enroll-from-object` — POST /api/v1/email/sequences/{sequenceId}/enroll/from-object */
  "email.sequence.enrollFromObject": Record<string, unknown>;
  /** List a sequence's enrollments (paginated, optional status filter). — `dench email sequence enrollments list` — GET /api/v1/email/sequences/{sequenceId}/enrollments */
  "email.sequence.enrollments.list": {
    sequenceId: string;
    limit?: number;
    cursor?: string;
    status?: string;
  };
  /** Pause one enrollment. — `dench email sequence enrollment pause` — POST /api/v1/email/sequences/enrollments/{enrollmentId}/pause */
  "email.sequence.enrollment.pause": Record<string, unknown>;
  /** Resume one paused enrollment. — `dench email sequence enrollment resume` — POST /api/v1/email/sequences/enrollments/{enrollmentId}/resume */
  "email.sequence.enrollment.resume": Record<string, unknown>;
  /** Stop one enrollment (no further steps send). — `dench email sequence enrollment stop` — POST /api/v1/email/sequences/enrollments/{enrollmentId}/stop */
  "email.sequence.enrollment.stop": Record<string, unknown>;
  /** Discover LinkedIn sender ids, labels, availability and remaining capacity visible to the acting workspace member. Never returns provider credentials. — `dench campaign accounts` — GET /api/v1/campaigns/accounts/linkedin */
  "campaigns.accounts.linkedin": Record<string, unknown>;
  /** Discover the mailboxes the acting workspace member can send campaign email from: ids for emailMailboxAccountIds, status, warm-up state and when it is done, the daily cold-email cap and what is left today. Never returns provider credentials. — `dench campaign accounts` — GET /api/v1/campaigns/accounts/email */
  "campaigns.accounts.email": Record<string, unknown>;
  /** List outreach campaigns (archived ones on request). — `dench campaign list [--with-references]` — GET /api/v1/campaigns */
  "campaigns.list": {
    /** Include bounded navigation references. Array reads return {data, references, referenceCoverage}; existing result envelopes keep their fields. */
    withReferences?: boolean;
    /** Include archived campaigns. */
    includeArchived?: boolean;
  };
  /** Create a draft outreach campaign with email and LinkedIn sender pools and a business-hours send window in the given timezone. — `dench campaign create` — POST /api/v1/campaigns */
  "campaigns.create": {
    name: string;
    /** Campaign email sender pool: up to 50 emailMailboxAccounts ids both you and the campaign owner may use. Omit to preserve existing configuration; [] clears the pool. A person's sender stays fixed for their conversation. Launch validates sender availability. */
    emailMailboxAccountIds?: string[];
    /** Campaign LinkedIn sender pool: up to 50 linkedinAccounts ids both you and the campaign owner may use. Omit to preserve existing configuration; [] clears the pool. Legacy step senders remain until a pool is configured. */
    linkedinAccountIds?: string[];
    /** IANA timezone for the default Mon-Fri 9-18 send window. */
    timezone?: string;
  };
  /** Copy a campaign into a new draft named "<name> copy": the same steps, schedule, sender pools and personalized lines, its lead source paused, and no people. To reach more than 300 people, duplicate and add the next page of the search to the copy. — `dench campaign duplicate` — POST /api/v1/campaigns/{sequenceId}/duplicate */
  "campaigns.duplicate": {
    /** The campaign to copy; any status, including archived. */
    sequenceId: string;
  };
  /** Read a campaign: settings, steps, people, their current step and hold, last touches, linked leads. — `dench campaign get` — GET /api/v1/campaigns/{sequenceId} */
  "campaigns.get": {
    sequenceId: string;
  };
  /** Campaign funnel: enrolled, contacted, invited, accepted, messaged, replied, opens and clicks, and for a workflow how many people took each If / else and Wait for them to accept path (branchStats). — `dench campaign get` — GET /api/v1/campaigns/{sequenceId}/analytics */
  "campaigns.analytics": {
    sequenceId: string;
  };
  /** What the campaign is doing now, what comes next and when, and why it is holding. — `dench campaign get` — GET /api/v1/campaigns/{sequenceId}/live */
  "campaigns.live": {
    sequenceId: string;
  };
  /** Where a campaign's people sit in the workspace's lead pipeline right now: each lead Status in order with how many enrolled leads are at it, and how many have no lead or a status outside the pipeline. — `dench campaign pipeline` — GET /api/v1/campaigns/{sequenceId}/pipeline */
  "campaigns.pipeline": {
    sequenceId: string;
  };
  /** Change a campaign's name, sender pools, send windows, daily email cap, stop-on-reply, start or end. Works until archived; existing conversations keep their assigned sender. — `dench campaign set` — PATCH /api/v1/campaigns/{sequenceId} */
  "campaigns.update": {
    sequenceId: string;
    name?: string;
    /** Campaign email sender pool: up to 50 emailMailboxAccounts ids both you and the campaign owner may use. Omit to preserve existing configuration; [] clears the pool. A person's sender stays fixed for their conversation. Launch validates sender availability. */
    emailMailboxAccountIds?: string[];
    /** Campaign LinkedIn sender pool: up to 50 linkedinAccounts ids both you and the campaign owner may use. Omit to preserve existing configuration; [] clears the pool. Legacy step senders remain until a pool is configured. */
    linkedinAccountIds?: string[];
    /** Stop a person's remaining steps when they reply. */
    stopOnReply?: boolean;
    /** Epoch ms; null clears the start. */
    startsAt?: number | null;
    /** Epoch ms; null clears the end. */
    endsAt?: number | null;
    sendSchedules?: {
      /** Label, e.g. "Mon-Fri 9-18". */
      name: string;
      /** IANA timezone, e.g. America/Los_Angeles. */
      timezone: string;
      /** First hour sends may go out (0-23). */
      startHour: number;
      /** Hour sends stop (1-24); must be after startHour. */
      endHour: number;
      /** Days sends may go out: 0 = Sunday ... 6 = Saturday. */
      weekdays: number[];
    }[];
    /** Legacy single-window timezone. Prefer sendSchedules. */
    timezone?: string;
    /** Legacy single-window start hour. Prefer sendSchedules. */
    sendWindowStartHour?: number;
    /** Legacy single-window end hour. Prefer sendSchedules. */
    sendWindowEndHour?: number;
    /** Legacy single-window weekdays, 0 = Sunday. Prefer sendSchedules. */
    sendWeekdays?: number[];
    /** Cold emails per day, 1-100. */
    dailySendCap?: number;
  };
  /** Replace every step of a draft campaign (email, wait, LinkedIn visit, connection request, message, post reaction, InMail, If / else, Wait for them to accept). A workflow (stepModel workflow, or steps with key, next, yesNext or noNext) branches: condition and wait_for_connection steps continue on yesNext or noNext, other steps on next; each points at another step's key or end. Steps are checked first: a field the step type would drop, missing text, {TOKEN} single braces or paths that don't hold together are rejected, not saved. Configure sender pools on the campaign; step sender ids are legacy-only. — `dench campaign steps set` — PUT /api/v1/campaigns/{sequenceId}/steps */
  "campaigns.steps.replace": {
    sequenceId: string;
    /** Every step, in send order (a workflow may list them in any order; they are stored in path order). Rejected, not trimmed: a field the step type would drop (onlyIf off email/post-like steps, a body on a visit, reply-in-thread on the first email, condition fields its check ignores), a missing subject or required body, an overlength note/message/InMail subject, out-of-range wait/withdrawal/post-age/acceptance values, {TOKEN} single braces, which would be sent as typed, and workflow paths that don't hold together (duplicate keys, a target that isn't a key or end, a condition or wait_for_connection without both yesNext and noNext, or any other step with them). */
    steps: Array<{
      /** Step type. condition (If / else) and wait_for_connection (Wait for them to accept) send nothing; they continue on yesNext or noNext and make the campaign a workflow. */
      type: "wait" | "email" | "linkedin_connection" | "linkedin_message" | "linkedin_visit" | "linkedin_like_post" | "linkedin_inmail" | "condition" | "wait_for_connection";
      /** wait steps: hours to wait before the next step. */
      waitHours?: number;
      /** Legacy email step sender. Pool campaigns choose senders in emailMailboxAccountIds on the campaign, not on individual steps. */
      emailMailboxAccountId?: string;
      /** email steps: subject; {{Column}} merge tokens allowed. */
      emailSubject?: string;
      /** email steps: HTML body. Sent instead of emailTextBody when both are set, so when you edit the text, update or drop this too. */
      emailHtmlBody?: string;
      /** email steps: plain-text body; used as the email when there is no emailHtmlBody. */
      emailTextBody?: string;
      /** email steps: thread under the previous email step instead of a new subject. */
      emailReplyToPrevious?: boolean;
      /** email and linkedin_like_post only: always (default), connected or not_connected. InMail automatically skips connected people; do not set a condition on it. */
      onlyIf?: "always" | "connected" | "not_connected";
      /** Legacy LinkedIn step sender (also on wait_for_connection, and on a condition that checks linkedin_connected). Pool campaigns use the campaign's linkedinAccountIds instead. */
      linkedinAccountId?: string;
      /** linkedin_connection: the invite note (optional, up to 300 chars; sent without it if LinkedIn refuses the note); linkedin_message: the required message (up to 3000 chars); linkedin_inmail: the required message (up to 1900 chars). */
      linkedinMessageBody?: string;
      /** linkedin_message: what to do when the invite is still pending. */
      linkedinMessageMode?: "skip_if_not_connected" | "wait_until_connected";
      /** linkedin_message with linkedinMessageMode=wait_until_connected: wait 1-2160 hours for acceptance (default 720); after a connection step this mode is the default in a linear campaign. wait_for_connection: wait 24-2160 hours (1-90 days, default 720) before taking the Not accepted path. */
      connectionTimeoutHours?: number;
      /** linkedin_like_post only: the reaction to leave (default like). */
      likeReaction?: "like" | "celebrate" | "support" | "love" | "insightful" | "funny";
      /** linkedin_like_post only: select the newest eligible original post from the last 1-365 days (default 30). */
      likeMaxPostAgeDays?: number;
      /** linkedin_like_post only: before the immediately preceding wait starts, check for eligible posts. If none exist, skip that wait and the like step, keeping following waits. Defaults to false when omitted. */
      likeSkipPreviousWait?: boolean;
      /** linkedin_like_post only: skip consecutive following wait steps whenever the reaction step is skipped (default true). False keeps those waits. */
      likeSkipNextWait?: boolean;
      /** linkedin_like_post only: how many recent posts to react to, 1-3 (default 1). */
      likeCount?: number;
      /** linkedin_inmail only: optional subject, up to 200 characters; merge tokens allowed. Clear with an empty string. */
      inmailSubject?: string;
      /** linkedin_connection only: withdraw a still-pending invitation sent by this campaign after 168-2160 hours (7-90 days). Omitted means off on creation; null turns it off on edit. */
      withdrawAfterHours?: number | null;
      /** Workflow steps: this step's id, unique in the campaign, which next, yesNext and noNext point at (not "end"). Left out, one is made. */
      key?: string;
      /** Workflow steps: where a step that isn't a condition or wait_for_connection goes; left out, the following step: another step's key, or "end" to stop there. Fixed once the campaign launches. */
      next?: string;
      /** Workflow steps: condition and wait_for_connection only, required: where the Yes (Accepted) path goes: another step's key, or "end" to stop there. Fixed once the campaign launches. */
      yesNext?: string;
      /** Workflow steps: condition and wait_for_connection only, required: where the No (Not accepted) path goes: another step's key, or "end" to stop there. Fixed once the campaign launches. */
      noNext?: string;
      /** condition only, required: linkedin_connected, has_email, opened_last_email (needs an email before it on every path) or field_value. Fixed once the campaign launches. */
      check?: "linkedin_connected" | "has_email" | "opened_last_email" | "field_value";
      /** condition with check=field_value: the lead field to check, like "Job Title" or "Source" (the campaign itself changes Status, Last touch and LinkedIn connection). Fixed once the campaign launches. */
      conditionField?: string;
      /** condition with check=field_value: is, is_not, contains, is_empty or is_not_empty (all case-insensitive). Fixed once the campaign launches. */
      conditionOperator?: "is" | "is_not" | "is_empty" | "is_not_empty" | "contains";
      /** condition with check=field_value and is, is_not or contains: the text to compare with. Editable after launch. */
      conditionValue?: string;
    }>;
    /** linear: steps run in order. workflow: steps have keys and paths (next, yesNext, noNext) and may include condition and wait_for_connection. Left out, a workflow stays one and steps with keys, paths or those types make one; nothing turns a workflow back into a list. When replacing a workflow's steps, send workflow, so steps without keys or paths are checked here the way they will be saved. */
    stepModel?: "linear" | "workflow";
    /** Send {single braces} exactly as typed instead of rejecting them. Merge tokens always use {{double braces}}. */
    allowSingleBraces?: boolean;
  };
  /** Edit the text, waits and conditions of a launched (or paused) campaign's steps in place. Each step keeps its id, type and place; pass the stepId and the updatedAt you read, and only the fields you change. A workflow keeps its paths and what each If / else checks (key, next, yesNext, noNext, check, conditionField, conditionOperator); conditionValue and acceptance waits stay editable. Messages already sent or being prepared keep their text; drafts use campaigns.steps.replace. — `dench campaign steps edit` — PATCH /api/v1/campaigns/{sequenceId}/steps */
  "campaigns.steps.update": {
    sequenceId: string;
    /** The steps to change. Rejected, not trimmed: a field the step type would drop, an overlength note/message/InMail subject, out-of-range wait/withdrawal/post-age/acceptance values, {TOKEN} single braces, and a changed path or If / else check. */
    steps: Array<{
      /** The step's current type. A launched step's type can't change. */
      type: "wait" | "email" | "linkedin_connection" | "linkedin_message" | "linkedin_visit" | "linkedin_like_post" | "linkedin_inmail" | "condition" | "wait_for_connection";
      /** wait steps: hours to wait before the next step. */
      waitHours?: number;
      /** Legacy email step sender. Pool campaigns choose senders in emailMailboxAccountIds on the campaign, not on individual steps. */
      emailMailboxAccountId?: string;
      /** email steps: subject; {{Column}} merge tokens allowed. */
      emailSubject?: string;
      /** email steps: HTML body. Sent instead of emailTextBody when both are set, so when you edit the text, update or drop this too. */
      emailHtmlBody?: string;
      /** email steps: plain-text body; used as the email when there is no emailHtmlBody. */
      emailTextBody?: string;
      /** email steps: thread under the previous email step instead of a new subject. */
      emailReplyToPrevious?: boolean;
      /** email and linkedin_like_post only: always (default), connected or not_connected. InMail automatically skips connected people; do not set a condition on it. */
      onlyIf?: "always" | "connected" | "not_connected";
      /** Legacy LinkedIn step sender (also on wait_for_connection, and on a condition that checks linkedin_connected). Pool campaigns use the campaign's linkedinAccountIds instead. */
      linkedinAccountId?: string;
      /** linkedin_connection: the invite note (optional, up to 300 chars; sent without it if LinkedIn refuses the note); linkedin_message: the required message (up to 3000 chars); linkedin_inmail: the required message (up to 1900 chars). */
      linkedinMessageBody?: string;
      /** linkedin_message: what to do when the invite is still pending. */
      linkedinMessageMode?: "skip_if_not_connected" | "wait_until_connected";
      /** linkedin_message with linkedinMessageMode=wait_until_connected: wait 1-2160 hours for acceptance (default 720); after a connection step this mode is the default in a linear campaign. wait_for_connection: wait 24-2160 hours (1-90 days, default 720) before taking the Not accepted path. */
      connectionTimeoutHours?: number;
      /** linkedin_like_post only: the reaction to leave (default like). */
      likeReaction?: "like" | "celebrate" | "support" | "love" | "insightful" | "funny";
      /** linkedin_like_post only: select the newest eligible original post from the last 1-365 days (default 30). */
      likeMaxPostAgeDays?: number;
      /** linkedin_like_post only: before the immediately preceding wait starts, check for eligible posts. If none exist, skip that wait and the like step, keeping following waits. Defaults to false when omitted. */
      likeSkipPreviousWait?: boolean;
      /** linkedin_like_post only: skip consecutive following wait steps whenever the reaction step is skipped (default true). False keeps those waits. */
      likeSkipNextWait?: boolean;
      /** linkedin_like_post only: how many recent posts to react to, 1-3 (default 1). */
      likeCount?: number;
      /** linkedin_inmail only: optional subject, up to 200 characters; merge tokens allowed. Clear with an empty string. */
      inmailSubject?: string;
      /** linkedin_connection only: withdraw a still-pending invitation sent by this campaign after 168-2160 hours (7-90 days). Omitted means off on creation; null turns it off on edit. */
      withdrawAfterHours?: number | null;
      /** Workflow steps: this step's id, unique in the campaign, which next, yesNext and noNext point at (not "end"). Left out, one is made. */
      key?: string;
      /** Workflow steps: where a step that isn't a condition or wait_for_connection goes; left out, the following step: another step's key, or "end" to stop there. Fixed once the campaign launches. */
      next?: string;
      /** Workflow steps: condition and wait_for_connection only, required: where the Yes (Accepted) path goes: another step's key, or "end" to stop there. Fixed once the campaign launches. */
      yesNext?: string;
      /** Workflow steps: condition and wait_for_connection only, required: where the No (Not accepted) path goes: another step's key, or "end" to stop there. Fixed once the campaign launches. */
      noNext?: string;
      /** condition only, required: linkedin_connected, has_email, opened_last_email (needs an email before it on every path) or field_value. Fixed once the campaign launches. */
      check?: "linkedin_connected" | "has_email" | "opened_last_email" | "field_value";
      /** condition with check=field_value: the lead field to check, like "Job Title" or "Source" (the campaign itself changes Status, Last touch and LinkedIn connection). Fixed once the campaign launches. */
      conditionField?: string;
      /** condition with check=field_value: is, is_not, contains, is_empty or is_not_empty (all case-insensitive). Fixed once the campaign launches. */
      conditionOperator?: "is" | "is_not" | "is_empty" | "is_not_empty" | "contains";
      /** condition with check=field_value and is, is_not or contains: the text to compare with. Editable after launch. */
      conditionValue?: string;
      /** The step's _id from campaigns.get steps[]. */
      stepId: string;
      /** The step's updatedAt when you read it. If someone saved it since, the edit is refused instead of overwriting theirs. */
      expectedUpdatedAt: number;
    }>;
    /** Send {single braces} exactly as typed instead of rejecting them. Merge tokens always use {{double braces}}. */
    allowSingleBraces?: boolean;
  };
  /** Read a campaign's personalized lines (written for each person): their {{keys}} for steps, instructions and fallbacks, how many people have them, and the cost per person. — `dench campaign personalize get` — GET /api/v1/campaigns/{sequenceId}/personalization */
  "campaigns.personalization.get": {
    sequenceId: string;
  };
  /** Define up to 5 personalized lines (each used as {{key}} in steps) and what you sell. Saving starts writing missing lines for up to 100 people, about 3 cents a person; for more it returns needsConfirm and writes nothing until campaigns.personalization.write is confirmed. — `dench campaign personalize set` — PUT /api/v1/campaigns/{sequenceId}/personalization */
  "campaigns.personalization.set": {
    sequenceId: string;
    /** The lines and context; null turns personalized lines off. */
    template: {
      variables: {
        /** The {{key}} used in steps: a letter, then letters, digits or _ (up to 40). Not a built-in field like firstName or company. */
        key: string;
        /** The line's name, up to 60 characters. */
        label: string;
        /** What the writer should say, up to 600 characters. */
        prompt: string;
        /** Sent when there is nothing specific to say; up to 300 characters, no {{variables}}. */
        fallback: string;
        /** A field to use before the fallback, e.g. Company. */
        fallbackFrom?: string;
        /** The longest line, default 200 characters. */
        maxChars?: number;
      }[];
      context: {
        /** What you sell, up to 1000 characters. */
        sells: string;
        /** The offer or call to action, up to 300 characters. */
        offer?: string;
      };
    } | null;
  };
  /** Turn off a campaign's personalized lines and cancel the ones not yet written. Refused while a step still uses one of the {{keys}}. — `dench campaign personalize clear` — DELETE /api/v1/campaigns/{sequenceId}/personalization */
  "campaigns.personalization.clear": {
    sequenceId: string;
  };
  /** Write personalized lines for the people missing them (mode missing) or rewrite everyone's (mode all). Rewriting everyone or more than 100 people returns needsConfirm and the estimate until called with confirmed: true. — `dench campaign personalize write` — POST /api/v1/campaigns/{sequenceId}/personalization/write */
  "campaigns.personalization.write": {
    sequenceId: string;
    /** missing (default): only people without lines. all: rewrite everyone's. */
    mode?: "missing" | "all";
    /** true after the user accepts the estimate from needsConfirm. */
    confirmed?: boolean;
  };
  /** Set one person's personalized line by hand; an empty value undoes the edit. Braces are removed and text past the line's length is cut. — `dench campaign personalize edit` — PUT /api/v1/campaigns/people/{enrollmentId}/personalization */
  "campaigns.personalization.edit": {
    /** From dench campaign people. */
    enrollmentId: string;
    /** The line's key, as in {{key}}. */
    key: string;
    /** The line to send; an empty string undoes the edit. */
    value: string;
  };
  /** Write a fresh personalized line for one person: one key, or all of their lines when key is left out. About 3 cents. — `dench campaign personalize rewrite` — POST /api/v1/campaigns/people/{enrollmentId}/personalization/rewrite */
  "campaigns.personalization.rewrite": {
    /** From dench campaign people. */
    enrollmentId: string;
    /** One line's key; leave out to rewrite all of their lines. */
    key?: string;
  };
  /** Add CRM records (up to 100 ids per call) to a campaign; returns how many were added and why others were skipped. — `dench campaign add` — POST /api/v1/campaigns/{sequenceId}/people */
  "campaigns.people.addFromCrm": {
    sequenceId: string;
    /** CRM object the ids belong to, e.g. lead or people. */
    objectName: string;
    entryIds: string[];
    /** Column holding the email when it is not "Email". */
    emailFieldName?: string;
    /** Column holding the LinkedIn profile URL. */
    linkedinUrlFieldName?: string;
    nameFieldName?: string;
    /** Follow this relation to the person record first. */
    relationFieldName?: string;
    relationDirection?: "reverse";
    /** Default true: skip people active in another campaign. */
    checkDuplicatesAcrossWorkspace?: boolean;
  };
  /** Add one person by email and/or LinkedIn profile URL. — `dench campaign add --name` — POST /api/v1/campaigns/{sequenceId}/person */
  "campaigns.people.add": {
    sequenceId: string;
    displayName?: string;
    email?: string;
    linkedinProfileUrl?: string;
    /** Existing CRM people entry to link. */
    entryId?: string;
    sourceEntryId?: string;
    sourceObjectName?: string;
    emailIdentityId?: string;
    linkedinIdentityId?: string;
    linkedinProviderUserId?: string;
    /** CRM object a new record is created in when none matches. */
    newRecordsObject?: "lead" | "people";
    personalization?: Record<string, unknown>;
    checkDuplicatesAcrossWorkspace?: boolean;
  };
  /** Show the message one person gets at one email or LinkedIn step, with their fields and personalized lines filled in: subject, body, sender, recipient, merge fields still missing, warnings, and why the step would be skipped. Nothing is sent, prepared or charged. — `dench campaign preview` — GET /api/v1/campaigns/{sequenceId}/preview */
  "campaigns.preview": {
    sequenceId: string;
    /** The person to preview, from dench campaign people. */
    enrollmentId: string;
    /** An email or LinkedIn step, its _id from campaigns.get steps[]. A wait step sends nothing. */
    stepId: string;
  };
  /** Launch readiness without launching: blockers grouped by problem, warnings, and the fingerprint `launch` requires. — `dench campaign launch --check` — GET /api/v1/campaigns/{sequenceId}/launch */
  "campaigns.launch.preview": {
    sequenceId: string;
  };
  /** Launch a ready draft. Pass the fingerprint from the preview and acknowledge the LinkedIn notice when LinkedIn steps exist. — `dench campaign launch` — POST /api/v1/campaigns/{sequenceId}/launch */
  "campaigns.launch": {
    sequenceId: string;
    /** From the launch preview. */
    fingerprint: string;
    /** Required when the campaign has LinkedIn steps. */
    linkedinRiskAcknowledged?: boolean;
  };
  /** Pause an active campaign. — `dench campaign pause` — POST /api/v1/campaigns/{sequenceId}/pause */
  "campaigns.pause": {
    sequenceId: string;
  };
  /** Resume a paused campaign. — `dench campaign resume` — POST /api/v1/campaigns/{sequenceId}/resume */
  "campaigns.resume": {
    sequenceId: string;
  };
  /** Archive a campaign and stop everyone still in flight. This is the app's Delete: campaigns are never erased, and their people, leads and activity stay. — `dench campaign archive` — POST /api/v1/campaigns/{sequenceId}/archive */
  "campaigns.archive": {
    sequenceId: string;
  };
  /** The campaign's activity log, newest first (sent, accepted, replied, skipped, failed, paused, stopped). — `dench campaign events` — GET /api/v1/campaigns/{sequenceId}/events */
  "campaigns.events": {
    sequenceId: string;
    /** Page size, default 50. */
    numItems?: number;
    /** continueCursor from the previous page. */
    cursor?: string;
  };
  /** Stop one person: nothing more is sent to them from this campaign. — `dench campaign stop` — POST /api/v1/campaigns/people/{enrollmentId}/stop */
  "campaigns.people.stop": {
    enrollmentId: string;
  };
  /** Resume one paused person in an active campaign. — `dench campaign resume-person` — POST /api/v1/campaigns/people/{enrollmentId}/resume */
  "campaigns.people.resume": {
    enrollmentId: string;
  };
  /** Give a person in a draft campaign a new or corrected email address; their linked CRM record gets it too. Only before launch; another person in the campaign can't share it. — `dench campaign person set --email` — PUT /api/v1/campaigns/people/{enrollmentId}/email */
  "campaigns.people.setEmail": {
    /** From dench campaign people. */
    enrollmentId: string;
    /** The address email steps should use. */
    email: string;
  };
  /** Give a person in a draft campaign a new or corrected LinkedIn profile URL; their linked CRM record gets it too. Only before launch. — `dench campaign person set --linkedin-url` — PUT /api/v1/campaigns/people/{enrollmentId}/linkedin */
  "campaigns.people.setLinkedin": {
    /** From dench campaign people. */
    enrollmentId: string;
    /** A LinkedIn member profile URL, e.g. https://linkedin.com/in/ada. */
    linkedinProfileUrl: string;
  };
  /** Fill or fix one {{merge field}} for a person in a draft campaign, e.g. a missing Company that blocks launch; a matching column on their CRM record is updated too. Only before launch; written personalized lines are not merge fields and can't be set here. — `dench campaign person set --field` — PUT /api/v1/campaigns/people/{enrollmentId}/fields */
  "campaigns.people.setField": {
    /** From dench campaign people. */
    enrollmentId: string;
    /** The merge token name without braces, e.g. Company for {{Company}} or fund for {{fund}}. */
    key: string;
    /** Up to 2000 characters. */
    value: string;
  };
  /** Resume every paused person in an active campaign at once, e.g. after a sending account is reconnected. Returns how many were resumed. — `dench campaign resume-person --all` — POST /api/v1/campaigns/{sequenceId}/people/resume */
  "campaigns.people.resumeAll": {
    /** An active campaign. */
    sequenceId: string;
  };
  /** Fill each unfinished person's empty email, LinkedIn URL, name and merge fields from their linked CRM record, e.g. after enriching the records. Never overwrites a value the campaign already has; returns how many people changed. — `dench campaign sync` — POST /api/v1/campaigns/{sequenceId}/people/sync */
  "campaigns.people.sync": {
    sequenceId: string;
  };
  /** The campaigns a CRM record (a person or a lead) is in, newest first, with the person's status in each and the accounts that send to them. — `dench campaign where` — GET /api/v1/campaigns/by-record/{entryId} */
  "campaigns.people.forRecord": {
    /** A CRM record's _id: a person, or a lead created from one. */
    entryId: string;
  };
  /** Everything a campaign did for one person, step by step: what was sent (subject and text), whether it was opened or clicked, what was skipped and why, waits, failures and retries. — `dench campaign person show` — GET /api/v1/campaigns/people/{enrollmentId}/timeline */
  "campaigns.people.timeline": {
    /** From dench campaign people. */
    enrollmentId: string;
  };
  /** Remove a person who was never contacted from a draft campaign. Frees their place in the 300-person cap and keeps the draft launchable; stop anyone already contacted instead. — `dench campaign remove` — DELETE /api/v1/campaigns/people/{enrollmentId} */
  "campaigns.people.remove": {
    /** From dench campaign people; the person must never have been contacted. */
    enrollmentId: string;
  };
  /** List routines. — `dench cron list` — GET /api/v1/routines */
  "cron.list": {
    enabledOnly?: boolean;
  };
  /** List routine run history. — `dench cron history` — GET /api/v1/routines/history */
  "cron.history": {
    limit?: number;
  };
  /** Get a routine. — `dench cron get` — GET /api/v1/routines/{jobId} */
  "cron.get": {
    jobId: string;
  };
  /** Create a routine. — `dench cron create` — POST /api/v1/routines */
  "cron.create": {
    name: string;
    /** Agent goal/message for each run. */
    prompt: string;
    /** Schedule: recurring (`every`), cron expression, or one-shot (`at`). */
    schedule: {
      kind: "every";
      /** Interval in milliseconds (1s to 365d). */
      everyMs: number;
      /** Optional anchor timestamp for the recurring fire. */
      anchorMs?: number;
    } | {
      kind: "cron";
      /** 5-field POSIX cron expression. */
      expr: string;
      /** IANA timezone, e.g. America/New_York. */
      tz?: string;
    } | {
      kind: "at";
      /** ISO 8601 timestamp for a one-shot run. */
      at: string;
    };
    description?: string;
    /** What to do when a previous run is still active. Defaults to `skip`. */
    overlapPolicy?: "skip" | "queue" | "kill_old";
    enabled?: boolean;
    deleteAfterRun?: boolean;
    /** Routine run target. */
    target?: "chat_turn";
  };
  /** Update a routine. — `dench cron update` — PATCH /api/v1/routines/{jobId} */
  "cron.update": {
    jobId: string;
    name?: string;
    prompt?: string;
    /** Schedule: recurring (`every`), cron expression, or one-shot (`at`). */
    schedule?: {
      kind: "every";
      /** Interval in milliseconds (1s to 365d). */
      everyMs: number;
      /** Optional anchor timestamp for the recurring fire. */
      anchorMs?: number;
    } | {
      kind: "cron";
      /** 5-field POSIX cron expression. */
      expr: string;
      /** IANA timezone, e.g. America/New_York. */
      tz?: string;
    } | {
      kind: "at";
      /** ISO 8601 timestamp for a one-shot run. */
      at: string;
    };
    description?: string;
    /** What to do when a previous run is still active. Defaults to `skip`. */
    overlapPolicy?: "skip" | "queue" | "kill_old";
    enabled?: boolean;
    deleteAfterRun?: boolean;
    /** Routine run target. */
    target?: "chat_turn";
  };
  /** Delete a routine. — `dench cron delete` — DELETE /api/v1/routines/{jobId} */
  "cron.delete": {
    jobId: string;
  };
  /** Enable a routine. — `dench cron enable` — POST /api/v1/routines/{jobId}/enable */
  "cron.enable": {
    jobId: string;
  };
  /** Disable a routine. — `dench cron disable` — POST /api/v1/routines/{jobId}/disable */
  "cron.disable": {
    jobId: string;
  };
  /** Run a routine now. — `dench cron run` — POST /api/v1/routines/{jobId}/run */
  "cron.run": {
    jobId: string;
  };
  /** List runs for a routine. — `dench cron runs` — GET /api/v1/routines/{jobId}/runs */
  "cron.runs": {
    jobId: string;
    limit?: number;
  };
  /** List workspace files. — `dench files ls` — GET /api/v1/files */
  "files.list": {
    /** Directory path, defaults to /. */
    prefix?: string;
    slug?: string;
  };
  /** Read a workspace file's text. — `dench files cat` — GET /api/v1/files/content */
  "files.content": {
    /** Workspace file path, e.g. /reports/q2.md. A leading /workspace/ mount prefix is stripped. */
    path: string;
    slug?: string;
  };
  /** Write a workspace file's text. — `dench files write` — PUT /api/v1/files/content */
  "files.write": {
    /** Workspace file path, e.g. /reports/q2.md. A leading /workspace/ mount prefix is stripped. */
    path: string;
    /** Full replacement text (UTF-8, <= 400 KB). */
    content: string;
    /** contentHash from the last read; the write is rejected with version_mismatch if the file changed since. */
    expectedPreviousHash?: string;
  };
  /** Get a signed file download URL. — `dench files download` — GET /api/v1/files/download-url */
  "files.downloadUrl": {
    path: string;
  };
  /** Remove a workspace file or directory. — `dench files rm` — DELETE /api/v1/files */
  "files.delete": {
    path: string;
  };
  /** Move a workspace file or directory. — `dench files mv` — POST /api/v1/files/move */
  "files.move": {
    /** Source workspace path. */
    from: string;
    /** Destination workspace path. */
    to: string;
  };
  /** Create a workspace directory (and any missing parents). Idempotent. — `dench files mkdir` — POST /api/v1/files/mkdir */
  "files.mkdir": {
    path: string;
  };
  /** Stage uploaded content into the workspace. — `dench stage` — POST /api/v1/files/stage */
  "files.stage": {
    /** Files to write. Each needs text or base64. */
    files?: {
      path: string;
      text?: string;
      base64?: string;
    }[];
    /** Single-file shortcut. */
    path?: string;
    text?: string;
    base64?: string;
    lastModifiedBy?: string;
  };
  /** Search the web through the Dench gateway. — `dench search` — POST /api/v1/search */
  "search.web": {
    /** Search query. */
    query: string;
    type?: "auto" | "neural" | "fast" | "deep" | "deep-reasoning" | "instant";
    numResults?: number;
    /** Entity categories return structured entities. Domain filters are unsupported for people; published-date filters are unsupported for people and company. */
    category?: "company" | "research paper" | "news" | "personal site" | "financial report" | "people";
    /** Unsupported for category=people. */
    includeDomains?: string[];
    /** Unsupported for category=people. */
    excludeDomains?: string[];
    /** Unsupported for category=people and category=company. */
    startPublishedDate?: string;
    /** Unsupported for category=people and category=company. */
    endPublishedDate?: string;
    includeText?: string[];
    excludeText?: string[];
    userLocation?: string;
    moderation?: boolean;
  };
  /** Fetch page contents through the Dench gateway. — `dench search contents` — POST /api/v1/search/contents */
  "search.contents": {
    /** URLs to fetch (max 10). */
    urls: string[];
    text?: boolean;
    /** Optional per-URL summary. */
    summary?: {
      query?: string;
    };
  };
  /** Answer a question with web search. — `dench search answer` — POST /api/v1/search/answer */
  "search.answer": {
    /** Question to answer with web search. */
    query: string;
    text?: boolean;
    stream?: boolean;
    outputSchema?: Record<string, unknown>;
  };
  /** Read a page as clean Markdown through Dench web. — `dench web scrape` — POST /api/v1/context/web-scrape-markdown */
  "web.scrape": Record<string, unknown>;
  /** Look up a brand kit from a domain or email. — `dench web brand` — POST /api/v1/context/brand-retrieve */
  "web.brand": Record<string, unknown>;
  /** List sitemap URLs for a domain. — `dench web sitemap` — POST /api/v1/context/web-sitemap */
  "web.sitemap": Record<string, unknown>;
  /** Crawl a site to Markdown (capped). — `dench web crawl` — POST /api/v1/context/web-crawl */
  "web.crawl": Record<string, unknown>;
  /** Capture a rendered page screenshot. — `dench web screenshot` — POST /api/v1/context/web-screenshot */
  "web.screenshot": Record<string, unknown>;
  /** Extract typed fields from a page using a JSON Schema. — `dench web extract` — POST /api/v1/context/web-extract */
  "web.extract": Record<string, unknown>;
  /** Extract a product listing from a URL. — `dench web product` — POST /api/v1/context/web-product */
  "web.product": Record<string, unknown>;
  /** Find competitors of a domain. — `dench web competitors` — POST /api/v1/context/web-competitors */
  "web.competitors": Record<string, unknown>;
  /** Read a brand styleguide from a domain. — `dench web styleguide` — POST /api/v1/context/brand-styleguide */
  "web.styleguide": Record<string, unknown>;
  /** Read site fonts from a domain. — `dench web fonts` — POST /api/v1/context/brand-fonts */
  "web.fonts": Record<string, unknown>;
  /** Classify a domain with NAICS or SIC. — `dench web classify` — POST /api/v1/context/classify-naics */
  "web.classify": Record<string, unknown>;
  /** Autocomplete brand names. — `dench web brand-search` — POST /api/v1/context/brand-search */
  "web.brandSearch": Record<string, unknown>;
  /** Generate an image through the Dench gateway. — `dench image generate` — POST /api/v1/images/generations */
  "image.generate": {
    /** Image prompt. */
    prompt: string;
    /** e.g. 1024x1024, 1536x1024, auto. */
    size?: string;
    quality?: "auto" | "low" | "medium" | "high";
    format?: "png" | "jpeg" | "webp";
    output_compression?: number;
    background?: "auto" | "opaque" | "transparent";
    /** Workspace path to write the image. */
    savePath?: string;
  };
  /** Edit an image through the Dench gateway. — `dench image edit` — POST /api/v1/images/edits */
  "image.edit": {
    /** Image prompt. */
    prompt: string;
    /** e.g. 1024x1024, 1536x1024, auto. */
    size?: string;
    quality?: "auto" | "low" | "medium" | "high";
    format?: "png" | "jpeg" | "webp";
    output_compression?: number;
    background?: "auto" | "opaque" | "transparent";
    /** Workspace path to write the image. */
    savePath?: string;
    /** Base64-encoded source images (1-8). */
    input_images_base64: string[];
    /** Optional base64 mask image. */
    mask_base64?: string;
  };
  /** List every connected integration — connected apps plus the Gmail, Outlook, Calendar, LinkedIn and Slack connections Dench provides itself (Slack rows report source: dench). — `dench integrations` — GET /api/v1/integrations */
  "integrations.list": Record<string, unknown>;
  /** List installed App Store apps in the workspace. — `dench apps list` — GET /api/v1/apps */
  "apps.list": Record<string, unknown>;
  /** List Discover listings — Official (Dench) + Community shelves. — `dench apps gallery` — GET /api/v1/apps/gallery */
  "apps.gallery": Record<string, unknown>;
  /** Scaffold and register a new App Store app. — `dench apps create` — POST /api/v1/apps */
  "apps.create": {
    /** Folder slug; becomes /apps/<slug>.dench.app. */
    slug: string;
    name: string;
    /** Lucide icon name. */
    icon?: string;
    description?: string;
  };
  /** Install an App Store listing into the workspace. — `dench apps install` — POST /api/v1/apps/install */
  "apps.install": {
    listingId: string;
  };
  /** Publish an app's files as a versioned App Store listing. — `dench apps publish` — POST /api/v1/apps/publish */
  "apps.publish": {
    /** Workspace path of the .dench.app folder. */
    appPath: string;
    slug: string;
    name: string;
    description?: string;
    icon?: string;
    visibility?: "org" | "public" | "official" | "unlisted";
    version?: string;
    permissions?: string[];
  };
  /** Uninstall an app from the workspace. — `dench apps uninstall` — DELETE /api/v1/apps/{slug} */
  "apps.uninstall": {
    slug: string;
  };
  /** Enable or disable an installed app. — `dench apps enable` — PATCH /api/v1/apps/{slug} */
  "apps.setEnabled": {
    slug: string;
    enabled: boolean;
  };
  /** Pin or unpin an installed app in the rail. — `dench apps pin` — POST /api/v1/apps/{slug}/pin */
  "apps.setPinned": {
    slug: string;
    pinned: boolean;
  };
  /** Register an inbound webhook for an app. Returns the URL and signing secret ONCE. — `dench apps webhooks register` — POST /api/v1/apps/{slug}/webhooks */
  "apps.webhooks.register": {
    /** Installed app slug. */
    slug: string;
    /** Hook name, e.g. `stripe` or `github-push`. */
    hookName: string;
  };
  /** List an app's registered webhooks (URLs, never secrets). — `dench apps webhooks list` — GET /api/v1/apps/{slug}/webhooks */
  "apps.webhooks.list": {
    slug: string;
  };
  /** Read events an app webhook received since a timestamp. — `dench apps webhooks poll` — GET /api/v1/apps/{slug}/webhooks/{hookName}/events */
  "apps.webhooks.poll": {
    slug: string;
    hookName: string;
    /** Only events received after this epoch ms. */
    since?: number;
    limit?: number;
  };
  /** Remove an app webhook and every event it stored. — `dench apps webhooks delete` — DELETE /api/v1/apps/{slug}/webhooks/{hookName} */
  "apps.webhooks.delete": {
    slug: string;
    hookName: string;
  };
  /** List connected tool accounts. — `dench tool status` — GET /api/v1/tools/status */
  "tool.status": Record<string, unknown>;
  /** Create a tool OAuth connection link. Slack is in-house, never a third-party connection: for toolkit slack the CLI prints the first-party install URL (/api/slack/install?slug=<workspace>, org admin) instead of calling this endpoint. — `dench tool connect` — POST /api/v1/tools/connections */
  "tool.connect": {
    /** Toolkit slug, e.g. github, gmail, stripe. */
    toolkit?: string;
    toolkit_slug?: string;
    /** Optional OAuth callback URL. */
    callback_url?: string;
    /** Native OAuth return path within the workspace. */
    returnTo?: string;
  };
  /** Search for external tool actions. — `dench tool search` — POST /api/v1/tools/search */
  "tool.search": {
    queries?: {
      /** Natural-language use case. */
      use_case: string;
      known_fields?: string;
    }[];
    query?: string;
    toolkit?: string;
    toolkit_slug?: string;
    limit?: number;
    important?: boolean;
    session?: {
      id?: string;
      generate_id?: boolean;
    };
    account?: string;
    model?: string;
  };
  /** Run an external tool action. SLACK_* slugs (SLACK_SEND_MESSAGE with Block Kit blocks/buttons, SLACK_FETCH_HISTORY, SLACK_LIST_CHANNELS, …) run through Dench's in-house Slack app install — any channel in the connected workspace — and are always preferred over any third-party Slack connection. — `dench tool run` — POST /api/v1/tools/run */
  "tool.run": {
    /** Execution ref from a prior search, OR pass session_id+tool_slug. */
    execution_ref?: string;
    session_id?: string;
    /** Tool slug, e.g. SLACK_LIST_CHANNELS. */
    tool_slug?: string;
    /** Tool arguments object. */
    arguments?: Record<string, unknown>;
    account?: string;
    connected_account_id?: string;
    approvalId?: string;
  };
  /** Disconnect an external tool account. — `dench tool disconnect` — DELETE /api/v1/tools/connections/{connectionId} */
  "tool.disconnect": {
    connectionId: string;
  };
  /** List human names given to connected accounts. — `dench tool labels` — GET /api/v1/tools/labels */
  "tool.labels.list": Record<string, unknown>;
  /** Name a connected account, or clear its name with an empty string. — `dench tool label` — PUT /api/v1/tools/connections/{connectionId}/label */
  "tool.label.set": {
    connectionId: string;
    /** Human name for the account. Empty clears it. */
    displayName: string;
  };
  /** Drive Dench Browser with a single interactive action (open, inspect, click, fill, type, screenshot, stop). Pass the step in `action` plus its arguments. — `dench browser` — POST /api/v1/browser/cli */
  "browser.action": Record<string, unknown>;
  /** Create a Dench Browser session and return a CDP connect URL for Playwright (chromium.connectOverCDP) plus a live-view URL. Use for durable scripts run from the sandbox. — `dench browser session create` — POST /api/v1/browser/sessions */
  "browser.session.create": Record<string, unknown>;
  /** Get the status, connect URL, and live-view URL for a Dench Browser session. — `dench browser session status` — GET /api/v1/browser/sessions/{sessionId} */
  "browser.session.status": Record<string, unknown>;
  /** Stop a Dench Browser session and release the remote browser. — `dench browser session stop` — DELETE /api/v1/browser/sessions/{sessionId} */
  "browser.session.stop": Record<string, unknown>;
  /** Read IDENTITY.md. — `dench context --sections identity` — GET /api/v1/agent-config/identity */
  "agentConfig.identity.show": Record<string, unknown>;
  /** Update IDENTITY.md. — `dench context set identity` — PUT /api/v1/agent-config/identity */
  "agentConfig.identity.edit": {
    content: string;
  };
  /** Read ORGANISATION.md. — `dench context --sections organisation` — GET /api/v1/agent-config/organisation */
  "agentConfig.organisation.show": Record<string, unknown>;
  /** Update ORGANISATION.md. — `dench context set organisation` — PUT /api/v1/agent-config/organisation */
  "agentConfig.organisation.edit": {
    content: string;
  };
  /** Read USER.md. — `dench context --sections user` — GET /api/v1/agent-config/user */
  "agentConfig.user.show": Record<string, unknown>;
  /** Update USER.md. — `dench context set user` — PUT /api/v1/agent-config/user */
  "agentConfig.user.edit": {
    content: string;
  };
  /** Read tool notes. — `dench context --sections tools` — GET /api/v1/agent-config/tools */
  "agentConfig.tools.show": Record<string, unknown>;
  /** Update tool notes. — `dench context set tools` — PUT /api/v1/agent-config/tools */
  "agentConfig.tools.edit": {
    content: string;
  };
  /** Update standing workspace rules; credentials belong in secrets and runnable setup in environments. — `dench context set rules` — PUT /api/v1/context/rules */
  "workspace.context.rules.set": {
    content: string;
  };
  /** Read aggregate memory. — `dench mem show` — GET /api/v1/agent-config/mem */
  "agentConfig.mem.show": Record<string, unknown>;
  /** Update aggregate memory. — `dench mem set` — PUT /api/v1/agent-config/mem */
  "agentConfig.mem.edit": {
    content: string;
    append?: boolean;
  };
  /** Read bootstrap state. — `dench bootstrap status` — GET /api/v1/agent-config/bootstrap */
  "agentConfig.bootstrap.show": Record<string, unknown>;
  /** Complete bootstrap. — `dench bootstrap complete` — POST /api/v1/agent-config/bootstrap/complete */
  "agentConfig.bootstrap.complete": {
    completed?: boolean;
  };
  /** Update bootstrap template. — `dench bootstrap template` — PUT /api/v1/agent-config/bootstrap/template */
  "agentConfig.bootstrap.template": {
    content: string;
  };
  /** Set the default chat model. — `dench model default` — PUT /api/v1/agent-config/model/default */
  "agentConfig.model.default": {
    /** Model id, or null to clear. */
    modelId: string | null;
  };
  /** Set a thread model override. — `dench model thread` — PUT /api/v1/agent-config/model/threads/{threadId} */
  "agentConfig.model.thread": {
    threadId: string;
    modelId: string | null;
  };
  /** Read today's daily activity path. — `dench daily today` — GET /api/v1/agent-config/daily/today */
  "agentConfig.daily.today": Record<string, unknown>;
  /** Read a daily activity path. — `dench daily show` — GET /api/v1/agent-config/daily/{date} */
  "agentConfig.daily.show": Record<string, unknown>;
  /** List your notifications (inbox, unread, archived, or all). — `dench notifications list` — GET /api/v1/notifications */
  "notifications.list": {
    filter?: "inbox" | "unread" | "archived" | "all";
    limit?: number;
  };
  /** How many unread notifications you have. — `dench notifications count` — GET /api/v1/notifications/unread-count */
  "notifications.unreadCount": Record<string, unknown>;
  /** Mark a notification read (or unread). — `dench notifications read` — PATCH /api/v1/notifications/{notificationId} */
  "notifications.read": {
    notificationId: string;
    /** Defaults to true; false marks unread. */
    read?: boolean;
  };
  /** Mark every inbox notification read. — `dench notifications read-all` — POST /api/v1/notifications/read-all */
  "notifications.readAll": Record<string, unknown>;
  /** Archive a notification. — `dench notifications archive` — POST /api/v1/notifications/{notificationId}/archive */
  "notifications.archive": {
    notificationId: string;
  };
  /** Read your notification preferences. — `dench notifications prefs` — GET /api/v1/notifications/preferences */
  "notifications.preferences.get": Record<string, unknown>;
  /** Update your notification preferences. — `dench notifications prefs --set` — PATCH /api/v1/notifications/preferences */
  "notifications.preferences.update": {
    inAppEnabled?: boolean;
    emailEnabled?: boolean;
    perKind?: Record<string, {
      inApp?: boolean;
      email?: boolean;
    }>;
    timezone?: string;
    digestWindowMinutes?: number;
    maxEmailsPerDay?: number;
  };
  /** Read the workspace's Sync switches (accounts from email, contacts from LinkedIn, Slack Connect, calendar, dossier, tasks from email, lead auto-qualify, summaries and Brief). All on by default. — `dench settings sync` — GET /api/v1/settings/sync */
  "settings.sync.get": Record<string, unknown>;
  /** Flip Sync switches (admin). Partial patch: only the keys sent change. Off stops new work; nothing already created is removed. — `dench settings sync set` — PATCH /api/v1/settings/sync */
  "settings.sync.update": {
    /** Accounts from email — new prospects and customers who email you become accounts and contacts. */
    detectAccounts?: boolean;
    /** Contacts from LinkedIn — everyone you message on LinkedIn becomes a contact, with their company. */
    linkedinContacts?: boolean;
    /** Accounts from Slack Connect — a shared channel binds to the company on the other side. */
    slackConnectAccounts?: boolean;
    /** Contacts from calendar — external invitees on upcoming meetings become contacts. */
    calendarContacts?: boolean;
    /** Research dossier — Dench researches each new account into its Notes. */
    dossier?: boolean;
    /** Tasks from email — replies and follow-ups you owe become tasks; support issues become cases. */
    emailTasks?: boolean;
    /** Qualify leads that book — a lead who books a meeting moves to Qualified and converts. */
    leadAutoQualify?: boolean;
    /** Summaries and Brief — conversations are summarised and each record keeps a Brief. */
    intelligence?: boolean;
  };
}

export interface ApiResponses {
  "environments.list": unknown;
  "environments.get": unknown;
  "environments.upload": unknown;
  "environments.save": unknown;
  "environments.delete": unknown;
  "secrets.list": unknown;
  "secrets.set": {
    name: string;
    kind: "env" | "file";
    version: number;
    revision: number;
    status: "stored";
  };
  "secrets.delete": unknown;
  "campaigns.drafts.create": {
    sequenceId: string;
    references?: Array<{
      kind: "crm-entry";
      objectName: string;
      entryId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "crm-object";
      objectName: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "campaign";
      sequenceId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    }>;
    referenceCoverage?: {
      returned: number;
      available: number;
      truncated: boolean;
    };
  };
  "campaigns.audience.search": {
    rows: Record<string, unknown>[];
    people: unknown[];
    recipients: {
      email?: string;
      linkedinProfileUrl?: string;
      displayName?: string;
      /** Merge values keyed by name, e.g. {"Company":"Acme"} for {{Company}}. */
      personalization?: Record<string, unknown>;
    }[];
    metadata: Record<string, unknown>;
    /** The search cost ceiling reported by Dench billing, in cents. Null means the receipt is unavailable. */
    estimatedCents: number | null;
    /** The actual search charge reported by Dench billing, in cents. Null means the receipt is unavailable; results remain valid. */
    chargedCents: number | null;
  };
  "campaigns.people.addFromSearch": {
    rows: Record<string, unknown>[];
    people: unknown[];
    recipients: {
      email?: string;
      linkedinProfileUrl?: string;
      displayName?: string;
      /** Merge values keyed by name, e.g. {"Company":"Acme"} for {{Company}}. */
      personalization?: Record<string, unknown>;
    }[];
    metadata: Record<string, unknown>;
    /** The search cost ceiling reported by Dench billing, in cents. Null means the receipt is unavailable. */
    estimatedCents: number | null;
    /** The actual search charge reported by Dench billing, in cents. Null means the receipt is unavailable; results remain valid. */
    chargedCents: number | null;
    added: number;
    requested: number;
    cappedAtLimit: number | null;
    duplicates: number;
    duplicatesElsewhere: number;
    suppressed: number;
    invalid: number;
    skippedNoIdentity: number;
    skippedMissingInfo: number;
    missingInfoSample?: unknown;
    found: number;
    skippedSearchProfiles: number;
  };
  "campaigns.people.addBatch": {
    added: number;
    requested: number;
    cappedAtLimit: number | null;
    duplicates: number;
    duplicatesElsewhere: number;
    suppressed: number;
    invalid: number;
    skippedNoIdentity: number;
    skippedMissingInfo: number;
    missingInfoSample?: unknown;
  };
  "campaigns.sources.get": Record<string, unknown> | null;
  "campaigns.sources.signals": Record<string, unknown> | null;
  "campaigns.sources.update": null;
  "campaigns.sources.preview": {
    ok: boolean;
    [key: string]: unknown;
  };
  "campaigns.sources.run": null;
  "campaigns.sources.overview": Record<string, unknown>;
  "campaigns.sources.pending": Record<string, unknown>[];
  "campaigns.sources.review": Record<string, unknown>;
  "campaigns.queue": Record<string, unknown> | null;
  "campaigns.builder.profile": {
    hasProfile: boolean;
    targeting: {
      titles: string[];
      locations: string[];
      companySizes: string[];
      industries: string[];
      excludes: string[];
      companies?: string[];
      companyTypes?: string[];
    };
    [key: string]: unknown;
  };
  "campaigns.builder.save": {
    draftId: string;
  };
  "campaigns.builder.get": {
    status: string;
    targeting: {
      titles: string[];
      locations: string[];
      companySizes: string[];
      industries: string[];
      excludes: string[];
      companies?: string[];
      companyTypes?: string[];
    };
    signals: Array<"post_engagement" | "keyword" | "hiring" | "funding" | "launch" | "new_leader" | "voice_engagement" | "company_engagement" | "brand_engagement" | "lookalike">;
    people: Record<string, unknown>[];
    [key: string]: unknown;
  };
  "campaigns.builder.build": {
    ok: boolean;
    started: boolean;
  };
  "campaigns.builder.create": {
    sequenceId: string;
    enrolled: number;
  };
  "campaigns.builder.opener": null;
  "campaigns.builder.drafts": Record<string, unknown>[];
  "campaigns.builder.resume": {
    clientRequestId: string;
    status: string;
    targeting: {
      titles: string[];
      locations: string[];
      companySizes: string[];
      industries: string[];
      excludes: string[];
      companies?: string[];
      companyTypes?: string[];
    };
    signals: Array<"post_engagement" | "keyword" | "hiring" | "funding" | "launch" | "new_leader" | "voice_engagement" | "company_engagement" | "brand_engagement" | "lookalike">;
    [key: string]: unknown;
  } | null;
  "campaigns.builder.discard": null;
  "campaigns.builder.outreach": null;
  "campaigns.builder.sequence": Record<string, unknown>;
  "campaigns.builder.lookalike": Record<string, unknown>;
  "campaigns.builder.voices": Record<string, unknown>;
  "campaigns.builder.autofill": {
    targeting: {
      titles: string[];
      locations: string[];
      companySizes: string[];
      industries: string[];
      excludes: string[];
      companies?: string[];
      companyTypes?: string[];
    };
    [key: string]: unknown;
  };
  "campaigns.builder.estimate": {
    count: number | null;
    [key: string]: unknown;
  };
  "commands.list": {
    operations: Array<{
      id: string;
      group: string;
      summary: string;
      cli: string;
      aliases: string[];
      method: string;
      path: string;
      backend: "api" | "gateway" | "custom" | "local";
      deprecated: boolean;
    }>;
  };
  "auth.signin.create": {
    status: "pending";
    /** Epoch ms when the sign-in code expires. */
    expiresAt: number;
  };
  "auth.signin.poll": {
    status: "pending" | "approved" | "rejected" | "expired";
    /** Present once approved. */
    organization?: {
      id: string;
      name: string;
      slug: string;
    };
    agent?: {
      id: string;
      name: string;
      kind: string;
    };
    sessionExpiresAt?: number;
  };
  "auth.otp.start": {
    ok: boolean;
  };
  "auth.otp.verify": {
    ok: boolean;
    result: {
      kind: "completed";
      organization?: {
        id: string;
        name: string;
        slug: string;
      };
      sessionExpiresAt?: number;
    } | {
      kind: "requiresOrgChoice";
      /** Pass to /auth/otp/finalize with the chosen org. */
      authToken: string;
      organizations: {
        id: string;
        name: string;
        slug: string;
      }[];
      expiresAt: number;
    };
  };
  "auth.otp.finalize": {
    ok: boolean;
    result: {
      organization?: {
        id: string;
        name: string;
        slug: string;
      };
      sessionExpiresAt?: number;
    };
  };
  "workspace.context.sections": Record<string, unknown>;
  "workspace.context": {
    workspace: {
      id: string;
      name: string;
      slug?: string;
    };
    agent: {
      id: string;
      name: string;
      kind: string;
    };
    rules: Array<{
      id: string;
      title: string;
      body: string;
      scope: "organization" | "project";
    }>;
    activeAgents: {
      id: string;
      name: string;
      kind: string;
      lastSeenAt?: number;
    }[];
    pendingApprovals: Array<{
      id: string;
      title: string;
      reason: string;
      kind?: string;
      /** Risk level. */
      risk: "low" | "medium" | "high";
      agentId?: string;
      createdAt: number;
      [key: string]: unknown;
    }>;
    recentArtifacts: Array<{
      id: string;
      runId: string;
      title: string;
      type: "note" | "draft" | "report" | "task_suggestion" | "patch" | "other";
      status: "draft" | "approved" | "rejected" | "applied" | "archived";
      content: string;
      createdAt: number;
      updatedAt: number;
    }>;
    suggestedWork: Array<{
      id: string;
      runId: string;
      title: string;
      type: "note" | "draft" | "report" | "task_suggestion" | "patch" | "other";
      status: "draft" | "approved" | "rejected" | "applied" | "archived";
      content: string;
      createdAt: number;
      updatedAt: number;
      nextCommands: string[];
    }>;
    memory: Array<{
      id: string;
      key: string;
      /** Memory classification. */
      kind: "fact" | "decision" | "preference" | "goal" | "tool_note" | "other" | "convention" | "project_context" | "agent_lesson" | "docs_knowledge" | "open_goal";
      text: string;
      tags: string[];
      status: "active" | "needs_review" | "archived";
      updatedAt: number;
    }>;
    chatAgents: {
      nextCommands: string[];
      activeRuns: {
        id: string;
        goal: string;
        status: string;
        model: string;
        createdAt: number;
        [key: string]: unknown;
      }[];
      templates: string[];
    };
    tools: {
      discovery: string[];
      cli: string[];
      approvalPolicy: string;
    };
    nextActions: string[];
  };
  "workspace.instructions": {
    /** Markdown standing instructions for external agents connected to this workspace. */
    instructions: string;
    workspace: {
      name: string;
      slug?: string;
    };
  };
  "workspace.status": {
    workspace: {
      id: string;
      name: string;
      slug?: string;
    };
    agent: {
      id: string;
      name: string;
      kind: string;
    };
    rules: Array<{
      id: string;
      title: string;
      body: string;
      scope: "organization" | "project";
    }>;
    activeAgents: {
      id: string;
      name: string;
      kind: string;
      lastSeenAt?: number;
    }[];
    pendingApprovals: Array<{
      id: string;
      title: string;
      reason: string;
      kind?: string;
      /** Risk level. */
      risk: "low" | "medium" | "high";
      agentId?: string;
      createdAt: number;
      [key: string]: unknown;
    }>;
    recentArtifacts: Array<{
      id: string;
      runId: string;
      title: string;
      type: "note" | "draft" | "report" | "task_suggestion" | "patch" | "other";
      status: "draft" | "approved" | "rejected" | "applied" | "archived";
      content: string;
      createdAt: number;
      updatedAt: number;
    }>;
    suggestedWork: Array<{
      id: string;
      runId: string;
      title: string;
      type: "note" | "draft" | "report" | "task_suggestion" | "patch" | "other";
      status: "draft" | "approved" | "rejected" | "applied" | "archived";
      content: string;
      createdAt: number;
      updatedAt: number;
      nextCommands: string[];
    }>;
    memory: Array<{
      id: string;
      key: string;
      /** Memory classification. */
      kind: "fact" | "decision" | "preference" | "goal" | "tool_note" | "other" | "convention" | "project_context" | "agent_lesson" | "docs_knowledge" | "open_goal";
      text: string;
      tags: string[];
      status: "active" | "needs_review" | "archived";
      updatedAt: number;
    }>;
    chatAgents: {
      nextCommands: string[];
      activeRuns: {
        id: string;
        goal: string;
        status: string;
        model: string;
        createdAt: number;
        [key: string]: unknown;
      }[];
      templates: string[];
    };
    tools: {
      discovery: string[];
      cli: string[];
      approvalPolicy: string;
    };
    nextActions: string[];
  };
  "workspace.agents": {
    workspace: {
      id: string;
      name: string;
      slug?: string;
    };
    agent: {
      id: string;
      name: string;
      kind: string;
    };
    rules: Array<{
      id: string;
      title: string;
      body: string;
      scope: "organization" | "project";
    }>;
    activeAgents: {
      id: string;
      name: string;
      kind: string;
      lastSeenAt?: number;
    }[];
    pendingApprovals: Array<{
      id: string;
      title: string;
      reason: string;
      kind?: string;
      /** Risk level. */
      risk: "low" | "medium" | "high";
      agentId?: string;
      createdAt: number;
      [key: string]: unknown;
    }>;
    recentArtifacts: Array<{
      id: string;
      runId: string;
      title: string;
      type: "note" | "draft" | "report" | "task_suggestion" | "patch" | "other";
      status: "draft" | "approved" | "rejected" | "applied" | "archived";
      content: string;
      createdAt: number;
      updatedAt: number;
    }>;
    suggestedWork: Array<{
      id: string;
      runId: string;
      title: string;
      type: "note" | "draft" | "report" | "task_suggestion" | "patch" | "other";
      status: "draft" | "approved" | "rejected" | "applied" | "archived";
      content: string;
      createdAt: number;
      updatedAt: number;
      nextCommands: string[];
    }>;
    memory: Array<{
      id: string;
      key: string;
      /** Memory classification. */
      kind: "fact" | "decision" | "preference" | "goal" | "tool_note" | "other" | "convention" | "project_context" | "agent_lesson" | "docs_knowledge" | "open_goal";
      text: string;
      tags: string[];
      status: "active" | "needs_review" | "archived";
      updatedAt: number;
    }>;
    chatAgents: {
      nextCommands: string[];
      activeRuns: {
        id: string;
        goal: string;
        status: string;
        model: string;
        createdAt: number;
        [key: string]: unknown;
      }[];
      templates: string[];
    };
    tools: {
      discovery: string[];
      cli: string[];
      approvalPolicy: string;
    };
    nextActions: string[];
  };
  "workspace.approvals.list": {
    workspace: {
      id: string;
      name: string;
      slug?: string;
    };
    agent: {
      id: string;
      name: string;
      kind: string;
    };
    rules: Array<{
      id: string;
      title: string;
      body: string;
      scope: "organization" | "project";
    }>;
    activeAgents: {
      id: string;
      name: string;
      kind: string;
      lastSeenAt?: number;
    }[];
    pendingApprovals: Array<{
      id: string;
      title: string;
      reason: string;
      kind?: string;
      /** Risk level. */
      risk: "low" | "medium" | "high";
      agentId?: string;
      createdAt: number;
      [key: string]: unknown;
    }>;
    recentArtifacts: Array<{
      id: string;
      runId: string;
      title: string;
      type: "note" | "draft" | "report" | "task_suggestion" | "patch" | "other";
      status: "draft" | "approved" | "rejected" | "applied" | "archived";
      content: string;
      createdAt: number;
      updatedAt: number;
    }>;
    suggestedWork: Array<{
      id: string;
      runId: string;
      title: string;
      type: "note" | "draft" | "report" | "task_suggestion" | "patch" | "other";
      status: "draft" | "approved" | "rejected" | "applied" | "archived";
      content: string;
      createdAt: number;
      updatedAt: number;
      nextCommands: string[];
    }>;
    memory: Array<{
      id: string;
      key: string;
      /** Memory classification. */
      kind: "fact" | "decision" | "preference" | "goal" | "tool_note" | "other" | "convention" | "project_context" | "agent_lesson" | "docs_knowledge" | "open_goal";
      text: string;
      tags: string[];
      status: "active" | "needs_review" | "archived";
      updatedAt: number;
    }>;
    chatAgents: {
      nextCommands: string[];
      activeRuns: {
        id: string;
        goal: string;
        status: string;
        model: string;
        createdAt: number;
        [key: string]: unknown;
      }[];
      templates: string[];
    };
    tools: {
      discovery: string[];
      cli: string[];
      approvalPolicy: string;
    };
    nextActions: string[];
  };
  "workspace.artifacts.list": Array<{
    id: string;
    runId: string;
    title: string;
    type: "note" | "draft" | "report" | "task_suggestion" | "patch" | "other";
    status: "draft" | "approved" | "rejected" | "applied" | "archived";
    content: string;
    createdAt: number;
    updatedAt: number;
  }>;
  "workspace.suggestedWork.list": Array<{
    id: string;
    runId: string;
    title: string;
    type: "note" | "draft" | "report" | "task_suggestion" | "patch" | "other";
    status: "draft" | "approved" | "rejected" | "applied" | "archived";
    content: string;
    createdAt: number;
    updatedAt: number;
  }>;
  "lists.list": unknown;
  "lists.rows": unknown;
  "lists.enrich": unknown;
  "lists.import": unknown;
  "lists.get": unknown;
  "lists.save": {
    artifactId: string;
    filePath: string;
    rowCount: number;
    previewRows: unknown[];
    title: string;
    createdFrom: string;
  };
  "lists.update": {
    artifactId: string;
    rowCount: number;
    previewRows: unknown[];
    title: string;
  };
  "lists.rename": unknown;
  "lists.delete": unknown;
  "lists.prospects.reviews": unknown;
  "lists.prospects.assess": unknown;
  "memory.search": Array<{
    _id: string;
    _creationTime: number;
    key: string;
    /** Memory classification. */
    kind: "fact" | "decision" | "preference" | "goal" | "tool_note" | "other" | "convention" | "project_context" | "agent_lesson" | "docs_knowledge" | "open_goal";
    text: string;
    tags: string[];
    status: "active" | "needs_review" | "archived";
    source: string;
    /** Who can see the memory. Defaults to `user`. */
    visibility?: "user" | "org";
    confidence?: number;
    importance?: number;
    createdAt: number;
    updatedAt: number;
    [key: string]: unknown;
  }>;
  "memory.save": {
    ok: boolean;
    memoryId: string;
    status: "active" | "needs_review" | "archived";
  };
  "approval.request": {
    ok: boolean;
    approvalId: string;
  };
  "approval.decide": {
    ok: true;
    /** Human decision for an approval request. */
    status: "approved" | "rejected";
  } | {
    ok: false;
    /** e.g. approval_not_pending. */
    code: string;
    error: string;
  };
  "billing.status": {
    workspace: {
      id: string;
      name: string;
      slug: string;
    };
    availableCreditsCents: number;
    creditConsumedCents: number;
    billedCents: number;
    onDemandSpendCents: number;
    monthlySpendLimitCents: number;
    spendLimitRemainingCents: number;
    subscriptionStatus: string | null;
    stripeCustomerId: string | null;
    grants: Array<{
      id: string;
      source: "starter" | "trial" | "monthly" | "topup" | "manual" | "referral";
      category: "promotional" | "paid";
      status: "pending" | "granted" | "depleted" | "expired" | "voided";
      amountCents: number;
      usedCents: number;
      remainingCents: number;
      effectiveAt: number;
      expiresAt: number | null;
    }>;
    nextCommands: string[];
    [key: string]: unknown;
  };
  "billing.topup": {
    charged: true;
    amountCents: number;
  } | {
    url: string | null;
  };
  "billing.upgrade": {
    updated: true;
    tier: string;
    billingCycle?: string;
    stripeSubscriptionId: string;
  } | {
    url: string | null;
  };
  "chat.list": Array<{
    threadId: string;
    title: string;
    lastMessageAt: number;
    createdAt: number;
    status: "idle" | "streaming" | "error";
    visibility: "private" | "shared";
    createdByUserId: string;
    archivedAt: number | null;
    fileContextPath: string | null;
    /** Parent thread when this is a spawned sub-agent. */
    parentThreadId: string | null;
    nestingDepth: number | null;
    summary: string | null;
    activeRunId: string | null;
  }>;
  "chat.search": Array<{
    threadId: string;
    threadTitle: string;
    messageId: string;
    role: "user" | "assistant" | "system";
    snippet: string;
    createdAt: number;
    runId: string | null;
  }>;
  "chat.read": {
    thread: {
      threadId: string;
      title: string;
      lastMessageAt: number;
      createdAt: number;
      status: "idle" | "streaming" | "error";
      visibility: "private" | "shared";
      createdByUserId: string;
      archivedAt: number | null;
      fileContextPath: string | null;
      /** Parent thread when this is a spawned sub-agent. */
      parentThreadId: string | null;
      nestingDepth: number | null;
      summary: string | null;
      activeRunId: string | null;
    };
    messages: Array<{
      id: string;
      role: "user" | "assistant" | "system";
      createdAt: number;
      updatedAt: number;
      text: string;
      runId: string | null;
      status: "streaming" | "complete" | "error" | "canceled" | null;
      revision: number;
      isDraft: boolean;
    }>;
  };
  "chat.tree": Array<{
    threadId: string;
    title: string;
    lastMessageAt: number;
    createdAt: number;
    status: "idle" | "streaming" | "error";
    visibility: "private" | "shared";
    createdByUserId: string;
    archivedAt: number | null;
    fileContextPath: string | null;
    /** Parent thread when this is a spawned sub-agent. */
    parentThreadId: string | null;
    nestingDepth: number | null;
    summary: string | null;
    activeRunId: string | null;
  }>;
  "chat.rename": {
    results: {
      threadId: string;
      ok: boolean;
      error?: string;
    }[];
    succeeded: number;
    failed: number;
  };
  "chat.delete": {
    scheduled: number;
    rejected: {
      threadId: string;
      /** e.g. automated_thread_protected. */
      reason: string;
      message?: string;
    }[];
    total: number;
  };
  "chat.new": {
    threadId: string;
    runId: string;
    workflowRunId: string | null;
    /** Web URL of the thread. */
    threadUrl: string;
    /** SSE stream URL for the live response. */
    streamUrl: string;
    yolo: boolean;
  };
  "chat.send": {
    threadId: string;
    runId: string;
    workflowRunId: string | null;
    /** Web URL of the thread. */
    threadUrl: string;
    /** SSE stream URL for the live response. */
    streamUrl: string;
    yolo: boolean;
  };
  "chat.follow": string;
  "crm.objects.list": Array<{
    _id: string;
    _creationTime: number;
    organizationId: string;
    name: string;
    description?: string;
    /** Default view rendered for the object. */
    defaultView: "table" | "kanban" | "calendar" | "timeline" | "gallery" | "list";
    sortOrder: number;
    immutable: boolean;
    /** Who can read the object's records. Always reported as the value the object behaves as: `meeting` defaults to owner_plus_members, `calendar_event` to owner_only, anything else to workspace. */
    visibility?: "workspace" | "owner_only" | "owner_plus_members";
    icon?: string;
    viewSettings?: Record<string, unknown>;
    savedViews?: Record<string, unknown>[];
    entryCount?: number;
    createdAt: number;
    updatedAt: number;
    [key: string]: unknown;
  }> | {
    data: Array<{
      _id: string;
      _creationTime: number;
      organizationId: string;
      name: string;
      description?: string;
      /** Default view rendered for the object. */
      defaultView: "table" | "kanban" | "calendar" | "timeline" | "gallery" | "list";
      sortOrder: number;
      immutable: boolean;
      /** Who can read the object's records. Always reported as the value the object behaves as: `meeting` defaults to owner_plus_members, `calendar_event` to owner_only, anything else to workspace. */
      visibility?: "workspace" | "owner_only" | "owner_plus_members";
      icon?: string;
      viewSettings?: Record<string, unknown>;
      savedViews?: Record<string, unknown>[];
      entryCount?: number;
      createdAt: number;
      updatedAt: number;
      [key: string]: unknown;
    }>;
    references: Array<{
      kind: "crm-entry";
      objectName: string;
      entryId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "crm-object";
      objectName: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "campaign";
      sequenceId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    }>;
    referenceCoverage: {
      returned: number;
      available: number;
      truncated: boolean;
    };
  };
  "crm.objects.listCompact": Array<{
    _id: string;
    name: string;
    displayName: string;
    description?: string;
    entryCount: number | null;
    countScope: "workspace" | "private_unknown";
    visibility: "workspace" | "owner_only" | "owner_plus_members";
    archived: boolean;
  }>;
  "crm.objects.get": {
    _id: string;
    _creationTime: number;
    organizationId: string;
    name: string;
    description?: string;
    /** Default view rendered for the object. */
    defaultView: "table" | "kanban" | "calendar" | "timeline" | "gallery" | "list";
    sortOrder: number;
    immutable: boolean;
    /** Who can read the object's records. Always reported as the value the object behaves as: `meeting` defaults to owner_plus_members, `calendar_event` to owner_only, anything else to workspace. */
    visibility?: "workspace" | "owner_only" | "owner_plus_members";
    icon?: string;
    viewSettings?: Record<string, unknown>;
    savedViews?: Record<string, unknown>[];
    entryCount?: number;
    createdAt: number;
    updatedAt: number;
    references?: Array<{
      kind: "crm-entry";
      objectName: string;
      entryId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "crm-object";
      objectName: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "campaign";
      sequenceId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    }>;
    referenceCoverage?: {
      returned: number;
      available: number;
      truncated: boolean;
    };
    [key: string]: unknown;
  } | null;
  "crm.objects.create": {
    id: string;
    /** The fields created from `fields`, in order. */
    fields?: {
      id: string;
      name: string;
    }[];
    references?: Array<{
      kind: "crm-entry";
      objectName: string;
      entryId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "crm-object";
      objectName: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "campaign";
      sequenceId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    }>;
    referenceCoverage?: {
      returned: number;
      available: number;
      truncated: boolean;
    };
  };
  "crm.objects.update": {
    ok: boolean;
  };
  "crm.objects.rename": {
    ok: boolean;
  };
  "crm.objects.delete": {
    ok: boolean;
  };
  "crm.objects.archive": {
    ok: boolean;
  };
  "crm.objects.unarchive": {
    ok: boolean;
  };
  "crm.views.list": {
    objectName: string;
    activeView: string | null;
    views: Record<string, unknown>[];
  };
  "crm.views.get": Record<string, unknown>;
  "crm.views.entries": {
    /** Materialized rows: id, entry_id, created_at, updated_at plus one key per field. */
    entries: Record<string, unknown>[];
    totalCount: number;
    page: number;
    pageSize: number;
    /** True when the read hit a server budget and rows may be missing. */
    truncated: boolean;
    /** The personal assignee scope that was applied, or null. */
    assigneeScope: {
      /** The user field the scope keyed on. */
      field: string;
      target: {
        kind: "user";
        userId: string;
      } | {
        kind: "unassigned";
      };
    } | null;
    [key: string]: unknown;
  };
  "crm.views.create": {
    ok: boolean;
    objectName: string;
    viewName: string;
    replaced: boolean;
    activeView: string | null;
  };
  "crm.views.update": {
    ok: boolean;
    objectName: string;
    viewName: string;
    replaced: boolean;
    activeView: string | null;
  };
  "crm.views.rename": unknown;
  "crm.views.delete": {
    ok: boolean;
    objectName: string;
    viewName: string;
    removed: boolean;
  };
  "crm.views.archive": {
    ok: boolean;
  };
  "crm.views.unarchive": {
    ok: boolean;
  };
  "crm.sidebar.list": {
    visible: Record<string, unknown>[];
    hidden: Record<string, unknown>[];
  };
  "crm.sidebar.move": {
    ok: boolean;
    navId: string;
    position: number | null;
    visibleOrder?: string[];
    error?: string;
  };
  "crm.sidebar.groups.create": unknown;
  "crm.sidebar.groups.rename": unknown;
  "crm.sidebar.groups.delete": unknown;
  "crm.sidebar.groups.move-item": unknown;
  "crm.sidebar.pins.set": unknown;
  "crm.fields.list": Array<{
    _id: string;
    _creationTime: number;
    organizationId: string;
    objectId: string;
    name: string;
    description?: string;
    /** Field data type. `relation` needs relatedObjectName + relationshipType; `enum` uses enumValues/enumColors; `user` cells store one member userId or an array of member userIds; long prose belongs in the protected `Notes` richtext field. */
    type: "text" | "email" | "phone" | "url" | "number" | "boolean" | "date" | "richtext" | "file" | "user" | "enum" | "relation" | "tags" | "action";
    required: boolean;
    defaultValue?: string;
    /** Read-only campaign activity boolean on people or lead (through Contact), not an expression. Cannot be required, indexed, enriched or have a default value. */
    calculation?: {
      kind: "campaign_activity";
      metric: "email_opened" | "email_clicked" | "replied" | "linkedin_connected";
      /** Same-workspace multichannel campaign ID readable by the viewer. Omit for any accessible multichannel campaign. */
      campaignId?: string;
    };
    relatedObjectId?: string;
    /** Relation cardinality for a `relation` field. */
    relationshipType?: "many_to_one" | "many_to_many";
    enumValues?: string[];
    enumColors?: string[];
    enumMultiple?: boolean;
    sortOrder: number;
    indexed?: boolean;
    createdAt: number;
    updatedAt: number;
    [key: string]: unknown;
  }>;
  "crm.fields.listCompact": {
    _id: string;
    name: string;
    type: string;
    required: boolean;
    readOnly: boolean;
    defaultValue?: string;
    enumValues?: string[];
    enumMultiple: boolean;
    relatedObjectId?: string;
    relationshipType?: string;
  }[];
  "crm.fields.create": {
    id: string;
  };
  "crm.fields.update": {
    ok: boolean;
  };
  "crm.fields.delete": {
    ok: boolean;
  };
  "crm.fields.reorder": {
    ok: boolean;
  };
  "crm.fields.enum.reorder": {
    ok: boolean;
    enumValues: string[];
    enumColors: string[] | null;
  };
  "crm.fields.enum.add": {
    ok: boolean;
    enumValues: string[];
    enumColors: string[];
    inserted: boolean;
  };
  "crm.fields.enum.remove": {
    ok: boolean;
    enumValues: string[];
    enumColors: string[] | null;
    removed: boolean;
  };
  "crm.fields.enum.rename": {
    ok: boolean;
    enumValues: string[];
    enumColors: string[];
    entriesUpdated: number;
  };
  "crm.fields.enum.color": {
    ok: boolean;
    enumColors: string[];
  };
  "crm.entries.list": {
    id: string;
    objectId: string;
    /** Field-name -> cell value map. */
    fields: Record<string, unknown>;
    createdAt: number;
    updatedAt: number;
    updatedBy: string;
    sortOrder: number;
  }[] | {
    data: {
      id: string;
      objectId: string;
      /** Field-name -> cell value map. */
      fields: Record<string, unknown>;
      createdAt: number;
      updatedAt: number;
      updatedBy: string;
      sortOrder: number;
    }[];
    references: Array<{
      kind: "crm-entry";
      objectName: string;
      entryId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "crm-object";
      objectName: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "campaign";
      sequenceId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    }>;
    referenceCoverage: {
      returned: number;
      available: number;
      truncated: boolean;
    };
  };
  "crm.entries.get": {
    id: string;
    objectId: string;
    /** Field-name -> cell value map. */
    fields: Record<string, unknown>;
    createdAt: number;
    updatedAt: number;
    updatedBy: string;
    sortOrder: number;
    references?: Array<{
      kind: "crm-entry";
      objectName: string;
      entryId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "crm-object";
      objectName: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "campaign";
      sequenceId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    }>;
    referenceCoverage?: {
      returned: number;
      available: number;
      truncated: boolean;
    };
  } | null;
  "crm.entries.syncHistory": unknown;
  "crm.entries.syncHistoryStatus": unknown;
  "crm.entries.dossier.get": unknown;
  "crm.entries.dossier.regenerate": unknown;
  "crm.privacy.get": unknown;
  "crm.privacy.set": unknown;
  "crm.detections.list": unknown;
  "crm.detections.undo": unknown;
  "crm.entries.history": unknown;
  "crm.activity.list": unknown;
  "crm.brief.get": unknown;
  "crm.context.get": unknown;
  "crm.brief.regenerate": unknown;
  "crm.activity.count": unknown;
  "crm.notes.list": unknown;
  "crm.notes.create": unknown;
  "crm.comments.list": {
    page: Array<{
      _id: string;
      entryId: string;
      parentCommentId?: string;
      rootCommentId?: string;
      depth: number;
      /** Markdown. */
      body: string;
      actor: {
        kind: string;
        label: string;
        displayName?: string;
        imageUrl?: string;
        userId?: string;
        isDench: boolean;
        [key: string]: unknown;
      };
      mentionedUserIds: string[];
      mentionsDench: boolean;
      replyCount: number;
      reactionSummary: {
        emoji: string;
        count: number;
      }[];
      viewerReactions: string[];
      editedAt?: number;
      deletedAt?: number;
      denchStatus?: "pending" | "failed" | "done";
      canEdit: boolean;
      createdAt: number;
      replies: Array<{
        _id: string;
        entryId: string;
        parentCommentId?: string;
        rootCommentId?: string;
        depth: number;
        /** Markdown. */
        body: string;
        actor: {
          kind: string;
          label: string;
          displayName?: string;
          imageUrl?: string;
          userId?: string;
          isDench: boolean;
          [key: string]: unknown;
        };
        mentionedUserIds: string[];
        mentionsDench: boolean;
        replyCount: number;
        reactionSummary: {
          emoji: string;
          count: number;
        }[];
        viewerReactions: string[];
        editedAt?: number;
        deletedAt?: number;
        denchStatus?: "pending" | "failed" | "done";
        canEdit: boolean;
        createdAt: number;
        [key: string]: unknown;
      }>;
      [key: string]: unknown;
    }>;
    isDone: boolean;
    continueCursor: string;
  };
  "crm.comments.replies": {
    page: Array<{
      _id: string;
      entryId: string;
      parentCommentId?: string;
      rootCommentId?: string;
      depth: number;
      /** Markdown. */
      body: string;
      actor: {
        kind: string;
        label: string;
        displayName?: string;
        imageUrl?: string;
        userId?: string;
        isDench: boolean;
        [key: string]: unknown;
      };
      mentionedUserIds: string[];
      mentionsDench: boolean;
      replyCount: number;
      reactionSummary: {
        emoji: string;
        count: number;
      }[];
      viewerReactions: string[];
      editedAt?: number;
      deletedAt?: number;
      denchStatus?: "pending" | "failed" | "done";
      canEdit: boolean;
      createdAt: number;
      [key: string]: unknown;
    }>;
    isDone: boolean;
    continueCursor: string;
  };
  "crm.comments.get": {
    _id: string;
    entryId: string;
    parentCommentId?: string;
    rootCommentId?: string;
    depth: number;
    /** Markdown. */
    body: string;
    actor: {
      kind: string;
      label: string;
      displayName?: string;
      imageUrl?: string;
      userId?: string;
      isDench: boolean;
      [key: string]: unknown;
    };
    mentionedUserIds: string[];
    mentionsDench: boolean;
    replyCount: number;
    reactionSummary: {
      emoji: string;
      count: number;
    }[];
    viewerReactions: string[];
    editedAt?: number;
    deletedAt?: number;
    denchStatus?: "pending" | "failed" | "done";
    canEdit: boolean;
    createdAt: number;
    objectName: string;
    entryLabel: string;
    [key: string]: unknown;
  };
  "crm.comments.create": {
    id: string;
    rootCommentId?: string;
    depth: number;
    mentionedUserIds: string[];
    mentionsDench: boolean;
  };
  "crm.comments.update": {
    ok: boolean;
    newlyMentioned: string[];
  };
  "crm.comments.delete": {
    ok: boolean;
    tombstoned: boolean;
  };
  "crm.comments.react": {
    reacted: boolean;
    reactionSummary: {
      emoji: string;
      count: number;
    }[];
  };
  "crm.watch.get": {
    watching: boolean;
    reason?: string;
    watcherCount: number;
  };
  "crm.watch.set": {
    watching: boolean;
  };
  "crm.tasks.pageAssigned": unknown;
  "crm.tasks.pageForEntry": unknown;
  "crm.tasks.prepare": unknown;
  "crm.tasks.mine": Record<string, unknown>[];
  "crm.tasks.forEntry": Record<string, unknown>[];
  "crm.tasks.createForEntry": Record<string, unknown>;
  "crm.tasks.complete": Record<string, unknown>;
  "crm.tasks.reopen": Record<string, unknown>;
  "crm.tasks.setPriority": Record<string, unknown>;
  "crm.tasks.subtasks.list": Record<string, unknown>[];
  "crm.tasks.subtasks.create": Record<string, unknown>;
  "crm.tasks.setParent": Record<string, unknown>;
  "crm.tasks.delete": Record<string, unknown>;
  "crm.tasks.repeat.get": Record<string, unknown> | null;
  "crm.tasks.repeat.set": Record<string, unknown> | null;
  "crm.tasks.repeat.clear": null;
  "crm.tasks.repeat.skip": Record<string, unknown>;
  "crm.tasks.repeat.pause": null;
  "crm.tasks.repeat.resume": null;
  "crm.tasks.series.list": Record<string, unknown>[];
  "crm.tasks.series.occurrences": Record<string, unknown>[];
  "crm.entries.create": {
    entryId: string;
    references?: Array<{
      kind: "crm-entry";
      objectName: string;
      entryId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "crm-object";
      objectName: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "campaign";
      sequenceId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    }>;
    referenceCoverage?: {
      returned: number;
      available: number;
      truncated: boolean;
    };
  };
  "crm.entries.createMany": {
    references?: Array<{
      kind: "crm-entry";
      objectName: string;
      entryId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "crm-object";
      objectName: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "campaign";
      sequenceId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    }>;
    referenceCoverage?: {
      returned: number;
      available: number;
      truncated: boolean;
    };
    results: {
      entryId: string;
    }[];
    count: number;
  };
  "crm.entries.update": {
    entryId: string;
    references?: Array<{
      kind: "crm-entry";
      objectName: string;
      entryId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "crm-object";
      objectName: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "campaign";
      sequenceId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    }>;
    referenceCoverage?: {
      returned: number;
      available: number;
      truncated: boolean;
    };
  };
  "crm.entries.updateMany": {
    references?: Array<{
      kind: "crm-entry";
      objectName: string;
      entryId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "crm-object";
      objectName: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "campaign";
      sequenceId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    }>;
    referenceCoverage?: {
      returned: number;
      available: number;
      truncated: boolean;
    };
    results: {
      entryId: string;
      deleted?: boolean;
      [key: string]: unknown;
    }[];
    count: number;
  };
  "crm.entries.delete": {
    ok: boolean;
  };
  "crm.entries.bulkDelete": {
    count: number;
  };
  "crm.cells.get": unknown;
  "crm.cells.set": {
    entryId: string;
    references?: Array<{
      kind: "crm-entry";
      objectName: string;
      entryId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "crm-object";
      objectName: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "campaign";
      sequenceId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    }>;
    referenceCoverage?: {
      returned: number;
      available: number;
      truncated: boolean;
    };
  };
  "crm.cells.setMany": {
    results: {
      entryId: string;
    }[];
    count: number;
  };
  "crm.cells.append": {
    entryId: string;
    references?: Array<{
      kind: "crm-entry";
      objectName: string;
      entryId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "crm-object";
      objectName: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "campaign";
      sequenceId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    }>;
    referenceCoverage?: {
      returned: number;
      available: number;
      truncated: boolean;
    };
  };
  "crm.query": Record<string, unknown>[] | {
    data: Record<string, unknown>[];
    references: Array<{
      kind: "crm-entry";
      objectName: string;
      entryId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "crm-object";
      objectName: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "campaign";
      sequenceId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    }>;
    referenceCoverage: {
      returned: number;
      available: number;
      truncated: boolean;
    };
  };
  "crm.queryPage": unknown;
  "crm.sql": {
    id: string;
    objectId: string;
    /** Field-name -> cell value map. */
    fields: Record<string, unknown>;
    createdAt: number;
    updatedAt: number;
    updatedBy: string;
    sortOrder: number;
  }[];
  "crm.aggregate": {
    key: string;
    count: number;
    sumNumber?: number;
  }[];
  "crm.search": {
    _id: string;
    _creationTime: number;
    objectId: string;
    /** Field-name -> cell value map. */
    data: Record<string, unknown>;
    sortOrder: number;
    createdAt: number;
    updatedAt: number;
    updatedBy: string;
    [key: string]: unknown;
  }[] | {
    data: {
      _id: string;
      _creationTime: number;
      objectId: string;
      /** Field-name -> cell value map. */
      data: Record<string, unknown>;
      sortOrder: number;
      createdAt: number;
      updatedAt: number;
      updatedBy: string;
      [key: string]: unknown;
    }[];
    references: Array<{
      kind: "crm-entry";
      objectName: string;
      entryId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "crm-object";
      objectName: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "campaign";
      sequenceId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    }>;
    referenceCoverage: {
      returned: number;
      available: number;
      truncated: boolean;
    };
  };
  "crm.search.page": {
    references?: Array<{
      kind: "crm-entry";
      objectName: string;
      entryId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "crm-object";
      objectName: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "campaign";
      sequenceId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    }>;
    referenceCoverage?: {
      returned: number;
      available: number;
      truncated: boolean;
    };
    page: {
      _id: string;
      objectId: string;
      /** Field-name -> cell value map. */
      data: Record<string, unknown>;
    }[];
    isDone: boolean;
    continueCursor: string | null;
    returnedCount: number;
    selectedFields: string[] | null;
    /** Present only when compact mode recovered unknown selected fields. selectedFields and row keys use actual canonical names; unresolved names are never fabricated as empty cells. Truncated values are previews, not complete cell values. */
    selectionFallback?: {
      mode: "compact";
      requestedFields: string[];
      unresolvedFields: string[];
      availableFields: {
        name: string;
        type: string;
      }[];
      availableFieldCount: number;
      schemaTruncated: boolean;
      omittedFieldCount: number;
      truncatedValues: {
        entryId: string;
        fields: string[];
      }[];
    };
    completeness: "page";
  };
  "crm.statuses.list": {
    _id: string;
    _creationTime: number;
    objectId: string;
    name: string;
    color: string;
    sortOrder: number;
    isDefault: boolean;
    [key: string]: unknown;
  }[];
  "crm.statuses.set": {
    ok: boolean;
  };
  "crm.batch": {
    references?: Array<{
      kind: "crm-entry";
      objectName: string;
      entryId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "crm-object";
      objectName: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "campaign";
      sequenceId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    }>;
    referenceCoverage?: {
      returned: number;
      available: number;
      truncated: boolean;
    };
    results: {
      entryId: string;
      deleted?: boolean;
      [key: string]: unknown;
    }[];
    count: number;
  };
  "crm.transaction.begin": {
    txnId: string;
  };
  "crm.transaction.add": {
    ok: boolean;
  };
  "crm.transaction.commit": {
    references?: Array<{
      kind: "crm-entry";
      objectName: string;
      entryId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "crm-object";
      objectName: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "campaign";
      sequenceId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    }>;
    referenceCoverage?: {
      returned: number;
      available: number;
      truncated: boolean;
    };
    results: {
      entryId: string;
      deleted?: boolean;
      [key: string]: unknown;
    }[];
    count: number;
  };
  "crm.transaction.abort": {
    ok: boolean;
  };
  "crm.transaction.inspect": {
    _id: string;
    _creationTime: number;
    status: "open" | "committed" | "aborted";
    ops?: Record<string, unknown>[];
    results?: Record<string, unknown>[];
    committedAt?: number;
    createdAt: number;
    updatedAt: number;
    [key: string]: unknown;
  } | null;
  "crm.docs.list": {
    _id: string;
    _creationTime: number;
    title: string;
    icon?: string;
    coverImage?: string;
    filePath: string;
    parentId?: string;
    parentObjectId?: string;
    entryId?: string;
    sortOrder: number;
    isPublished: boolean;
    createdAt: number;
    updatedAt: number;
    [key: string]: unknown;
  }[];
  "crm.docs.create": {
    id: string;
  };
  "crm.docs.link": {
    ok: boolean;
  };
  "crm.docs.delete": {
    ok: boolean;
  };
  "crm.actions.list": Array<{
    _id: string;
    _creationTime: number;
    actionId: string;
    fieldId: string;
    entryId: string;
    objectId: string;
    runId?: string;
    status: "pending" | "running" | "completed" | "failed";
    startedAt: number;
    completedAt?: number;
    result?: string;
    error?: string;
    [key: string]: unknown;
  }>;
  "crm.actions.create": {
    fieldId: string;
    actionId: string;
    fieldCreated: boolean;
  };
  "crm.actions.update": {
    fieldId: string;
    actionId: string;
    fieldCreated: boolean;
  };
  "crm.actions.delete": {
    ok: boolean;
    remaining: number;
    fieldDeleted: boolean;
  };
  "crm.actions.run": {
    results: Array<{
      entryId: string;
      status: "success" | "error";
      operations?: number;
      error?: string;
    }>;
  };
  "crm.members.list": {
    members: Array<{
      userId: string;
      name: string | null;
      email: string | null;
      image: string | null;
      tagline: string | null;
      /** IANA zone, when the member set one. */
      timezone: string | null;
      presence: "online" | "away" | "offline";
      lastActiveAt: number | null;
      role: string;
      joinedAt: number;
    }>;
    organizationId: string;
    organizationSlug: string | null;
    organizationName: string;
  };
  "members.presence": Array<{
    userId: string;
    state: "online" | "away" | "offline";
    lastActiveAt: number | null;
  }>;
  "members.get": {
    userId: string;
    name: string | null;
    email: string | null;
    image: string | null;
    tagline: string | null;
    role: "ADMIN" | "MEMBER";
    joinedAt: number;
    timezone: {
      value: string;
      source: "auto" | "manual" | "agent";
      updatedAt: number;
    } | null;
    presence: {
      state: "online" | "away" | "offline";
      lastActiveAt: number | null;
    };
    /** Capped at 500. */
    openTaskCount: number;
    /** True when openTaskCount stopped at its cap. */
    openTaskCountCapped?: boolean;
    /** Capped at 200. */
    commentCount: number;
    /** Capped at 200. */
    changeCount: number;
    lastContributionAt: number | null;
    isSelf: boolean;
  } | null;
  "members.activity": Array<{
    kind: "comment";
    id: string;
    entryId: string;
    objectName: string;
    entryLabel: string;
    body: string;
    parentCommentId?: string;
    deleted: boolean;
    at: number;
  } | {
    kind: "change";
    id: string;
    entryId: string;
    objectName: string;
    entryLabel: string;
    changeKind: "create" | "update" | "delete";
    changes: {
      fieldName: string;
      before?: unknown;
      after?: unknown;
    }[];
    at: number;
    [key: string]: unknown;
  }>;
  "members.tasks": Array<{
    id: string;
    name: string;
    /** Same as name: the task's title field. */
    title: string;
    status: string | null;
    dueDate: number | null;
    dueDateKey: string | null;
    done: boolean;
  }>;
  "me.profile.get": {
    userId: string;
    name: string | null;
    email: string | null;
    image: string | null;
    tagline: string | null;
    role: "ADMIN" | "MEMBER";
    joinedAt: number;
    timezone: {
      value: string;
      source: "auto" | "manual" | "agent";
      updatedAt: number;
    } | null;
    presence: {
      state: "online" | "away" | "offline";
      lastActiveAt: number | null;
    };
    /** Capped at 500. */
    openTaskCount: number;
    /** True when openTaskCount stopped at its cap. */
    openTaskCountCapped?: boolean;
    /** Capped at 200. */
    commentCount: number;
    /** Capped at 200. */
    changeCount: number;
    lastContributionAt: number | null;
    isSelf: boolean;
  } | null;
  "me.profile.update": {
    userId: string;
    name: string | null;
    email: string | null;
    image: string | null;
    tagline: string | null;
    role: "ADMIN" | "MEMBER";
    joinedAt: number;
    timezone: {
      value: string;
      source: "auto" | "manual" | "agent";
      updatedAt: number;
    } | null;
    presence: {
      state: "online" | "away" | "offline";
      lastActiveAt: number | null;
    };
    /** Capped at 500. */
    openTaskCount: number;
    /** True when openTaskCount stopped at its cap. */
    openTaskCountCapped?: boolean;
    /** Capped at 200. */
    commentCount: number;
    /** Capped at 200. */
    changeCount: number;
    lastContributionAt: number | null;
    isSelf: boolean;
  };
  "me.avatar.uploadUrl": string;
  "me.avatar.set": {
    image: string;
  };
  "me.avatar.clear": {
    ok: boolean;
  };
  "crm.reports.generate": {
    spec: {
      objectName: string;
      /** Chart type for the generated report. */
      type: "pie" | "bar" | "line" | "table";
      groupByField: string;
      /** Aggregation metric. Defaults to `count`. */
      metric: "count" | "sum" | "avg" | "min" | "max";
      metricField?: string;
    };
    buckets: {
      key: string;
      label: string;
      count: number;
      sum?: number;
      avg?: number;
    }[];
    totalCount: number;
    /** True when a bounded row scan (not the exact pre-aggregates) produced the sums. */
    truncated?: boolean;
  };
  "crm.analytics.get": {
    objectName: string;
    analytics: {
      panels: Array<{
        /** Stable id (template panels use `tpl:<template>:<slug>`). */
        id: string;
        title: string;
        type: "stat" | "bar" | "line" | "area" | "donut" | "funnel" | "leaderboard" | "forecast" | "map";
        metric: "count" | "sum" | "avg" | "min" | "max";
        /** Numeric field for sum/avg/min/max. Ignored for count. */
        metricField?: string;
        /** Bucketing field (enum/user/relation/boolean/text, or $location). On a time-series panel it splits the series into one line per value. */
        groupBy?: string;
        /** Date field for line/area/forecast bucketing (or $createdAt). */
        dateField?: string;
        dateBucket?: "day" | "week" | "month" | "quarter";
        /** Panel-scoped FilterGroup, same shape as saved-view filters. */
        filters?: Record<string, unknown>;
        /** Deprecated; ignored for layout. Use `span`. */
        size?: "sm" | "md" | "lg";
        /** Card width on the 6-track dashboard grid: 2 = a third, 3 = half, 4 = two thirds, 6 = full row. Defaults: funnel 4; map and leaderboard 2; bar/donut grouped by a user field 2, by anything else 4; trends 3. */
        span?: 2 | 3 | 4 | 6;
        /** Hide from the strip above the table; still shown in the full analytics view. */
        hidden?: boolean;
        sortOrder: number;
        /** Role-driven derived metric; when set the panel computes from fieldRoles instead of metric/groupBy. */
        derived?: "conversion_rate" | "win_rate" | "won_amount" | "lost_amount" | "open_pipeline" | "pipeline_forecast" | "mrr" | "arr";
      }>;
      /** Template panel ids the user deleted; never resurrected. */
      removedPanelIds?: string[];
      /** The object's analytics setup, shared by every chart and every view: the semantic field roles derived metrics (win rate, won $, open pipeline, forecast, MRR/ARR), maps and card defaults read. */
      fieldRoles?: {
        /** Numeric field holding the deal value ("Amount") — the "Value field" in the setup sheet. */
        amount?: string;
        /** Enum field driving the pipeline ("Stage" / "Status") — the "Progress field". */
        stage?: string;
        /** `stage` options that count as won (closed, successful). */
        wonValues?: string[];
        /** `stage` options that count as lost (closed, gone). */
        lostValues?: string[];
        /** `stage` options that count as converted (a lead reached "Qualified"). */
        convertedValues?: string[];
        /** Date field for time bucketing, forecasts and the period pill (falls back to $createdAt). */
        closeDate?: string;
        /** User field naming who owns each record ("Owner"). Rankings on it default to a narrow card and draw member faces. */
        owner?: string;
        /** Place-name field maps plot. May be a relation path like "Account.HQ Location" (one hop through a relation). */
        location?: string;
        /** How a won amount recurs: annual treats Amount as ARR, monthly as MRR, one_time disables MRR/ARR panels. */
        recurrence?: "monthly" | "annual" | "one_time";
        /** Chance of closing per OPEN stage, 0..1, for the weighted forecast. Unlisted stages are spaced evenly; won = 1, lost = 0. */
        stageProbabilities?: Record<string, number>;
      };
      stripCollapsed?: boolean;
    } | null;
    /** The named view's own dashboard, or null when it inherits. */
    viewAnalytics: {
      panels: Array<{
        /** Stable id (template panels use `tpl:<template>:<slug>`). */
        id: string;
        title: string;
        type: "stat" | "bar" | "line" | "area" | "donut" | "funnel" | "leaderboard" | "forecast" | "map";
        metric: "count" | "sum" | "avg" | "min" | "max";
        /** Numeric field for sum/avg/min/max. Ignored for count. */
        metricField?: string;
        /** Bucketing field (enum/user/relation/boolean/text, or $location). On a time-series panel it splits the series into one line per value. */
        groupBy?: string;
        /** Date field for line/area/forecast bucketing (or $createdAt). */
        dateField?: string;
        dateBucket?: "day" | "week" | "month" | "quarter";
        /** Panel-scoped FilterGroup, same shape as saved-view filters. */
        filters?: Record<string, unknown>;
        /** Deprecated; ignored for layout. Use `span`. */
        size?: "sm" | "md" | "lg";
        /** Card width on the 6-track dashboard grid: 2 = a third, 3 = half, 4 = two thirds, 6 = full row. Defaults: funnel 4; map and leaderboard 2; bar/donut grouped by a user field 2, by anything else 4; trends 3. */
        span?: 2 | 3 | 4 | 6;
        /** Hide from the strip above the table; still shown in the full analytics view. */
        hidden?: boolean;
        sortOrder: number;
        /** Role-driven derived metric; when set the panel computes from fieldRoles instead of metric/groupBy. */
        derived?: "conversion_rate" | "win_rate" | "won_amount" | "lost_amount" | "open_pipeline" | "pipeline_forecast" | "mrr" | "arr";
      }>;
      /** Template panel ids the user deleted; never resurrected. */
      removedPanelIds?: string[];
    } | null;
    viewExists: boolean;
    fields: Array<{
      name: string;
      type: string;
      enumValues: string[] | null;
      enumColors: string[] | null;
    }>;
  };
  "crm.analytics.compute": {
    objectName: string;
    /** True when the table exceeded the 5,000-row scan and numbers are approximate. */
    truncated: boolean;
    scannedRows: number;
    locationRole?: string;
    panels: Array<{
      id: string;
      unit: "number" | "currency" | "percent";
      value?: number;
      secondaryValue?: number;
      /** The same value over the comparison window (period / compareFilters). */
      previousValue?: number;
      buckets?: {
        key: string;
        label: string;
        count: number;
        value: number;
        color?: string;
        /** Funnel only: sum of the amount role over the rows in this stage. */
        amount?: number;
      }[];
      series?: {
        bucket: string;
        label: string;
        value: number;
        count: number;
        projected?: boolean;
      }[];
      seriesGroups?: {
        key: string;
        label: string;
        color?: string;
        series: {
          bucket: string;
          label: string;
          value: number;
          count: number;
          projected?: boolean;
        }[];
      }[];
      error?: string;
    }>;
  };
  "crm.analytics.save": {
    ok: boolean;
    panelId: string;
  };
  "crm.analytics.update": {
    ok: boolean;
    /** One analytics panel definition. */
    panel: {
      /** Stable id (template panels use `tpl:<template>:<slug>`). */
      id: string;
      title: string;
      type: "stat" | "bar" | "line" | "area" | "donut" | "funnel" | "leaderboard" | "forecast" | "map";
      metric: "count" | "sum" | "avg" | "min" | "max";
      /** Numeric field for sum/avg/min/max. Ignored for count. */
      metricField?: string;
      /** Bucketing field (enum/user/relation/boolean/text, or $location). On a time-series panel it splits the series into one line per value. */
      groupBy?: string;
      /** Date field for line/area/forecast bucketing (or $createdAt). */
      dateField?: string;
      dateBucket?: "day" | "week" | "month" | "quarter";
      /** Panel-scoped FilterGroup, same shape as saved-view filters. */
      filters?: Record<string, unknown>;
      /** Deprecated; ignored for layout. Use `span`. */
      size?: "sm" | "md" | "lg";
      /** Card width on the 6-track dashboard grid: 2 = a third, 3 = half, 4 = two thirds, 6 = full row. Defaults: funnel 4; map and leaderboard 2; bar/donut grouped by a user field 2, by anything else 4; trends 3. */
      span?: 2 | 3 | 4 | 6;
      /** Hide from the strip above the table; still shown in the full analytics view. */
      hidden?: boolean;
      sortOrder: number;
      /** Role-driven derived metric; when set the panel computes from fieldRoles instead of metric/groupBy. */
      derived?: "conversion_rate" | "win_rate" | "won_amount" | "lost_amount" | "open_pipeline" | "pipeline_forecast" | "mrr" | "arr";
    };
  };
  "crm.analytics.hide": {
    ok: boolean;
    /** One analytics panel definition. */
    panel: {
      /** Stable id (template panels use `tpl:<template>:<slug>`). */
      id: string;
      title: string;
      type: "stat" | "bar" | "line" | "area" | "donut" | "funnel" | "leaderboard" | "forecast" | "map";
      metric: "count" | "sum" | "avg" | "min" | "max";
      /** Numeric field for sum/avg/min/max. Ignored for count. */
      metricField?: string;
      /** Bucketing field (enum/user/relation/boolean/text, or $location). On a time-series panel it splits the series into one line per value. */
      groupBy?: string;
      /** Date field for line/area/forecast bucketing (or $createdAt). */
      dateField?: string;
      dateBucket?: "day" | "week" | "month" | "quarter";
      /** Panel-scoped FilterGroup, same shape as saved-view filters. */
      filters?: Record<string, unknown>;
      /** Deprecated; ignored for layout. Use `span`. */
      size?: "sm" | "md" | "lg";
      /** Card width on the 6-track dashboard grid: 2 = a third, 3 = half, 4 = two thirds, 6 = full row. Defaults: funnel 4; map and leaderboard 2; bar/donut grouped by a user field 2, by anything else 4; trends 3. */
      span?: 2 | 3 | 4 | 6;
      /** Hide from the strip above the table; still shown in the full analytics view. */
      hidden?: boolean;
      sortOrder: number;
      /** Role-driven derived metric; when set the panel computes from fieldRoles instead of metric/groupBy. */
      derived?: "conversion_rate" | "win_rate" | "won_amount" | "lost_amount" | "open_pipeline" | "pipeline_forecast" | "mrr" | "arr";
    };
  };
  "crm.analytics.show": {
    ok: boolean;
    /** One analytics panel definition. */
    panel: {
      /** Stable id (template panels use `tpl:<template>:<slug>`). */
      id: string;
      title: string;
      type: "stat" | "bar" | "line" | "area" | "donut" | "funnel" | "leaderboard" | "forecast" | "map";
      metric: "count" | "sum" | "avg" | "min" | "max";
      /** Numeric field for sum/avg/min/max. Ignored for count. */
      metricField?: string;
      /** Bucketing field (enum/user/relation/boolean/text, or $location). On a time-series panel it splits the series into one line per value. */
      groupBy?: string;
      /** Date field for line/area/forecast bucketing (or $createdAt). */
      dateField?: string;
      dateBucket?: "day" | "week" | "month" | "quarter";
      /** Panel-scoped FilterGroup, same shape as saved-view filters. */
      filters?: Record<string, unknown>;
      /** Deprecated; ignored for layout. Use `span`. */
      size?: "sm" | "md" | "lg";
      /** Card width on the 6-track dashboard grid: 2 = a third, 3 = half, 4 = two thirds, 6 = full row. Defaults: funnel 4; map and leaderboard 2; bar/donut grouped by a user field 2, by anything else 4; trends 3. */
      span?: 2 | 3 | 4 | 6;
      /** Hide from the strip above the table; still shown in the full analytics view. */
      hidden?: boolean;
      sortOrder: number;
      /** Role-driven derived metric; when set the panel computes from fieldRoles instead of metric/groupBy. */
      derived?: "conversion_rate" | "win_rate" | "won_amount" | "lost_amount" | "open_pipeline" | "pipeline_forecast" | "mrr" | "arr";
    };
  };
  "crm.analytics.resize": {
    ok: boolean;
    /** One analytics panel definition. */
    panel: {
      /** Stable id (template panels use `tpl:<template>:<slug>`). */
      id: string;
      title: string;
      type: "stat" | "bar" | "line" | "area" | "donut" | "funnel" | "leaderboard" | "forecast" | "map";
      metric: "count" | "sum" | "avg" | "min" | "max";
      /** Numeric field for sum/avg/min/max. Ignored for count. */
      metricField?: string;
      /** Bucketing field (enum/user/relation/boolean/text, or $location). On a time-series panel it splits the series into one line per value. */
      groupBy?: string;
      /** Date field for line/area/forecast bucketing (or $createdAt). */
      dateField?: string;
      dateBucket?: "day" | "week" | "month" | "quarter";
      /** Panel-scoped FilterGroup, same shape as saved-view filters. */
      filters?: Record<string, unknown>;
      /** Deprecated; ignored for layout. Use `span`. */
      size?: "sm" | "md" | "lg";
      /** Card width on the 6-track dashboard grid: 2 = a third, 3 = half, 4 = two thirds, 6 = full row. Defaults: funnel 4; map and leaderboard 2; bar/donut grouped by a user field 2, by anything else 4; trends 3. */
      span?: 2 | 3 | 4 | 6;
      /** Hide from the strip above the table; still shown in the full analytics view. */
      hidden?: boolean;
      sortOrder: number;
      /** Role-driven derived metric; when set the panel computes from fieldRoles instead of metric/groupBy. */
      derived?: "conversion_rate" | "win_rate" | "won_amount" | "lost_amount" | "open_pipeline" | "pipeline_forecast" | "mrr" | "arr";
    };
  };
  "crm.analytics.delete": {
    ok: boolean;
    removed: boolean;
  };
  "crm.analytics.reorder": {
    ok: boolean;
  };
  "crm.analytics.roles": {
    ok: boolean;
    /** The mapping as stored after the write. */
    fieldRoles: {
      /** Numeric field holding the deal value ("Amount") — the "Value field" in the setup sheet. */
      amount?: string;
      /** Enum field driving the pipeline ("Stage" / "Status") — the "Progress field". */
      stage?: string;
      /** `stage` options that count as won (closed, successful). */
      wonValues?: string[];
      /** `stage` options that count as lost (closed, gone). */
      lostValues?: string[];
      /** `stage` options that count as converted (a lead reached "Qualified"). */
      convertedValues?: string[];
      /** Date field for time bucketing, forecasts and the period pill (falls back to $createdAt). */
      closeDate?: string;
      /** User field naming who owns each record ("Owner"). Rankings on it default to a narrow card and draw member faces. */
      owner?: string;
      /** Place-name field maps plot. May be a relation path like "Account.HQ Location" (one hop through a relation). */
      location?: string;
      /** How a won amount recurs: annual treats Amount as ARR, monthly as MRR, one_time disables MRR/ARR panels. */
      recurrence?: "monthly" | "annual" | "one_time";
      /** Chance of closing per OPEN stage, 0..1, for the weighted forecast. Unlisted stages are spaced evenly; won = 1, lost = 0. */
      stageProbabilities?: Record<string, number>;
    };
  };
  "crm.analytics.collapse": {
    ok: boolean;
  };
  "crm.analytics.expand": {
    ok: boolean;
  };
  "crm.analytics.scope": {
    ok: boolean;
    changed: boolean;
  };
  "crm.enrich.cell": {
    enqueued: boolean;
    hint: string;
  };
  "crm.enrich.object": {
    /** Number of cells queued for enrichment. */
    enqueued: number;
  };
  "crm.people.search": {
    source: "live" | "cache";
    /** Search results normalized to the CRM upsert shape. */
    people: {
      fullName?: string;
      firstName?: string;
      lastName?: string;
      headline?: string;
      seniority?: string;
      jobFunctions?: string[];
      currentCompanyName?: string;
      currentCompanyWebsite?: string;
      linkedinID?: string;
      emails?: Record<string, unknown>[];
      phones?: Record<string, unknown>[];
      [key: string]: unknown;
    }[];
    resolvedPersonIds: string[];
    creditsCharged: number;
    billing?: {
      /** Search cost ceiling authorized by Dench billing, in cents. */
      estimatedCents: number;
      /** Actual workspace search charge reported by Dench billing, in cents. */
      chargedCents: number;
    };
    metadata?: {
      /** Total matches for the search. Stable across pages; absent when only an estimate exists. */
      total?: number;
      /** True when the total is a lower bound rather than exact. */
      totalIsEstimate?: boolean;
      offset?: number;
      /** Opaque token for the next page. Pass it back as pageToken; absent on the last page. */
      nextPageToken?: string;
      [key: string]: unknown;
    };
    [key: string]: unknown;
  };
  "crm.companies.search": {
    source: "live" | "cache";
    /** Search results normalized to the CRM upsert shape. */
    companies: {
      name?: string;
      website?: string;
      description?: string;
      founded?: number;
      headcount?: number;
      industry?: string;
      linkedinUrl?: string;
      linkedinID?: string;
      [key: string]: unknown;
    }[];
    resolvedCompanyIds: string[];
    creditsCharged: number;
    billing?: {
      /** Search cost ceiling authorized by Dench billing, in cents. */
      estimatedCents: number;
      /** Actual workspace search charge reported by Dench billing, in cents. */
      chargedCents: number;
    };
    metadata?: {
      /** Total matches for the search. Stable across pages; absent when only an estimate exists. */
      total?: number;
      /** True when the total is a lower bound rather than exact. */
      totalIsEstimate?: boolean;
      offset?: number;
      /** Opaque token for the next page. Pass it back as pageToken; absent on the last page. */
      nextPageToken?: string;
      [key: string]: unknown;
    };
    [key: string]: unknown;
  };
  "enrichment.jobs.search": {
    source: "live" | "cache";
    /** Job postings in the canonical job_posting shape. */
    jobs: {
      title?: string;
      company?: string;
      location?: string;
      url?: string;
      workplaceType?: string;
      postedAt?: string;
      [key: string]: unknown;
    }[];
    metadata?: {
      /** Total matches for the search. Stable across pages; absent when only an estimate exists. */
      total?: number;
      /** True when the total is a lower bound rather than exact. */
      totalIsEstimate?: boolean;
      offset?: number;
      /** Opaque token for the next page. Pass it back as pageToken; absent on the last page. */
      nextPageToken?: string;
      [key: string]: unknown;
    };
    [key: string]: unknown;
  };
  "enrichment.person": {
    source: "live" | "cache";
    data: unknown | null;
    [key: string]: unknown;
  };
  "enrichment.company": {
    source: "live" | "cache";
    data: unknown | null;
    [key: string]: unknown;
  };
  "enrichment.person.contact": Record<string, unknown>;
  "enrichment.profiles.bulk": {
    kind: "people" | "companies";
    records: Array<{
      inputIndex: number;
      /** Dench person/company profile, or null for a genuine miss. No provider-specific IDs or payloads. */
      data: Record<string, unknown> | null;
    }>;
    billing: {
      charged_cents: number;
    };
  };
  "enrichment.company.related": {
    kind: "employees" | "founders" | "funding" | "investors" | "acquisitions" | "investments";
    /** Normalized records for the requested kind; employees include employment, funding includes USD amounts and investors. */
    items: Record<string, unknown>[];
    metadata: {
      total: number;
      nextPageToken?: string;
    };
    billing: {
      charged_cents: number;
    };
  };
  "enrichment.search.preview": {
    count: number;
    source?: "live" | "cache";
  };
  "crm.templates.list": unknown;
  "crm.templates.install": unknown;
  "crm.templates.removeSampleData": unknown;
  "crm.automations.list": unknown;
  "crm.automations.setEnabled": unknown;
  "meetings.list": unknown;
  "meetings.transcript.list": unknown;
  "meetings.transcript.append": unknown;
  "meetings.transcript.clear": unknown;
  "meetings.actionItems.list": unknown;
  "meetings.actionItems.add": unknown;
  "meetings.actionItems.setDone": unknown;
  "meetings.actionItems.delete": unknown;
  "meetings.participants.list": unknown;
  "meetings.participants.set": unknown;
  "meetings.sharing.get": unknown;
  "meetings.sharing.set": unknown;
  "email.identity.verify": {
    ok: boolean;
    identity: string;
    /** Identity scope. `domain` verifies via DNS (DKIM); `email` verifies a single mailbox via a confirmation email. */
    type: "domain" | "email";
    /** Provider identity type, e.g. "DOMAIN" or "EMAIL_ADDRESS". */
    identityType: string | null;
    verifiedForSendingStatus: boolean;
    /** Verification email id (email identities only). */
    messageId?: string | null;
    /** DKIM tokens for DNS records (domain identities). */
    dkimTokens: string[];
    [key: string]: unknown;
  };
  "email.identity.create": {
    identityId: string;
  };
  "email.identity.refresh": {
    identityId: string;
    identity: string;
    /** Provider-side (DNS/mailbox) verification status. */
    deliveryVerificationStatus: "pending" | "verified" | "failed" | "disabled";
    deliveryVerified: boolean;
    domain?: string;
    domainVerified: boolean;
    emailVerified: boolean;
    /** Workspace-side sender verification status. */
    denchVerificationStatus: "pending" | "verified" | "expired" | "disabled";
    disabled: boolean;
    dnsRecords?: {
      /** Record type, e.g. CNAME or TXT. */
      type: string;
      name: string;
      value: string;
      /** Why the record is needed (DKIM/SPF/DMARC). */
      purpose: string;
    }[];
    /** Provider DNS poll info for pending domains. */
    domainVerificationInfo?: {
      errorType?: string;
      lastCheckedAt?: string;
      lastSuccessAt?: string;
    };
    message?: string;
    [key: string]: unknown;
  };
  "email.identity.beginVerification": {
    identityId: string;
    fromEmail: string;
    denchVerificationStatus: "pending" | "verified";
    deliveryVerificationStatus: "pending" | "verified";
    action: "already_verified" | "mailbox_verification_sent" | "domain_dns_ready" | "workspace_verification_sent";
    dkimTokens?: string[];
    dnsRecords?: {
      /** Record type, e.g. CNAME or TXT. */
      type: string;
      name: string;
      value: string;
      /** Why the record is needed (DKIM/SPF/DMARC). */
      purpose: string;
    }[];
    message: string;
  };
  "email.identity.status": {
    ok: boolean;
    identity: string;
    verifiedForSendingStatus: boolean;
    /** Provider status, e.g. "PENDING" | "SUCCESS" | "FAILED". */
    verificationStatus: string;
    /** Provider DKIM attributes (Tokens, Status, ...). */
    dkimAttributes: Record<string, unknown> | null;
    mailFromAttributes: Record<string, unknown> | null;
    verificationInfo: {
      errorType: string | null;
      lastCheckedAt: string | null;
      lastSuccessAt: string | null;
    } | null;
    [key: string]: unknown;
  };
  "email.identity.list": Array<{
    identityId: string;
    /** Identity scope. `domain` verifies via DNS (DKIM); `email` verifies a single mailbox via a confirmation email. */
    type: "domain" | "email";
    domain?: string;
    fromEmail: string;
    fromName?: string;
    /** Provider-side (DNS/mailbox) verification status. */
    deliveryVerificationStatus: "pending" | "verified" | "failed" | "disabled";
    /** Workspace-side sender verification status. */
    denchVerificationStatus: "pending" | "verified" | "expired" | "disabled";
    disabled: boolean;
    disabledAt?: number;
    createdAt: number;
  }>;
  "email.identity.dns": {
    identityId: string;
    identity: string;
    /** Provider-side (DNS/mailbox) verification status. */
    deliveryVerificationStatus: "pending" | "verified" | "failed" | "disabled";
    deliveryVerified: boolean;
    domain?: string;
    domainVerified: boolean;
    emailVerified: boolean;
    /** Workspace-side sender verification status. */
    denchVerificationStatus: "pending" | "verified" | "expired" | "disabled";
    disabled: boolean;
    /** DKIM/SPF/DMARC records to add for a pending domain. */
    dnsRecords?: {
      /** Record type, e.g. CNAME or TXT. */
      type: string;
      name: string;
      value: string;
      /** Why the record is needed (DKIM/SPF/DMARC). */
      purpose: string;
    }[];
    message?: string;
    [key: string]: unknown;
  };
  "email.identity.disable": {
    ok: boolean;
    disabled: {
      identityId: string;
      fromEmail: string;
      domain?: string;
      disabled: boolean;
    }[];
  };
  "email.identity.restore": {
    ok: boolean;
    restored: {
      identityId: string;
      fromEmail: string;
      domain?: string;
      disabled: boolean;
    }[];
  };
  "email.identity.delete": {
    ok: boolean;
    deleted: {
      identityId: string;
      fromEmail: string;
      domain?: string;
      disabled: boolean;
    }[];
  };
  "email.inbox.search": {
    page: Array<{
      messageHandle: string;
      threadHandle: string;
      mailboxId: string;
      from: {
        email: string;
        name?: string;
      };
      to: {
        email: string;
        name?: string;
      }[];
      subject: string;
      at: number;
      dateSource: "sentAt" | "createdAt";
      direction: "inbound" | "outbound";
      status: string;
      hasAttachments: boolean;
      headersTruncated: boolean;
    }>;
    continueCursor: string | null;
    isDone: boolean;
    coverage: {
      source: "synced";
      scope: "mailbox_linked_messages";
      mailboxId: string;
      mailboxEmail: string;
      mailboxStatus: string;
      ingestionMode: string;
      phase: string;
      syncStatus: string | null;
      lastPolledAt: number | null;
      lastBackfillCompletedAt: number | null;
      oldestSeenAt: number | null;
      backfillStatus: string | null;
      backfillCapped: boolean;
      providerComplete: false;
      privacyLimited: boolean;
    };
    order: "sentAt_desc_then_undated";
  };
  "email.inbox.thread": {
    page: Array<{
      messageHandle: string;
      threadHandle: string;
      mailboxId: string;
      from: {
        email: string;
        name?: string;
      };
      to: {
        email: string;
        name?: string;
      }[];
      subject: string;
      at: number;
      dateSource: "sentAt" | "createdAt";
      direction: "inbound" | "outbound";
      status: string;
      hasAttachments: boolean;
      headersTruncated: boolean;
    }>;
    continueCursor: string | null;
    isDone: boolean;
    coverage: {
      source: "synced";
      scope: "mailbox_linked_messages";
      mailboxId: string;
      mailboxEmail: string;
      mailboxStatus: string;
      ingestionMode: string;
      phase: string;
      syncStatus: string | null;
      lastPolledAt: number | null;
      lastBackfillCompletedAt: number | null;
      oldestSeenAt: number | null;
      backfillStatus: string | null;
      backfillCapped: boolean;
      providerComplete: false;
      privacyLimited: boolean;
    };
    order: "sentAt_desc_then_undated";
  };
  "email.inbox.message": {
    header: {
      messageHandle: string;
      threadHandle: string;
      mailboxId: string;
      from: {
        email: string;
        name?: string;
      };
      to: {
        email: string;
        name?: string;
      }[];
      subject: string;
      at: number;
      dateSource: "sentAt" | "createdAt";
      direction: "inbound" | "outbound";
      status: string;
      hasAttachments: boolean;
      headersTruncated: boolean;
    };
    coverage: {
      source: "synced";
      scope: "mailbox_linked_messages";
      mailboxId: string;
      mailboxEmail: string;
      mailboxStatus: string;
      ingestionMode: string;
      phase: string;
      syncStatus: string | null;
      lastPolledAt: number | null;
      lastBackfillCompletedAt: number | null;
      oldestSeenAt: number | null;
      backfillStatus: string | null;
      backfillCapped: boolean;
      providerComplete: false;
      privacyLimited: boolean;
    };
    body: {
      format: "text" | "html";
      content: string;
      truncated: boolean;
      totalBytes: number;
    };
    recipients: {
      to: {
        email: string;
        name?: string;
      }[];
      cc: {
        email: string;
        name?: string;
      }[];
      bcc: {
        email: string;
        name?: string;
      }[];
      truncated: boolean;
    };
  };
  "email.drafts.create": {
    ok: boolean;
    kind: "email";
    draftId: string;
    syncStatus: string;
    revision: number;
    [key: string]: unknown;
  };
  "email.drafts.get": {
    ok: boolean;
    kind: "email";
    draftId: string;
    syncStatus: string;
    revision: number;
    [key: string]: unknown;
  };
  "email.drafts.senders": Record<string, unknown>[];
  "email.drafts.update": {
    ok: boolean;
    kind: "email";
    draftId: string;
    syncStatus: string;
    revision: number;
    [key: string]: unknown;
  };
  "email.drafts.send": {
    ok: boolean;
    kind: "email";
    draftId: string;
    syncStatus: string;
    revision: number;
    [key: string]: unknown;
  };
  "email.drafts.upload": {
    storageId: string;
    name: string;
    contentType: string;
    size: number;
  };
  "email.drafts.signature": Record<string, unknown>;
  "email.native.send": {
    ok: boolean;
    kind: "email";
    draftId: string;
    syncStatus: string;
    revision: number;
    [key: string]: unknown;
  };
  "email.send": {
    ok: boolean;
    /** Dench message id for `dench email message status`. */
    messageId: string;
    providerMessageId: string;
    /** RFC 5322 Message-ID usable for reply threading. */
    rfcMessageId?: string;
    recipients: number;
    status: "sent";
    inReplyTo?: string;
    message: string;
  };
  "email.message.get": {
    messageId: string;
    /** Raw email message lifecycle status. */
    status: "queued" | "sent" | "failed" | "delivered" | "opened" | "clicked" | "bounced" | "complained";
    fromEmail: string;
    fromName?: string;
    to: {
      /** Recipient email address. */
      email: string;
      /** Optional display name. */
      name?: string;
    }[];
    cc?: {
      /** Recipient email address. */
      email: string;
      /** Optional display name. */
      name?: string;
    }[];
    bcc?: {
      /** Recipient email address. */
      email: string;
      /** Optional display name. */
      name?: string;
    }[];
    subject: string;
    inReplyTo?: string;
    references?: string[];
    providerMessageId?: string;
    rfcMessageId?: string;
    recipientCount: number;
    openCount: number;
    clickCount: number;
    sentAt?: number;
    deliveredAt?: number;
    firstOpenedAt?: number;
    lastOpenedAt?: number;
    firstClickedAt?: number;
    bouncedAt?: number;
    complainedAt?: number;
    lastError?: string;
    createdAt: number;
  };
  "email.message.list": Array<{
    messageId: string;
    /** Raw email message lifecycle status. */
    status: "queued" | "sent" | "failed" | "delivered" | "opened" | "clicked" | "bounced" | "complained";
    fromEmail: string;
    fromName?: string;
    to: {
      /** Recipient email address. */
      email: string;
      /** Optional display name. */
      name?: string;
    }[];
    cc?: {
      /** Recipient email address. */
      email: string;
      /** Optional display name. */
      name?: string;
    }[];
    bcc?: {
      /** Recipient email address. */
      email: string;
      /** Optional display name. */
      name?: string;
    }[];
    subject: string;
    inReplyTo?: string;
    references?: string[];
    providerMessageId?: string;
    rfcMessageId?: string;
    recipientCount: number;
    openCount: number;
    clickCount: number;
    sentAt?: number;
    deliveredAt?: number;
    firstOpenedAt?: number;
    lastOpenedAt?: number;
    firstClickedAt?: number;
    bouncedAt?: number;
    complainedAt?: number;
    lastError?: string;
    createdAt: number;
  }>;
  "email.template.create": {
    templateId: string;
  };
  "email.template.preview": {
    subject: string;
    htmlBody: string;
    textBody?: string;
    variableNames: string[];
  };
  "email.campaign.create": {
    campaignId: string;
  };
  "email.campaign.get": {
    _id: string;
    _creationTime: number;
    organizationId: string;
    name: string;
    /** Campaign lifecycle status. */
    status: "draft" | "pending_approval" | "scheduled" | "sending" | "paused" | "completed" | "cancelled" | "failed";
    sendingIdentityId: string;
    templateId: string;
    subjectSnapshot: string;
    htmlSnapshot: string;
    textSnapshot?: string;
    fromEmailSnapshot: string;
    fromNameSnapshot?: string;
    replyToEmailSnapshot?: string;
    scheduledAt?: number;
    submittedAt?: number;
    startedAt?: number;
    completedAt?: number;
    cancelledAt?: number;
    createdBy: string;
    totalRecipients: number;
    queuedCount: number;
    sendingCount: number;
    sentCount: number;
    deliveredCount: number;
    openedCount: number;
    clickedCount: number;
    bouncedCount: number;
    complainedCount: number;
    failedCount: number;
    suppressedCount: number;
    unsubscribedCount: number;
    maxRecipients: number;
    batchSize: number;
    lastError?: string;
    createdAt: number;
    updatedAt: number;
    [key: string]: unknown;
  };
  "email.campaign.recipients.add": {
    added: number;
    duplicates: number;
    suppressed: number;
    invalid: number;
    totalRecipients: number;
  };
  "email.campaign.preview": {
    campaignId: string;
    previews: {
      recipientId: string;
      to: string;
      subject: string;
      htmlBody: string;
      textBody?: string;
    }[];
  };
  "email.campaign.submit": {
    ok: boolean;
    summary: {
      campaignId: string;
      /** Campaign lifecycle status. */
      status: "draft" | "pending_approval" | "scheduled" | "sending" | "paused" | "completed" | "cancelled" | "failed";
      totalRecipients: number;
      queuedCount: number;
      sendingCount: number;
      sentCount: number;
      deliveredCount: number;
      openedCount: number;
      clickedCount: number;
      bouncedCount: number;
      complainedCount: number;
      failedCount: number;
      suppressedCount: number;
      unsubscribedCount: number;
    };
  };
  "email.campaign.pause": {
    campaignId: string;
    /** Campaign lifecycle status. */
    status: "draft" | "pending_approval" | "scheduled" | "sending" | "paused" | "completed" | "cancelled" | "failed";
    totalRecipients: number;
    queuedCount: number;
    sendingCount: number;
    sentCount: number;
    deliveredCount: number;
    openedCount: number;
    clickedCount: number;
    bouncedCount: number;
    complainedCount: number;
    failedCount: number;
    suppressedCount: number;
    unsubscribedCount: number;
  };
  "email.campaign.resume": {
    campaignId: string;
    /** Campaign lifecycle status. */
    status: "draft" | "pending_approval" | "scheduled" | "sending" | "paused" | "completed" | "cancelled" | "failed";
    totalRecipients: number;
    queuedCount: number;
    sendingCount: number;
    sentCount: number;
    deliveredCount: number;
    openedCount: number;
    clickedCount: number;
    bouncedCount: number;
    complainedCount: number;
    failedCount: number;
    suppressedCount: number;
    unsubscribedCount: number;
  };
  "email.campaign.cancel": {
    campaignId: string;
    /** Campaign lifecycle status. */
    status: "draft" | "pending_approval" | "scheduled" | "sending" | "paused" | "completed" | "cancelled" | "failed";
    totalRecipients: number;
    queuedCount: number;
    sendingCount: number;
    sentCount: number;
    deliveredCount: number;
    openedCount: number;
    clickedCount: number;
    bouncedCount: number;
    complainedCount: number;
    failedCount: number;
    suppressedCount: number;
    unsubscribedCount: number;
  };
  "email.campaign.list": unknown;
  "email.campaign.recipients.list": unknown;
  "email.campaign.recipients.addFromObject": unknown;
  "email.sequence.create": unknown;
  "email.sequence.update": unknown;
  "email.sequence.activate": unknown;
  "email.sequence.deactivate": unknown;
  "email.sequence.archive": unknown;
  "email.sequence.list": unknown;
  "email.sequence.get": unknown;
  "email.sequence.step.add": unknown;
  "email.sequence.step.update": unknown;
  "email.sequence.step.remove": unknown;
  "email.sequence.step.reorder": unknown;
  "email.sequence.enroll": unknown;
  "email.sequence.enrollFromObject": unknown;
  "email.sequence.enrollments.list": unknown;
  "email.sequence.enrollment.pause": unknown;
  "email.sequence.enrollment.resume": unknown;
  "email.sequence.enrollment.stop": unknown;
  "campaigns.accounts.linkedin": Array<{
    /** Local sender id for linkedinAccountIds, never a provider credential. */
    linkedinAccountId: string;
    displayName: string;
    status: "running" | "paused" | "disconnected" | "errored";
    ownerName: string;
    isOwner: boolean;
    visibility: "private" | "shared";
    remainingToday: {
      /** Daily capacity, also bounded by the rolling weekly invite limit. */
      invites: number;
      messages: number;
      profiles: number;
    };
    remainingInvitesThisWeek: number;
    /** Account availability snapshot. Queued work, campaign limits and launch/dispatch checks still apply. */
    availability: "ready" | "paused" | "disconnected" | "errored" | "disabled" | "circuit_break" | "spacing" | "outside_window" | "daily_cap";
  }>;
  "campaigns.accounts.email": Array<{
    /** The emailMailboxAccountId to put in emailMailboxAccountIds. */
    _id: string;
    email: string;
    provider: "gmail" | "outlook";
    status: "running" | "disconnected" | "errored";
    statusReason?: string;
    /** ready or skipped: sends at its cap. warming: sends less until readyAt. pending_auth and error need the owner in the app. */
    warmupStatus: "skipped" | "pending_auth" | "warming" | "ready" | "error";
    /** When warm-up finished, or is expected to finish while warming (epoch ms). */
    readyAt?: number;
    /** The most cold emails a day; the mailbox owner sets it in the app. */
    dailyColdSendCap: number;
    /** Cold emails it can still send today. */
    remainingToday: number;
    ownerName: string;
    isOwner: boolean;
    visibility: "private" | "shared";
    [key: string]: unknown;
  }>;
  "campaigns.list": Array<{
    _id: string;
    name: string;
    /** Campaign lifecycle status. */
    status: "draft" | "active" | "paused" | "completed" | "archived";
    stopOnReply: boolean;
    /** Campaign email sender pool: up to 50 emailMailboxAccounts ids both you and the campaign owner may use. Omit to preserve existing configuration; [] clears the pool. A person's sender stays fixed for their conversation. Launch validates sender availability. */
    emailMailboxAccountIds?: string[];
    /** Campaign LinkedIn sender pool: up to 50 linkedinAccounts ids both you and the campaign owner may use. Omit to preserve existing configuration; [] clears the pool. Legacy step senders remain until a pool is configured. */
    linkedinAccountIds?: string[];
    timezone?: string;
    startsAt?: number;
    endsAt?: number;
    sendSchedules?: {
      /** Label, e.g. "Mon-Fri 9-18". */
      name: string;
      /** IANA timezone, e.g. America/Los_Angeles. */
      timezone: string;
      /** First hour sends may go out (0-23). */
      startHour: number;
      /** Hour sends stop (1-24); must be after startHour. */
      endHour: number;
      /** Days sends may go out: 0 = Sunday ... 6 = Saturday. */
      weekdays: number[];
    }[];
    dailySendCap?: number;
    stepCount: number;
    /** linear: steps run in order. workflow: steps have keys and paths (next, yesNext, noNext) and may include condition and wait_for_connection. Left out, a workflow stays one and steps with keys, paths or those types make one; nothing turns a workflow back into a list. */
    stepModel?: "linear" | "workflow";
    totalEnrolled: number;
    activeCount: number;
    pausedCount: number;
    finishedCount: number;
    repliedCount: number;
    failedCount: number;
    stoppedCount: number;
    launchedAt?: number;
    ownerName?: string;
    isOwner?: boolean;
    createdAt: number;
    updatedAt: number;
    [key: string]: unknown;
  }> | {
    data: Array<{
      _id: string;
      name: string;
      /** Campaign lifecycle status. */
      status: "draft" | "active" | "paused" | "completed" | "archived";
      stopOnReply: boolean;
      /** Campaign email sender pool: up to 50 emailMailboxAccounts ids both you and the campaign owner may use. Omit to preserve existing configuration; [] clears the pool. A person's sender stays fixed for their conversation. Launch validates sender availability. */
      emailMailboxAccountIds?: string[];
      /** Campaign LinkedIn sender pool: up to 50 linkedinAccounts ids both you and the campaign owner may use. Omit to preserve existing configuration; [] clears the pool. Legacy step senders remain until a pool is configured. */
      linkedinAccountIds?: string[];
      timezone?: string;
      startsAt?: number;
      endsAt?: number;
      sendSchedules?: {
        /** Label, e.g. "Mon-Fri 9-18". */
        name: string;
        /** IANA timezone, e.g. America/Los_Angeles. */
        timezone: string;
        /** First hour sends may go out (0-23). */
        startHour: number;
        /** Hour sends stop (1-24); must be after startHour. */
        endHour: number;
        /** Days sends may go out: 0 = Sunday ... 6 = Saturday. */
        weekdays: number[];
      }[];
      dailySendCap?: number;
      stepCount: number;
      /** linear: steps run in order. workflow: steps have keys and paths (next, yesNext, noNext) and may include condition and wait_for_connection. Left out, a workflow stays one and steps with keys, paths or those types make one; nothing turns a workflow back into a list. */
      stepModel?: "linear" | "workflow";
      totalEnrolled: number;
      activeCount: number;
      pausedCount: number;
      finishedCount: number;
      repliedCount: number;
      failedCount: number;
      stoppedCount: number;
      launchedAt?: number;
      ownerName?: string;
      isOwner?: boolean;
      createdAt: number;
      updatedAt: number;
      [key: string]: unknown;
    }>;
    references: Array<{
      kind: "crm-entry";
      objectName: string;
      entryId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "crm-object";
      objectName: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "campaign";
      sequenceId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    }>;
    referenceCoverage: {
      returned: number;
      available: number;
      truncated: boolean;
    };
  };
  "campaigns.create": {
    sequenceId: string;
    references?: Array<{
      kind: "crm-entry";
      objectName: string;
      entryId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "crm-object";
      objectName: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "campaign";
      sequenceId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    }>;
    referenceCoverage?: {
      returned: number;
      available: number;
      truncated: boolean;
    };
  };
  "campaigns.duplicate": {
    references?: Array<{
      kind: "crm-entry";
      objectName: string;
      entryId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "crm-object";
      objectName: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "campaign";
      sequenceId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    }>;
    referenceCoverage?: {
      returned: number;
      available: number;
      truncated: boolean;
    };
    /** The new draft. Rename it with campaigns.update. */
    sequenceId: string;
  };
  "campaigns.get": {
    references?: Array<{
      kind: "crm-entry";
      objectName: string;
      entryId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "crm-object";
      objectName: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    } | {
      kind: "campaign";
      sequenceId: string;
      label: string;
      href: string;
      url?: string;
      imageUrl?: string;
      objectIcon?: string;
    }>;
    referenceCoverage?: {
      returned: number;
      available: number;
      truncated: boolean;
    };
    sequence: {
      _id: string;
      name: string;
      /** Campaign lifecycle status. */
      status: "draft" | "active" | "paused" | "completed" | "archived";
      stopOnReply: boolean;
      /** Campaign email sender pool: up to 50 emailMailboxAccounts ids both you and the campaign owner may use. Omit to preserve existing configuration; [] clears the pool. A person's sender stays fixed for their conversation. Launch validates sender availability. */
      emailMailboxAccountIds?: string[];
      /** Campaign LinkedIn sender pool: up to 50 linkedinAccounts ids both you and the campaign owner may use. Omit to preserve existing configuration; [] clears the pool. Legacy step senders remain until a pool is configured. */
      linkedinAccountIds?: string[];
      timezone?: string;
      startsAt?: number;
      endsAt?: number;
      sendSchedules?: {
        /** Label, e.g. "Mon-Fri 9-18". */
        name: string;
        /** IANA timezone, e.g. America/Los_Angeles. */
        timezone: string;
        /** First hour sends may go out (0-23). */
        startHour: number;
        /** Hour sends stop (1-24); must be after startHour. */
        endHour: number;
        /** Days sends may go out: 0 = Sunday ... 6 = Saturday. */
        weekdays: number[];
      }[];
      dailySendCap?: number;
      stepCount: number;
      /** linear: steps run in order. workflow: steps have keys and paths (next, yesNext, noNext) and may include condition and wait_for_connection. Left out, a workflow stays one and steps with keys, paths or those types make one; nothing turns a workflow back into a list. */
      stepModel?: "linear" | "workflow";
      totalEnrolled: number;
      activeCount: number;
      pausedCount: number;
      finishedCount: number;
      repliedCount: number;
      failedCount: number;
      stoppedCount: number;
      launchedAt?: number;
      ownerName?: string;
      isOwner?: boolean;
      createdAt: number;
      updatedAt: number;
      [key: string]: unknown;
    };
    /** The steps in order, each with its _id. condition and wait_for_connection steps also carry a readable label. */
    steps: Array<{
      /** Step type. condition (If / else) and wait_for_connection (Wait for them to accept) send nothing; they continue on yesNext or noNext and make the campaign a workflow. */
      type: "wait" | "email" | "linkedin_connection" | "linkedin_message" | "linkedin_visit" | "linkedin_like_post" | "linkedin_inmail" | "condition" | "wait_for_connection";
      /** wait steps: hours to wait before the next step. */
      waitHours?: number;
      /** Legacy email step sender. Pool campaigns choose senders in emailMailboxAccountIds on the campaign, not on individual steps. */
      emailMailboxAccountId?: string;
      /** email steps: subject; {{Column}} merge tokens allowed. */
      emailSubject?: string;
      /** email steps: HTML body. Sent instead of emailTextBody when both are set, so when you edit the text, update or drop this too. */
      emailHtmlBody?: string;
      /** email steps: plain-text body; used as the email when there is no emailHtmlBody. */
      emailTextBody?: string;
      /** email steps: thread under the previous email step instead of a new subject. */
      emailReplyToPrevious?: boolean;
      /** email and linkedin_like_post only: always (default), connected or not_connected. InMail automatically skips connected people; do not set a condition on it. */
      onlyIf?: "always" | "connected" | "not_connected";
      /** Legacy LinkedIn step sender (also on wait_for_connection, and on a condition that checks linkedin_connected). Pool campaigns use the campaign's linkedinAccountIds instead. */
      linkedinAccountId?: string;
      /** linkedin_connection: the invite note (optional, up to 300 chars; sent without it if LinkedIn refuses the note); linkedin_message: the required message (up to 3000 chars); linkedin_inmail: the required message (up to 1900 chars). */
      linkedinMessageBody?: string;
      /** linkedin_message: what to do when the invite is still pending. */
      linkedinMessageMode?: "skip_if_not_connected" | "wait_until_connected";
      /** linkedin_message with linkedinMessageMode=wait_until_connected: wait 1-2160 hours for acceptance (default 720); after a connection step this mode is the default in a linear campaign. wait_for_connection: wait 24-2160 hours (1-90 days, default 720) before taking the Not accepted path. */
      connectionTimeoutHours?: number;
      /** linkedin_like_post only: the reaction to leave (default like). */
      likeReaction?: "like" | "celebrate" | "support" | "love" | "insightful" | "funny";
      /** linkedin_like_post only: select the newest eligible original post from the last 1-365 days (default 30). */
      likeMaxPostAgeDays?: number;
      /** linkedin_like_post only: before the immediately preceding wait starts, check for eligible posts. If none exist, skip that wait and the like step, keeping following waits. Defaults to false when omitted. */
      likeSkipPreviousWait?: boolean;
      /** linkedin_like_post only: skip consecutive following wait steps whenever the reaction step is skipped (default true). False keeps those waits. */
      likeSkipNextWait?: boolean;
      /** linkedin_like_post only: how many recent posts to react to, 1-3 (default 1). */
      likeCount?: number;
      /** linkedin_inmail only: optional subject, up to 200 characters; merge tokens allowed. Clear with an empty string. */
      inmailSubject?: string;
      /** linkedin_connection only: withdraw a still-pending invitation sent by this campaign after 168-2160 hours (7-90 days). Omitted means off on creation; null turns it off on edit. */
      withdrawAfterHours?: number | null;
      /** Workflow steps: this step's id, unique in the campaign, which next, yesNext and noNext point at (not "end"). Left out, one is made. */
      key?: string;
      /** Workflow steps: where a step that isn't a condition or wait_for_connection goes; left out, the following step: another step's key, or "end" to stop there. Fixed once the campaign launches. */
      next?: string;
      /** Workflow steps: condition and wait_for_connection only, required: where the Yes (Accepted) path goes: another step's key, or "end" to stop there. Fixed once the campaign launches. */
      yesNext?: string;
      /** Workflow steps: condition and wait_for_connection only, required: where the No (Not accepted) path goes: another step's key, or "end" to stop there. Fixed once the campaign launches. */
      noNext?: string;
      /** condition only, required: linkedin_connected, has_email, opened_last_email (needs an email before it on every path) or field_value. Fixed once the campaign launches. */
      check?: "linkedin_connected" | "has_email" | "opened_last_email" | "field_value";
      /** condition with check=field_value: the lead field to check, like "Job Title" or "Source" (the campaign itself changes Status, Last touch and LinkedIn connection). Fixed once the campaign launches. */
      conditionField?: string;
      /** condition with check=field_value: is, is_not, contains, is_empty or is_not_empty (all case-insensitive). Fixed once the campaign launches. */
      conditionOperator?: "is" | "is_not" | "is_empty" | "is_not_empty" | "contains";
      /** condition with check=field_value and is, is_not or contains: the text to compare with. Editable after launch. */
      conditionValue?: string;
      [key: string]: unknown;
    }>;
    enrollments: Record<string, unknown>[];
    /** enrollmentId -> the step run in progress, its hold and LinkedIn action. */
    currentRuns: Record<string, unknown>;
    lastTouches: Record<string, {
      type: string;
      at: number;
    }>;
    /** enrollmentId -> linked CRM record and lead status. */
    connectedEntries: Record<string, unknown>;
    connectedFieldNames: string[];
    isOwner: boolean;
    [key: string]: unknown;
  } | null;
  "campaigns.analytics": {
    audience: number;
    contacted: number;
    linkedinInvited: number;
    linkedinConnected: number;
    linkedinMessaged: number;
    linkedinReplied: number;
    active: number;
    paused: number;
    finished: number;
    replied: number;
    failed: number;
    stopped: number;
    emailSent: number;
    opened: number;
    clicked: number;
    linkedinSent: number;
    replyRate: number;
    openRate: number;
    clickRate: number;
    /** Workflows only: each condition and wait_for_connection step, in step order, with how many people took each path. */
    branchStats?: {
      stepId: string;
      /** People who took the Yes (Accepted) path. */
      yes: number;
      /** People who took the No (Not accepted) path. */
      no: number;
    }[];
    truncated: boolean;
    [key: string]: unknown;
  };
  "campaigns.live": {
    /** Campaign lifecycle status. */
    status: "draft" | "active" | "paused" | "completed" | "archived";
    usesEmail: boolean;
    usesLinkedin: boolean;
    emailsToday: number;
    dailySendCap: number | null;
    nextEmailAt: number | null;
    now: Record<string, unknown> | null;
    next: {
      /** profile, visit, invite, message, like, inmail, withdraw, email, wait or check (an If / else). */
      kind: string;
      /** Waiting for them to accept: when the wait ends either way. */
      acceptanceDeadline?: number;
      /** kind check: what the If / else checks, e.g. "Has an email address". */
      label?: string;
      [key: string]: unknown;
    } | null;
    paused: Record<string, unknown> | null;
    senders: Record<string, unknown>[];
    [key: string]: unknown;
  };
  "campaigns.pipeline": {
    /** People in the campaign. */
    total: number;
    /** The workspace's lead Statuses, in pipeline order. */
    statuses: {
      /** A lead Status, as named in the CRM. */
      name: string;
      color: string;
      /** Enrolled leads at this Status. */
      count: number;
    }[];
    /** People with no lead, or a Status outside the pipeline. */
    other: number;
  } | null;
  "campaigns.update": {
    ok: boolean;
  };
  "campaigns.steps.replace": {
    ok: boolean;
    stepCount: number;
  };
  "campaigns.steps.update": {
    ok: boolean;
    /** How many steps were edited. */
    stepCount: number;
  };
  "campaigns.personalization.get": {
    template: {
      variables: {
        /** The {{key}} used in steps: a letter, then letters, digits or _ (up to 40). Not a built-in field like firstName or company. */
        key: string;
        /** The line's name, up to 60 characters. */
        label: string;
        /** What the writer should say, up to 600 characters. */
        prompt: string;
        /** Sent when there is nothing specific to say; up to 300 characters, no {{variables}}. */
        fallback: string;
        /** A field to use before the fallback, e.g. Company. */
        fallbackFrom?: string;
        /** The longest line, default 200 characters. */
        maxChars?: number;
      }[];
      context: {
        /** What you sell, up to 1000 characters. */
        sells: string;
        /** The offer or call to action, up to 300 characters. */
        offer?: string;
      };
      version: number;
      updatedAt: number;
      [key: string]: unknown;
    } | null;
    counts: {
      done: number;
      pending: number;
      failed: number;
      total: number;
    };
    paused: boolean;
    notice: {
      code: "insufficient_credits";
      at: number;
    } | null;
    suggestedContext: {
      sells?: string;
    };
    estimatedCentsPerPerson: number;
    eligible: number;
    [key: string]: unknown;
  };
  "campaigns.personalization.set": {
    version: number;
    /** People who would get a line. */
    eligible: number;
    /** About 3 cents a person. */
    estimatedCents: number;
    /** True when nothing was written: confirm with campaigns.personalization.write and confirmed: true. */
    needsConfirm: boolean;
    /** People whose lines are being written now. */
    queued: number;
  };
  "campaigns.personalization.clear": {
    version: number;
    /** People who would get a line. */
    eligible: number;
    /** About 3 cents a person. */
    estimatedCents: number;
    /** True when nothing was written: confirm with campaigns.personalization.write and confirmed: true. */
    needsConfirm: boolean;
    /** People whose lines are being written now. */
    queued: number;
  };
  "campaigns.personalization.write": {
    version: number;
    /** People who would get a line. */
    eligible: number;
    /** About 3 cents a person. */
    estimatedCents: number;
    /** True when nothing was written: confirm with campaigns.personalization.write and confirmed: true. */
    needsConfirm: boolean;
    /** People whose lines are being written now. */
    queued: number;
  };
  "campaigns.personalization.edit": {
    ok: boolean;
  };
  "campaigns.personalization.rewrite": {
    /** False when new lines are already being written. */
    queued: boolean;
  };
  "campaigns.people.addFromCrm": {
    added: number;
    requested: number;
    /** The campaign's people cap when it cut the batch short (300), else null. */
    cappedAtLimit: number | null;
    /** Already in this campaign. */
    duplicates: number;
    /** Duplicates that gained a missing email or LinkedIn URL. */
    merged: number;
    /** Active in another campaign; skipped unless checkDuplicatesAcrossWorkspace is false. */
    duplicatesElsewhere: number;
    suppressed: number;
    invalid: number;
    /** No usable email or LinkedIn URL on the record. */
    skippedNoIdentity: number;
    skippedSample: number;
    /** Launched campaigns only: a merge token the steps use is empty for them. */
    skippedMissingInfo: number;
    missingInfoSample?: {
      displayName?: string;
      missingKeys: string[];
    };
  };
  "campaigns.people.add": {
    enrollmentId: string;
  };
  "campaigns.preview": {
    channel: "email" | "linkedin";
    /** Email steps. */
    subject?: string;
    /** Email steps: plain text. */
    textBody?: string;
    /** Email steps: HTML. */
    htmlBody?: string;
    /** LinkedIn steps: the note or message, or a line saying no note or message is sent. */
    messageBody?: string;
    /** The sending account. */
    fromName?: string;
    fromEmail?: string;
    toName: string;
    toEmail?: string;
    /** {{merge fields}} this person has no value for; fill them with campaigns.people.setField. */
    missingFields: string[];
    warnings: string[];
    /** Set when the person would skip this step, e.g. no email address. */
    skippedReason?: string;
    highlights?: string[];
    personalized?: Array<{
      /** The line's {{key}}. */
      key: string;
      label: string;
      /** What this person gets: the written line, or the fallback. */
      value: string;
      /** written or edited: the line is final. fallback: nothing specific was found, so the fallback is used. writing, paused and not_written: the fallback shows until the line is written. */
      state: "written" | "edited" | "writing" | "paused" | "fallback" | "not_written";
      /** What the line was written from. */
      source?: "company" | "news" | "signal" | "profile" | "fallback";
      maxChars: number;
      /** A new line is being written over the current one. */
      rewriting?: "writing" | "paused";
      [key: string]: unknown;
    }>;
    [key: string]: unknown;
  };
  "campaigns.launch.preview": {
    ready: boolean;
    /** Pass this to `launch`; it changes whenever the campaign changes. */
    fingerprint: string;
    blockingReasons: string[];
    blockers: Array<{
      code: string;
      scope: "sequence" | "step" | "person";
      target: "sequence" | "people" | "schedule";
      title: string;
      hint?: string;
      stepIndex?: number;
      people: {
        enrollmentId?: string;
        name: string;
      }[];
      count: number;
      [key: string]: unknown;
    }>;
    warnings: string[];
    stepCount: number;
    audienceCount: number;
    usesEmail: boolean;
    usesLinkedin: boolean;
    [key: string]: unknown;
  };
  "campaigns.launch": {
    ok: boolean;
    status: "active";
  };
  "campaigns.pause": {
    ok: boolean;
  };
  "campaigns.resume": {
    ok: boolean;
  };
  "campaigns.archive": {
    ok: boolean;
  };
  "campaigns.events": {
    page: Record<string, unknown>[];
    isDone: boolean;
    continueCursor: string;
    [key: string]: unknown;
  };
  "campaigns.people.stop": {
    ok: boolean;
  };
  "campaigns.people.resume": {
    ok: boolean;
  };
  "campaigns.people.setEmail": {
    ok: boolean;
  };
  "campaigns.people.setLinkedin": {
    ok: boolean;
  };
  "campaigns.people.setField": {
    ok: boolean;
  };
  "campaigns.people.resumeAll": {
    /** How many paused people were resumed. */
    resumed: number;
  };
  "campaigns.people.sync": {
    /** How many people gained a detail from their CRM record. */
    updated: number;
  };
  "campaigns.people.forRecord": Array<{
    /** The person in that campaign: _id, sequenceId, status, currentStepIndex, repliedAt. */
    enrollment: Record<string, unknown>;
    sequenceName: string;
    isOwner: boolean;
    canManage: boolean;
    /** The accounts that send to this person. */
    senders: {
      email: {
        accountId: string;
        /** The mailbox address or LinkedIn name. */
        label: string;
        status: string;
      } | null;
      linkedin: {
        accountId: string;
        /** The mailbox address or LinkedIn name. */
        label: string;
        status: string;
      } | null;
    };
    [key: string]: unknown;
  }>;
  "campaigns.people.timeline": {
    /** The person in this campaign: status, lastError, repliedAt. */
    enrollment: Record<string, unknown>;
    sequence: Record<string, unknown> | null;
    /** The campaign's steps in order, each with its _id. */
    steps: Array<{
      /** Step type. condition (If / else) and wait_for_connection (Wait for them to accept) send nothing; they continue on yesNext or noNext and make the campaign a workflow. */
      type: "wait" | "email" | "linkedin_connection" | "linkedin_message" | "linkedin_visit" | "linkedin_like_post" | "linkedin_inmail" | "condition" | "wait_for_connection";
      /** wait steps: hours to wait before the next step. */
      waitHours?: number;
      /** Legacy email step sender. Pool campaigns choose senders in emailMailboxAccountIds on the campaign, not on individual steps. */
      emailMailboxAccountId?: string;
      /** email steps: subject; {{Column}} merge tokens allowed. */
      emailSubject?: string;
      /** email steps: HTML body. Sent instead of emailTextBody when both are set, so when you edit the text, update or drop this too. */
      emailHtmlBody?: string;
      /** email steps: plain-text body; used as the email when there is no emailHtmlBody. */
      emailTextBody?: string;
      /** email steps: thread under the previous email step instead of a new subject. */
      emailReplyToPrevious?: boolean;
      /** email and linkedin_like_post only: always (default), connected or not_connected. InMail automatically skips connected people; do not set a condition on it. */
      onlyIf?: "always" | "connected" | "not_connected";
      /** Legacy LinkedIn step sender (also on wait_for_connection, and on a condition that checks linkedin_connected). Pool campaigns use the campaign's linkedinAccountIds instead. */
      linkedinAccountId?: string;
      /** linkedin_connection: the invite note (optional, up to 300 chars; sent without it if LinkedIn refuses the note); linkedin_message: the required message (up to 3000 chars); linkedin_inmail: the required message (up to 1900 chars). */
      linkedinMessageBody?: string;
      /** linkedin_message: what to do when the invite is still pending. */
      linkedinMessageMode?: "skip_if_not_connected" | "wait_until_connected";
      /** linkedin_message with linkedinMessageMode=wait_until_connected: wait 1-2160 hours for acceptance (default 720); after a connection step this mode is the default in a linear campaign. wait_for_connection: wait 24-2160 hours (1-90 days, default 720) before taking the Not accepted path. */
      connectionTimeoutHours?: number;
      /** linkedin_like_post only: the reaction to leave (default like). */
      likeReaction?: "like" | "celebrate" | "support" | "love" | "insightful" | "funny";
      /** linkedin_like_post only: select the newest eligible original post from the last 1-365 days (default 30). */
      likeMaxPostAgeDays?: number;
      /** linkedin_like_post only: before the immediately preceding wait starts, check for eligible posts. If none exist, skip that wait and the like step, keeping following waits. Defaults to false when omitted. */
      likeSkipPreviousWait?: boolean;
      /** linkedin_like_post only: skip consecutive following wait steps whenever the reaction step is skipped (default true). False keeps those waits. */
      likeSkipNextWait?: boolean;
      /** linkedin_like_post only: how many recent posts to react to, 1-3 (default 1). */
      likeCount?: number;
      /** linkedin_inmail only: optional subject, up to 200 characters; merge tokens allowed. Clear with an empty string. */
      inmailSubject?: string;
      /** linkedin_connection only: withdraw a still-pending invitation sent by this campaign after 168-2160 hours (7-90 days). Omitted means off on creation; null turns it off on edit. */
      withdrawAfterHours?: number | null;
      /** Workflow steps: this step's id, unique in the campaign, which next, yesNext and noNext point at (not "end"). Left out, one is made. */
      key?: string;
      /** Workflow steps: where a step that isn't a condition or wait_for_connection goes; left out, the following step: another step's key, or "end" to stop there. Fixed once the campaign launches. */
      next?: string;
      /** Workflow steps: condition and wait_for_connection only, required: where the Yes (Accepted) path goes: another step's key, or "end" to stop there. Fixed once the campaign launches. */
      yesNext?: string;
      /** Workflow steps: condition and wait_for_connection only, required: where the No (Not accepted) path goes: another step's key, or "end" to stop there. Fixed once the campaign launches. */
      noNext?: string;
      /** condition only, required: linkedin_connected, has_email, opened_last_email (needs an email before it on every path) or field_value. Fixed once the campaign launches. */
      check?: "linkedin_connected" | "has_email" | "opened_last_email" | "field_value";
      /** condition with check=field_value: the lead field to check, like "Job Title" or "Source" (the campaign itself changes Status, Last touch and LinkedIn connection). Fixed once the campaign launches. */
      conditionField?: string;
      /** condition with check=field_value: is, is_not, contains, is_empty or is_not_empty (all case-insensitive). Fixed once the campaign launches. */
      conditionOperator?: "is" | "is_not" | "is_empty" | "is_not_empty" | "contains";
      /** condition with check=field_value and is, is_not or contains: the text to compare with. Editable after launch. */
      conditionValue?: string;
      [key: string]: unknown;
    }>;
    /** One run for each step the person has reached, in order. */
    runs: Array<{
      _id: string;
      /** The step's _id, as in steps[]. */
      stepId: string;
      /** The step's place, from 0. */
      stepIndex: number;
      /** Step type. condition (If / else) and wait_for_connection (Wait for them to accept) send nothing; they continue on yesNext or noNext and make the campaign a workflow. */
      type: "wait" | "email" | "linkedin_connection" | "linkedin_message" | "linkedin_visit" | "linkedin_like_post" | "linkedin_inmail" | "condition" | "wait_for_connection";
      /** sent: done (a wait that finished is sent too). skipped: see result.reason. retry: will be tried again at retryAt. unknown: needs a look. */
      status: "queued" | "running" | "waiting" | "retry" | "sent" | "skipped" | "failed" | "unknown";
      scheduledAt?: number;
      startedAt?: number;
      waitUntil?: number;
      retryAt?: number;
      completedAt?: number;
      /** The email this run sent, in emailMessages[]. */
      emailMessageId?: string;
      lastError?: string;
      /** wait_for_connection: when it stops waiting for the accept. */
      timeoutAt?: number;
      /** For a skipped step, { reason } says why. A finished condition or wait_for_connection has { branch: "yes" | "no" } (Yes / Accepted or No / Not accepted), and { reason } for some No paths. */
      result?: unknown;
      [key: string]: unknown;
    }>;
    /** The emails those runs sent: subject, textBody, status, sentAt, firstOpenedAt, firstClickedAt. */
    emailMessages: Record<string, unknown>[];
    /** The LinkedIn messages those runs sent: text, sentAt, deliveredAt, readAt, outreachStepRunId. */
    linkedinMessages: Record<string, unknown>[];
    [key: string]: unknown;
  };
  "campaigns.people.remove": {
    ok: boolean;
  };
  "cron.list": {
    jobs: Array<{
      id: string;
      name: string;
      description?: string;
      enabled: boolean;
      deleteAfterRun: boolean;
      createdAtMs: number;
      updatedAtMs: number;
      /** Schedule: recurring (`every`), cron expression, or one-shot (`at`). */
      schedule?: {
        kind: "every";
        /** Interval in milliseconds (1s to 365d). */
        everyMs: number;
        /** Optional anchor timestamp for the recurring fire. */
        anchorMs?: number;
      } | {
        kind: "cron";
        /** 5-field POSIX cron expression. */
        expr: string;
        /** IANA timezone, e.g. America/New_York. */
        tz?: string;
      } | {
        kind: "at";
        /** ISO 8601 timestamp for a one-shot run. */
        at: string;
      };
      sessionTarget: string;
      wakeMode: string;
      payload: {
        kind: "agentTurn";
        message: string;
      } | {
        kind: "systemEvent";
        text: string;
      };
      state: {
        nextRunAtMs?: number;
        runningAtMs?: number;
        lastRunAtMs?: number;
        lastStatus?: "ok" | "error" | "skipped";
        lastError?: string;
        lastDurationMs?: number;
      };
      [key: string]: unknown;
    }>;
    cronStatus: {
      enabled: boolean;
      nextWakeAtMs: number | null;
    };
  };
  "cron.history": {
    entries: Array<{
      ts: number;
      jobId: string;
      action: string;
      status?: "ok" | "error" | "skipped" | "running";
      error?: string;
      summary?: string;
      sessionId?: string;
      runAtMs?: number;
      durationMs?: number;
      nextRunAtMs?: number;
      [key: string]: unknown;
    }>;
  };
  "cron.get": {
    id: string;
    name: string;
    description?: string;
    enabled: boolean;
    deleteAfterRun: boolean;
    createdAtMs: number;
    updatedAtMs: number;
    /** Schedule: recurring (`every`), cron expression, or one-shot (`at`). */
    schedule?: {
      kind: "every";
      /** Interval in milliseconds (1s to 365d). */
      everyMs: number;
      /** Optional anchor timestamp for the recurring fire. */
      anchorMs?: number;
    } | {
      kind: "cron";
      /** 5-field POSIX cron expression. */
      expr: string;
      /** IANA timezone, e.g. America/New_York. */
      tz?: string;
    } | {
      kind: "at";
      /** ISO 8601 timestamp for a one-shot run. */
      at: string;
    };
    sessionTarget: string;
    wakeMode: string;
    payload: {
      kind: "agentTurn";
      message: string;
    } | {
      kind: "systemEvent";
      text: string;
    };
    state: {
      nextRunAtMs?: number;
      runningAtMs?: number;
      lastRunAtMs?: number;
      lastStatus?: "ok" | "error" | "skipped";
      lastError?: string;
      lastDurationMs?: number;
    };
    [key: string]: unknown;
  };
  "cron.create": {
    jobId: string;
    nextFireAt?: number | null;
  };
  "cron.update": {
    jobId: string;
    nextFireAt?: number | null;
  };
  "cron.delete": {
    ok: boolean;
  };
  "cron.enable": {
    jobId: string;
    nextFireAt?: number | null;
  };
  "cron.disable": {
    jobId: string;
    nextFireAt?: number | null;
  };
  "cron.run": {
    runId: string;
    threadId: string;
    target: "chat_turn";
  };
  "cron.runs": {
    entries: Array<{
      ts: number;
      jobId: string;
      action: string;
      status?: "ok" | "error" | "skipped" | "running";
      error?: string;
      summary?: string;
      sessionId?: string;
      runAtMs?: number;
      durationMs?: number;
      nextRunAtMs?: number;
      [key: string]: unknown;
    }>;
  };
  "files.list": {
    _id: string;
    _creationTime: number;
    path: string;
    parentPath: string;
    isDir: boolean;
    size?: number;
    mtime?: number;
    contentHash?: string;
    storageId?: string;
    lastModifiedBy?: string;
    /** True for synthesized magic files (IDENTITY.md etc.). */
    virtual?: boolean;
    [key: string]: unknown;
  }[];
  "files.content": {
    path: string;
    isDir: boolean;
    virtual: boolean;
    size: number | null;
    mtime?: number | null;
    /** Inline text, or null for binary / uncached files. */
    content: string | null;
    encoding: string | null;
    contentHash?: string | null;
    downloadable: boolean;
    [key: string]: unknown;
  } | null;
  "files.write": {
    /** Normalized workspace path that was written. */
    path: string;
    contentHash: string;
  };
  "files.downloadUrl": string | null;
  "files.delete": {
    path: string;
  } | null;
  "files.move": {
    ok: boolean;
    from: string;
    to: string;
    moved: {
      from: string;
      to: string;
    }[];
  };
  "files.mkdir": unknown;
  "files.stage": {
    ok: boolean;
    staged: {
      path: string;
      size: number;
      result: {
        path: string;
        contentHash: string;
        [key: string]: unknown;
      };
    }[];
  };
  "search.web": {
    results: {
      url: string;
      title?: string;
      publishedDate?: string;
      author?: string;
      score?: number;
      text?: string;
      summary?: string;
      highlights?: string[];
      image?: string;
      favicon?: string;
      id?: string;
      /** Structured entity metadata returned by category=people or category=company. */
      entities?: Record<string, unknown>[];
      [key: string]: unknown;
    }[];
    resolvedSearchType?: string;
    autopromptString?: string;
    requestId?: string;
    costDollars?: Record<string, unknown>;
    [key: string]: unknown;
  };
  "search.contents": {
    results: {
      url: string;
      title?: string;
      publishedDate?: string;
      author?: string;
      score?: number;
      text?: string;
      summary?: string;
      highlights?: string[];
      image?: string;
      favicon?: string;
      id?: string;
      /** Structured entity metadata returned by category=people or category=company. */
      entities?: Record<string, unknown>[];
      [key: string]: unknown;
    }[];
    resolvedSearchType?: string;
    autopromptString?: string;
    requestId?: string;
    costDollars?: Record<string, unknown>;
    [key: string]: unknown;
  };
  "search.answer": {
    answer: string;
    citations?: {
      url: string;
      title?: string;
      publishedDate?: string;
      author?: string;
      score?: number;
      text?: string;
      summary?: string;
      highlights?: string[];
      image?: string;
      favicon?: string;
      id?: string;
      /** Structured entity metadata returned by category=people or category=company. */
      entities?: Record<string, unknown>[];
      [key: string]: unknown;
    }[];
    costDollars?: Record<string, unknown>;
    [key: string]: unknown;
  };
  "web.scrape": unknown;
  "web.brand": unknown;
  "web.sitemap": unknown;
  "web.crawl": unknown;
  "web.screenshot": unknown;
  "web.extract": unknown;
  "web.product": unknown;
  "web.competitors": unknown;
  "web.styleguide": unknown;
  "web.fonts": unknown;
  "web.classify": unknown;
  "web.brandSearch": unknown;
  "image.generate": {
    ok: boolean;
    model: string;
    endpoint: "generations" | "edits";
    prompt: string;
    revisedPrompt?: string;
    quality?: string;
    requestedSize?: string;
    format?: string;
    mimeType?: string;
    estimatedCostUsd?: number;
    /** Base64-encoded image bytes. */
    b64_json: string;
    storageId?: string;
    /** Workspace path where the image was saved. */
    path: string;
    signedUrl: string | null;
    contentHash?: string;
    sizeBytes?: number;
    usage?: {
      inputTokens?: number;
      outputTokens?: number;
      totalTokens?: number;
      [key: string]: unknown;
    };
    [key: string]: unknown;
  };
  "image.edit": {
    ok: boolean;
    model: string;
    endpoint: "generations" | "edits";
    prompt: string;
    revisedPrompt?: string;
    quality?: string;
    requestedSize?: string;
    format?: string;
    mimeType?: string;
    estimatedCostUsd?: number;
    /** Base64-encoded image bytes. */
    b64_json: string;
    storageId?: string;
    /** Workspace path where the image was saved. */
    path: string;
    signedUrl: string | null;
    contentHash?: string;
    sizeBytes?: number;
    usage?: {
      inputTokens?: number;
      outputTokens?: number;
      totalTokens?: number;
      [key: string]: unknown;
    };
    [key: string]: unknown;
  };
  "integrations.list": {
    items: Array<{
      id: string | null;
      connectionId: string | null;
      toolkit: {
        slug: string | null;
        name: string | null;
        [key: string]: unknown;
      };
      /** e.g. "ACTIVE". */
      status: string | null;
      createdAt: string | null;
      updatedAt: string | null;
      /** Normalized account identity (stableId, label, email, ...). */
      account: Record<string, unknown>;
      reconnect?: Record<string, unknown>;
      [key: string]: unknown;
    }>;
    /** Alias of items for older clients. */
    connections: Array<{
      id: string | null;
      connectionId: string | null;
      toolkit: {
        slug: string | null;
        name: string | null;
        [key: string]: unknown;
      };
      /** e.g. "ACTIVE". */
      status: string | null;
      createdAt: string | null;
      updatedAt: string | null;
      /** Normalized account identity (stableId, label, email, ...). */
      account: Record<string, unknown>;
      reconnect?: Record<string, unknown>;
      [key: string]: unknown;
    }>;
    /** Deprecated: the unprocessed provider response. Do not depend on it. */
    raw: unknown;
    [key: string]: unknown;
  };
  "apps.list": unknown;
  "apps.gallery": unknown;
  "apps.create": unknown;
  "apps.install": unknown;
  "apps.publish": unknown;
  "apps.uninstall": unknown;
  "apps.setEnabled": unknown;
  "apps.setPinned": unknown;
  "apps.webhooks.register": unknown;
  "apps.webhooks.list": unknown;
  "apps.webhooks.poll": unknown;
  "apps.webhooks.delete": unknown;
  "tool.status": {
    items: Array<{
      id: string | null;
      connectionId: string | null;
      toolkit: {
        slug: string | null;
        name: string | null;
        [key: string]: unknown;
      };
      /** e.g. "ACTIVE". */
      status: string | null;
      createdAt: string | null;
      updatedAt: string | null;
      /** Normalized account identity (stableId, label, email, ...). */
      account: Record<string, unknown>;
      reconnect?: Record<string, unknown>;
      [key: string]: unknown;
    }>;
    /** Alias of items for older clients. */
    connections: Array<{
      id: string | null;
      connectionId: string | null;
      toolkit: {
        slug: string | null;
        name: string | null;
        [key: string]: unknown;
      };
      /** e.g. "ACTIVE". */
      status: string | null;
      createdAt: string | null;
      updatedAt: string | null;
      /** Normalized account identity (stableId, label, email, ...). */
      account: Record<string, unknown>;
      reconnect?: Record<string, unknown>;
      [key: string]: unknown;
    }>;
    /** Deprecated: the unprocessed provider response. Do not depend on it. */
    raw: unknown;
    [key: string]: unknown;
  };
  "tool.connect": {
    /** OAuth URL the user opens to finish connecting. */
    redirect_url?: string;
    connection_id?: string;
    redirectUrl?: string;
    link?: string;
    artifact?: {
      kind: "connect";
      data: {
        toolkit: string;
      };
    };
    [key: string]: unknown;
  };
  "tool.search": {
    success?: boolean;
    error?: string | null;
    results?: {
      use_case: string;
      primary_tool_slugs?: string[];
      related_tool_slugs?: string[];
      toolkits?: string[];
      execution_guidance?: string;
      recommended_plan_steps?: string[];
      known_pitfalls?: string[];
      [key: string]: unknown;
    }[];
    toolkit_connection_statuses?: Array<{
      toolkit: string;
      has_active_connection: boolean;
      status_message?: string | null;
      accounts?: Record<string, unknown>[];
      [key: string]: unknown;
    }>;
    /** Tool slug -> schema with gateway-added execution_ref for tool.run. */
    tool_schemas?: Record<string, Record<string, unknown>>;
    /** Tool-router session; reuse session.id for follow-up calls. */
    session?: {
      id: string;
      [key: string]: unknown;
    };
    items?: Record<string, unknown>[];
    nativeAvailable?: boolean;
    available?: boolean;
    execution_ref_version?: number;
    [key: string]: unknown;
  };
  "tool.run": {
    /** Tool output (provider passthrough). */
    data?: unknown;
    error?: unknown | null;
    log_id?: string;
    execution_mode?: string;
    tool_slug?: string;
    tool_router_session_id?: string;
    toolkit?: string;
    account?: string;
    [key: string]: unknown;
  };
  "tool.disconnect": {
    id?: string;
    deleted?: boolean;
    [key: string]: unknown;
  };
  "tool.labels.list": {
    labels: {
      composioConnectionId: string;
      displayName: string;
    }[];
  };
  "tool.label.set": {
    ok: boolean;
    displayName: string | null;
  };
  "browser.action": unknown;
  "browser.session.create": unknown;
  "browser.session.status": unknown;
  "browser.session.stop": unknown;
  "agentConfig.identity.show": {
    agentConfig: {
      identity: {
        content: string;
        updatedAt: number;
      } | null;
      organisation: {
        content: string;
        updatedAt: number;
      } | null;
      memoryAggregate: {
        content: string;
        updatedAt: number;
      } | null;
      toolsNotes: {
        content: string;
        updatedAt: number;
      } | null;
      bootstrap: {
        completed: boolean;
        completedAt?: number;
        template?: string;
      };
    };
    userProfile: {
      content: string;
      updatedAt: number;
    } | null;
    userTimezone: {
      value: string;
      source: "auto" | "manual" | "agent";
      updatedAt: number;
    } | null;
    organizationId: string;
    [key: string]: unknown;
  };
  "agentConfig.identity.edit": {
    identity: {
      content: string;
      updatedAt: number;
    } | null;
    organisation: {
      content: string;
      updatedAt: number;
    } | null;
    memoryAggregate: {
      content: string;
      updatedAt: number;
    } | null;
    toolsNotes: {
      content: string;
      updatedAt: number;
    } | null;
    bootstrap: {
      completed: boolean;
      completedAt?: number;
      template?: string;
    };
  };
  "agentConfig.organisation.show": {
    agentConfig: {
      identity: {
        content: string;
        updatedAt: number;
      } | null;
      organisation: {
        content: string;
        updatedAt: number;
      } | null;
      memoryAggregate: {
        content: string;
        updatedAt: number;
      } | null;
      toolsNotes: {
        content: string;
        updatedAt: number;
      } | null;
      bootstrap: {
        completed: boolean;
        completedAt?: number;
        template?: string;
      };
    };
    userProfile: {
      content: string;
      updatedAt: number;
    } | null;
    userTimezone: {
      value: string;
      source: "auto" | "manual" | "agent";
      updatedAt: number;
    } | null;
    organizationId: string;
    [key: string]: unknown;
  };
  "agentConfig.organisation.edit": {
    identity: {
      content: string;
      updatedAt: number;
    } | null;
    organisation: {
      content: string;
      updatedAt: number;
    } | null;
    memoryAggregate: {
      content: string;
      updatedAt: number;
    } | null;
    toolsNotes: {
      content: string;
      updatedAt: number;
    } | null;
    bootstrap: {
      completed: boolean;
      completedAt?: number;
      template?: string;
    };
  };
  "agentConfig.user.show": {
    agentConfig: {
      identity: {
        content: string;
        updatedAt: number;
      } | null;
      organisation: {
        content: string;
        updatedAt: number;
      } | null;
      memoryAggregate: {
        content: string;
        updatedAt: number;
      } | null;
      toolsNotes: {
        content: string;
        updatedAt: number;
      } | null;
      bootstrap: {
        completed: boolean;
        completedAt?: number;
        template?: string;
      };
    };
    userProfile: {
      content: string;
      updatedAt: number;
    } | null;
    userTimezone: {
      value: string;
      source: "auto" | "manual" | "agent";
      updatedAt: number;
    } | null;
    organizationId: string;
    [key: string]: unknown;
  };
  "agentConfig.user.edit": {
    content: string;
    updatedAt: number;
  };
  "agentConfig.tools.show": {
    agentConfig: {
      identity: {
        content: string;
        updatedAt: number;
      } | null;
      organisation: {
        content: string;
        updatedAt: number;
      } | null;
      memoryAggregate: {
        content: string;
        updatedAt: number;
      } | null;
      toolsNotes: {
        content: string;
        updatedAt: number;
      } | null;
      bootstrap: {
        completed: boolean;
        completedAt?: number;
        template?: string;
      };
    };
    userProfile: {
      content: string;
      updatedAt: number;
    } | null;
    userTimezone: {
      value: string;
      source: "auto" | "manual" | "agent";
      updatedAt: number;
    } | null;
    organizationId: string;
    [key: string]: unknown;
  };
  "agentConfig.tools.edit": {
    identity: {
      content: string;
      updatedAt: number;
    } | null;
    organisation: {
      content: string;
      updatedAt: number;
    } | null;
    memoryAggregate: {
      content: string;
      updatedAt: number;
    } | null;
    toolsNotes: {
      content: string;
      updatedAt: number;
    } | null;
    bootstrap: {
      completed: boolean;
      completedAt?: number;
      template?: string;
    };
  };
  "workspace.context.rules.set": unknown;
  "agentConfig.mem.show": {
    agentConfig: {
      identity: {
        content: string;
        updatedAt: number;
      } | null;
      organisation: {
        content: string;
        updatedAt: number;
      } | null;
      memoryAggregate: {
        content: string;
        updatedAt: number;
      } | null;
      toolsNotes: {
        content: string;
        updatedAt: number;
      } | null;
      bootstrap: {
        completed: boolean;
        completedAt?: number;
        template?: string;
      };
    };
    userProfile: {
      content: string;
      updatedAt: number;
    } | null;
    userTimezone: {
      value: string;
      source: "auto" | "manual" | "agent";
      updatedAt: number;
    } | null;
    organizationId: string;
    [key: string]: unknown;
  };
  "agentConfig.mem.edit": {
    identity: {
      content: string;
      updatedAt: number;
    } | null;
    organisation: {
      content: string;
      updatedAt: number;
    } | null;
    memoryAggregate: {
      content: string;
      updatedAt: number;
    } | null;
    toolsNotes: {
      content: string;
      updatedAt: number;
    } | null;
    bootstrap: {
      completed: boolean;
      completedAt?: number;
      template?: string;
    };
  };
  "agentConfig.bootstrap.show": {
    agentConfig: {
      identity: {
        content: string;
        updatedAt: number;
      } | null;
      organisation: {
        content: string;
        updatedAt: number;
      } | null;
      memoryAggregate: {
        content: string;
        updatedAt: number;
      } | null;
      toolsNotes: {
        content: string;
        updatedAt: number;
      } | null;
      bootstrap: {
        completed: boolean;
        completedAt?: number;
        template?: string;
      };
    };
    userProfile: {
      content: string;
      updatedAt: number;
    } | null;
    userTimezone: {
      value: string;
      source: "auto" | "manual" | "agent";
      updatedAt: number;
    } | null;
    organizationId: string;
    [key: string]: unknown;
  };
  "agentConfig.bootstrap.complete": {
    identity: {
      content: string;
      updatedAt: number;
    } | null;
    organisation: {
      content: string;
      updatedAt: number;
    } | null;
    memoryAggregate: {
      content: string;
      updatedAt: number;
    } | null;
    toolsNotes: {
      content: string;
      updatedAt: number;
    } | null;
    bootstrap: {
      completed: boolean;
      completedAt?: number;
      template?: string;
    };
  };
  "agentConfig.bootstrap.template": {
    identity: {
      content: string;
      updatedAt: number;
    } | null;
    organisation: {
      content: string;
      updatedAt: number;
    } | null;
    memoryAggregate: {
      content: string;
      updatedAt: number;
    } | null;
    toolsNotes: {
      content: string;
      updatedAt: number;
    } | null;
    bootstrap: {
      completed: boolean;
      completedAt?: number;
      template?: string;
    };
  };
  "agentConfig.model.default": {
    defaultChatModelId: string | null;
  };
  "agentConfig.model.thread": {
    threadId: string;
    modelOverride: string | null;
  };
  "agentConfig.daily.today": {
    agentConfig: {
      identity: {
        content: string;
        updatedAt: number;
      } | null;
      organisation: {
        content: string;
        updatedAt: number;
      } | null;
      memoryAggregate: {
        content: string;
        updatedAt: number;
      } | null;
      toolsNotes: {
        content: string;
        updatedAt: number;
      } | null;
      bootstrap: {
        completed: boolean;
        completedAt?: number;
        template?: string;
      };
    };
    userProfile: {
      content: string;
      updatedAt: number;
    } | null;
    userTimezone: {
      value: string;
      source: "auto" | "manual" | "agent";
      updatedAt: number;
    } | null;
    organizationId: string;
    [key: string]: unknown;
  };
  "agentConfig.daily.show": {
    agentConfig: {
      identity: {
        content: string;
        updatedAt: number;
      } | null;
      organisation: {
        content: string;
        updatedAt: number;
      } | null;
      memoryAggregate: {
        content: string;
        updatedAt: number;
      } | null;
      toolsNotes: {
        content: string;
        updatedAt: number;
      } | null;
      bootstrap: {
        completed: boolean;
        completedAt?: number;
        template?: string;
      };
    };
    userProfile: {
      content: string;
      updatedAt: number;
    } | null;
    userTimezone: {
      value: string;
      source: "auto" | "manual" | "agent";
      updatedAt: number;
    } | null;
    organizationId: string;
    [key: string]: unknown;
  };
  "notifications.list": {
    _id: string;
    kind: string;
    title: string;
    body?: string;
    link?: string;
    readAt?: number;
    archivedAt?: number;
    createdAt: number;
    [key: string]: unknown;
  }[];
  "notifications.unreadCount": number;
  "notifications.read": {
    ok: boolean;
  };
  "notifications.readAll": {
    ok: boolean;
    patched: number;
  };
  "notifications.archive": {
    ok: boolean;
  };
  "notifications.preferences.get": {
    inAppEnabled: boolean;
    emailEnabled: boolean;
    perKind: Record<string, {
      inApp?: boolean;
      email?: boolean;
    }>;
    timezone: string | null;
    digestWindowMinutes: number;
    maxEmailsPerDay: number;
  } | null;
  "notifications.preferences.update": {
    ok: boolean;
  };
  "settings.sync.get": {
    detectAccounts: boolean;
    linkedinContacts: boolean;
    slackConnectAccounts: boolean;
    calendarContacts: boolean;
    dossier: boolean;
    emailTasks: boolean;
    leadAutoQualify: boolean;
    intelligence: boolean;
  };
  "settings.sync.update": {
    detectAccounts: boolean;
    linkedinContacts: boolean;
    slackConnectAccounts: boolean;
    calendarContacts: boolean;
    dossier: boolean;
    emailTasks: boolean;
    leadAutoQualify: boolean;
    intelligence: boolean;
  };
}

export type ApiOperationId = keyof ApiRequests;
export type Req<K extends ApiOperationId> = ApiRequests[K];
export type Res<K extends ApiOperationId> = ApiResponses[K];

export type ApiOperationInfo = {
  id: ApiOperationId;
  group: string;
  summary: string;
  cli: string;
  method: string;
  path: string;
  permission: string | null;
  deprecated?: true;
};

/** `dench.api.<group>.<name>(args)` — every operation, nested by id. */
export type DenchApiTree = {
  agentConfig: {
    bootstrap: {
      /** Complete bootstrap. (`dench bootstrap complete`) */
      complete(args: Req<"agentConfig.bootstrap.complete">): Promise<Res<"agentConfig.bootstrap.complete">>;
      /** Read bootstrap state. (`dench bootstrap status`) */
      show(args?: Req<"agentConfig.bootstrap.show">): Promise<Res<"agentConfig.bootstrap.show">>;
      /** Update bootstrap template. (`dench bootstrap template`) */
      template(args: Req<"agentConfig.bootstrap.template">): Promise<Res<"agentConfig.bootstrap.template">>;
    };
    daily: {
      /** Read a daily activity path. (`dench daily show`) */
      show(args: Req<"agentConfig.daily.show">): Promise<Res<"agentConfig.daily.show">>;
      /** Read today's daily activity path. (`dench daily today`) */
      today(args?: Req<"agentConfig.daily.today">): Promise<Res<"agentConfig.daily.today">>;
    };
    identity: {
      /** Update IDENTITY.md. (`dench context set identity`) */
      edit(args: Req<"agentConfig.identity.edit">): Promise<Res<"agentConfig.identity.edit">>;
      /** Read IDENTITY.md. (`dench context --sections identity`) */
      show(args?: Req<"agentConfig.identity.show">): Promise<Res<"agentConfig.identity.show">>;
    };
    mem: {
      /** Update aggregate memory. (`dench mem set`) */
      edit(args: Req<"agentConfig.mem.edit">): Promise<Res<"agentConfig.mem.edit">>;
      /** Read aggregate memory. (`dench mem show`) */
      show(args?: Req<"agentConfig.mem.show">): Promise<Res<"agentConfig.mem.show">>;
    };
    model: {
      /** Set the default chat model. (`dench model default`) */
      default(args: Req<"agentConfig.model.default">): Promise<Res<"agentConfig.model.default">>;
      /** Set a thread model override. (`dench model thread`) */
      thread(args: Req<"agentConfig.model.thread">): Promise<Res<"agentConfig.model.thread">>;
    };
    organisation: {
      /** Update ORGANISATION.md. (`dench context set organisation`) */
      edit(args: Req<"agentConfig.organisation.edit">): Promise<Res<"agentConfig.organisation.edit">>;
      /** Read ORGANISATION.md. (`dench context --sections organisation`) */
      show(args?: Req<"agentConfig.organisation.show">): Promise<Res<"agentConfig.organisation.show">>;
    };
    tools: {
      /** Update tool notes. (`dench context set tools`) */
      edit(args: Req<"agentConfig.tools.edit">): Promise<Res<"agentConfig.tools.edit">>;
      /** Read tool notes. (`dench context --sections tools`) */
      show(args?: Req<"agentConfig.tools.show">): Promise<Res<"agentConfig.tools.show">>;
    };
    user: {
      /** Update USER.md. (`dench context set user`) */
      edit(args: Req<"agentConfig.user.edit">): Promise<Res<"agentConfig.user.edit">>;
      /** Read USER.md. (`dench context --sections user`) */
      show(args?: Req<"agentConfig.user.show">): Promise<Res<"agentConfig.user.show">>;
    };
  };
  approval: {
    /** Record an approval decision. (`dench approval approve|reject`) */
    decide(args: Req<"approval.decide">): Promise<Res<"approval.decide">>;
    /** Request human approval. (`dench approval request`) */
    request(args: Req<"approval.request">): Promise<Res<"approval.request">>;
  };
  apps: {
    /** Scaffold and register a new App Store app. (`dench apps create`) */
    create(args: Req<"apps.create">): Promise<Res<"apps.create">>;
    /** List Discover listings — Official (Dench) + Community shelves. (`dench apps gallery`) */
    gallery(args?: Req<"apps.gallery">): Promise<Res<"apps.gallery">>;
    /** Install an App Store listing into the workspace. (`dench apps install`) */
    install(args: Req<"apps.install">): Promise<Res<"apps.install">>;
    /** List installed App Store apps in the workspace. (`dench apps list`) */
    list(args?: Req<"apps.list">): Promise<Res<"apps.list">>;
    /** Publish an app's files as a versioned App Store listing. (`dench apps publish`) */
    publish(args: Req<"apps.publish">): Promise<Res<"apps.publish">>;
    /** Enable or disable an installed app. (`dench apps enable`) */
    setEnabled(args: Req<"apps.setEnabled">): Promise<Res<"apps.setEnabled">>;
    /** Pin or unpin an installed app in the rail. (`dench apps pin`) */
    setPinned(args: Req<"apps.setPinned">): Promise<Res<"apps.setPinned">>;
    /** Uninstall an app from the workspace. (`dench apps uninstall`) */
    uninstall(args: Req<"apps.uninstall">): Promise<Res<"apps.uninstall">>;
    webhooks: {
      /** Remove an app webhook and every event it stored. (`dench apps webhooks delete`) */
      delete(args: Req<"apps.webhooks.delete">): Promise<Res<"apps.webhooks.delete">>;
      /** List an app's registered webhooks (URLs, never secrets). (`dench apps webhooks list`) */
      list(args: Req<"apps.webhooks.list">): Promise<Res<"apps.webhooks.list">>;
      /** Read events an app webhook received since a timestamp. (`dench apps webhooks poll`) */
      poll(args: Req<"apps.webhooks.poll">): Promise<Res<"apps.webhooks.poll">>;
      /** Register an inbound webhook for an app. Returns the URL and signing secret ONCE. (`dench apps webhooks register`) */
      register(args: Req<"apps.webhooks.register">): Promise<Res<"apps.webhooks.register">>;
    };
  };
  auth: {
    otp: {
      /** Finalize an email OTP sign-in session. (`dench signin --email`) */
      finalize(args: Req<"auth.otp.finalize">): Promise<Res<"auth.otp.finalize">>;
      /** Start the email OTP sign-in flow. (`dench signin --email`) */
      start(args: Req<"auth.otp.start">): Promise<Res<"auth.otp.start">>;
      /** Verify an email OTP sign-in code. (`dench signin --email`) */
      verify(args: Req<"auth.otp.verify">): Promise<Res<"auth.otp.verify">>;
    };
    signin: {
      /** Create an agent sign-in request. (`dench signin`) */
      create(args: Req<"auth.signin.create">): Promise<Res<"auth.signin.create">>;
      /** Poll an agent sign-in request until approval. (`dench signin`) */
      poll(args: Req<"auth.signin.poll">): Promise<Res<"auth.signin.poll">>;
    };
  };
  billing: {
    /** Get billing and AI credit status. (`dench billing status`) */
    status(args?: Req<"billing.status">): Promise<Res<"billing.status">>;
    /** Create an AI credit top-up checkout link. (`dench billing topup`) */
    topup(args: Req<"billing.topup">): Promise<Res<"billing.topup">>;
    /** Create a workspace upgrade checkout link. (`dench upgrade`) */
    upgrade(args: Req<"billing.upgrade">): Promise<Res<"billing.upgrade">>;
  };
  browser: {
    /** Drive Dench Browser with a single interactive action (open, inspect, click, fill, type, screenshot, stop). Pass the step in `action` plus its arguments. (`dench browser`) */
    action(args: Req<"browser.action">): Promise<Res<"browser.action">>;
    session: {
      /** Create a Dench Browser session and return a CDP connect URL for Playwright (chromium.connectOverCDP) plus a live-view URL. Use for durable scripts run from the sandbox. (`dench browser session create`) */
      create(args: Req<"browser.session.create">): Promise<Res<"browser.session.create">>;
      /** Get the status, connect URL, and live-view URL for a Dench Browser session. (`dench browser session status`) */
      status(args: Req<"browser.session.status">): Promise<Res<"browser.session.status">>;
      /** Stop a Dench Browser session and release the remote browser. (`dench browser session stop`) */
      stop(args: Req<"browser.session.stop">): Promise<Res<"browser.session.stop">>;
    };
  };
  campaigns: {
    accounts: {
      /** Discover the mailboxes the acting workspace member can send campaign email from: ids for emailMailboxAccountIds, status, warm-up state and when it is done, the daily cold-email cap and what is left today. Never returns provider credentials. (`dench campaign accounts`) */
      email(args?: Req<"campaigns.accounts.email">): Promise<Res<"campaigns.accounts.email">>;
      /** Discover LinkedIn sender ids, labels, availability and remaining capacity visible to the acting workspace member. Never returns provider credentials. (`dench campaign accounts`) */
      linkedin(args?: Req<"campaigns.accounts.linkedin">): Promise<Res<"campaigns.accounts.linkedin">>;
    };
    /** Campaign funnel: enrolled, contacted, invited, accepted, messaged, replied, opens and clicks, and for a workflow how many people took each If / else and Wait for them to accept path (branchStats). (`dench campaign get`) */
    analytics(args: Req<"campaigns.analytics">): Promise<Res<"campaigns.analytics">>;
    /** Archive a campaign and stop everyone still in flight. This is the app's Delete: campaigns are never erased, and their people, leads and activity stay. (`dench campaign archive`) */
    archive(args: Req<"campaigns.archive">): Promise<Res<"campaigns.archive">>;
    audience: {
      /** Search people by filters without adding CRM records or campaign recipients. Search credits apply; this is not a free provider preview. (`dench campaign search`) */
      search(args: Req<"campaigns.audience.search">): Promise<Res<"campaigns.audience.search">>;
    };
    builder: {
      /** Turn an audience description into targeting filters. AI credits apply. (`dench campaign builder autofill`) */
      autofill(args: Req<"campaigns.builder.autofill">): Promise<Res<"campaigns.builder.autofill">>;
      /** Start the same billable signal/audience/message build used by the UI; poll the draft for progress. (`dench campaign builder build`) */
      build(args: Req<"campaigns.builder.build">): Promise<Res<"campaigns.builder.build">>;
      /** Create a campaign from a reviewed signal draft. Does not launch the campaign. (`dench campaign builder create`) */
      create(args: Req<"campaigns.builder.create">): Promise<Res<"campaigns.builder.create">>;
      /** Discard a saved draft that has not become a campaign. (`dench campaign builder discard`) */
      discard(args: Req<"campaigns.builder.discard">): Promise<Res<"campaigns.builder.discard">>;
      /** List saved, unfinished campaign drafts that can be resumed. (`dench campaign builder drafts`) */
      drafts(args?: Req<"campaigns.builder.drafts">): Promise<Res<"campaigns.builder.drafts">>;
      /** Estimate audience or weekly signal volume using the UI's cached estimator. Provider credits may apply. (`dench campaign builder estimate`) */
      estimate(args: Req<"campaigns.builder.estimate">): Promise<Res<"campaigns.builder.estimate">>;
      /** Read signal build progress, preview people, messages and errors. (`dench campaign builder get`) */
      get(args: Req<"campaigns.builder.get">): Promise<Res<"campaigns.builder.get">>;
      /** Set up a lookalike from the best lead's LinkedIn URL (role, similar roles, place, industry, similar companies), suggest roles again, or re-scope to a company. Nothing is saved. Provider credits apply. (`dench campaign builder lookalike`) */
      lookalike(args: Req<"campaigns.builder.lookalike">): Promise<Res<"campaigns.builder.lookalike">>;
      /** Edit or reset one preview person's opening line before creating the campaign. (`dench campaign builder opener`) */
      opener(args: Req<"campaigns.builder.opener">): Promise<Res<"campaigns.builder.opener">>;
      /** Save a draft's Outreach and Review choices: AI or manual steps, the brief, the steps, who sends and when, and auto or manual approval. (`dench campaign builder outreach`) */
      outreach(args: Req<"campaigns.builder.outreach">): Promise<Res<"campaigns.builder.outreach">>;
      /** Read the company profile and suggested campaign audience. (`dench campaign builder profile`) */
      profile(args?: Req<"campaigns.builder.profile">): Promise<Res<"campaigns.builder.profile">>;
      /** Read a saved draft's setup (source, name, targeting, signals, terms, lookalike) to resume it. (`dench campaign builder resume`) */
      resume(args: Req<"campaigns.builder.resume">): Promise<Res<"campaigns.builder.resume">>;
      /** Save a signal campaign's audience, signals and terms idempotently. Does not start a build. (`dench campaign builder save`) */
      save(args: Req<"campaigns.builder.save">): Promise<Res<"campaigns.builder.save">>;
      /** Generate the draft's sequence from a brief (goal, problem, tone, channels), as Generate sequence does. AI credits apply. (`dench campaign builder sequence`) */
      sequence(args: Req<"campaigns.builder.sequence">): Promise<Res<"campaigns.builder.sequence">>;
      /** Suggest market voices (LinkedIn experts) for the campaign's topics, to watch with voice_engagement. AI credits apply. (`dench campaign builder voices`) */
      voices(args: Req<"campaigns.builder.voices">): Promise<Res<"campaigns.builder.voices">>;
    };
    /** Create a draft outreach campaign with email and LinkedIn sender pools and a business-hours send window in the given timezone. (`dench campaign create`) */
    create(args: Req<"campaigns.create">): Promise<Res<"campaigns.create">>;
    drafts: {
      /** Create an idempotent empty campaign draft with the caller's available sender pools. Does not launch or send. (`dench campaign draft`) */
      create(args: Req<"campaigns.drafts.create">): Promise<Res<"campaigns.drafts.create">>;
    };
    /** Copy a campaign into a new draft named "<name> copy": the same steps, schedule, sender pools and personalized lines, its lead source paused, and no people. To reach more than 300 people, duplicate and add the next page of the search to the copy. (`dench campaign duplicate`) */
    duplicate(args: Req<"campaigns.duplicate">): Promise<Res<"campaigns.duplicate">>;
    /** The campaign's activity log, newest first (sent, accepted, replied, skipped, failed, paused, stopped). (`dench campaign events`) */
    events(args: Req<"campaigns.events">): Promise<Res<"campaigns.events">>;
    /** Read a campaign: settings, steps, people, their current step and hold, last touches, linked leads. (`dench campaign get`) */
    get(args: Req<"campaigns.get">): Promise<Res<"campaigns.get">>;
    launch: {
      /** Launch a ready draft. Pass the fingerprint from the preview and acknowledge the LinkedIn notice when LinkedIn steps exist. (`dench campaign launch`) */
      (args: Req<"campaigns.launch">): Promise<Res<"campaigns.launch">>;
      $call(args: Req<"campaigns.launch">): Promise<Res<"campaigns.launch">>;
      /** Launch readiness without launching: blockers grouped by problem, warnings, and the fingerprint `launch` requires. (`dench campaign launch --check`) */
      preview(args: Req<"campaigns.launch.preview">): Promise<Res<"campaigns.launch.preview">>;
    };
    /** List outreach campaigns (archived ones on request). (`dench campaign list [--with-references]`) */
    list(args?: Req<"campaigns.list">): Promise<Res<"campaigns.list">>;
    /** What the campaign is doing now, what comes next and when, and why it is holding. (`dench campaign get`) */
    live(args: Req<"campaigns.live">): Promise<Res<"campaigns.live">>;
    /** Pause an active campaign. (`dench campaign pause`) */
    pause(args: Req<"campaigns.pause">): Promise<Res<"campaigns.pause">>;
    people: {
      /** Add one person by email and/or LinkedIn profile URL. (`dench campaign add --name`) */
      add(args: Req<"campaigns.people.add">): Promise<Res<"campaigns.people.add">>;
      /** Add up to 50 selected recipients without another search. Deduplicates, applies suppression, and preserves the campaign's launch state. (`dench campaign add --people-file`) */
      addBatch(args: Req<"campaigns.people.addBatch">): Promise<Res<"campaigns.people.addBatch">>;
      /** Add CRM records (up to 100 ids per call) to a campaign; returns how many were added and why others were skipped. (`dench campaign add`) */
      addFromCrm(args: Req<"campaigns.people.addFromCrm">): Promise<Res<"campaigns.people.addFromCrm">>;
      /** Search and add up to 50 people to an existing campaign. New identities become Leads. Search credits apply; use nextPageToken for another page. (`dench campaign add --search`) */
      addFromSearch(args: Req<"campaigns.people.addFromSearch">): Promise<Res<"campaigns.people.addFromSearch">>;
      /** The campaigns a CRM record (a person or a lead) is in, newest first, with the person's status in each and the accounts that send to them. (`dench campaign where`) */
      forRecord(args: Req<"campaigns.people.forRecord">): Promise<Res<"campaigns.people.forRecord">>;
      /** Remove a person who was never contacted from a draft campaign. Frees their place in the 300-person cap and keeps the draft launchable; stop anyone already contacted instead. (`dench campaign remove`) */
      remove(args: Req<"campaigns.people.remove">): Promise<Res<"campaigns.people.remove">>;
      /** Resume one paused person in an active campaign. (`dench campaign resume-person`) */
      resume(args: Req<"campaigns.people.resume">): Promise<Res<"campaigns.people.resume">>;
      /** Resume every paused person in an active campaign at once, e.g. after a sending account is reconnected. Returns how many were resumed. (`dench campaign resume-person --all`) */
      resumeAll(args: Req<"campaigns.people.resumeAll">): Promise<Res<"campaigns.people.resumeAll">>;
      /** Give a person in a draft campaign a new or corrected email address; their linked CRM record gets it too. Only before launch; another person in the campaign can't share it. (`dench campaign person set --email`) */
      setEmail(args: Req<"campaigns.people.setEmail">): Promise<Res<"campaigns.people.setEmail">>;
      /** Fill or fix one {{merge field}} for a person in a draft campaign, e.g. a missing Company that blocks launch; a matching column on their CRM record is updated too. Only before launch; written personalized lines are not merge fields and can't be set here. (`dench campaign person set --field`) */
      setField(args: Req<"campaigns.people.setField">): Promise<Res<"campaigns.people.setField">>;
      /** Give a person in a draft campaign a new or corrected LinkedIn profile URL; their linked CRM record gets it too. Only before launch. (`dench campaign person set --linkedin-url`) */
      setLinkedin(args: Req<"campaigns.people.setLinkedin">): Promise<Res<"campaigns.people.setLinkedin">>;
      /** Stop one person: nothing more is sent to them from this campaign. (`dench campaign stop`) */
      stop(args: Req<"campaigns.people.stop">): Promise<Res<"campaigns.people.stop">>;
      /** Fill each unfinished person's empty email, LinkedIn URL, name and merge fields from their linked CRM record, e.g. after enriching the records. Never overwrites a value the campaign already has; returns how many people changed. (`dench campaign sync`) */
      sync(args: Req<"campaigns.people.sync">): Promise<Res<"campaigns.people.sync">>;
      /** Everything a campaign did for one person, step by step: what was sent (subject and text), whether it was opened or clicked, what was skipped and why, waits, failures and retries. (`dench campaign person show`) */
      timeline(args: Req<"campaigns.people.timeline">): Promise<Res<"campaigns.people.timeline">>;
    };
    personalization: {
      /** Turn off a campaign's personalized lines and cancel the ones not yet written. Refused while a step still uses one of the {{keys}}. (`dench campaign personalize clear`) */
      clear(args: Req<"campaigns.personalization.clear">): Promise<Res<"campaigns.personalization.clear">>;
      /** Set one person's personalized line by hand; an empty value undoes the edit. Braces are removed and text past the line's length is cut. (`dench campaign personalize edit`) */
      edit(args: Req<"campaigns.personalization.edit">): Promise<Res<"campaigns.personalization.edit">>;
      /** Read a campaign's personalized lines (written for each person): their {{keys}} for steps, instructions and fallbacks, how many people have them, and the cost per person. (`dench campaign personalize get`) */
      get(args: Req<"campaigns.personalization.get">): Promise<Res<"campaigns.personalization.get">>;
      /** Write a fresh personalized line for one person: one key, or all of their lines when key is left out. About 3 cents. (`dench campaign personalize rewrite`) */
      rewrite(args: Req<"campaigns.personalization.rewrite">): Promise<Res<"campaigns.personalization.rewrite">>;
      /** Define up to 5 personalized lines (each used as {{key}} in steps) and what you sell. Saving starts writing missing lines for up to 100 people, about 3 cents a person; for more it returns needsConfirm and writes nothing until campaigns.personalization.write is confirmed. (`dench campaign personalize set`) */
      set(args: Req<"campaigns.personalization.set">): Promise<Res<"campaigns.personalization.set">>;
      /** Write personalized lines for the people missing them (mode missing) or rewrite everyone's (mode all). Rewriting everyone or more than 100 people returns needsConfirm and the estimate until called with confirmed: true. (`dench campaign personalize write`) */
      write(args: Req<"campaigns.personalization.write">): Promise<Res<"campaigns.personalization.write">>;
    };
    /** Where a campaign's people sit in the workspace's lead pipeline right now: each lead Status in order with how many enrolled leads are at it, and how many have no lead or a status outside the pipeline. (`dench campaign pipeline`) */
    pipeline(args: Req<"campaigns.pipeline">): Promise<Res<"campaigns.pipeline">>;
    /** Show the message one person gets at one email or LinkedIn step, with their fields and personalized lines filled in: subject, body, sender, recipient, merge fields still missing, warnings, and why the step would be skipped. Nothing is sent, prepared or charged. (`dench campaign preview`) */
    preview(args: Req<"campaigns.preview">): Promise<Res<"campaigns.preview">>;
    /** Today's queue: who the campaign plans to contact today, warmest first, within the senders' limits. (`dench campaign queue`) */
    queue(args: Req<"campaigns.queue">): Promise<Res<"campaigns.queue">>;
    /** Resume a paused campaign. (`dench campaign resume`) */
    resume(args: Req<"campaigns.resume">): Promise<Res<"campaigns.resume">>;
    sources: {
      /** Read a campaign's saved signal source, targeting and schedule. (`dench campaign sources get`) */
      get(args: Req<"campaigns.sources.get">): Promise<Res<"campaigns.sources.get">>;
      /** Read the Sources tab: each signal's status, last and next run, people found and anything needing attention. (`dench campaign sources overview`) */
      overview(args: Req<"campaigns.sources.overview">): Promise<Res<"campaigns.sources.overview">>;
      /** List people a signal found who are waiting for approval (manual approval mode). (`dench campaign sources pending`) */
      pending(args: Req<"campaigns.sources.pending">): Promise<Res<"campaigns.sources.pending">>;
      /** Preview a signal source using its current audience. Provider credits may apply; does not enroll people. (`dench campaign sources preview`) */
      preview(args: Req<"campaigns.sources.preview">): Promise<Res<"campaigns.sources.preview">>;
      /** Approve people waiting for review (they start the sequence) or reject them. (`dench campaign sources approve|reject`) */
      review(args: Req<"campaigns.sources.review">): Promise<Res<"campaigns.sources.review">>;
      /** Run a live campaign's signals now instead of waiting for the schedule (Run now). Provider credits apply; limited to 6 runs an hour. (`dench campaign sources run`) */
      run(args: Req<"campaigns.sources.run">): Promise<Res<"campaigns.sources.run">>;
      /** Read signal choices, suggested terms and current source configuration. (`dench campaign sources signals`) */
      signals(args: Req<"campaigns.sources.signals">): Promise<Res<"campaigns.sources.signals">>;
      /** Update source cadence, pause/resume, targeting, signals or terms. Active sources may perform billable future work. (`dench campaign sources set`) */
      update(args: Req<"campaigns.sources.update">): Promise<Res<"campaigns.sources.update">>;
    };
    steps: {
      /** Replace every step of a draft campaign (email, wait, LinkedIn visit, connection request, message, post reaction, InMail, If / else, Wait for them to accept). A workflow (stepModel workflow, or steps with key, next, yesNext or noNext) branches: condition and wait_for_connection steps continue on yesNext or noNext, other steps on next; each points at another step's key or end. Steps are checked first: a field the step type would drop, missing text, {TOKEN} single braces or paths that don't hold together are rejected, not saved. Configure sender pools on the campaign; step sender ids are legacy-only. (`dench campaign steps set`) */
      replace(args: Req<"campaigns.steps.replace">): Promise<Res<"campaigns.steps.replace">>;
      /** Edit the text, waits and conditions of a launched (or paused) campaign's steps in place. Each step keeps its id, type and place; pass the stepId and the updatedAt you read, and only the fields you change. A workflow keeps its paths and what each If / else checks (key, next, yesNext, noNext, check, conditionField, conditionOperator); conditionValue and acceptance waits stay editable. Messages already sent or being prepared keep their text; drafts use campaigns.steps.replace. (`dench campaign steps edit`) */
      update(args: Req<"campaigns.steps.update">): Promise<Res<"campaigns.steps.update">>;
    };
    /** Change a campaign's name, sender pools, send windows, daily email cap, stop-on-reply, start or end. Works until archived; existing conversations keep their assigned sender. (`dench campaign set`) */
    update(args: Req<"campaigns.update">): Promise<Res<"campaigns.update">>;
  };
  chat: {
    /** Delete one or more chat threads. (`dench chat delete`) */
    delete(args: Req<"chat.delete">): Promise<Res<"chat.delete">>;
    /** Follow a live chat response stream. (`dench chat follow`) */
    follow(args: Req<"chat.follow">): Promise<Res<"chat.follow">>;
    /** List past chat threads. (`dench chat list`) */
    list(args?: Req<"chat.list">): Promise<Res<"chat.list">>;
    /** Start a new chat-turn workflow. (`dench chat new`) */
    new(args: Req<"chat.new">): Promise<Res<"chat.new">>;
    /** Read a past chat thread. (`dench chat read`) */
    read(args: Req<"chat.read">): Promise<Res<"chat.read">>;
    /** Rename one or more chat threads. (`dench chat rename`) */
    rename(args: Req<"chat.rename">): Promise<Res<"chat.rename">>;
    /** Search past chat messages. (`dench chat search`) */
    search(args?: Req<"chat.search">): Promise<Res<"chat.search">>;
    /** Send a message to an existing chat thread. (`dench chat send`) */
    send(args: Req<"chat.send">): Promise<Res<"chat.send">>;
    /** Read the parent-child chat thread hierarchy. (`dench chat tree`) */
    tree(args?: Req<"chat.tree">): Promise<Res<"chat.tree">>;
  };
  commands: {
    /** List all CLI/API operations and parity classifications. (`dench help`) */
    list(args?: Req<"commands.list">): Promise<Res<"commands.list">>;
  };
  crm: {
    actions: {
      /** Create or upsert an action button on a named action column (fieldName is the column header; a column can hold multiple buttons — reuse fieldName to add more). (`dench crm actions create`) */
      create(args: Req<"crm.actions.create">): Promise<Res<"crm.actions.create">>;
      /** Delete an action button from a CRM field. (`dench crm actions delete`) */
      delete(args: Req<"crm.actions.delete">): Promise<Res<"crm.actions.delete">>;
      /** List CRM actions. (`dench crm actions list`) */
      list(args?: Req<"crm.actions.list">): Promise<Res<"crm.actions.list">>;
      /** Run a CRM action on one or more entries. (`dench crm actions run`) */
      run(args: Req<"crm.actions.run">): Promise<Res<"crm.actions.run">>;
      /** Update an action button on a CRM field. (`dench crm actions edit`) */
      update(args: Req<"crm.actions.update">): Promise<Res<"crm.actions.update">>;
    };
    activity: {
      /** Bounded per-source counts of a CRM entry's activity ledger. (`dench crm activity`) */
      count(args: Req<"crm.activity.count">): Promise<Res<"crm.activity.count">>;
      /** List a CRM entry's activity ledger (comments, notes, field changes, emails, meetings, Slack, LinkedIn) in one timeline, newest first by default. (`dench crm activity`) */
      list(args: Req<"crm.activity.list">): Promise<Res<"crm.activity.list">>;
    };
    /** Aggregate CRM entries. (`dench crm aggregate`) */
    aggregate(args: Req<"crm.aggregate">): Promise<Res<"crm.aggregate">>;
    analytics: {
      /** Collapse the analytics strip above the object's table (team-shared, like saved views). (`dench crm analytics collapse`) */
      collapse(args: Req<"crm.analytics.collapse">): Promise<Res<"crm.analytics.collapse">>;
      /** Compute chart-ready results (buckets / series / values) for the stored dashboard, a subset of its panels, or ad-hoc panel definitions — optionally scoped to a saved view, a period preset (with the previous interval as previousValue) and extra filters. Same query the strip renders from. (`dench crm analytics compute`) */
      compute(args: Req<"crm.analytics.compute">): Promise<Res<"crm.analytics.compute">>;
      /** Delete one panel (idempotent). Template panels are tombstoned so a re-install never resurrects them. (`dench crm analytics delete`) */
      delete(args: Req<"crm.analytics.delete">): Promise<Res<"crm.analytics.delete">>;
      /** Expand the analytics strip above the object's table. (`dench crm analytics expand`) */
      expand(args: Req<"crm.analytics.expand">): Promise<Res<"crm.analytics.expand">>;
      /** Read an object's analytics dashboard: panels, field roles, the strip's collapsed flag, the named view's own dashboard (if any), and the fields panels may bucket on (synthetic $createdAt / $location last). (`dench crm analytics get`) */
      get(args: Req<"crm.analytics.get">): Promise<Res<"crm.analytics.get">>;
      /** Take a chart off the strip above the table (hidden: true). It stays in the full analytics view, counted by the strip's “+N more”. (`dench crm analytics hide`) */
      hide(args: Req<"crm.analytics.hide">): Promise<Res<"crm.analytics.hide">>;
      /** Persist the full panel order. panelIds must name every stored panel of the targeted dashboard. (`dench crm analytics reorder`) */
      reorder(args: Req<"crm.analytics.reorder">): Promise<Res<"crm.analytics.reorder">>;
      /** Set a card's width on the 6-track dashboard grid: span 2 (third), 3 (half), 4 (two thirds), 6 (full), or null for the chart kind's default. (`dench crm analytics resize`) */
      resize(args: Req<"crm.analytics.resize">): Promise<Res<"crm.analytics.resize">>;
      /** Set the object's analytics setup — the field roles shared by every chart and view (amount, stage, won/lost/converted values, stageProbabilities, closeDate, recurrence, owner, location). Replaces the mapping; with merge: true only the keys given change and null clears one. (`dench crm analytics roles`) */
      roles(args: Req<"crm.analytics.roles">): Promise<Res<"crm.analytics.roles">>;
      /** Create or update one panel (upsert by id). With viewName the write lands on that saved view's own dashboard, forking a copy if it was still inheriting the object's. (`dench crm analytics save`) */
      save(args: Req<"crm.analytics.save">): Promise<Res<"crm.analytics.save">>;
      /** Give a saved view its own dashboard (mode "own": starts as a copy of the object's panels) or hand it back to the object's shared one (mode "shared"). (`dench crm analytics scope`) */
      scope(args: Req<"crm.analytics.scope">): Promise<Res<"crm.analytics.scope">>;
      /** Bring a hidden chart back onto the strip (hidden: false). (`dench crm analytics show`) */
      show(args: Req<"crm.analytics.show">): Promise<Res<"crm.analytics.show">>;
      /** Edit part of one stored panel: only the keys in `patch` change (title, type, metric, metricField, groupBy, dateField, dateBucket, filters, derived, span, hidden, sortOrder); null clears an optional key. What the card's ⋮ menu writes. (`dench crm analytics update`) */
      update(args: Req<"crm.analytics.update">): Promise<Res<"crm.analytics.update">>;
    };
    automations: {
      /** List deterministic CRM automations (rules that fire inside entry writes, e.g. qualified prospect → opportunity). (`dench crm automations list`) */
      list(args?: Req<"crm.automations.list">): Promise<Res<"crm.automations.list">>;
      /** Enable or disable a CRM automation. (`dench crm automations enable|disable`) */
      setEnabled(args: Req<"crm.automations.setEnabled">): Promise<Res<"crm.automations.setEnabled">>;
    };
    /** Apply a CRM batch. (`dench crm batch`) */
    batch(args: Req<"crm.batch">): Promise<Res<"crm.batch">>;
    brief: {
      /** The record's generated Brief: health, who owes the next move, open threads, commitments, risks, next step. Read this before the ledger. (`dench crm brief`) */
      get(args: Req<"crm.brief.get">): Promise<Res<"crm.brief.get">>;
      /** Rebuild a record's Brief from the current timeline. (`dench crm brief --regenerate`) */
      regenerate(args: Req<"crm.brief.regenerate">): Promise<Res<"crm.brief.regenerate">>;
    };
    cells: {
      /** Append to a CRM cell. (`dench crm cells append`) */
      append(args: Req<"crm.cells.append">): Promise<Res<"crm.cells.append">>;
      /** Get a CRM cell value. (`dench crm cells get`) */
      get(args: Req<"crm.cells.get">): Promise<Res<"crm.cells.get">>;
      /** Set a CRM cell value. (`dench crm cells set`) */
      set(args: Req<"crm.cells.set">): Promise<Res<"crm.cells.set">>;
      /** Set many CRM cell values. (`dench crm cells set-many`) */
      setMany(args: Req<"crm.cells.setMany">): Promise<Res<"crm.cells.setMany">>;
    };
    comments: {
      /** Comment on a CRM entry (markdown). Mention members with [@Name](/?member=<userId>); mention Dench with [@Dench](/?member=dench) or mentionDench. (`dench crm comments create`) */
      create(args: Req<"crm.comments.create">): Promise<Res<"crm.comments.create">>;
      /** Delete a comment (kept as a tombstone when it has replies). (`dench crm comments delete`) */
      delete(args: Req<"crm.comments.delete">): Promise<Res<"crm.comments.delete">>;
      /** Get one comment with its entry label. (`dench crm comments get`) */
      get(args: Req<"crm.comments.get">): Promise<Res<"crm.comments.get">>;
      /** List comments on a CRM entry (roots newest first, with preview replies). (`dench crm comments list`) */
      list(args: Req<"crm.comments.list">): Promise<Res<"crm.comments.list">>;
      /** Toggle an emoji reaction on a comment. (`dench crm comments react`) */
      react(args: Req<"crm.comments.react">): Promise<Res<"crm.comments.react">>;
      /** List every reply under a root comment, oldest first. (`dench crm comments replies`) */
      replies(args: Req<"crm.comments.replies">): Promise<Res<"crm.comments.replies">>;
      /** Edit a comment you wrote. (`dench crm comments update`) */
      update(args: Req<"crm.comments.update">): Promise<Res<"crm.comments.update">>;
    };
    companies: {
      /** Search for companies through the enrichment gateway (also `dench companies find`). (`dench crm companies search`) */
      search(args: Req<"crm.companies.search">): Promise<Res<"crm.companies.search">>;
    };
    context: {
      /** Read-only source diagnostics: accessible evidence, association reasons, last Brief source manifest, generation queue, and your mailbox delivery health. Bounded, cursor-paged snapshot; does not certify complete history. (`dench crm context`) */
      get(args: Req<"crm.context.get">): Promise<Res<"crm.context.get">>;
    };
    detections: {
      /** List account-detection verdicts — why a domain (or personal address) did or did not become an account: verdict, counterparty type, probabilities, evidence threads, the rows created. `kind` picks the creator: `detections` (email + sweep), `linkedin` (the LinkedIn resolver's rows) or `all` (default). Newest first. (`dench crm detections list`) */
      list(args?: Req<"crm.detections.list">): Promise<Res<"crm.detections.list">>;
      /** Undo what the ingestion jobs created since a timestamp (admin): `kind` = `detections` (accounts + contacts from the email detector and the sweep), `linkedin` (the LinkedIn resolver's contacts + accounts; their conversations are unlinked and parked), `email-tasks` (auto-created tasks and cases) or `all` (default). Deletes only rows no human has touched and marks the verdicts / decisions rolled_back so they are never re-created. `dryRun` lists what would go; per-kind counts in `kinds`. (`dench crm detections undo`) */
      undo(args: Req<"crm.detections.undo">): Promise<Res<"crm.detections.undo">>;
    };
    docs: {
      /** Create a CRM document. (`dench crm docs create`) */
      create(args: Req<"crm.docs.create">): Promise<Res<"crm.docs.create">>;
      /** Delete a CRM document page; its workspace file stays and nested pages move up. (`dench crm docs delete`) */
      delete(args: Req<"crm.docs.delete">): Promise<Res<"crm.docs.delete">>;
      /** Link a CRM document. (`dench crm docs link`) */
      link(args: Req<"crm.docs.link">): Promise<Res<"crm.docs.link">>;
      /** List CRM documents. (`dench crm docs list`) */
      list(args?: Req<"crm.docs.list">): Promise<Res<"crm.docs.list">>;
    };
    enrich: {
      /** Request enrichment for one CRM cell. (`dench crm enrich cell`) */
      cell(args: Req<"crm.enrich.cell">): Promise<Res<"crm.enrich.cell">>;
      /** Request enrichment for a CRM object. (`dench crm enrich object`) */
      object(args: Req<"crm.enrich.object">): Promise<Res<"crm.enrich.object">>;
    };
    entries: {
      /** Bulk delete CRM entries. (`dench crm entries bulk-delete`) */
      bulkDelete(args: Req<"crm.entries.bulkDelete">): Promise<Res<"crm.entries.bulkDelete">>;
      /** Create a CRM entry. (`dench crm entries create`) */
      create(args: Req<"crm.entries.create">): Promise<Res<"crm.entries.create">>;
      /** Create many CRM entries. (`dench crm entries create-many`) */
      createMany(args: Req<"crm.entries.createMany">): Promise<Res<"crm.entries.createMany">>;
      /** Delete a CRM entry. (`dench crm entries delete`) */
      delete(args: Req<"crm.entries.delete">): Promise<Res<"crm.entries.delete">>;
      dossier: {
        /** Status of the account's research dossier — the delimited `dench:dossier` section Dench keeps in the record's Notes: status, when it was written, how many dated updates followed, the last error. (`dench crm entries dossier`) */
        get(args: Req<"crm.entries.dossier.get">): Promise<Res<"crm.entries.dossier.get">>;
        /** Research the account again and append a fresh dossier section to its Notes (needs a Website / Domain on the record). (`dench crm entries dossier --regenerate`) */
        regenerate(args: Req<"crm.entries.dossier.regenerate">): Promise<Res<"crm.entries.dossier.regenerate">>;
      };
      /** Get a CRM entry. (`dench crm entries get`) */
      get(args: Req<"crm.entries.get">): Promise<Res<"crm.entries.get">>;
      /** List a CRM entry's audit history. (`dench crm history`) */
      history(args: Req<"crm.entries.history">): Promise<Res<"crm.entries.history">>;
      /** List CRM entries. (`dench crm entries list [--with-references]`) */
      list(args: Req<"crm.entries.list">): Promise<Res<"crm.entries.list">>;
      /** Queue a full, paged pull of the record's email history from every connected mailbox; the ledger fills as pages land. (`dench crm entries sync-history`) */
      syncHistory(args: Req<"crm.entries.syncHistory">): Promise<Res<"crm.entries.syncHistory">>;
      /** Has Dench read this record's email history? One row per address per mailbox. (`dench crm entries sync-history --status`) */
      syncHistoryStatus(args: Req<"crm.entries.syncHistoryStatus">): Promise<Res<"crm.entries.syncHistoryStatus">>;
      /** Update a CRM entry. (`dench crm entries update`) */
      update(args: Req<"crm.entries.update">): Promise<Res<"crm.entries.update">>;
      /** Update many CRM entries. (`dench crm entries update-many`) */
      updateMany(args: Req<"crm.entries.updateMany">): Promise<Res<"crm.entries.updateMany">>;
    };
    fields: {
      /** Create a CRM field or read-only campaign activity boolean column. (`dench crm fields create`) */
      create(args: Req<"crm.fields.create">): Promise<Res<"crm.fields.create">>;
      /** Delete a CRM field. (`dench crm fields delete`) */
      delete(args: Req<"crm.fields.delete">): Promise<Res<"crm.fields.delete">>;
      enum: {
        /** Add an enum value. (`dench crm fields enum-add`) */
        add(args: Req<"crm.fields.enum.add">): Promise<Res<"crm.fields.enum.add">>;
        /** Set an enum color. (`dench crm fields enum-set-color`) */
        color(args: Req<"crm.fields.enum.color">): Promise<Res<"crm.fields.enum.color">>;
        /** Remove an enum value. (`dench crm fields enum-remove`) */
        remove(args: Req<"crm.fields.enum.remove">): Promise<Res<"crm.fields.enum.remove">>;
        /** Rename an enum value. (`dench crm fields enum-rename`) */
        rename(args: Req<"crm.fields.enum.rename">): Promise<Res<"crm.fields.enum.rename">>;
        /** Reorder enum values. (`dench crm fields enum-reorder`) */
        reorder(args: Req<"crm.fields.enum.reorder">): Promise<Res<"crm.fields.enum.reorder">>;
      };
      /** List fields for a CRM object, including read-only calculation metadata. (`dench crm fields list`) */
      list(args: Req<"crm.fields.list">): Promise<Res<"crm.fields.list">>;
      /** List field names, types and effective constraints without indexing or enrichment internals. (`dench crm fields list --compact`) */
      listCompact(args: Req<"crm.fields.listCompact">): Promise<Res<"crm.fields.listCompact">>;
      /** Reorder CRM fields. (`dench crm fields reorder`) */
      reorder(args: Req<"crm.fields.reorder">): Promise<Res<"crm.fields.reorder">>;
      /** Update a CRM field or change/explicitly clear an existing campaign calculation. (`dench crm fields update`) */
      update(args: Req<"crm.fields.update">): Promise<Res<"crm.fields.update">>;
    };
    members: {
      /** List workspace members for CRM user fields. (`dench members list`) */
      list(args?: Req<"crm.members.list">): Promise<Res<"crm.members.list">>;
    };
    notes: {
      /** Add a titled note to a CRM entry's activity timeline (markdown body). Research goes here, never into the Notes document. (`dench crm notes create`) */
      create(args: Req<"crm.notes.create">): Promise<Res<"crm.notes.create">>;
      /** List a CRM entry's notes (titled, document-style comments), newest first. (`dench crm notes list`) */
      list(args: Req<"crm.notes.list">): Promise<Res<"crm.notes.list">>;
    };
    objects: {
      /** Hide a CRM object's workspace sidebar row for the whole workspace. Not a delete — the table keeps working. Admin-only. (`dench crm objects archive`) */
      archive(args: Req<"crm.objects.archive">): Promise<Res<"crm.objects.archive">>;
      /** Create a CRM object. (`dench crm objects create`) */
      create(args: Req<"crm.objects.create">): Promise<Res<"crm.objects.create">>;
      /** Delete a CRM object. (`dench crm objects delete`) */
      delete(args: Req<"crm.objects.delete">): Promise<Res<"crm.objects.delete">>;
      /** Get a CRM object. (`dench crm objects get`) */
      get(args: Req<"crm.objects.get">): Promise<Res<"crm.objects.get">>;
      /** List CRM objects. (`dench crm objects list [--with-references]`) */
      list(args?: Req<"crm.objects.list">): Promise<Res<"crm.objects.list">>;
      /** List names, display labels, visibility and workspace counts without internal state. (`dench crm objects list --compact`) */
      listCompact(args?: Req<"crm.objects.listCompact">): Promise<Res<"crm.objects.listCompact">>;
      /** Rename a CRM object. (`dench crm objects rename`) */
      rename(args: Req<"crm.objects.rename">): Promise<Res<"crm.objects.rename">>;
      /** Restore a CRM object's workspace sidebar row. Admin-only. (`dench crm objects unarchive`) */
      unarchive(args: Req<"crm.objects.unarchive">): Promise<Res<"crm.objects.unarchive">>;
      /** Update a CRM object. (`dench crm objects update`) */
      update(args: Req<"crm.objects.update">): Promise<Res<"crm.objects.update">>;
    };
    people: {
      /** Search for people through the enrichment gateway. `companyDomains` takes up to 1000 domains (e.g. a resolved company list; `dench leads find --company-list <id|view>` resolves one for you) — the gateway fans large lists out as sequential vendor-safe chunks behind one `nextPageToken` stream. (`dench crm people search`) */
      search(args: Req<"crm.people.search">): Promise<Res<"crm.people.search">>;
    };
    privacy: {
      /** Whether the caller hides their own emails / messages with this record from the workspace (directly, or through its account), and whether they own a connection the toggle applies to. (`dench crm privacy status`) */
      get(args: Req<"crm.privacy.get">): Promise<Res<"crm.privacy.get">>;
      /** Hide (`hidden: true`) or show the caller's own emails / messages with this record to the workspace. An account covers every contact and opportunity linked to it; existing ledger rows are restamped and the shared Brief regenerates. (`dench crm privacy hide|show`) */
      set(args: Req<"crm.privacy.set">): Promise<Res<"crm.privacy.set">>;
    };
    /** Query CRM entries. (`dench crm query [--with-references]`) */
    query(args: Req<"crm.query">): Promise<Res<"crm.query">>;
    /** Scan CRM entries with a resumable cursor. Empty filtered pages can have more results. (`dench crm query --page`) */
    queryPage(args: Req<"crm.queryPage">): Promise<Res<"crm.queryPage">>;
    reports: {
      /** Generate a CRM report. (`dench crm reports generate`) */
      generate(args: Req<"crm.reports.generate">): Promise<Res<"crm.reports.generate">>;
    };
    search: {
      /** Search CRM entries. (`dench crm search [--with-references]`) */
      (args?: Req<"crm.search">): Promise<Res<"crm.search">>;
      $call(args?: Req<"crm.search">): Promise<Res<"crm.search">>;
      /** Search bounded pages of readable CRM entries, optionally projecting cells. Always follow continueCursor until isDone. (`dench crm search --page`) */
      page(args?: Req<"crm.search.page">): Promise<Res<"crm.search.page">>;
    };
    sidebar: {
      groups: {
        /** Create a named sidebar group (e.g. "Hiring") in the workspace-shared Library. Open to any member. (`dench crm sidebar group create`) */
        create(args: Req<"crm.sidebar.groups.create">): Promise<Res<"crm.sidebar.groups.create">>;
        /** Dissolve a sidebar group; its rows return to the top level in its slot. Open to any member. (`dench crm sidebar group delete`) */
        delete(args: Req<"crm.sidebar.groups.delete">): Promise<Res<"crm.sidebar.groups.delete">>;
        /** Move a sidebar row into a group (groupId set) or back to the top level (groupId null). Open to any member. (`dench crm sidebar group add`) */
        "move-item"(args: Req<"crm.sidebar.groups.move-item">): Promise<Res<"crm.sidebar.groups.move-item">>;
        /** Rename a sidebar group. Open to any member. (`dench crm sidebar group rename`) */
        rename(args: Req<"crm.sidebar.groups.rename">): Promise<Res<"crm.sidebar.groups.rename">>;
      };
      /** Describe the workspace sidebar: Library rows in tree order (with their groups), the home-level Pinned strip, what is hidden and why, and whether the caller is an admin. (`dench crm sidebar list`) */
      list(args?: Req<"crm.sidebar.list">): Promise<Res<"crm.sidebar.list">>;
      /** Reposition one Library row (or group) among the Library's top-level slots. Does not add a home-level Pinned tab. Workspace-shared; admin-only. (`dench crm sidebar move`) */
      move(args: Req<"crm.sidebar.move">): Promise<Res<"crm.sidebar.move">>;
      pins: {
        /** Pin (pinned true) or unpin a Library row — or a whole group — on the home-level Pinned shortcut strip (the "tab on the left"). Does not move the row inside Library. Workspace-shared; open to any member. (`dench crm sidebar pin`) */
        set(args: Req<"crm.sidebar.pins.set">): Promise<Res<"crm.sidebar.pins.set">>;
      };
    };
    /** Run CRM SQL-compatible query. (`dench crm sql`) */
    sql(args: Req<"crm.sql">): Promise<Res<"crm.sql">>;
    statuses: {
      /** List CRM statuses. (`dench crm statuses list`) */
      list(args: Req<"crm.statuses.list">): Promise<Res<"crm.statuses.list">>;
      /** Set CRM statuses. (`dench crm statuses set`) */
      set(args: Req<"crm.statuses.set">): Promise<Res<"crm.statuses.set">>;
    };
    tasks: {
      /** Mark a task done. (`dench crm tasks complete`) */
      complete(args: Req<"crm.tasks.complete">): Promise<Res<"crm.tasks.complete">>;
      /** Create a task linked to a CRM entry. (`dench crm tasks create`) */
      createForEntry(args: Req<"crm.tasks.createForEntry">): Promise<Res<"crm.tasks.createForEntry">>;
      /** Delete a task and its subtasks, or keep them as tasks. (`dench crm tasks delete`) */
      delete(args: Req<"crm.tasks.delete">): Promise<Res<"crm.tasks.delete">>;
      /** Tasks linked to a CRM entry. (`dench crm tasks list`) */
      forEntry(args: Req<"crm.tasks.forEntry">): Promise<Res<"crm.tasks.forEntry">>;
      /** Your open tasks (plus ones completed today). (`dench crm tasks mine`) */
      mine(args?: Req<"crm.tasks.mine">): Promise<Res<"crm.tasks.mine">>;
      /** Page assigned tasks in priority order (or completed tasks by recency). (`dench crm tasks mine --page`) */
      pageAssigned(args: Req<"crm.tasks.pageAssigned">): Promise<Res<"crm.tasks.pageAssigned">>;
      /** Page all tasks linked to a record, including subtasks. (`dench crm tasks list --page`) */
      pageForEntry(args: Req<"crm.tasks.pageForEntry">): Promise<Res<"crm.tasks.pageForEntry">>;
      /** Start or resume preparation of exact task ordering and progress. (`dench crm tasks prepare`) */
      prepare(args: Req<"crm.tasks.prepare">): Promise<Res<"crm.tasks.prepare">>;
      /** Reopen a completed task. (`dench crm tasks reopen`) */
      reopen(args: Req<"crm.tasks.reopen">): Promise<Res<"crm.tasks.reopen">>;
      repeat: {
        /** Stop a task repeating (past occurrences are kept). (`dench crm tasks repeat --off`) */
        clear(args: Req<"crm.tasks.repeat.clear">): Promise<Res<"crm.tasks.repeat.clear">>;
        /** How a task repeats (rule, RRULE, trigger, ends, next due). (`dench crm tasks repeat`) */
        get(args: Req<"crm.tasks.repeat.get">): Promise<Res<"crm.tasks.repeat.get">>;
        /** Pause a repeating task. (`dench crm tasks repeat --pause`) */
        pause(args: Req<"crm.tasks.repeat.pause">): Promise<Res<"crm.tasks.repeat.pause">>;
        /** Resume a paused repeating task. (`dench crm tasks repeat --resume`) */
        resume(args: Req<"crm.tasks.repeat.resume">): Promise<Res<"crm.tasks.repeat.resume">>;
        /** Make a task repeat, or change how it repeats (JSON rule or RRULE). An undated task gets its due date anchored on the first matching day from today. (`dench crm tasks repeat`) */
        set(args: Req<"crm.tasks.repeat.set">): Promise<Res<"crm.tasks.repeat.set">>;
        /** Skip the current occurrence: the next one is created now. (`dench crm tasks repeat --skip`) */
        skip(args: Req<"crm.tasks.repeat.skip">): Promise<Res<"crm.tasks.repeat.skip">>;
      };
      series: {
        /** Every repeating-task series in the workspace. (`dench crm tasks series`) */
        list(args?: Req<"crm.tasks.series.list">): Promise<Res<"crm.tasks.series.list">>;
        /** Every occurrence (task) of one series. (`dench crm tasks series <seriesId> --occurrences`) */
        occurrences(args: Req<"crm.tasks.series.occurrences">): Promise<Res<"crm.tasks.series.occurrences">>;
      };
      /** Nest a task under a parent, or promote it (parentEntryId: null). (`dench crm tasks parent`) */
      setParent(args: Req<"crm.tasks.setParent">): Promise<Res<"crm.tasks.setParent">>;
      /** Set or clear a task's priority. (`dench crm tasks priority`) */
      setPriority(args: Req<"crm.tasks.setPriority">): Promise<Res<"crm.tasks.setPriority">>;
      subtasks: {
        /** Create a subtask under a task (inherits the parent's record relations). (`dench crm tasks create-subtask`) */
        create(args: Req<"crm.tasks.subtasks.create">): Promise<Res<"crm.tasks.subtasks.create">>;
        /** A task's subtasks. (`dench crm tasks subtasks`) */
        list(args: Req<"crm.tasks.subtasks.list">): Promise<Res<"crm.tasks.subtasks.list">>;
      };
    };
    templates: {
      /** Install a CRM template. Idempotent: re-installs top up missing pieces and never duplicate objects, automations, or sample rows. (`dench crm templates install`) */
      install(args: Req<"crm.templates.install">): Promise<Res<"crm.templates.install">>;
      /** List one-click CRM templates (objects + automations + sample rows) with per-workspace installed flags. (`dench crm templates list`) */
      list(args?: Req<"crm.templates.list">): Promise<Res<"crm.templates.list">>;
      /** Delete a CRM template's sample rows (tagged "Sample"); schema, views, and automations stay. (`dench crm templates remove-sample-data`) */
      removeSampleData(args: Req<"crm.templates.removeSampleData">): Promise<Res<"crm.templates.removeSampleData">>;
    };
    transaction: {
      /** Abort a CRM transaction. (`dench crm transaction abort`) */
      abort(args: Req<"crm.transaction.abort">): Promise<Res<"crm.transaction.abort">>;
      /** Add an operation to a CRM transaction. (`dench crm transaction add`) */
      add(args: Req<"crm.transaction.add">): Promise<Res<"crm.transaction.add">>;
      /** Begin a CRM transaction. (`dench crm transaction begin`) */
      begin(args: Req<"crm.transaction.begin">): Promise<Res<"crm.transaction.begin">>;
      /** Commit a CRM transaction. (`dench crm transaction commit`) */
      commit(args: Req<"crm.transaction.commit">): Promise<Res<"crm.transaction.commit">>;
      /** Inspect a CRM transaction. (`dench crm transaction inspect`) */
      inspect(args: Req<"crm.transaction.inspect">): Promise<Res<"crm.transaction.inspect">>;
    };
    views: {
      /** Move a pinned view's sidebar row into the Archived flyout. Admin-only. (`dench crm views archive`) */
      archive(args: Req<"crm.views.archive">): Promise<Res<"crm.views.archive">>;
      /** Create a saved view (named filters/sort/columns combo) on a CRM object. (`dench crm views create`) */
      create(args: Req<"crm.views.create">): Promise<Res<"crm.views.create">>;
      /** Delete a saved view by name (idempotent). (`dench crm views delete`) */
      delete(args: Req<"crm.views.delete">): Promise<Res<"crm.views.delete">>;
      /** Materialize a saved view's rows (applies its filters/sort/pins), paginated. (`dench crm views entries`) */
      entries(args: Req<"crm.views.entries">): Promise<Res<"crm.views.entries">>;
      /** Get one saved view's definition by name. (`dench crm views get`) */
      get(args: Req<"crm.views.get">): Promise<Res<"crm.views.get">>;
      /** List the saved views on a CRM object (plus the active view). (`dench crm views list`) */
      list(args: Req<"crm.views.list">): Promise<Res<"crm.views.list">>;
      /** Rename a saved view in place — keeps its filters, pins, and sidebar slot. (`dench crm views rename`) */
      rename(args: Req<"crm.views.rename">): Promise<Res<"crm.views.rename">>;
      /** Restore a view's sidebar row (re-asserts its pin). Admin-only. (`dench crm views unarchive`) */
      unarchive(args: Req<"crm.views.unarchive">): Promise<Res<"crm.views.unarchive">>;
      /** Replace a saved view's definition (upsert by name). (`dench crm views update`) */
      update(args: Req<"crm.views.update">): Promise<Res<"crm.views.update">>;
    };
    watch: {
      /** Whether you follow a CRM entry's activity. (`dench crm watch status`) */
      get(args: Req<"crm.watch.get">): Promise<Res<"crm.watch.get">>;
      /** Follow or unfollow a CRM entry's activity. (`dench crm watch`) */
      set(args: Req<"crm.watch.set">): Promise<Res<"crm.watch.set">>;
    };
  };
  cron: {
    /** Create a routine. (`dench cron create`) */
    create(args: Req<"cron.create">): Promise<Res<"cron.create">>;
    /** Delete a routine. (`dench cron delete`) */
    delete(args: Req<"cron.delete">): Promise<Res<"cron.delete">>;
    /** Disable a routine. (`dench cron disable`) */
    disable(args: Req<"cron.disable">): Promise<Res<"cron.disable">>;
    /** Enable a routine. (`dench cron enable`) */
    enable(args: Req<"cron.enable">): Promise<Res<"cron.enable">>;
    /** Get a routine. (`dench cron get`) */
    get(args: Req<"cron.get">): Promise<Res<"cron.get">>;
    /** List routine run history. (`dench cron history`) */
    history(args?: Req<"cron.history">): Promise<Res<"cron.history">>;
    /** List routines. (`dench cron list`) */
    list(args?: Req<"cron.list">): Promise<Res<"cron.list">>;
    /** Run a routine now. (`dench cron run`) */
    run(args: Req<"cron.run">): Promise<Res<"cron.run">>;
    /** List runs for a routine. (`dench cron runs`) */
    runs(args: Req<"cron.runs">): Promise<Res<"cron.runs">>;
    /** Update a routine. (`dench cron update`) */
    update(args: Req<"cron.update">): Promise<Res<"cron.update">>;
  };
  email: {
    campaign: {
      /** Cancel an email campaign. (`dench email campaign cancel`) */
      cancel(args: Req<"email.campaign.cancel">): Promise<Res<"email.campaign.cancel">>;
      /** Create a managed email campaign draft from a connected inbox or verified sender. (`dench email campaign create`) */
      create(args: Req<"email.campaign.create">): Promise<Res<"email.campaign.create">>;
      /** Read campaign status and counters. (`dench email campaign status`) */
      get(args: Req<"email.campaign.get">): Promise<Res<"email.campaign.get">>;
      /** List managed email campaigns (paginated, optional status filter). (`dench email campaign list`) */
      list(args?: Req<"email.campaign.list">): Promise<Res<"email.campaign.list">>;
      /** Pause a sending email campaign. (`dench email campaign pause`) */
      pause(args: Req<"email.campaign.pause">): Promise<Res<"email.campaign.pause">>;
      /** Preview rendered messages for a campaign sample. (`dench email campaign preview`) */
      preview(args: Req<"email.campaign.preview">): Promise<Res<"email.campaign.preview">>;
      recipients: {
        /** Add recipients to a managed email campaign. (`dench email campaign recipients add`) */
        add(args: Req<"email.campaign.recipients.add">): Promise<Res<"email.campaign.recipients.add">>;
        /** Add campaign recipients from a CRM object: pick the object, the email field, and the entry ids. (`dench email campaign recipients add-from-object`) */
        addFromObject(args: Req<"email.campaign.recipients.addFromObject">): Promise<Res<"email.campaign.recipients.addFromObject">>;
        /** List a campaign's recipients (paginated, optional status filter). (`dench email campaign recipients list`) */
        list(args: Req<"email.campaign.recipients.list">): Promise<Res<"email.campaign.recipients.list">>;
      };
      /** Resume a paused email campaign. (`dench email campaign resume`) */
      resume(args: Req<"email.campaign.resume">): Promise<Res<"email.campaign.resume">>;
      /** Submit a campaign for approval or sending. (`dench email campaign submit`) */
      submit(args: Req<"email.campaign.submit">): Promise<Res<"email.campaign.submit">>;
    };
    drafts: {
      /** Create an editable Dench email draft and synchronize its selected native mailbox asynchronously. Use a stable requestId for retries. (`dench email draft create`) */
      create(args: Req<"email.drafts.create">): Promise<Res<"email.drafts.create">>;
      /** Read an email draft, eligible senders and provider sync status. (`dench email draft show`) */
      get(args: Req<"email.drafts.get">): Promise<Res<"email.drafts.get">>;
      /** Send the current Dench draft revision through its native mailbox. Repeated requests share a durable receipt. (`dench email draft send`) */
      send(args: Req<"email.drafts.send">): Promise<Res<"email.drafts.send">>;
      /** List native mailboxes this caller may use. (`dench email draft senders`) */
      senders(args?: Req<"email.drafts.senders">): Promise<Res<"email.drafts.senders">>;
      /** Load the selected mailbox signature for explicit visible insertion. (`dench email draft signature`) */
      signature(args: Req<"email.drafts.signature">): Promise<Res<"email.drafts.signature">>;
      /** Save draft content using expectedRevision; sender changes require a new draft after provider binding. (`dench email draft update`) */
      update(args: Req<"email.drafts.update">): Promise<Res<"email.drafts.update">>;
      /** Upload attachment bytes authorized against this draft before adding its storage reference. (`dench email draft attach`) */
      upload(args: Req<"email.drafts.upload">): Promise<Res<"email.drafts.upload">>;
    };
    identity: {
      /** Begin the full Dench sender verification flow for a sending identity. (`dench email identity verify`) */
      beginVerification(args: Req<"email.identity.beginVerification">): Promise<Res<"email.identity.beginVerification">>;
      /** Create a durable Dench email sending identity record. (`dench email identity verify`) */
      create(args: Req<"email.identity.create">): Promise<Res<"email.identity.create">>;
      /** Permanently delete a sender (or every sender on a domain) from the workspace; re-adding it requires verification from scratch. (`dench email identity delete`) */
      delete(args: Req<"email.identity.delete">): Promise<Res<"email.identity.delete">>;
      /** Soft-disable a sender (or every sender on a domain) for the workspace; sends are blocked until restored. (`dench email identity disable`) */
      disable(args: Req<"email.identity.disable">): Promise<Res<"email.identity.disable">>;
      /** Fetch DNS records (DKIM/SPF/DMARC) for a pending domain sender verification. (`dench email identity dns`) */
      dns(args: Req<"email.identity.dns">): Promise<Res<"email.identity.dns">>;
      /** List the workspace's email sending identities. (`dench email identity list`) */
      list(args?: Req<"email.identity.list">): Promise<Res<"email.identity.list">>;
      /** Refresh a Dench Emailing Service sender verification status. (`dench email identity status --identity-id`) */
      refresh(args: Req<"email.identity.refresh">): Promise<Res<"email.identity.refresh">>;
      /** Restore a previously disabled sender for the workspace. (`dench email identity restore`) */
      restore(args: Req<"email.identity.restore">): Promise<Res<"email.identity.restore">>;
      /** Read Dench Emailing Service sender verification status. (`dench email identity status`) */
      status(args: Req<"email.identity.status">): Promise<Res<"email.identity.status">>;
      /** Start Dench Emailing Service sender verification. (`dench email identity verify`) */
      verify(args: Req<"email.identity.verify">): Promise<Res<"email.identity.verify">>;
    };
    inbox: {
      /** Read a bounded stored body using an exact message handle from inbox search; rechecks mailbox and record privacy. (`dench email inbox message`) */
      message(args: Req<"email.inbox.message">): Promise<Res<"email.inbox.message">>;
      /** Search authorized synced mailbox headers with bounded cursor pagination. isDone covers stored records, not provider completeness. (`dench email inbox search`) */
      search(args?: Req<"email.inbox.search">): Promise<Res<"email.inbox.search">>;
      /** Read a bounded page of synced headers using an exact thread handle from inbox search; bodies remain on demand. (`dench email inbox thread`) */
      thread(args: Req<"email.inbox.thread">): Promise<Res<"email.inbox.thread">>;
    };
    message: {
      /** Read a raw email message's status and open/click counters. (`dench email message status`) */
      get(args: Req<"email.message.get">): Promise<Res<"email.message.get">>;
      /** List recent raw email messages for the workspace. (`dench email message list`) */
      list(args?: Req<"email.message.list">): Promise<Res<"email.message.list">>;
    };
    native: {
      /** Send through a native Gmail or Outlook mailbox with a durable request receipt. Only use for an explicit send request. (`dench email send [--mailbox <id/email>]`) */
      send(args: Req<"email.native.send">): Promise<Res<"email.native.send">>;
    };
    /** Send one raw email (no campaign): to/cc/bcc, custom from-name and reply-to, optional reply threading via replyToMessageId. (`dench email send --from <verified-email>`) */
    send(args: Req<"email.send">): Promise<Res<"email.send">>;
    sequence: {
      /** Activate a sequence so its enrollments begin sending. (`dench email sequence activate`) */
      activate(args: Req<"email.sequence.activate">): Promise<Res<"email.sequence.activate">>;
      /** Archive a sequence (stops all sending). (`dench email sequence archive`) */
      archive(args: Req<"email.sequence.archive">): Promise<Res<"email.sequence.archive">>;
      /** Create a follow-up sequence from a connected inbox or verified sender. (`dench email sequence create`) */
      create(args: Req<"email.sequence.create">): Promise<Res<"email.sequence.create">>;
      /** Deactivate a sequence (pause sending, revert to draft). (`dench email sequence deactivate`) */
      deactivate(args: Req<"email.sequence.deactivate">): Promise<Res<"email.sequence.deactivate">>;
      /** Enroll explicit recipients into a sequence. (`dench email sequence enroll`) */
      enroll(args: Req<"email.sequence.enroll">): Promise<Res<"email.sequence.enroll">>;
      /** Enroll people from a CRM object: pick the object, the email field, and the entry ids. (`dench email sequence enroll-from-object`) */
      enrollFromObject(args: Req<"email.sequence.enrollFromObject">): Promise<Res<"email.sequence.enrollFromObject">>;
      enrollment: {
        /** Pause one enrollment. (`dench email sequence enrollment pause`) */
        pause(args: Req<"email.sequence.enrollment.pause">): Promise<Res<"email.sequence.enrollment.pause">>;
        /** Resume one paused enrollment. (`dench email sequence enrollment resume`) */
        resume(args: Req<"email.sequence.enrollment.resume">): Promise<Res<"email.sequence.enrollment.resume">>;
        /** Stop one enrollment (no further steps send). (`dench email sequence enrollment stop`) */
        stop(args: Req<"email.sequence.enrollment.stop">): Promise<Res<"email.sequence.enrollment.stop">>;
      };
      enrollments: {
        /** List a sequence's enrollments (paginated, optional status filter). (`dench email sequence enrollments list`) */
        list(args: Req<"email.sequence.enrollments.list">): Promise<Res<"email.sequence.enrollments.list">>;
      };
      /** Read a sequence with its ordered steps. (`dench email sequence status`) */
      get(args: Req<"email.sequence.get">): Promise<Res<"email.sequence.get">>;
      /** List the workspace's follow-up sequences. (`dench email sequence list`) */
      list(args?: Req<"email.sequence.list">): Promise<Res<"email.sequence.list">>;
      step: {
        /** Add a step (subject, body, and wait delay) to a sequence. (`dench email sequence steps add`) */
        add(args: Req<"email.sequence.step.add">): Promise<Res<"email.sequence.step.add">>;
        /** Remove a step from a sequence. (`dench email sequence steps remove`) */
        remove(args: Req<"email.sequence.step.remove">): Promise<Res<"email.sequence.step.remove">>;
        /** Reorder a sequence's steps. (`dench email sequence steps reorder`) */
        reorder(args: Req<"email.sequence.step.reorder">): Promise<Res<"email.sequence.step.reorder">>;
        /** Update a sequence step's subject, body, or delay. (`dench email sequence steps update`) */
        update(args: Req<"email.sequence.step.update">): Promise<Res<"email.sequence.step.update">>;
      };
      /** Update a sequence's name, sender, or reply/stop settings. (`dench email sequence update`) */
      update(args: Req<"email.sequence.update">): Promise<Res<"email.sequence.update">>;
    };
    template: {
      /** Create a managed email campaign template. (`dench email template create`) */
      create(args: Req<"email.template.create">): Promise<Res<"email.template.create">>;
      /** Preview a managed email campaign template. (`dench email template preview`) */
      preview(args: Req<"email.template.preview">): Promise<Res<"email.template.preview">>;
    };
  };
  enrichment: {
    company: {
      /** Look up one company profile. (`dench crm enrich cell`) */
      (args: Req<"enrichment.company">): Promise<Res<"enrichment.company">>;
      $call(args: Req<"enrichment.company">): Promise<Res<"enrichment.company">>;
      /** Read company employees, founders, funding, investors, acquisitions, or investments. Pass domain or linkedinUrl, kind, limit (1–100), and optional pageToken. Does not import CRM records or buy contacts. (`dench companies related`) */
      related(args: Req<"enrichment.company.related">): Promise<Res<"enrichment.company.related">>;
    };
    jobs: {
      /** Search job postings through Dench find. `companyDomains` takes up to 1000 domains (chunked automatically); `dench jobs find --company-list <id|view>` resolves a saved company list into it. (`dench jobs find`) */
      search(args: Req<"enrichment.jobs.search">): Promise<Res<"enrichment.jobs.search">>;
    };
    person: {
      /** Look up one person profile. (`dench crm enrich cell`) */
      (args: Req<"enrichment.person">): Promise<Res<"enrichment.person">>;
      $call(args: Req<"enrichment.person">): Promise<Res<"enrichment.person">>;
      /** Look up verified emails and phones for people. (`dench crm enrich cell`) */
      contact(args: Req<"enrichment.person.contact">): Promise<Res<"enrichment.person.contact">>;
    };
    profiles: {
      /** Look up up to 100 people or company profiles without buying emails or phones. Pass kind (people|companies) and lookups; results preserve inputIndex. People require linkedinUrl or email; companies require domain or linkedinUrl. (`dench crm enrich profiles`) */
      bulk(args: Req<"enrichment.profiles.bulk">): Promise<Res<"enrichment.profiles.bulk">>;
    };
    search: {
      /** Preview how many records a find would return. (`dench leads find --limit 1`) */
      preview(args: Req<"enrichment.search.preview">): Promise<Res<"enrichment.search.preview">>;
    };
  };
  environments: {
    /** Retire a saved setup from new selection; retain immutable revisions and active job evidence. (`dench env delete`) */
    delete(args: Req<"environments.delete">): Promise<Res<"environments.delete">>;
    /** Inspect a saved setup, its manifest, and an optional immutable revision. (`dench env show`) */
    get(args: Req<"environments.get">): Promise<Res<"environments.get">>;
    /** List workspace-shared reusable setups and ready revisions (metadata only). (`dench env list`) */
    list(args?: Req<"environments.list">): Promise<Res<"environments.list">>;
    /** Publish an explicitly saved source and manifest for one-time preparation. Returns pending/building until verified; does not run the task. (`dench env save`) */
    save(args: Req<"environments.save">): Promise<Res<"environments.save">>;
    /** Reserve an owner-bound source upload. Prefix the uploaded bytes with the returned proof before saving. (`dench env save`) */
    upload(args: Req<"environments.upload">): Promise<Res<"environments.upload">>;
  };
  files: {
    /** Read a workspace file's text. (`dench files cat`) */
    content(args?: Req<"files.content">): Promise<Res<"files.content">>;
    /** Remove a workspace file or directory. (`dench files rm`) */
    delete(args: Req<"files.delete">): Promise<Res<"files.delete">>;
    /** Get a signed file download URL. (`dench files download`) */
    downloadUrl(args?: Req<"files.downloadUrl">): Promise<Res<"files.downloadUrl">>;
    /** List workspace files. (`dench files ls`) */
    list(args?: Req<"files.list">): Promise<Res<"files.list">>;
    /** Create a workspace directory (and any missing parents). Idempotent. (`dench files mkdir`) */
    mkdir(args: Req<"files.mkdir">): Promise<Res<"files.mkdir">>;
    /** Move a workspace file or directory. (`dench files mv`) */
    move(args: Req<"files.move">): Promise<Res<"files.move">>;
    /** Stage uploaded content into the workspace. (`dench stage`) */
    stage(args: Req<"files.stage">): Promise<Res<"files.stage">>;
    /** Write a workspace file's text. (`dench files write`) */
    write(args: Req<"files.write">): Promise<Res<"files.write">>;
  };
  image: {
    /** Edit an image through the Dench gateway. (`dench image edit`) */
    edit(args: Req<"image.edit">): Promise<Res<"image.edit">>;
    /** Generate an image through the Dench gateway. (`dench image generate`) */
    generate(args: Req<"image.generate">): Promise<Res<"image.generate">>;
  };
  integrations: {
    /** List every connected integration — connected apps plus the Gmail, Outlook, Calendar, LinkedIn and Slack connections Dench provides itself (Slack rows report source: dench). (`dench integrations`) */
    list(args?: Req<"integrations.list">): Promise<Res<"integrations.list">>;
  };
  lists: {
    /** Delete a saved search / list, its exported CSV/JSONL files, and any linked watch. (`dench lists delete`) */
    delete(args: Req<"lists.delete">): Promise<Res<"lists.delete">>;
    /** Buy contact details for 1–100 saved profiles and save them to the list. Skips fields already found, looked up empty, or in flight. Requires a signed-in member or their personal agent. (`dench lists enrich`) */
    enrich(args: Req<"lists.enrich">): Promise<Res<"lists.enrich">>;
    /** Get one saved search / list by artifact id. (`dench lists show`) */
    get(args: Req<"lists.get">): Promise<Res<"lists.get">>;
    /** Explicitly import selected saved profiles, optionally filtered by enrichment, with a configured Lead status. Reuses CRM records; never sends outreach or triggers conversion. (`dench artifacts import`) */
    import(args: Req<"lists.import">): Promise<Res<"lists.import">>;
    /** List saved searches (find-result lists) in the workspace, newest first. (`dench lists`) */
    list(args?: Req<"lists.list">): Promise<Res<"lists.list">>;
    prospects: {
      /** Suggest ICP fit for one profile. Never changes a human review decision. (`dench lists assess`) */
      assess(args: Req<"lists.prospects.assess">): Promise<Res<"lists.prospects.assess">>;
      /** Read durable enrichment activity (legacy review metadata remains readable). Use lists rows for current saved profiles and contacts. (`dench lists reviews`) */
      reviews(args: Req<"lists.prospects.reviews">): Promise<Res<"lists.prospects.reviews">>;
    };
    /** Rename a saved search / list. (`dench lists rename`) */
    rename(args: Req<"lists.rename">): Promise<Res<"lists.rename">>;
    /** Read saved rows with current enrichment results and original indices; cursor-paged, without repeating a search. (`dench lists rows`) */
    rows(args: Req<"lists.rows">): Promise<Res<"lists.rows">>;
    /** Save find results as a named list (rows + filters become a workspace artifact). (`dench lists save`) */
    save(args: Req<"lists.save">): Promise<Res<"lists.save">>;
    /** Update a saved list in place (title, filters, and/or replacement rows). (`dench lists update`) */
    update(args: Req<"lists.update">): Promise<Res<"lists.update">>;
  };
  me: {
    avatar: {
      /** Remove your avatar. (`dench members me --clear-avatar`) */
      clear(args: Req<"me.avatar.clear">): Promise<Res<"me.avatar.clear">>;
      /** Set your avatar from an uploaded storageId. (`dench members me --avatar <file>`) */
      set(args: Req<"me.avatar.set">): Promise<Res<"me.avatar.set">>;
      /** Get a one-time URL to POST an avatar image to; then PUT /me/avatar with the returned storageId. (`dench members me --avatar <file>`) */
      uploadUrl(args: Req<"me.avatar.uploadUrl">): Promise<Res<"me.avatar.uploadUrl">>;
    };
    profile: {
      /** Your own member profile. (`dench members me`) */
      get(args?: Req<"me.profile.get">): Promise<Res<"me.profile.get">>;
      /** Update your name, tagline, avatar URL, or timezone. (`dench members me --name … --tagline … --timezone …`) */
      update(args: Req<"me.profile.update">): Promise<Res<"me.profile.update">>;
    };
  };
  meetings: {
    actionItems: {
      /** Add action items to a meeting; `replace: true` swaps the whole list. (`dench meetings action-items set`) */
      add(args: Req<"meetings.actionItems.add">): Promise<Res<"meetings.actionItems.add">>;
      /** Delete one action item. (`dench meetings action-items delete`) */
      delete(args: Req<"meetings.actionItems.delete">): Promise<Res<"meetings.actionItems.delete">>;
      /** List a meeting's action items. (`dench meetings action-items list`) */
      list(args: Req<"meetings.actionItems.list">): Promise<Res<"meetings.actionItems.list">>;
      /** Tick or untick one action item. (`dench meetings action-items done`) */
      setDone(args: Req<"meetings.actionItems.setDone">): Promise<Res<"meetings.actionItems.setDone">>;
    };
    /** List meetings, newest first, with status and participants. (`dench meetings list`) */
    list(args?: Req<"meetings.list">): Promise<Res<"meetings.list">>;
    participants: {
      /** Who was in the meeting, merged with the linked calendar invite. (`dench meetings participants list`) */
      list(args: Req<"meetings.participants.list">): Promise<Res<"meetings.participants.list">>;
      /** Record attendees by name/email; known members and existing people are linked, nobody is created. (`dench meetings participants set`) */
      set(args: Req<"meetings.participants.set">): Promise<Res<"meetings.participants.set">>;
    };
    sharing: {
      /** Whether a meeting is shared with the whole workspace, and whether you may change that. (`dench meetings share`) */
      get(args: Req<"meetings.sharing.get">): Promise<Res<"meetings.sharing.get">>;
      /** Share one meeting with the workspace, or take it back to owner + invitees. (`dench meetings share --workspace`) */
      set(args: Req<"meetings.sharing.set">): Promise<Res<"meetings.sharing.set">>;
    };
    transcript: {
      /** Append up to 500 transcript segments to a meeting (speakers with an email link to existing people). (`dench meetings transcript set`) */
      append(args: Req<"meetings.transcript.append">): Promise<Res<"meetings.transcript.append">>;
      /** Delete a batch of a meeting's transcript segments; repeat until `done` before re-appending. (`dench meetings transcript clear`) */
      clear(args: Req<"meetings.transcript.clear">): Promise<Res<"meetings.transcript.clear">>;
      /** Read a meeting's transcript, in order, one page at a time. (`dench meetings transcript get`) */
      list(args: Req<"meetings.transcript.list">): Promise<Res<"meetings.transcript.list">>;
    };
  };
  members: {
    /** A member's recent comments and record changes across the CRM, newest first. (`dench members activity`) */
    activity(args: Req<"members.activity">): Promise<Res<"members.activity">>;
    /** A member's profile: name, email, tagline, role, timezone, presence, open task count. (`dench members get`) */
    get(args: Req<"members.get">): Promise<Res<"members.get">>;
    /** Live presence (online / away / offline) for workspace members. (`dench members presence`) */
    presence(args?: Req<"members.presence">): Promise<Res<"members.presence">>;
    /** Open tasks assigned to a member (plus ones completed today). (`dench members tasks`) */
    tasks(args: Req<"members.tasks">): Promise<Res<"members.tasks">>;
  };
  memory: {
    /** Save a durable workspace memory fact. (`dench memory save`) */
    save(args: Req<"memory.save">): Promise<Res<"memory.save">>;
    /** Search durable workspace memory. (`dench memory search`) */
    search(args?: Req<"memory.search">): Promise<Res<"memory.search">>;
  };
  notifications: {
    /** Archive a notification. (`dench notifications archive`) */
    archive(args: Req<"notifications.archive">): Promise<Res<"notifications.archive">>;
    /** List your notifications (inbox, unread, archived, or all). (`dench notifications list`) */
    list(args?: Req<"notifications.list">): Promise<Res<"notifications.list">>;
    preferences: {
      /** Read your notification preferences. (`dench notifications prefs`) */
      get(args?: Req<"notifications.preferences.get">): Promise<Res<"notifications.preferences.get">>;
      /** Update your notification preferences. (`dench notifications prefs --set`) */
      update(args: Req<"notifications.preferences.update">): Promise<Res<"notifications.preferences.update">>;
    };
    /** Mark a notification read (or unread). (`dench notifications read`) */
    read(args: Req<"notifications.read">): Promise<Res<"notifications.read">>;
    /** Mark every inbox notification read. (`dench notifications read-all`) */
    readAll(args: Req<"notifications.readAll">): Promise<Res<"notifications.readAll">>;
    /** How many unread notifications you have. (`dench notifications count`) */
    unreadCount(args?: Req<"notifications.unreadCount">): Promise<Res<"notifications.unreadCount">>;
  };
  search: {
    /** Answer a question with web search. (`dench search answer`) */
    answer(args: Req<"search.answer">): Promise<Res<"search.answer">>;
    /** Fetch page contents through the Dench gateway. (`dench search contents`) */
    contents(args: Req<"search.contents">): Promise<Res<"search.contents">>;
    /** Search the web through the Dench gateway. (`dench search`) */
    web(args: Req<"search.web">): Promise<Res<"search.web">>;
  };
  secrets: {
    /** Revoke a workspace credential for future resolution, optionally checking its version. (`dench secrets delete`) */
    delete(args: Req<"secrets.delete">): Promise<Res<"secrets.delete">>;
    /** List workspace-shared credential names, kinds and versions; never values. (`dench secrets list`) */
    list(args?: Req<"secrets.list">): Promise<Res<"secrets.list">>;
    /** Encrypt a workspace credential. Use CLI stdin or the secure chat form; return metadata only. Do not put values in chat, manifests or scripts. (`dench secrets set`) */
    set(args: Req<"secrets.set">): Promise<Res<"secrets.set">>;
  };
  settings: {
    sync: {
      /** Read the workspace's Sync switches (accounts from email, contacts from LinkedIn, Slack Connect, calendar, dossier, tasks from email, lead auto-qualify, summaries and Brief). All on by default. (`dench settings sync`) */
      get(args?: Req<"settings.sync.get">): Promise<Res<"settings.sync.get">>;
      /** Flip Sync switches (admin). Partial patch: only the keys sent change. Off stops new work; nothing already created is removed. (`dench settings sync set`) */
      update(args: Req<"settings.sync.update">): Promise<Res<"settings.sync.update">>;
    };
  };
  tool: {
    /** Create a tool OAuth connection link. Slack is in-house, never a third-party connection: for toolkit slack the CLI prints the first-party install URL (/api/slack/install?slug=<workspace>, org admin) instead of calling this endpoint. (`dench tool connect`) */
    connect(args: Req<"tool.connect">): Promise<Res<"tool.connect">>;
    /** Disconnect an external tool account. (`dench tool disconnect`) */
    disconnect(args: Req<"tool.disconnect">): Promise<Res<"tool.disconnect">>;
    label: {
      /** Name a connected account, or clear its name with an empty string. (`dench tool label`) */
      set(args: Req<"tool.label.set">): Promise<Res<"tool.label.set">>;
    };
    labels: {
      /** List human names given to connected accounts. (`dench tool labels`) */
      list(args?: Req<"tool.labels.list">): Promise<Res<"tool.labels.list">>;
    };
    /** Run an external tool action. SLACK_* slugs (SLACK_SEND_MESSAGE with Block Kit blocks/buttons, SLACK_FETCH_HISTORY, SLACK_LIST_CHANNELS, …) run through Dench's in-house Slack app install — any channel in the connected workspace — and are always preferred over any third-party Slack connection. (`dench tool run`) */
    run(args: Req<"tool.run">): Promise<Res<"tool.run">>;
    /** Search for external tool actions. (`dench tool search`) */
    search(args: Req<"tool.search">): Promise<Res<"tool.search">>;
    /** List connected tool accounts. (`dench tool status`) */
    status(args?: Req<"tool.status">): Promise<Res<"tool.status">>;
  };
  web: {
    /** Look up a brand kit from a domain or email. (`dench web brand`) */
    brand(args: Req<"web.brand">): Promise<Res<"web.brand">>;
    /** Autocomplete brand names. (`dench web brand-search`) */
    brandSearch(args: Req<"web.brandSearch">): Promise<Res<"web.brandSearch">>;
    /** Classify a domain with NAICS or SIC. (`dench web classify`) */
    classify(args: Req<"web.classify">): Promise<Res<"web.classify">>;
    /** Find competitors of a domain. (`dench web competitors`) */
    competitors(args: Req<"web.competitors">): Promise<Res<"web.competitors">>;
    /** Crawl a site to Markdown (capped). (`dench web crawl`) */
    crawl(args: Req<"web.crawl">): Promise<Res<"web.crawl">>;
    /** Extract typed fields from a page using a JSON Schema. (`dench web extract`) */
    extract(args: Req<"web.extract">): Promise<Res<"web.extract">>;
    /** Read site fonts from a domain. (`dench web fonts`) */
    fonts(args: Req<"web.fonts">): Promise<Res<"web.fonts">>;
    /** Extract a product listing from a URL. (`dench web product`) */
    product(args: Req<"web.product">): Promise<Res<"web.product">>;
    /** Read a page as clean Markdown through Dench web. (`dench web scrape`) */
    scrape(args: Req<"web.scrape">): Promise<Res<"web.scrape">>;
    /** Capture a rendered page screenshot. (`dench web screenshot`) */
    screenshot(args: Req<"web.screenshot">): Promise<Res<"web.screenshot">>;
    /** List sitemap URLs for a domain. (`dench web sitemap`) */
    sitemap(args: Req<"web.sitemap">): Promise<Res<"web.sitemap">>;
    /** Read a brand styleguide from a domain. (`dench web styleguide`) */
    styleguide(args: Req<"web.styleguide">): Promise<Res<"web.styleguide">>;
  };
  workspace: {
    /** List agents visible in the workspace status payload. (`dench agents`) */
    agents(args?: Req<"workspace.agents">): Promise<Res<"workspace.agents">>;
    approvals: {
      /** List approval requests visible in the workspace status payload. (`dench approvals`) */
      list(args?: Req<"workspace.approvals.list">): Promise<Res<"workspace.approvals.list">>;
    };
    artifacts: {
      /** List artifacts for the authenticated workspace. (`dench artifacts`) */
      list(args?: Req<"workspace.artifacts.list">): Promise<Res<"workspace.artifacts.list">>;
    };
    context: {
      /** Return the current Dench workspace context for the bearer. (`dench context`) */
      (args?: Req<"workspace.context">): Promise<Res<"workspace.context">>;
      $call(args?: Req<"workspace.context">): Promise<Res<"workspace.context">>;
      rules: {
        /** Update standing workspace rules; credentials belong in secrets and runnable setup in environments. (`dench context set rules`) */
        set(args: Req<"workspace.context.rules.set">): Promise<Res<"workspace.context.rules.set">>;
      };
      /** Read selected scoped workspace documents and a compact context index without writes. (`dench context --sections`) */
      sections(args?: Req<"workspace.context.sections">): Promise<Res<"workspace.context.sections">>;
    };
    /** Return the current workspace's standing instructions for external agents. (`dench context --instructions`) */
    instructions(args?: Req<"workspace.instructions">): Promise<Res<"workspace.instructions">>;
    /** Return workspace and agent status. (`dench status`) */
    status(args?: Req<"workspace.status">): Promise<Res<"workspace.status">>;
    suggestedWork: {
      /** List draft suggested-work artifacts. (`dench suggested-work`) */
      list(args?: Req<"workspace.suggestedWork.list">): Promise<Res<"workspace.suggestedWork.list">>;
    };
  };
};

// ── Shared shapes ───────────────────────────────────────────────────────

export type AppManifest = {
  name: string;
  slug?: string;
  icon?: string;
  entry?: string;
  description?: string;
  version?: string;
  permissions?: string[];
  [key: string]: unknown;
};

export type ObjectEntry = { id: string; createdAt?: number; updatedAt?: number; [field: string]: unknown };

export type ObjectsListOptions = {
  page?: number;
  pageSize?: number;
  search?: string;
  filters?: unknown;
  sort?: unknown;
};

export type ObjectsListResult = {
  entries: ObjectEntry[];
  total?: number;
  page?: number;
  pageSize?: number;
  [key: string]: unknown;
};

export type ObjectsQuery = {
  object: string;
  filter?: Record<string, unknown>;
  select?: string[];
  sort?: Record<string, "asc" | "desc"> | Array<{ field: string; direction: "asc" | "desc" }>;
  limit?: number;
};

export type ObjectsQueryResult = { rows: ObjectEntry[]; count?: number; [key: string]: unknown };

export type ObjectSchema = {
  name: string;
  displayName?: string;
  fields: Array<{ name: string; type: string; options?: string[]; [key: string]: unknown }>;
  [key: string]: unknown;
};

export type ChatStreamEvent = { type: "text-delta"; data: string } & Record<string, unknown>;

export type CronScheduleOptions = {
  name: string;
  prompt: string;
  schedule: Req<"cron.create">["schedule"];
  description?: string;
  enabled?: boolean;
};

export type AppWebhookEvent = {
  id: string;
  hookName: string;
  receivedAt: number;
  verified: boolean;
  method: string;
  headers: Record<string, string>;
  body: unknown;
};

export type IntegrationConnection = {
  toolkit: string;
  toolkitName?: string;
  status: string;
  isActive: boolean;
  connectedAccountId: string;
  accountLabel?: string;
};

export type AgentConfigSection = "identity" | "organisation" | "user" | "tools" | "mem" | "bootstrap";

export type GeoRegionHit = { id: string; name: string; [key: string]: unknown };
export type GeoRegionFeature = {
  type: "Feature";
  id: string;
  geometry: unknown;
  properties: { name: string; postal?: string; alt?: string[]; type?: string; lat: number; lng: number };
};

/** Every bridge rejection is a DenchBridgeError with a stable `code`. */
export interface DenchBridgeError extends Error {
  name: "DenchBridgeError";
  code:
    | "permission_denied"
    | "unknown_method"
    | "unknown_operation"
    | "unsupported_local"
    | "validation_failed"
    | "unavailable"
    | "timeout"
    | "deprecated"
    | "upstream_failed";
  method?: string;
  operationId?: string;
  permission?: string | null;
  status?: number;
  details?: unknown;
}

// ── window.dench ────────────────────────────────────────────────────────

export interface DenchApp {
  /** The parsed .dench.yaml of this app. Permission: none. */
  getManifest(): Promise<AppManifest>;
  /** Current workspace theme ("light" | "dark"). Permission: none. */
  getTheme(): Promise<"light" | "dark">;
}

export interface DenchContext {
  /** Workspace name/slug the app is running in. Permission: none. */
  getWorkspace(): Promise<{ name: string; slug: string | null }>;
  /** App path, folder slug, granted permissions and manifest. Permission: none. */
  getAppInfo(): Promise<{ appPath: string; folderName: string; permissions: string[]; manifest: AppManifest }>;
}

export interface DenchApi {
  /** Call ANY public /api/v1 operation by id (e.g. "crm.query"). Permission is the operation's own scope. Permission: none. */
  call<K extends ApiOperationId>(operationId: K, args?: Req<K>): Promise<Res<K>>;
  /** Runtime catalog of every callable operation: id, cli, method, path, permission. Permission: none. */
  operations(opts?: { group?: string }): Promise<ApiOperationInfo[]>;
}

export interface DenchObjects {
  /** Paged rows of an object (flat `id` + field-on-row shape). Permission: `crm:read`. */
  list(name: string, opts?: ObjectsListOptions): Promise<ObjectsListResult>;
  /** Filter/sort/select rows with the query DSL (max 1000). Aggregate with analytics.compute instead. Permission: `crm:read`. */
  query(dsl: ObjectsQuery): Promise<ObjectsQueryResult>;
  /** One entry by id. Permission: `crm:read`. */
  get(name: string, entryId: string): Promise<ObjectEntry>;
  /** Create an entry. Permission: `crm:write`. */
  create(name: string, fields: Record<string, unknown>): Promise<ObjectEntry>;
  /** Patch an entry's fields. Permission: `crm:write`. */
  update(name: string, entryId: string, fields: Record<string, unknown>): Promise<{ ok: boolean }>;
  /** Delete one entry. Permission: `crm:write`. */
  delete(name: string, entryId: string): Promise<{ ok: boolean }>;
  /** Delete many entries. Permission: `crm:write`. */
  bulkDelete(name: string, entryIds: string[]): Promise<{ ok: boolean; deleted?: number }>;
  /** Object definition: fields, types, enum options, relations. Permission: `crm:read`. */
  getSchema(name: string): Promise<ObjectSchema>;
  /** Relation picker options (id + label) for an object, optionally filtered. Permission: `crm:read`. */
  getOptions(name: string, query?: string): Promise<Array<{ id: string; label: string }>>;
}

export interface DenchAnalytics {
  /** Stored dashboard: panels, field roles, collapsed flag (+ the view's own dashboard when viewName is set). Permission: `crm:read`. Wraps `crm.analytics.get`. */
  get(objectName: string, opts?: Omit<Req<"crm.analytics.get">, "objectName">): Promise<Res<"crm.analytics.get">>;
  /** Pre-bucketed KPIs/charts/maps — the strip's own math. Stored dashboard, `panelIds`, or ad-hoc `panels`; `period` and `drillFilters` expand server-side. Permission: `crm:read`. Wraps `crm.analytics.compute`. */
  compute(objectName: string, opts?: Omit<Req<"crm.analytics.compute">, "objectName">): Promise<Res<"crm.analytics.compute">>;
  /** Create or update a stored panel (object dashboard, or the view's when viewName is set — first save forks an inheriting view). Permission: `crm:write`. Wraps `crm.analytics.save`. */
  save(objectName: string, panelId: string, panel: Req<"crm.analytics.save">["panel"], opts?: Omit<Req<"crm.analytics.save">, "objectName" | "panelId" | "panel">): Promise<Res<"crm.analytics.save">>;
  /** Edit part of a stored panel (title, type, metric, groupBy, dateField, filters, derived, span, hidden, sortOrder …); null clears an optional key. Permission: `crm:write`. Wraps `crm.analytics.update`. */
  update(objectName: string, panelId: string, patch: Req<"crm.analytics.update">["patch"], opts?: Omit<Req<"crm.analytics.update">, "objectName" | "panelId" | "patch">): Promise<Res<"crm.analytics.update">>;
  /** Take a chart off the strip above the table; it stays in the full analytics view. Permission: `crm:write`. Wraps `crm.analytics.hide`. */
  hide(objectName: string, panelId: string, opts?: Omit<Req<"crm.analytics.hide">, "objectName" | "panelId">): Promise<Res<"crm.analytics.hide">>;
  /** Bring a hidden chart back onto the strip. Permission: `crm:write`. Wraps `crm.analytics.show`. */
  show(objectName: string, panelId: string, opts?: Omit<Req<"crm.analytics.show">, "objectName" | "panelId">): Promise<Res<"crm.analytics.show">>;
  /** Set a card's width: span 2 (third) | 3 (half) | 4 (two thirds) | 6 (full) | null (default for the chart kind). Permission: `crm:write`. Wraps `crm.analytics.resize`. */
  resize(objectName: string, panelId: string, span: Req<"crm.analytics.resize">["span"], opts?: Omit<Req<"crm.analytics.resize">, "objectName" | "panelId" | "span">): Promise<Res<"crm.analytics.resize">>;
  /** Delete a stored panel. Permission: `crm:write`. Wraps `crm.analytics.delete`. */
  delete(objectName: string, panelId: string, opts?: Omit<Req<"crm.analytics.delete">, "objectName" | "panelId">): Promise<Res<"crm.analytics.delete">>;
  /** Persist the full panel order. Permission: `crm:write`. Wraps `crm.analytics.reorder`. */
  reorder(objectName: string, panelIds: string[], opts?: Omit<Req<"crm.analytics.reorder">, "objectName" | "panelIds">): Promise<Res<"crm.analytics.reorder">>;
  /** Set the object's analytics setup shared by every chart and view: amount / stage / won-lost-converted / stageProbabilities / closeDate / recurrence / owner / location. Pass merge: true to change only the keys given (null clears one). Permission: `crm:write`. Wraps `crm.analytics.roles`. */
  roles(objectName: string, fieldRoles: Req<"crm.analytics.roles">["fieldRoles"], opts?: Omit<Req<"crm.analytics.roles">, "objectName" | "fieldRoles">): Promise<Res<"crm.analytics.roles">>;
  /** Collapse the team-shared strip for this object. Permission: `crm:write`. Wraps `crm.analytics.collapse`. */
  collapse(objectName: string): Promise<Res<"crm.analytics.collapse">>;
  /** Expand the team-shared strip for this object. Permission: `crm:write`. Wraps `crm.analytics.expand`. */
  expand(objectName: string): Promise<Res<"crm.analytics.expand">>;
  /** Flip a saved view between its "own" dashboard and the object's "shared" one. Permission: `crm:write`. Wraps `crm.analytics.scope`. */
  scope(objectName: string, viewName: string, mode: Req<"crm.analytics.scope">["mode"]): Promise<Res<"crm.analytics.scope">>;
}

export interface DenchComments {
  /** Root comments on an entry (with reply previews), paged. Permission: `crm:read`. Wraps `crm.comments.list`. */
  list(objectName: string, entryId: string, opts?: Omit<Req<"crm.comments.list">, "objectName" | "entryId">): Promise<Res<"crm.comments.list">>;
  /** Replies under a root comment. Permission: `crm:read`. Wraps `crm.comments.replies`. */
  replies(commentId: string, opts?: Omit<Req<"crm.comments.replies">, "commentId">): Promise<Res<"crm.comments.replies">>;
  /** One comment. Permission: `crm:read`. Wraps `crm.comments.get`. */
  get(commentId: string): Promise<Res<"crm.comments.get">>;
  /** Post a markdown comment (mention members with [@Name](/?member=<userId>), Dench with [@Dench](/?member=dench)). Permission: `crm:write`. Wraps `crm.comments.create`. */
  create(objectName: string, entryId: string, body: string, opts?: Omit<Req<"crm.comments.create">, "objectName" | "entryId" | "body">): Promise<Res<"crm.comments.create">>;
  /** Edit a comment body. Permission: `crm:write`. Wraps `crm.comments.update`. */
  update(commentId: string, body: string): Promise<Res<"crm.comments.update">>;
  /** Delete a comment. Permission: `crm:write`. Wraps `crm.comments.delete`. */
  delete(commentId: string): Promise<Res<"crm.comments.delete">>;
  /** Toggle an emoji reaction. Permission: `crm:write`. Wraps `crm.comments.react`. */
  react(commentId: string, emoji: string): Promise<Res<"crm.comments.react">>;
}

export interface DenchWatch {
  /** Am I following this entry? Permission: `crm:read`. Wraps `crm.watch.get`. */
  get(objectName: string, entryId: string): Promise<Res<"crm.watch.get">>;
  /** Follow (default) or unfollow an entry. Permission: `crm:write`. Wraps `crm.watch.set`. */
  set(objectName: string, entryId: string, watching?: boolean): Promise<Res<"crm.watch.set">>;
}

export interface DenchViews {
  /** Saved views of an object. Permission: `crm:read`. Wraps `crm.views.list`. */
  list(objectName: string): Promise<Res<"crm.views.list">>;
  /** One saved view (filters, sort, columns, analytics). Permission: `crm:read`. Wraps `crm.views.get`. */
  get(objectName: string, viewName: string): Promise<Res<"crm.views.get">>;
  /** Rows as the saved view shows them. Permission: `crm:read`. Wraps `crm.views.entries`. */
  entries(objectName: string, viewName: string, opts?: Omit<Req<"crm.views.entries">, "objectName" | "viewName">): Promise<Res<"crm.views.entries">>;
  /** Create a saved view. Permission: `crm:write`. Wraps `crm.views.create`. */
  create(objectName: string, view: Omit<Req<"crm.views.create">, "objectName">): Promise<Res<"crm.views.create">>;
  /** Update a saved view. Permission: `crm:write`. Wraps `crm.views.update`. */
  update(objectName: string, viewName: string, patch: Omit<Req<"crm.views.update">, "objectName" | "viewName">): Promise<Res<"crm.views.update">>;
  /** Delete a saved view. Permission: `crm:write`. Wraps `crm.views.delete`. */
  delete(objectName: string, viewName: string): Promise<Res<"crm.views.delete">>;
}

export interface DenchTasks {
  /** Open tasks assigned to me. Permission: `crm:read`. Wraps `crm.tasks.mine`. */
  mine(opts?: Req<"crm.tasks.mine">): Promise<Res<"crm.tasks.mine">>;
  /** Tasks linked to an entry. Permission: `crm:read`. Wraps `crm.tasks.forEntry`. */
  forEntry(objectName: string, entryId: string): Promise<Res<"crm.tasks.forEntry">>;
  /** Create a task on an entry. Permission: `crm:write`. Wraps `crm.tasks.createForEntry`. */
  create(objectName: string, entryId: string, task: Omit<Req<"crm.tasks.createForEntry">, "objectName" | "entryId">): Promise<Res<"crm.tasks.createForEntry">>;
  /** Mark a task done. Permission: `crm:write`. Wraps `crm.tasks.complete`. */
  complete(entryId: string): Promise<Res<"crm.tasks.complete">>;
  /** Reopen a task. Permission: `crm:write`. Wraps `crm.tasks.reopen`. */
  reopen(entryId: string): Promise<Res<"crm.tasks.reopen">>;
  /** Set a task's priority (one of the workspace's options) or clear it with null. Permission: `crm:write`. Wraps `crm.tasks.setPriority`. */
  setPriority(entryId: string, priority: string | null): Promise<Res<"crm.tasks.setPriority">>;
  /** A task's subtasks. Permission: `crm:read`. Wraps `crm.tasks.subtasks.list`. */
  subtasks(entryId: string): Promise<Res<"crm.tasks.subtasks.list">>;
  /** Create a subtask under a task (one level deep; inherits the parent's record relations). Permission: `crm:write`. Wraps `crm.tasks.subtasks.create`. */
  createSubtask(entryId: string, subtask: Omit<Req<"crm.tasks.subtasks.create">, "entryId">): Promise<Res<"crm.tasks.subtasks.create">>;
  /** Nest a task under a parent, or promote it with null. Permission: `crm:write`. Wraps `crm.tasks.setParent`. */
  setParent(entryId: string, parentEntryId: string | null): Promise<Res<"crm.tasks.setParent">>;
  /** Delete a task; its subtasks go with it unless subtasks is "keep". Permission: `crm:write`. Wraps `crm.tasks.delete`. */
  delete(entryId: string, subtasks?: "delete" | "keep"): Promise<Res<"crm.tasks.delete">>;
  /** How a task repeats (rule, RRULE, trigger, ends, next due), or null. Permission: `crm:read`. Wraps `crm.tasks.repeat.get`. */
  getRepeat(entryId: string): Promise<Res<"crm.tasks.repeat.get">>;
  /** Make a task repeat or change how it repeats (JSON rule or RRULE). An undated task gets its due date anchored on the first matching day from today. Permission: `crm:write`. Wraps `crm.tasks.repeat.set`. */
  setRepeat(entryId: string, repeat: Omit<Req<"crm.tasks.repeat.set">, "entryId">): Promise<Res<"crm.tasks.repeat.set">>;
  /** Stop a task repeating. Permission: `crm:write`. Wraps `crm.tasks.repeat.clear`. */
  clearRepeat(entryId: string): Promise<Res<"crm.tasks.repeat.clear">>;
  /** Skip the current occurrence; the next one is created now. Permission: `crm:write`. Wraps `crm.tasks.repeat.skip`. */
  skipRepeat(entryId: string): Promise<Res<"crm.tasks.repeat.skip">>;
  /** Pause a repeating task. Permission: `crm:write`. Wraps `crm.tasks.repeat.pause`. */
  pauseRepeat(entryId: string): Promise<Res<"crm.tasks.repeat.pause">>;
  /** Resume a paused repeating task. Permission: `crm:write`. Wraps `crm.tasks.repeat.resume`. */
  resumeRepeat(entryId: string): Promise<Res<"crm.tasks.repeat.resume">>;
  /** Every repeating-task series in the workspace. Permission: `crm:read`. Wraps `crm.tasks.series.list`. */
  series(opts?: Req<"crm.tasks.series.list">): Promise<Res<"crm.tasks.series.list">>;
  /** Every occurrence of one series. Permission: `crm:read`. Wraps `crm.tasks.series.occurrences`. */
  seriesOccurrences(seriesId: string): Promise<Res<"crm.tasks.series.occurrences">>;
}

export interface DenchNotifications {
  /** My notifications (inbox | unread | archived | all | mentions). Permission: `notifications:read`. Wraps `notifications.list`. */
  list(opts?: Req<"notifications.list">): Promise<Res<"notifications.list">>;
  /** Unread badge count. Permission: `notifications:read`. Wraps `notifications.unreadCount`. */
  unreadCount(): Promise<Res<"notifications.unreadCount">>;
  /** Mark one read (or unread). Permission: `notifications:write`. Wraps `notifications.read`. */
  read(notificationId: string, read?: boolean): Promise<Res<"notifications.read">>;
  /** Mark everything read. Permission: `notifications:write`. Wraps `notifications.readAll`. */
  readAll(): Promise<Res<"notifications.readAll">>;
  /** Archive one notification. Permission: `notifications:write`. Wraps `notifications.archive`. */
  archive(notificationId: string): Promise<Res<"notifications.archive">>;
  /** My notification preferences. Permission: `notifications:read`. Wraps `notifications.preferences.get`. */
  getPreferences(): Promise<Res<"notifications.preferences.get">>;
  /** Update my notification preferences. Permission: `notifications:write`. Wraps `notifications.preferences.update`. */
  updatePreferences(patch: Req<"notifications.preferences.update">): Promise<Res<"notifications.preferences.update">>;
}

export interface DenchMembers {
  /** A member's profile. Permission: `members:read`. Wraps `members.get`. */
  get(userId: string): Promise<Res<"members.get">>;
  /** Who is online / away / offline. Permission: `members:read`. Wraps `members.presence`. */
  presence(): Promise<Res<"members.presence">>;
  /** A member's recent CRM activity. Permission: `members:read`. Wraps `members.activity`. */
  activity(userId: string, opts?: Omit<Req<"members.activity">, "userId">): Promise<Res<"members.activity">>;
  /** A member's open tasks. Permission: `members:read`. Wraps `members.tasks`. */
  tasks(userId: string, opts?: Omit<Req<"members.tasks">, "userId">): Promise<Res<"members.tasks">>;
  /** My own profile. Permission: `members:read`. Wraps `me.profile.get`. */
  me(): Promise<Res<"me.profile.get">>;
  /** Update my name / tagline / timezone. Permission: `members:write`. Wraps `me.profile.update`. */
  updateMe(patch: Req<"me.profile.update">): Promise<Res<"me.profile.update">>;
}

export interface DenchMeetings {
  /** Meetings (CRM `meeting` rows), newest first. Permission: `meetings:read`. Wraps `meetings.list`. */
  list(opts?: Req<"meetings.list">): Promise<Res<"meetings.list">>;
  /** Transcript segments of a meeting. Permission: `meetings:read`. Wraps `meetings.transcript.list`. */
  transcript(meetingEntryId: string, opts?: Omit<Req<"meetings.transcript.list">, "meetingEntryId">): Promise<Res<"meetings.transcript.list">>;
  /** Action items of a meeting. Permission: `meetings:read`. Wraps `meetings.actionItems.list`. */
  actionItems(meetingEntryId: string): Promise<Res<"meetings.actionItems.list">>;
  /** Add action items to a meeting. Permission: `meetings:write`. Wraps `meetings.actionItems.add`. */
  addActionItems(meetingEntryId: string, items: Req<"meetings.actionItems.add">["items"]): Promise<Res<"meetings.actionItems.add">>;
  /** Check or uncheck an action item. Permission: `meetings:write`. Wraps `meetings.actionItems.setDone`. */
  setActionItemDone(itemId: string, done: boolean): Promise<Res<"meetings.actionItems.setDone">>;
  /** Participants of a meeting. Permission: `meetings:read`. Wraps `meetings.participants.list`. */
  participants(meetingEntryId: string): Promise<Res<"meetings.participants.list">>;
  /** Whether a meeting is shared with the whole workspace. Permission: `meetings:read`. Wraps `meetings.sharing.get`. */
  sharing(meetingEntryId: string): Promise<Res<"meetings.sharing.get">>;
  /** Share a meeting with the workspace, or take it back to owner + invitees. Permission: `meetings:write`. Wraps `meetings.sharing.set`. */
  setSharing(meetingEntryId: string, shared: boolean): Promise<Res<"meetings.sharing.set">>;
}

export interface DenchLists {
  /** Saved lead lists. Permission: `lists:read`. Wraps `lists.list`. */
  list(opts?: Req<"lists.list">): Promise<Res<"lists.list">>;
  /** One saved list with its rows. Permission: `lists:read`. Wraps `lists.get`. */
  get(artifactId: string): Promise<Res<"lists.get">>;
  /** Rename a list. Permission: `lists:write`. Wraps `lists.rename`. */
  rename(artifactId: string, title: string): Promise<Res<"lists.rename">>;
  /** Delete a list. Permission: `lists:write`. Wraps `lists.delete`. */
  delete(artifactId: string): Promise<Res<"lists.delete">>;
}

export interface DenchCampaigns {
  /** Create a draft campaign. Permission: `campaigns:write`. Wraps `campaigns.create`. */
  create(opts: Req<"campaigns.create">): Promise<Res<"campaigns.create">>;
  /** Create an idempotent draft with available sender pools. Permission: `campaigns:write`. Wraps `campaigns.drafts.create`. */
  draft(opts: Req<"campaigns.drafts.create">): Promise<Res<"campaigns.drafts.create">>;
  /** Search people without enrolling them. Search credits apply. Permission: `campaigns:write`. Wraps `campaigns.audience.search`. */
  search(opts: Req<"campaigns.audience.search">): Promise<Res<"campaigns.audience.search">>;
  /** Add up to 50 selected recipients without running another search. Permission: `campaigns:write`. Wraps `campaigns.people.addBatch`. */
  addPeople(opts: Req<"campaigns.people.addBatch">): Promise<Res<"campaigns.people.addBatch">>;
  /** Search and add up to 50 people to an existing campaign. Permission: `campaigns:write`. Wraps `campaigns.people.addFromSearch`. */
  addFromSearch(opts: Req<"campaigns.people.addFromSearch">): Promise<Res<"campaigns.people.addFromSearch">>;
  /** Read the campaign's lead source. Permission: `campaigns:read`. Wraps `campaigns.sources.get`. */
  sources(sequenceId: string): Promise<Res<"campaigns.sources.get">>;
  /** Read signal choices and suggestions. Permission: `campaigns:read`. Wraps `campaigns.sources.signals`. */
  sourceSignals(sequenceId: string): Promise<Res<"campaigns.sources.signals">>;
  /** Update targeting, signals, cadence or source status. Permission: `campaigns:write`. Wraps `campaigns.sources.update`. */
  updateSources(opts: Req<"campaigns.sources.update">): Promise<Res<"campaigns.sources.update">>;
  /** Preview a signal without enrolling people. Provider credits may apply. Permission: `campaigns:write`. Wraps `campaigns.sources.preview`. */
  previewSignal(opts: Req<"campaigns.sources.preview">): Promise<Res<"campaigns.sources.preview">>;
  /** Read suggested campaign targeting. Permission: `campaigns:read`. Wraps `campaigns.builder.profile`. */
  profile(): Promise<Res<"campaigns.builder.profile">>;
  /** Save signal-draft targeting and choices. Permission: `campaigns:write`. Wraps `campaigns.builder.save`. */
  saveDraft(opts: Req<"campaigns.builder.save">): Promise<Res<"campaigns.builder.save">>;
  /** Read preview people, messages and build progress. Permission: `campaigns:read`. Wraps `campaigns.builder.get`. */
  getDraft(draftId: string): Promise<Res<"campaigns.builder.get">>;
  /** Start a billable signal draft build. Permission: `campaigns:write`. Wraps `campaigns.builder.build`. */
  buildDraft(draftId: string): Promise<Res<"campaigns.builder.build">>;
  /** Create a campaign from a reviewed signal draft, without launching. Permission: `campaigns:write`. Wraps `campaigns.builder.create`. */
  createFromDraft(opts: Req<"campaigns.builder.create">): Promise<Res<"campaigns.builder.create">>;
  /** Edit a preview person's opening line. Permission: `campaigns:write`. Wraps `campaigns.builder.opener`. */
  setDraftOpener(opts: Req<"campaigns.builder.opener">): Promise<Res<"campaigns.builder.opener">>;
  /** Translate a description into targeting. AI credits apply. Permission: `campaigns:write`. Wraps `campaigns.builder.autofill`. */
  autofill(opts: Req<"campaigns.builder.autofill">): Promise<Res<"campaigns.builder.autofill">>;
  /** List saved, unfinished campaign drafts. Permission: `campaigns:read`. Wraps `campaigns.builder.drafts`. */
  savedDrafts(): Promise<Res<"campaigns.builder.drafts">>;
  /** Read a saved draft's setup to resume it. Permission: `campaigns:read`. Wraps `campaigns.builder.resume`. */
  resumeDraft(draftId: string): Promise<Res<"campaigns.builder.resume">>;
  /** Discard a saved draft. Permission: `campaigns:write`. Wraps `campaigns.builder.discard`. */
  discardDraft(draftId: string): Promise<Res<"campaigns.builder.discard">>;
  /** Save a draft's steps, brief, senders, schedule and approval mode. Permission: `campaigns:write`. Wraps `campaigns.builder.outreach`. */
  saveOutreach(opts: Req<"campaigns.builder.outreach">): Promise<Res<"campaigns.builder.outreach">>;
  /** Generate a draft's sequence from a brief. AI credits apply. Permission: `campaigns:write`. Wraps `campaigns.builder.sequence`. */
  generateSequence(opts: Req<"campaigns.builder.sequence">): Promise<Res<"campaigns.builder.sequence">>;
  /** Set up a lookalike from a best lead's LinkedIn URL. Provider credits apply. Permission: `campaigns:write`. Wraps `campaigns.builder.lookalike`. */
  lookalike(opts: Req<"campaigns.builder.lookalike">): Promise<Res<"campaigns.builder.lookalike">>;
  /** Suggest LinkedIn experts to watch for the topics. AI credits apply. Permission: `campaigns:write`. Wraps `campaigns.builder.voices`. */
  suggestVoices(opts: Req<"campaigns.builder.voices">): Promise<Res<"campaigns.builder.voices">>;
  /** Run a live campaign's signals now. Provider credits apply. Permission: `campaigns:write`. Wraps `campaigns.sources.run`. */
  runSources(sequenceId: string): Promise<Res<"campaigns.sources.run">>;
  /** People a signal found who wait for approval. Permission: `campaigns:read`. Wraps `campaigns.sources.pending`. */
  pendingReview(sequenceId: string): Promise<Res<"campaigns.sources.pending">>;
  /** Approve or reject people waiting for review. Permission: `campaigns:write`. Wraps `campaigns.sources.review`. */
  reviewPeople(opts: Req<"campaigns.sources.review">): Promise<Res<"campaigns.sources.review">>;
  /** Who the campaign plans to contact today. Permission: `campaigns:read`. Wraps `campaigns.queue`. */
  todayQueue(sequenceId: string): Promise<Res<"campaigns.queue">>;
  /** Estimate audience or signal volume. Permission: `campaigns:write`. Wraps `campaigns.builder.estimate`. */
  estimate(opts: Req<"campaigns.builder.estimate">): Promise<Res<"campaigns.builder.estimate">>;
  /** Mailboxes campaigns can send from, with warm-up and daily cap. Permission: `campaigns:read`. Wraps `campaigns.accounts.email`. */
  mailboxes(): Promise<Res<"campaigns.accounts.email">>;
  /** LinkedIn accounts campaigns can send from, with capacity. Permission: `campaigns:read`. Wraps `campaigns.accounts.linkedin`. */
  linkedinAccounts(): Promise<Res<"campaigns.accounts.linkedin">>;
  /** LinkedIn / multi-channel outreach campaigns. Permission: `campaigns:read`. Wraps `campaigns.list`. */
  list(): Promise<Res<"campaigns.list">>;
  /** One campaign. Permission: `campaigns:read`. Wraps `campaigns.get`. */
  get(sequenceId: string): Promise<Res<"campaigns.get">>;
  /** Replace every step of a draft campaign. Permission: `campaigns:write`. Wraps `campaigns.steps.replace`. */
  setSteps(opts: Req<"campaigns.steps.replace">): Promise<Res<"campaigns.steps.replace">>;
  /** Edit launched steps in place by stepId and updatedAt. Permission: `campaigns:write`. Wraps `campaigns.steps.update`. */
  editSteps(opts: Req<"campaigns.steps.update">): Promise<Res<"campaigns.steps.update">>;
  /** Copy a campaign into a new draft without its people. Permission: `campaigns:write`. Wraps `campaigns.duplicate`. */
  duplicate(sequenceId: string): Promise<Res<"campaigns.duplicate">>;
  /** Campaign funnel numbers. Permission: `campaigns:read`. Wraps `campaigns.analytics`. */
  analytics(sequenceId: string): Promise<Res<"campaigns.analytics">>;
  /** Campaign event log. Permission: `campaigns:read`. Wraps `campaigns.events`. */
  events(sequenceId: string, opts?: Omit<Req<"campaigns.events">, "sequenceId">): Promise<Res<"campaigns.events">>;
  /** Pause a campaign. Permission: `campaigns:write`. Wraps `campaigns.pause`. */
  pause(sequenceId: string): Promise<Res<"campaigns.pause">>;
  /** Resume a campaign. Permission: `campaigns:write`. Wraps `campaigns.resume`. */
  resume(sequenceId: string): Promise<Res<"campaigns.resume">>;
  /** Archive (the app's Delete) a campaign; nothing is erased. Permission: `campaigns:write`. Wraps `campaigns.archive`. */
  archive(sequenceId: string): Promise<Res<"campaigns.archive">>;
  /** The message one person gets at one step, fields filled in. Sends nothing. Permission: `campaigns:read`. Wraps `campaigns.preview`. */
  previewMessage(sequenceId: string, enrollmentId: string, stepId: string): Promise<Res<"campaigns.preview">>;
  /** Personalized lines, their {{keys}} and how many are written. Permission: `campaigns:read`. Wraps `campaigns.personalization.get`. */
  personalization(sequenceId: string): Promise<Res<"campaigns.personalization.get">>;
  /** Define up to 5 personalized lines. Writing them costs credits. Permission: `campaigns:write`. Wraps `campaigns.personalization.set`. */
  setPersonalization(opts: Req<"campaigns.personalization.set">): Promise<Res<"campaigns.personalization.set">>;
  /** Turn personalized lines off. Permission: `campaigns:write`. Wraps `campaigns.personalization.clear`. */
  clearPersonalization(sequenceId: string): Promise<Res<"campaigns.personalization.clear">>;
  /** Write missing (or all) personalized lines. Costs credits. Permission: `campaigns:write`. Wraps `campaigns.personalization.write`. */
  writeLines(opts: Req<"campaigns.personalization.write">): Promise<Res<"campaigns.personalization.write">>;
  /** Set one person's personalized line by hand. Permission: `campaigns:write`. Wraps `campaigns.personalization.edit`. */
  editLine(enrollmentId: string, key: string, value: string): Promise<Res<"campaigns.personalization.edit">>;
  /** Write a fresh line for one person. Costs credits. Permission: `campaigns:write`. Wraps `campaigns.personalization.rewrite`. */
  rewriteLine(enrollmentId: string, key?: string): Promise<Res<"campaigns.personalization.rewrite">>;
  /** Fill people's empty contact details from their CRM records. Permission: `campaigns:write`. Wraps `campaigns.people.sync`. */
  syncPeople(sequenceId: string): Promise<Res<"campaigns.people.sync">>;
  /** Resume every paused person in an active campaign. Permission: `campaigns:write`. Wraps `campaigns.people.resumeAll`. */
  resumeAllPeople(sequenceId: string): Promise<Res<"campaigns.people.resumeAll">>;
  /** Fix a draft person's email address. Permission: `campaigns:write`. Wraps `campaigns.people.setEmail`. */
  setPersonEmail(enrollmentId: string, email: string): Promise<Res<"campaigns.people.setEmail">>;
  /** Fix a draft person's LinkedIn profile URL. Permission: `campaigns:write`. Wraps `campaigns.people.setLinkedin`. */
  setPersonLinkedin(enrollmentId: string, linkedinProfileUrl: string): Promise<Res<"campaigns.people.setLinkedin">>;
  /** Fill one {{merge field}} for a draft person. Permission: `campaigns:write`. Wraps `campaigns.people.setField`. */
  setPersonField(enrollmentId: string, key: string, value: string): Promise<Res<"campaigns.people.setField">>;
  /** Where the campaign's people sit in the lead pipeline. Permission: `campaigns:read`. Wraps `campaigns.pipeline`. */
  pipeline(sequenceId: string): Promise<Res<"campaigns.pipeline">>;
  /** The campaigns a CRM record is in, with its status in each. Permission: `campaigns:read`. Wraps `campaigns.people.forRecord`. */
  campaignsForRecord(entryId: string): Promise<Res<"campaigns.people.forRecord">>;
  /** Everything a campaign did for one person, step by step. Permission: `campaigns:read`. Wraps `campaigns.people.timeline`. */
  personTimeline(enrollmentId: string): Promise<Res<"campaigns.people.timeline">>;
  /** Remove a never-contacted person from a draft campaign. Permission: `campaigns:write`. Wraps `campaigns.people.remove`. */
  removePerson(enrollmentId: string): Promise<Res<"campaigns.people.remove">>;
}

export interface DenchEmail {
  /** Create a native mailbox draft with a stable request receipt. Permission: `email:write`. Wraps `email.drafts.create`. */
  createDraft(draft: Req<"email.drafts.create">): Promise<Res<"email.drafts.create">>;
  /** Read a native email draft and sync status. Permission: `email:read`. Wraps `email.drafts.get`. */
  draft(draftId: string): Promise<Res<"email.drafts.get">>;
  /** Save the next email draft revision. Permission: `email:write`. Wraps `email.drafts.update`. */
  updateDraft(input: Req<"email.drafts.update">): Promise<Res<"email.drafts.update">>;
  /** Send the frozen native email draft revision. Permission: `email:write`. Wraps `email.drafts.send`. */
  sendDraft(input: Req<"email.drafts.send">): Promise<Res<"email.drafts.send">>;
  /** List eligible native mailboxes. Permission: `email:read`. Wraps `email.drafts.senders`. */
  senders(opts?: Req<"email.drafts.senders">): Promise<Res<"email.drafts.senders">>;
  /** Upload attachment bytes for a native draft. Permission: `email:write`. Wraps `email.drafts.upload`. */
  uploadAttachment(input: Req<"email.drafts.upload">): Promise<Res<"email.drafts.upload">>;
  /** Load the selected mailbox signature for visible insertion. Permission: `email:read`. Wraps `email.drafts.signature`. */
  signature(draftId: string): Promise<Res<"email.drafts.signature">>;
  /** Explicitly send through a native Gmail or Outlook mailbox. Permission: `email:write`. Wraps `email.native.send`. */
  sendFromMailbox(message: Req<"email.native.send">): Promise<Res<"email.native.send">>;
  /** Send one email from a verified identity. Permission: `email:write`. Wraps `email.send`. */
  send(message: Req<"email.send">): Promise<Res<"email.send">>;
  /** Sent messages. Permission: `email:read`. Wraps `email.message.list`. */
  messages(opts?: Req<"email.message.list">): Promise<Res<"email.message.list">>;
  /** One sent message with delivery events. Permission: `email:read`. Wraps `email.message.get`. */
  message(messageId: string): Promise<Res<"email.message.get">>;
  /** Email campaigns. Permission: `email:read`. Wraps `email.campaign.list`. */
  campaigns(opts?: Req<"email.campaign.list">): Promise<Res<"email.campaign.list">>;
  /** One email campaign. Permission: `email:read`. Wraps `email.campaign.get`. */
  campaign(campaignId: string): Promise<Res<"email.campaign.get">>;
  /** Verified sending identities. Permission: `email:read`. Wraps `email.identity.list`. */
  identities(): Promise<Res<"email.identity.list">>;
}

export interface DenchBilling {
  /** Plan, AI balance and usage for the workspace. Permission: `billing:read`. Wraps `billing.status`. */
  status(): Promise<Res<"billing.status">>;
  /** Start an AI credit top-up (returns a Stripe URL). Permission: `billing:write`. Wraps `billing.topup`. */
  topup(opts?: Req<"billing.topup">): Promise<Res<"billing.topup">>;
  /** Upgrade the plan (returns a Stripe Checkout URL or updates in place). Permission: `billing:write`. Wraps `billing.upgrade`. */
  upgrade(opts?: Req<"billing.upgrade">): Promise<Res<"billing.upgrade">>;
}

export interface DenchApprovals {
  /** Pending approvals in the workspace. Permission: `approvals:read`. Wraps `workspace.approvals.list`. */
  list(): Promise<Res<"workspace.approvals.list">>;
  /** Ask a human to approve an action. Permission: `approvals:write`. Wraps `approval.request`. */
  request(request: Req<"approval.request">): Promise<Res<"approval.request">>;
  /** Approve or reject a pending approval. Permission: `approvals:write`. Wraps `approval.decide`. */
  decide(approvalId: string, decision: Req<"approval.decide">["decision"], opts?: Omit<Req<"approval.decide">, "approvalId" | "decision">): Promise<Res<"approval.decide">>;
}

export interface DenchMemory {
  /** The workspace's saved memories (legacy shape). Permission: `memory:read`. @deprecated Use memory.search(query). */
  get(): Promise<unknown>;
  /** Full-text search over saved memories. Permission: `memory:read`. Wraps `memory.search`. */
  search(query: string, opts?: Omit<Req<"memory.search">, "query">): Promise<Res<"memory.search">>;
  /** Save a memory under a stable key. Permission: `memory:write`. Wraps `memory.save`. */
  save(memory: Req<"memory.save">): Promise<Res<"memory.save">>;
}

export interface DenchWorkspace {
  /** What this workspace has: objects, agents, integrations, next commands. Permission: `workspace:read`. Wraps `workspace.context`. */
  context(): Promise<Res<"workspace.context">>;
  /** Workspace status snapshot. Permission: `workspace:read`. Wraps `workspace.status`. */
  status(): Promise<Res<"workspace.status">>;
  /** Agents in this workspace. Permission: `workspace:read`. Wraps `workspace.agents`. */
  agents(): Promise<Res<"workspace.agents">>;
  /** Recent artifacts (reports, docs, lists). Permission: `workspace:read`. Wraps `workspace.artifacts.list`. */
  artifacts(opts?: Req<"workspace.artifacts.list">): Promise<Res<"workspace.artifacts.list">>;
  /** Workspace instructions the agent follows. Permission: `workspace:read`. Wraps `workspace.instructions`. */
  instructions(): Promise<Res<"workspace.instructions">>;
}

export interface DenchSearch {
  /** Web search (gateway). Permission: `search:read`. Wraps `search.web`. */
  web(query: string, opts?: Omit<Req<"search.web">, "query">): Promise<Res<"search.web">>;
  /** Fetch page contents for search results. Permission: `search:read`. Wraps `search.contents`. */
  contents(opts: Req<"search.contents">): Promise<Res<"search.contents">>;
  /** Answer a question from web sources. Permission: `search:read`. Wraps `search.answer`. */
  answer(query: string, opts?: Omit<Req<"search.answer">, "query">): Promise<Res<"search.answer">>;
}

export interface DenchWeb {
  /** Scrape a URL to Markdown. Permission: `web:read`. Wraps `web.scrape`. */
  scrape(url: string, opts?: Omit<Req<"web.scrape">, "url">): Promise<Res<"web.scrape">>;
  /** Brand kit (logo, colors, fonts) for a domain. Permission: `web:read`. Wraps `web.brand`. */
  brand(domain: string, opts?: Omit<Req<"web.brand">, "domain">): Promise<Res<"web.brand">>;
  /** Screenshot a rendered page. Permission: `web:read`. Wraps `web.screenshot`. */
  screenshot(url: string, opts?: Omit<Req<"web.screenshot">, "url">): Promise<Res<"web.screenshot">>;
  /** Extract structured data from a page. Permission: `web:read`. Wraps `web.extract`. */
  extract(opts: Req<"web.extract">): Promise<Res<"web.extract">>;
}

export interface DenchImages {
  /** Generate an image from a prompt. Permission: `image:write`. Wraps `image.generate`. */
  generate(opts: Req<"image.generate">): Promise<Res<"image.generate">>;
  /** Edit an image with a prompt. Permission: `image:write`. Wraps `image.edit`. */
  edit(opts: Req<"image.edit">): Promise<Res<"image.edit">>;
}

export interface DenchAgentConfig {
  /** Read one config section: "identity" | "organisation" | "user" | "tools" | "mem" | "bootstrap". Permission: `agent-config:read`. */
  show(section: AgentConfigSection): Promise<unknown>;
  /** Replace one config section's markdown. Permission: `agent-config:write`. */
  edit(section: AgentConfigSection, content: string): Promise<unknown>;
}

export interface DenchFiles {
  /** Read a workspace file (text inline; binary → `downloadable: true`). Permission: `files:read`. Wraps `files.content`. */
  read(path: string): Promise<Res<"files.content">>;
  /** List a directory (default /). Permission: `files:read`. Wraps `files.list`. */
  list(dir?: string): Promise<Res<"files.list">>;
  /** Write a UTF-8 text file (creates parents). Permission: `files:write`. Wraps `files.write`. */
  write(path: string, content: string, opts?: Omit<Req<"files.write">, "path" | "content">): Promise<Res<"files.write">>;
  /** Delete a file or directory. Permission: `files:write`. Wraps `files.delete`. */
  delete(path: string): Promise<Res<"files.delete">>;
  /** Create a directory (and parents). Permission: `files:write`. Wraps `files.mkdir`. */
  mkdir(path: string): Promise<Res<"files.mkdir">>;
  /** Move / rename a file or directory. Permission: `files:write`. Wraps `files.move`. */
  move(from: string, to: string): Promise<Res<"files.move">>;
  /** Short-lived signed URL for a file's bytes. Permission: `files:read`. Wraps `files.downloadUrl`. */
  download(path: string): Promise<Res<"files.downloadUrl">>;
}

export interface DenchChat {
  /** Create an empty chat thread; returns its id. Permission: `ai:chat`. */
  createSession(title?: string): Promise<{ id: string; threadId: string; _id: string }>;
  /** Send a message to a thread. With `onEvent`, text-delta chunks stream in; resolves with the full reply. Permission: `ai:chat`. */
  send(sessionId: string, message: string, opts?: { onEvent?: (event: ChatStreamEvent) => void }): Promise<{ text: string; threadId: string }>;
  /** Messages in a thread (via chat.read). Permission: `ai:chat`. Wraps `chat.read`. */
  getHistory(sessionId: string, opts?: { limit?: number }): Promise<Res<"chat.read">>;
  /** Recent threads. Permission: `ai:chat`. Wraps `chat.list`. */
  getSessions(opts?: Req<"chat.list">): Promise<Res<"chat.list">>;
  /** Stop the active run on a thread. Permission: `ai:chat`. */
  abort(sessionId: string): Promise<unknown>;
  /** Whether the thread has a running turn. Permission: `ai:chat`. */
  isActive(sessionId: string): Promise<boolean>;
  /** Recent threads (alias of getSessions). Permission: `ai:chat`. Wraps `chat.list`. */
  list(opts?: Req<"chat.list">): Promise<Res<"chat.list">>;
  /** Full-text search across past messages. Permission: `ai:chat`. Wraps `chat.search`. */
  search(query: string, opts?: Omit<Req<"chat.search">, "query">): Promise<Res<"chat.search">>;
  /** Rename a thread. Permission: `ai:chat`. Wraps `chat.rename`. */
  rename(threadId: string, title: string): Promise<Res<"chat.rename">>;
  /** Delete one or more threads. Permission: `ai:chat`. Wraps `chat.delete`. */
  delete(threadIds: string | string[]): Promise<Res<"chat.delete">>;
}

export interface DenchAgent {
  /** Start a new agent turn in a fresh thread. Resolves once the run is accepted. Permission: `agent:invoke`. */
  send(message: string, opts?: { title?: string; model?: string; yolo?: boolean }): Promise<{ threadId: string; runId: string | null }>;
}

export interface DenchTool {
  /** Expose a function the workspace agent can call while this app is open. Permission: `agent:invoke`. */
  register(name: string, handler: (args: unknown) => unknown | Promise<unknown>, opts?: { description?: string; inputSchema?: unknown }): Promise<{ ok: boolean }>;
}

export interface DenchUi {
  /** Show a toast. Permission: `ui`. */
  toast(message: string, opts?: { type?: "success" | "error" | "info" }): Promise<{ ok: boolean }>;
  /** Navigate the workspace to a path (e.g. /objects/company). Permission: `ui`. */
  navigate(path: string): Promise<{ ok: boolean }>;
  /** Open a CRM record in the workspace. Permission: `ui`. */
  openEntry(objectName: string, entryId: string): Promise<{ ok: boolean }>;
  /** Set the app tab title. Permission: `ui`. */
  setTitle(title: string): Promise<{ ok: boolean }>;
  /** Native confirm dialog. Permission: `ui`. */
  confirm(message: string): Promise<boolean>;
  /** Native prompt dialog. Permission: `ui`. */
  prompt(message: string, defaultValue?: string): Promise<string | null>;
}

export interface DenchStore {
  /** Read a per-app value. Permission: `store:read`. */
  get(key: string): Promise<unknown>;
  /** Write a per-app value (JSON). Permission: `store:write`. */
  set(key: string, value: unknown): Promise<{ ok: boolean }>;
  /** Delete a key. Permission: `store:write`. */
  delete(key: string): Promise<{ ok: boolean }>;
  /** All keys for this app. Permission: `store:read`. */
  list(): Promise<string[]>;
  /** Delete every key. Permission: `store:write`. */
  clear(): Promise<{ ok: boolean }>;
}

export interface DenchHttp {
  /** Fetch an external URL through the SSRF-guarded proxy. Permission: `http:external`. */
  fetch(url: string, opts?: { method?: string; headers?: Record<string, string>; body?: unknown }): Promise<{ status: number; headers: Record<string, string>; body: unknown }>;
}

export interface DenchEvents {
  /** Subscribe to a channel ("object.entry.created" | "object.entry.updated" | "object.entry.deleted" | "theme.changed"). Permission: none. */
  on(channel: string, callback: (data: unknown) => void): void;
  /** Unsubscribe. Permission: none. */
  off(channel: string, callback?: (data: unknown) => void): void;
}

export interface DenchBus {
  /** Send a message to another open app. Permission: `apps:message`. */
  send(targetApp: string, message: unknown): Promise<{ ok: boolean }>;
  /** Receive messages from other apps. Permission: `apps:message`. */
  on(callback: (message: { from: string; message: unknown }) => void): void;
  /** Other apps currently open. Permission: `apps:message`. */
  list(): Promise<Array<{ appName: string; tools: string[] }>>;
}

export interface DenchApps {
  /** Installed apps in this workspace. Permission: `apps:read`. Wraps `apps.list`. */
  list(): Promise<Res<"apps.list">>;
  /** Discover listings (Official + Community). Permission: `apps:read`. Wraps `apps.gallery`. */
  gallery(): Promise<Res<"apps.gallery">>;
  /** Scaffold and register a new app. Permission: `apps:write`. Wraps `apps.create`. */
  create(opts: Req<"apps.create">): Promise<Res<"apps.create">>;
  /** Install a listing. Permission: `apps:write`. Wraps `apps.install`. */
  install(listingId: string): Promise<Res<"apps.install">>;
  /** Publish an app folder as a listing version. Permission: `apps:write`. Wraps `apps.publish`. */
  publish(opts: Req<"apps.publish">): Promise<Res<"apps.publish">>;
  /** Uninstall an app. Permission: `apps:write`. Wraps `apps.uninstall`. */
  uninstall(slug: string): Promise<Res<"apps.uninstall">>;
  /** Enable an installed app. Permission: `apps:write`. Wraps `apps.setEnabled`. */
  enable(slug: string): Promise<Res<"apps.setEnabled">>;
  /** Disable an installed app. Permission: `apps:write`. Wraps `apps.setEnabled`. */
  disable(slug: string): Promise<Res<"apps.setEnabled">>;
  /** Pin an app in the rail. Permission: `apps:write`. Wraps `apps.setPinned`. */
  pin(slug: string): Promise<Res<"apps.setPinned">>;
  /** Unpin an app. Permission: `apps:write`. Wraps `apps.setPinned`. */
  unpin(slug: string): Promise<Res<"apps.setPinned">>;
  /** Deprecated alias of bus.send. Permission: `apps:message`. @deprecated Use dench.bus.send. */
  send(targetApp: string, message: unknown): Promise<{ ok: boolean }>;
  /** Deprecated alias of bus.on. Permission: `apps:message`. @deprecated Use dench.bus.on. */
  on(eventType: "message", callback: (message: { from: string; message: unknown }) => void): void;
}

export interface DenchCron {
  /** Create a scheduled agent (automation). Permission: `cron:schedule`. */
  schedule(opts: CronScheduleOptions): Promise<unknown>;
  /** Automations in the workspace. Permission: `cron:schedule`. */
  list(): Promise<unknown[]>;
  /** Update an automation. Permission: `cron:schedule`. */
  update(jobId: string, patch: Partial<CronScheduleOptions>): Promise<unknown>;
  /** Run an automation now. Permission: `cron:schedule`. */
  run(jobId: string): Promise<unknown>;
  /** Delete an automation. Permission: `cron:schedule`. */
  cancel(jobId: string): Promise<unknown>;
}

export interface DenchWebhooks {
  /** Register an inbound webhook for this app. Returns the URL and signing secret ONCE — store the secret with the sender. Permission: `webhooks:receive`. */
  register(hookName: string): Promise<Res<"apps.webhooks.register">>;
  /** Receive events for a hook while the app is open (polls every 5s). Permission: `webhooks:receive`. */
  on(hookName: string, callback: (event: AppWebhookEvent) => void): void;
  /** Events received since a timestamp. Permission: `webhooks:receive`. */
  poll(hookName: string, opts?: { since?: number; limit?: number }): Promise<Res<"apps.webhooks.poll">>;
  /** This app's registered hooks (URLs, never secrets). Permission: `webhooks:receive`. */
  list(): Promise<Res<"apps.webhooks.list">>;
  /** Remove a hook and its stored events. Permission: `webhooks:receive`. */
  delete(hookName: string): Promise<Res<"apps.webhooks.delete">>;
}

export interface DenchClipboard {
  /** Read clipboard text. Permission: `clipboard:read`. */
  read(): Promise<string | null>;
  /** Write clipboard text. Permission: `clipboard:write`. */
  write(text: string): Promise<{ ok: boolean }>;
}

export interface DenchIntegrations {
  /** Connected accounts (toolkit, status, connectedAccountId). Permission: `integrations:read`. */
  list(): Promise<IntegrationConnection[]>;
  /** Find tools by natural-language query and/or toolkit. Permission: `integrations:read`. */
  search(opts: { query?: string; toolkit?: string; limit?: number }): Promise<unknown>;
  /** Run a tool. Write-classified tools additionally need integrations:write. Permission: `integrations:read`. */
  execute(opts: { tool: string; arguments?: Record<string, unknown>; connectedAccountId?: string }): Promise<unknown>;
}

export interface DenchGeo {
  /** Free text → country (ISO2 + ISO numeric). Same rules as the analytics map. Permission: none. */
  resolveLocation(text: string): Promise<{ id: string; iso2: string; name: string } | null>;
  /** Free text → admin-1 region (state/province) within a country. Loads that country's file on first use. Permission: none. */
  resolveRegion(text: string, iso2: string): Promise<GeoRegionHit | null>;
  /** First-level divisions of a country as GeoJSON features (what the map draws). Permission: none. */
  loadAdmin1(iso2: string): Promise<GeoRegionFeature[] | null>;
}

export interface DenchDb {
  /** Removed. DuckDB SQL is gone — use objects.query / analytics.compute. Permission: `crm:read`. @deprecated Removed: use objects.query or analytics.compute. */
  query(sql: string): Promise<never>;
  /** Removed. Use objects.create / update / delete. Permission: `crm:write`. @deprecated Removed: use objects.create / update / delete. */
  execute(sql: string): Promise<never>;
}

export interface Dench {
  /** SDK semver. */
  version: string;
  /** Every curated method name (`ns.method`). */
  capabilities: string[];
  app: DenchApp;
  context: DenchContext;
  api: DenchApi & DenchApiTree;
  objects: DenchObjects;
  analytics: DenchAnalytics;
  comments: DenchComments;
  watch: DenchWatch;
  views: DenchViews;
  tasks: DenchTasks;
  notifications: DenchNotifications;
  members: DenchMembers;
  meetings: DenchMeetings;
  lists: DenchLists;
  campaigns: DenchCampaigns;
  email: DenchEmail;
  billing: DenchBilling;
  approvals: DenchApprovals;
  memory: DenchMemory;
  workspace: DenchWorkspace;
  search: DenchSearch;
  web: DenchWeb;
  images: DenchImages;
  agentConfig: DenchAgentConfig;
  files: DenchFiles;
  chat: DenchChat;
  agent: DenchAgent;
  tool: DenchTool;
  ui: DenchUi;
  store: DenchStore;
  http: DenchHttp;
  events: DenchEvents;
  bus: DenchBus;
  apps: DenchApps;
  cron: DenchCron;
  webhooks: DenchWebhooks;
  clipboard: DenchClipboard;
  integrations: DenchIntegrations;
  geo: DenchGeo;
  db: DenchDb;
}

declare global {
  interface Window {
    dench: Dench;
  }
}

export {};