@graph8/sdk 0.251.0 → 0.260.0

package/dist/types/newsletter.d.ts

@@ -0,0 +1,212 @@
+export interface Newsletter {
+    id: string;
+    name: string | null;
+    slug: string | null;
+    status: string | null;
+    goal: string | null;
+    audience_list_id: unknown;
+    created_at: string | null;
+    updated_at: string | null;
+    [key: string]: unknown;
+}
+export interface NewsletterIssue {
+    id: string;
+    newsletter_id: string | null;
+    subject: string | null;
+    status: string | null;
+    scheduled_at: string | null;
+    sent_at: string | null;
+    [key: string]: unknown;
+}
+export interface NewsletterTemplate {
+    id: string;
+    name: string | null;
+    [key: string]: unknown;
+}
+export interface NewsletterSubscriber {
+    id: string;
+    email: string | null;
+    status: string | null;
+    subscribed_at: string | null;
+    [key: string]: unknown;
+}
+export interface NewsletterIssueKpis {
+    sent: number | null;
+    delivered: number | null;
+    opens: number | null;
+    clicks: number | null;
+    unsubscribes: number | null;
+    bounces: number | null;
+    [key: string]: unknown;
+}
+/**
+ * Mirrors `NewsletterCreateRequest` in
+ * `developer_api/interfaces/dtos/newsletter.py:29`. No index signature: an
+ * invented field here (e.g. `description`/`from_name`/`from_email`, none of
+ * which the DTO declares) would 422 in production while every fetch-mocked
+ * test stayed green.
+ */
+export interface NewsletterCreateParams {
+    /** newsletter.py:32 — required, max_length=255. */
+    name: string;
+    /** newsletter.py:33 — optional. */
+    goal?: string;
+}
+/**
+ * Mirrors `IssueCreateRequest` in `developer_api/interfaces/dtos/newsletter.py:42`.
+ * `subject` and `html_body` are the only required fields — everything else is
+ * optional. No index signature (see `NewsletterCreateParams`).
+ */
+export interface NewsletterIssueCreateParams {
+    /** newsletter.py:43 — required, max_length=2000. */
+    subject: string;
+    /** newsletter.py:45 — required. */
+    html_body: string;
+    /** newsletter.py:44 — optional, max_length=500. */
+    preview_text?: string;
+    /** newsletter.py:46 — optional. */
+    plain_text?: string;
+    /** newsletter.py:47 — optional, max_length=255. */
+    sender_name?: string;
+    /** newsletter.py:48 — optional, must be a valid email. */
+    sender_email?: string;
+    /** newsletter.py:49 — optional, must be a valid email. */
+    reply_to?: string;
+}
+/**
+ * Mirrors `IssueUpdateRequest` in `developer_api/interfaces/dtos/newsletter.py:52`
+ * — a SEPARATE, fully-partial DTO from `IssueCreateRequest`. Every field is
+ * optional (the backend applies `exclude_unset=True`, so only fields you pass
+ * are changed). Do not reuse `NewsletterIssueCreateParams` here: that type's
+ * required `subject`/`html_body` would force callers to resend the whole
+ * issue on every partial edit.
+ */
+export interface NewsletterIssueUpdateParams {
+    /** newsletter.py:57 — optional, max_length=2000. */
+    subject?: string;
+    /** newsletter.py:59 — optional. */
+    html_body?: string;
+    /** newsletter.py:58 — optional, max_length=500. */
+    preview_text?: string;
+    /** newsletter.py:60 — optional. */
+    plain_text?: string;
+    /** newsletter.py:61 — optional, max_length=255. */
+    sender_name?: string;
+    /** newsletter.py:62 — optional, must be a valid email. */
+    sender_email?: string;
+    /** newsletter.py:63 — optional, must be a valid email. */
+    reply_to?: string;
+}
+/**
+ * Query params for `list()`/`listSubscribers()`. Kept open (unlike the body
+ * param interfaces above): these flow into `RequestOptions.query`, which is
+ * `Record<string, unknown>`, so a closed interface fails `tsc` here even
+ * though the underlying router endpoints do not model these as a Pydantic
+ * request body — an extra query key is a silent no-op on the wire, not a
+ * 422, so this file's index-signature review does not apply the same way.
+ */
+export interface NewsletterListParams {
+    limit?: number;
+    offset?: number;
+    [key: string]: unknown;
+}
+/**
+ * Newsletter API - manage newsletters, issues, subscribers and send analytics.
+ * Requires API key (server-side).
+ *
+ * Backed by:
+ *   GET    /api/v1/newsletters
+ *   POST   /api/v1/newsletters
+ *   GET    /api/v1/newsletters/templates
+ *   GET    /api/v1/newsletters/{newsletter_id}
+ *   GET    /api/v1/newsletters/{newsletter_id}/issues
+ *   POST   /api/v1/newsletters/{newsletter_id}/issues
+ *   GET    /api/v1/newsletters/{newsletter_id}/issues/{issue_id}
+ *   PUT    /api/v1/newsletters/{newsletter_id}/issues/{issue_id}
+ *   POST   /api/v1/newsletters/{newsletter_id}/issues/{issue_id}/duplicate
+ *   POST   /api/v1/newsletters/{newsletter_id}/issues/{issue_id}/send
+ *   POST   /api/v1/newsletters/{newsletter_id}/issues/{issue_id}/send-test
+ *   GET    /api/v1/newsletters/{newsletter_id}/issues/{issue_id}/analytics/kpis
+ *   GET    /api/v1/newsletters/{newsletter_id}/subscribers
+ *   POST   /api/v1/newsletters/{newsletter_id}/subscribers
+ *   PATCH  /api/v1/newsletters/{newsletter_id}/subscribers/{subscriber_id}/unsubscribe
+ *
+ * Request param types are field-checked against the vendored
+ * `developer-contract/openapi.json` component schemas via
+ * `expectBodyMatchesContract()` in
+ * `tests/parity-companies-notes-newsletter.test.ts` — see that file before
+ * changing any interface above.
+ */
+export declare const createNewsletterClient: (apiKey: string, apiUrl?: string) => {
+    /** List newsletters for the org. */
+    list(params?: NewsletterListParams): Promise<{
+        data: Newsletter[];
+    }>;
+    /** Create a newsletter. Mirrors `NewsletterCreateRequest` (newsletter.py:29). */
+    create(params: NewsletterCreateParams): Promise<Newsletter>;
+    /** List available newsletter templates. */
+    templates(): Promise<{
+        data: NewsletterTemplate[];
+    }>;
+    /** Get a single newsletter. */
+    get(newsletterId: string): Promise<Newsletter>;
+    /** List issues of a newsletter. */
+    listIssues(newsletterId: string): Promise<{
+        data: NewsletterIssue[];
+    }>;
+    /** Create an issue on a newsletter. Mirrors `IssueCreateRequest` (newsletter.py:42). */
+    createIssue(newsletterId: string, params: NewsletterIssueCreateParams): Promise<NewsletterIssue>;
+    /** Get a single issue. */
+    getIssue(newsletterId: string, issueId: string): Promise<NewsletterIssue>;
+    /**
+     * Update fields on a draft issue. Partial — only the fields you pass are
+     * changed. Mirrors `IssueUpdateRequest` (newsletter.py:52), NOT
+     * `IssueCreateRequest`: every field is optional here even though the
+     * transport verb is PUT.
+     */
+    updateIssue(newsletterId: string, issueId: string, params: NewsletterIssueUpdateParams): Promise<NewsletterIssue>;
+    /** Duplicate an issue into a new draft. */
+    duplicateIssue(newsletterId: string, issueId: string): Promise<NewsletterIssue>;
+    /**
+     * Send an issue to its subscribers. This sends real email — pass an
+     * `idempotencyKey` so a retry cannot double-send. `scheduled_at` mirrors
+     * `IssueSendRequest.scheduled_at` (newsletter.py:70); omitted (or left
+     * undefined) sends immediately, matching the DTO's own default. Note
+     * `idempotencyKey` is a transport header (`Idempotency-Key`), not a body
+     * field, so it is not part of the `IssueSendRequest` mirror.
+     */
+    sendIssue(newsletterId: string, issueId: string, opts?: {
+        idempotencyKey?: string;
+        scheduled_at?: string;
+    }): Promise<{
+        data: unknown;
+    }>;
+    /**
+     * Send a test copy of an issue to a single address. Mirrors
+     * `IssueSendTestRequest` (newsletter.py:73): ONE required `test_email`
+     * string, not a `recipients` array — the previous shape here always
+     * 422'd against the real API.
+     */
+    sendTestEmail(newsletterId: string, issueId: string, testEmail: string): Promise<{
+        data: unknown;
+    }>;
+    /** Engagement KPIs for a sent issue. */
+    issueKpis(newsletterId: string, issueId: string): Promise<NewsletterIssueKpis>;
+    /** List subscribers of a newsletter. */
+    listSubscribers(newsletterId: string, params?: NewsletterListParams): Promise<{
+        data: NewsletterSubscriber[];
+    }>;
+    /**
+     * Add a subscriber to a newsletter. Mirrors `SubscriberAddRequest`
+     * (newsletter.py:77) — `email` required, `first_name`/`last_name`
+     * optional.
+     */
+    addSubscriber(newsletterId: string, email: string, opts?: {
+        first_name?: string;
+        last_name?: string;
+    }): Promise<NewsletterSubscriber>;
+    /** Unsubscribe a subscriber. */
+    unsubscribe(newsletterId: string, subscriberId: string): Promise<{
+        data: unknown;
+    }>;
+};

package/dist/types/notes.d.ts

@@ -0,0 +1,57 @@
+export interface Note {
+    id: string;
+    entity_type: string;
+    entity_id: string;
+    content: string;
+    created_by: string | null;
+    created_by_name: string | null;
+    created_at: string | null;
+    updated_at: string | null;
+}
+/**
+ * Notes API - CRUD for notes attached to contacts, companies and deals.
+ * Requires API key (server-side).
+ *
+ * Backed by:
+ *   GET    /api/v1/contacts/{contact_id}/notes
+ *   POST   /api/v1/contacts/{contact_id}/notes
+ *   GET    /api/v1/companies/{company_id}/notes
+ *   POST   /api/v1/companies/{company_id}/notes
+ *   GET    /api/v1/deals/{deal_id}/notes
+ *   POST   /api/v1/deals/{deal_id}/notes
+ *   PATCH  /api/v1/notes/{note_id}
+ *   DELETE /api/v1/notes/{note_id}
+ *
+ * `list()` / `create()` remain contact-scoped for backwards compatibility.
+ * Use the `ForCompany` / `ForDeal` variants for the other two entity types.
+ * Note IDs are shared across entity types, so `update()` and `delete()` work
+ * on a note from any of the three.
+ */
+export declare const createNotesClient: (apiKey: string, apiUrl?: string) => {
+    /** List all notes on a contact. */
+    list(contactId: number): Promise<{
+        data: Note[];
+    }>;
+    /** Create a note on a contact. */
+    create(contactId: number, content: string): Promise<Note>;
+    /** List all notes on a company. */
+    listForCompany(companyId: number): Promise<{
+        data: Note[];
+    }>;
+    /** Create a note on a company. */
+    createForCompany(companyId: number, content: string): Promise<Note>;
+    /** List all notes on a deal. `dealId` is a UUID string, not a number. */
+    listForDeal(dealId: string): Promise<{
+        data: Note[];
+    }>;
+    /** Create a note on a deal. `dealId` is a UUID string, not a number. */
+    createForDeal(dealId: string, content: string): Promise<Note>;
+    /** Update a note's content. Works for contact, company and deal notes. */
+    update(noteId: string, content: string): Promise<Note>;
+    /** Delete a note. */
+    delete(noteId: string): Promise<{
+        data: {
+            deleted: boolean;
+        };
+    }>;
+};

package/dist/types/objects.d.ts

@@ -0,0 +1,281 @@
+export type CustomObjectIcon = "box" | "briefcase" | "building" | "calendar" | "flag" | "folder" | "globe" | "heart" | "layers" | "package" | "target" | "users";
+/** A custom object type in your workspace — a record type you define. */
+export interface CustomObject {
+    /** Stable API slug, e.g. `invoices`. */
+    slug: string;
+    singular_noun: string;
+    plural_noun: string;
+    /** True for object types graph8 ships; system objects cannot be deleted. */
+    is_system: boolean;
+    is_archived: boolean;
+    /** Presentation settings may be absent on older servers. */
+    description?: string | null;
+    icon?: string | null;
+    display_attribute_slug?: string | null;
+}
+/** Native schema creation requires objects:manage and current Admin access. */
+export interface CreateCustomObject {
+    slug: string;
+    singular_noun: string;
+    plural_noun: string;
+    description?: string | null;
+    icon?: CustomObjectIcon | null;
+}
+/** Omitted labels/state are preserved. The API slug is immutable. */
+export interface UpdateCustomObject {
+    singular_noun?: string;
+    plural_noun?: string;
+    is_archived?: boolean;
+    /** Omit to preserve; null clears the setting. */
+    description?: string | null;
+    icon?: CustomObjectIcon | null;
+    display_attribute_slug?: string | null;
+}
+/**
+ * One attribute on a custom object, and the rules its values must satisfy.
+ *
+ * `attribute_type` is one of 16 supported types and decides how a value is
+ * validated and canonicalized: `text`, `number`, `currency`, `date`,
+ * `timestamp`, `checkbox`, `select`, `status`, `email_address`, `phone_number`,
+ * `domain`, `location`, `personal_name`, `record_reference`, `rating`,
+ * `actor_reference`.
+ */
+export interface CustomObjectAttribute {
+    slug: string;
+    /** Customer-facing label. Display metadata is absent on older servers. */
+    title?: string;
+    description?: string | null;
+    /** Display order; ties are ordered by slug. */
+    sort_order?: number;
+    /** Protected system field rather than a customer-defined field. */
+    is_system?: boolean;
+    /** Archive state; absent on older servers. */
+    is_archived?: boolean;
+    attribute_type: string;
+    is_required: boolean;
+    /** No two ACTIVE records may hold the same value. A collision returns 409. */
+    is_unique: boolean;
+    is_multiselect: boolean;
+    /** Apply a non-null default to omitted create fields, never PATCH. Absent on older servers. */
+    is_default_value_enabled?: boolean;
+    /** Configured default; validated like an explicit value when enabled. */
+    default_value?: unknown;
+    /** Type-specific configuration, e.g. the allowed options for a `select`. */
+    config: Record<string, unknown>;
+}
+/** Schema creation requires objects:manage and current Admin access. */
+export interface CreateCustomObjectAttribute {
+    slug: string;
+    title: string;
+    attribute_type: "text" | "number" | "currency" | "date" | "timestamp" | "checkbox" | "select" | "status" | "email_address" | "phone_number" | "domain" | "location" | "personal_name" | "record_reference" | "rating" | "actor_reference";
+    description?: string | null;
+    is_required?: boolean;
+    is_unique?: boolean;
+    is_multiselect?: boolean;
+    is_default_value_enabled?: boolean;
+    default_value?: unknown;
+    config?: Record<string, unknown>;
+    sort_order?: number;
+}
+/** Omitted fields are preserved; explicit null can clear the configured default. */
+export type UpdateCustomObjectAttribute = Partial<Omit<CreateCustomObjectAttribute, "slug" | "attribute_type">> & {
+    is_archived?: boolean;
+};
+/** One record, with its currently active attribute values. */
+export interface CustomObjectRecord {
+    id: string;
+    object_slug: string;
+    /**
+     * Values keyed by attribute slug. Untyped by necessity — the valid keys come
+     * from YOUR attribute definitions at runtime, so call `listAttributes` for the
+     * schema. Saying `any` here would imply the shape was considered and found to
+     * be free.
+     */
+    values: Record<string, unknown>;
+    is_archived: boolean;
+    /** Revision for conditional updates; absent on older servers. */
+    revision?: number;
+    created_at: string | null;
+    updated_at: string | null;
+}
+/** One generation of one attribute's value. */
+export interface CustomObjectHistoryEntry {
+    attribute: string;
+    value: unknown;
+    active_from: string | null;
+    /** Null means this value is still in force. */
+    active_until: string | null;
+    actor_id: string | null;
+}
+export interface CustomObjectHistory {
+    record_id: string;
+    entries: CustomObjectHistoryEntry[];
+}
+export interface CustomObjectMutation {
+    id: string;
+    action: "created" | "updated" | "archived" | "restored";
+    occurred_at: string;
+    revision: number;
+    actor_id: string | null;
+    actor_type: "user" | "api" | "app" | "integration" | "system";
+    source: string;
+    app_id: string | null;
+    changes: Record<string, {
+        before_present: boolean;
+        before: unknown;
+        after_present: boolean;
+        after: unknown;
+    }>;
+    was_archived: boolean;
+    is_archived: boolean;
+}
+export interface CustomObjectMutations {
+    record_id: string;
+    entries: CustomObjectMutation[];
+    next_cursor: string | null;
+}
+export interface ListRecordsParams {
+    page?: number;
+    /** 1-200, default 50. */
+    limit?: number;
+    /** Opaque cursor from a prior response. Takes precedence over `page`. */
+    cursor?: string;
+}
+/**
+ * Pagination envelope for record listings.
+ *
+ * Named distinctly rather than `PaginationMeta`: `deals.ts` and `quotes.ts` each
+ * already declare their own structurally identical `PaginationMeta`, and one of
+ * them is re-exported from `index.ts` — so a third with that name is a
+ * `TS2300: Duplicate identifier` at the package's export site. Consolidating the
+ * three into one shared type is worth doing and is not this change.
+ */
+export interface ObjectPagination {
+    page: number;
+    limit: number;
+    total: number;
+    has_next: boolean;
+    next_cursor: string | null;
+}
+/**
+ * Custom Objects API — your own record types, their schema, and their records (M6-3).
+ * Requires an API key (server-side). On the hardened HTTP core: throws a typed
+ * `G8Error` on failure and retries transient errors.
+ *
+ * Access requires an authenticated credential with the applicable object scope.
+ *
+ * HOW THIS DIFFERS FROM `g8.fields`. A FIELD adds a column to an existing
+ * contact or company. A CUSTOM OBJECT is a whole new record type with its own
+ * attributes and its own records. Use fields to extend a contact; use custom
+ * objects to model an invoice, a shipment, or a subscription.
+ *
+ * THREE BEHAVIOURS WORTH KNOWING BEFORE YOU WRITE
+ *
+ *   1. An unknown field is REJECTED (422), not ignored. A typo does not silently
+ *      lose your data, and the response lists every problem at once so a payload
+ *      with three mistakes takes one round trip to fix.
+ *   2. `update` is a PARTIAL write. Attributes you omit are left alone; sending
+ *      an explicit `null` clears an optional attribute. Required attributes
+ *      cannot be cleared with `null` or an empty multivalue list (422).
+ *   3. `archive` does not destroy anything. The record leaves listings, stays
+ *      readable by id, and keeps its history.
+ *
+ * Record references must resolve to an active record of `config.target_object`
+ * within the same organization and app. Unavailable targets return a 422 with
+ * `invalid_reference` in the field error's `reason`, without disclosing whether
+ * a target exists outside the caller's scope.
+ *
+ * Backed by:
+ *   GET    /api/v1/objects
+ *   GET    /api/v1/objects/{slug}
+ *   GET    /api/v1/objects/{slug}/attributes
+ *   GET    /api/v1/objects/{slug}/records
+ *   POST   /api/v1/objects/{slug}/records
+ *   GET    /api/v1/objects/{slug}/records/{id}
+ *   PATCH  /api/v1/objects/{slug}/records/{id}
+ *   DELETE /api/v1/objects/{slug}/records/{id}
+ *   GET    /api/v1/objects/{slug}/records/{id}/history
+ */
+export declare const createObjectsClient: (apiKey: string, apiUrl?: string) => {
+    /** List the custom object types in your workspace. */
+    list(params?: {
+        include_archived?: boolean;
+    }): Promise<{
+        data: CustomObject[];
+    }>;
+    /** Create a native custom object. Requires objects:manage and Admin access. */
+    create(input: CreateCustomObject): Promise<CustomObject>;
+    /** Rename, archive or restore an object while preserving its slug and data. */
+    update(objectSlug: string, input: UpdateCustomObject): Promise<CustomObject>;
+    /** Archive the object without deleting records; restore with update({ is_archived: false }). */
+    archive(objectSlug: string): Promise<CustomObject>;
+    /** Fetch one object type by slug. */
+    get(objectSlug: string): Promise<CustomObject>;
+    /** The object's attributes — the schema its records must satisfy. */
+    listAttributes(objectSlug: string, params?: {
+        include_archived?: boolean;
+    }): Promise<{
+        data: CustomObjectAttribute[];
+    }>;
+    /** Create a field using the same schema rules as the customer UI. */
+    createAttribute(objectSlug: string, input: CreateCustomObjectAttribute): Promise<CustomObjectAttribute>;
+    /** Edit or restore a field; its type and slug are immutable. */
+    updateAttribute(objectSlug: string, attributeSlug: string, input: UpdateCustomObjectAttribute): Promise<CustomObjectAttribute>;
+    /** Archive without deleting values; restore with updateAttribute({ is_archived: false }). */
+    archiveAttribute(objectSlug: string, attributeSlug: string): Promise<CustomObjectAttribute>;
+    /** Paginated custom records or canonical deals with current values and revisions.
+     * Deal totals and related references respect current record access. */
+    listRecords(objectSlug: string, params?: ListRecordsParams): Promise<{
+        data: CustomObjectRecord[];
+        pagination?: ObjectPagination;
+    }>;
+    /**
+     * Create a record. Every field is validated against the object's attributes;
+     * an unknown one is a 422 listing every problem at once, and a collision on a
+     * unique attribute is a 409.
+     */
+    createRecord(objectSlug: string, values: Record<string, unknown>): Promise<CustomObjectRecord>;
+    /** Match a unique single-value key, creating or updating while preserving omitted fields. */
+    upsertRecord(objectSlug: string, matchingAttribute: string, values: Record<string, unknown>, options?: {
+        expectedRevision?: number;
+    }): Promise<CustomObjectRecord>;
+    /** Fetch one custom record, canonical contact/company, or deal by its stable graph8 ID.
+     * Deals retain their UUIDs and expose company, primary-contact and contact_ids references only
+     * when permitted. Generic deal mutations are not yet supported.
+     */
+    getRecord(objectSlug: string, recordId: string): Promise<CustomObjectRecord>;
+    /**
+     * Update a record. PARTIAL: only the attributes you send are touched, so
+     * required attributes you omit are left alone rather than reported missing.
+     * Sending an explicit `null` CLEARS that attribute.
+     *
+     * Custom values retain generations through `history`. Canonical contacts and
+     * companies require expectedRevision from a fresh read and expose recorded
+     * mutations through `changes`. They do not yet support appendValues/removeValues.
+     */
+    updateRecord(objectSlug: string, recordId: string, values: Record<string, unknown>, options?: {
+        expectedRevision?: number;
+        appendValues?: Record<string, unknown[]>;
+        removeValues?: Record<string, unknown[]>;
+    }): Promise<CustomObjectRecord>;
+    /**
+     * Archive a record. It leaves listings, stays readable by id, and keeps its
+     * history and associations. Nothing is destroyed.
+     */
+    archiveRecord(objectSlug: string, recordId: string): Promise<CustomObjectRecord>;
+    /** Restore archived values under current constraints. Conflicts leave the record archived. */
+    restoreRecord(objectSlug: string, recordId: string): Promise<CustomObjectRecord>;
+    /**
+     * A record's value timeline, newest first. An entry whose `active_until` is
+     * null is the value currently in force.
+     */
+    history(objectSlug: string, recordId: string, limit?: number): Promise<CustomObjectHistory>;
+    /** Recorded custom-record or canonical contact/company mutations. Pass next_cursor to continue.
+     * Canonical history respects current access/privacy; archived records and older
+     * unrecorded writes are not reconstructed. Store unavailability returns 503.
+     */
+    changes(objectSlug: string, recordId: string, options?: {
+        limit?: number;
+        cursor?: string;
+    }): Promise<CustomObjectMutations>;
+};

package/dist/types/pipelines.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Stage Checklist v2 pipelines. A "pipeline" here is a multi-stage workflow
+ * (with evidence requirements and per-channel scripts) that lives parallel
+ * to deal pipelines. Use `g8.deals.pipelines()` for deal-pipeline reads.
+ */
+export interface StagePipelineStage {
+    id: string;
+    name: string;
+    position: number;
+    /** Evidence keys that must be collected before the stage can be marked done. */
+    required_elements: string[];
+    /** Evidence keys that are recommended but not enforced. */
+    recommended_elements: string[];
+    /** Channel-specific scripts (call, email, linkedin, etc.). */
+    channel_scripts: Record<string, string>;
+    color: string | null;
+    stage_type: string | null;
+}
+export interface StagePipeline {
+    id: string;
+    name: string;
+    target: string | null;
+    is_default: boolean;
+    stages: StagePipelineStage[];
+    created_at: string | null;
+    updated_at: string | null;
+}
+export interface StagePipelineCreateParams {
+    name: string;
+    target?: string;
+    /** If true, creates an empty pipeline (no default stages). */
+    blank?: boolean;
+}
+export interface StagePipelineUpdateParams {
+    name?: string;
+    target?: string;
+}
+export interface StageCreateParams {
+    name: string;
+    position?: number;
+    required_elements?: string[];
+    recommended_elements?: string[];
+    channel_scripts?: Record<string, string>;
+    color?: string;
+    stage_type?: string;
+}
+export interface StageUpdateParams {
+    name?: string;
+    position?: number;
+    required_elements?: string[];
+    recommended_elements?: string[];
+    channel_scripts?: Record<string, string>;
+    color?: string;
+}
+export interface EvidenceKey {
+    key: string;
+    label: string;
+    description: string;
+    category: string;
+}
+export interface PipelineSuggestion {
+    suggestion_id: string;
+    name: string;
+    target: string;
+    stages: Array<{
+        name: string;
+        required_elements: string[];
+        channel_scripts: Record<string, string>;
+    }>;
+    rationale: string;
+}
+/**
+ * Stage Checklist Pipelines API - workflow pipelines with evidence + scripts.
+ * Requires API key (server-side). On the hardened HTTP core: throws a typed
+ * `G8Error` on failure and retries transient errors.
+ *
+ * Backed by:
+ *   GET    /api/v1/pipelines
+ *   GET    /api/v1/pipelines/{id}
+ *   GET    /api/v1/pipelines/evidence-library
+ *   POST   /api/v1/pipelines
+ *   PUT    /api/v1/pipelines/{id}
+ *   DELETE /api/v1/pipelines/{id}
+ *   POST   /api/v1/pipelines/{id}/stages
+ *   PUT    /api/v1/pipelines/{id}/stages/{stage_id}
+ *   DELETE /api/v1/pipelines/{id}/stages/{stage_id}
+ *   PUT    /api/v1/pipelines/{id}/stages/reorder
+ *   POST   /api/v1/pipelines/suggest
+ *   POST   /api/v1/pipelines/from-suggestion
+ */
+export declare const createPipelinesClient: (apiKey: string, apiUrl?: string) => {
+    /** List all stage-checklist pipelines with stages, evidence, scripts. */
+    list(): Promise<{
+        data: StagePipeline[];
+    }>;
+    /** Get a single pipeline by ID. */
+    get(pipelineId: string): Promise<StagePipeline>;
+    /** Get the canonical evidence-key library (used when defining stages). */
+    evidenceLibrary(): Promise<{
+        data: EvidenceKey[];
+    }>;
+    /** Create a new pipeline. Defaults to a templated set of stages; pass blank=true for empty. */
+    create(params: StagePipelineCreateParams): Promise<StagePipeline>;
+    /** Update pipeline metadata (name, target). */
+    update(pipelineId: string, fields: StagePipelineUpdateParams): Promise<StagePipeline>;
+    /** Delete a pipeline. Only allowed when no deals reference it. */
+    delete(pipelineId: string): Promise<{
+        data: {
+            deleted: boolean;
+        };
+    }>;
+    /** Add a new stage to a pipeline. */
+    createStage(pipelineId: string, stage: StageCreateParams): Promise<StagePipelineStage>;
+    /** Update a stage (evidence, scripts, position). */
+    updateStage(pipelineId: string, stageId: string, fields: StageUpdateParams): Promise<StagePipelineStage>;
+    /** Reorder stages within a pipeline (pass full ordered list of stage IDs). */
+    reorderStages(pipelineId: string, stageIds: string[]): Promise<{
+        data: StagePipelineStage[];
+    }>;
+    /** Delete a stage from a pipeline. */
+    deleteStage(pipelineId: string, stageId: string): Promise<{
+        data: {
+            deleted: boolean;
+        };
+    }>;
+    /** Get an AI-suggested pipeline based on org context (brand, ICP, messaging). */
+    suggest(): Promise<{
+        data: PipelineSuggestion;
+    }>;
+    /** Create a real pipeline from an AI suggestion (optionally with overrides). */
+    fromSuggestion(suggestionId: string, overrides?: Partial<{
+        name: string;
+        target: string;
+    }>): Promise<StagePipeline>;
+};