@curviate/sdk 0.15.0 → 0.16.0

package/dist/index.js

@@ -40,6 +40,18 @@ var ERROR_CODES = [
   "CHECKPOINT_ALREADY_RESOLVED",
   "CHECKPOINT_UNSUPPORTED",
   "CONNECTION_IN_PROGRESS",
+  // One-premium boundary rejection — LinkedIn permits only one individual
+  // Premium subscription per profile. Surfaces on connect/reconnect (a seat
+  // resolving to both premiums) and on the billing seat/tier endpoints (a
+  // "naked enable" of one premium while the seat already holds the other).
+  // user_fixable, never retryable — the remedy is two seats, or pairing
+  // enable with disable of the current premium in one call.
+  "PREMIUM_CONFLICT",
+  // A reconnect whose seat-derived scope differs from the account's recorded
+  // scope was attempted with cookie auth — a cookie replay cannot change
+  // scope, so a full credentials re-authentication is required. user_fixable,
+  // never retryable.
+  "REAUTH_REQUIRED",
   // LinkedIn-specific connect errors
   "LINKEDIN_AUTH_FAILED",
   "LINKEDIN_RATE_LIMITED",
@@ -405,6 +417,17 @@ var AuthResource = class {
    * LinkedIn identity already present on the workspace (claiming it into your
    * account) rather than connecting a brand-new one — it is absent on a normal
    * connect.
+   *
+   * Connection scope (which LinkedIn products are enabled: classic, company,
+   * a premium tier) is **seat-derived**: there is no products input on this
+   * body, and the recorded scope is readable back as `requested_products` on
+   * the account (`accounts.list()` / `accounts.get()`). A reconnect that
+   * would change scope must use `auth_method: "credentials"`, since a cookie
+   * replay cannot change scope and throws `CurviateError(code:
+   * "REAUTH_REQUIRED")` instead. A seat resolving to both individual-Premium
+   * tiers at once throws `CurviateError(code: "PREMIUM_CONFLICT")` (LinkedIn
+   * permits only one per profile). Pin a managed proxy with the optional
+   * `country`/`ip`, or supply `proxy` to override it entirely.
    */
   intent(body) {
     return this.ctx.request({
@@ -495,8 +518,12 @@ var MessagingResource = class {
   }
   /**
    * Start a new chat with one or more members. `POST /v1/{account_id}/chats`
-   * `attachments[]`, when supplied, carry base64-encoded file bytes — always
+   * `attachments[]`, when supplied, carry base64-encoded file bytes, always
    * sent as JSON, never multipart.
+   *
+   * Company pages are reply-only and cannot start a conversation this way.
+   * Reply to an existing one instead, with `sendMessage()` using a
+   * `COMPANY_` chat id from `inboxes.listChats()`.
    */
   startChat(body) {
     return this.ctx.request({
@@ -536,9 +563,31 @@ var MessagingResource = class {
   }
   /**
    * Send a message in a chat. `POST /v1/{account_id}/chats/{chat_id}/messages`
-   * `attachments[]`, when supplied, carry base64-encoded file bytes — always
+   * `attachments[]`, when supplied, carry base64-encoded file bytes, always
    * sent as JSON, never multipart. At least one of `text`/`attachments` is
    * required (enforced server-side).
+   *
+   * Sending on behalf of a company page: this same method is the reply
+   * surface for a company page, there is no separate send-as-page method.
+   * Pass a `COMPANY_` chat id (from `inboxes.listChats()`, e.g.
+   * `"COMPANY_83734124_2-YTQ3ODU3Njgt"`) and the message sends AS THE PAGE,
+   * no extra parameter needed. Any other chat id sends as the connected
+   * member. Company pages are reply-only: they can answer an existing
+   * conversation this way, but `startChat()` cannot start one on their
+   * behalf.
+   *
+   * The response echoes `sent_as`, the acting identity actually used:
+   * `{ kind: "company", company_id, name }` (`company_id` is `null` when
+   * the page could not be correlated to a managed page) or
+   * `{ kind: "personal" }`. Never infer the acting identity from a
+   * message's `sender` field, only from `sent_as`.
+   *
+   * @example
+   * const acc = curviate.account("acc_YOUR_ACCOUNT_ID");
+   * const result = await acc.messaging.sendMessage("COMPANY_83734124_2-YTQ3ODU3Njgt", {
+   *   text: "Thanks for reaching out!",
+   * });
+   * console.log(result.sent_as); // { kind: "company", company_id: "112013061", name: "Acme Inc" }
    */
   sendMessage(chatId, body) {
     return this.ctx.request({
@@ -608,6 +657,20 @@ var MessagingResource = class {
       body
     });
   }
+  /**
+   * Free-text search the account's own inbox — matches participant names
+   * and message content. `GET /v1/{account_id}/chats/search`
+   *
+   * @param params - `query` (required free-text term) plus `limit` and an
+   *   opaque `cursor` for pagination.
+   */
+  searchChats(params) {
+    return this.ctx.request({
+      method: "GET",
+      path: "/v1/{account_id}/chats/search",
+      query: params
+    });
+  }
 };
 
 // src/resources/users.ts
@@ -893,6 +956,48 @@ var SearchResource = class {
       } : {}
     });
   }
+  /**
+   * Search LinkedIn groups by keyword.
+   * `GET /v1/{account_id}/search/groups`
+   */
+  groups(query) {
+    return this.ctx.request({
+      method: "GET",
+      path: "/v1/{account_id}/search/groups",
+      query
+    });
+  }
+  /**
+   * Search Services Marketplace providers with structured filters.
+   * `POST /v1/{account_id}/search/services`
+   * `limit`/`cursor` are top-level query params, never in the body. Resolve
+   * `service_category`/`location` filter values with `getServiceParameters()`
+   * first — both take opaque ids, not free text.
+   */
+  services(body) {
+    const split = splitPagination(body);
+    return this.ctx.request({
+      method: "POST",
+      path: "/v1/{account_id}/search/services",
+      body: split.body,
+      ...split.query ? { query: split.query } : {}
+    });
+  }
+  /**
+   * Resolve human-readable service-filter terms into the opaque ids
+   * `services()` accepts.
+   * `GET /v1/{account_id}/search/services/parameters`
+   *
+   * @param query - `type` selects `service_category` (default) or `location`;
+   *   `keywords` is the free-text term to resolve.
+   */
+  getServiceParameters(query) {
+    return this.ctx.request({
+      method: "GET",
+      path: "/v1/{account_id}/search/services/parameters",
+      query
+    });
+  }
 };
 
 // src/resources/posts.ts
@@ -984,6 +1089,58 @@ var PostsResource = class {
       ...params ? { query: params } : {}
     });
   }
+  /**
+   * List the connected account's own saved posts (a private bookmark list)
+   * — newest-saved-first. A self resource: there is no other-member
+   * saved-posts view, so this takes no target param. Each item is a
+   * PREVIEW — `snippet` capped at ≤140 chars, never the full post body.
+   * `GET /v1/{account_id}/saved-posts`
+   *
+   * @param params - optional `limit` (default 20, a page-aligned lower
+   *   bound) and an opaque `cursor` from a prior response.
+   */
+  listSaved(params) {
+    return this.ctx.request({
+      method: "GET",
+      path: "/v1/{account_id}/saved-posts",
+      ...params ? { query: params } : {}
+    });
+  }
+  /**
+   * Save a post to the connected account's private bookmark list. Any post
+   * may be saved — it does not notify the author and is never visible to
+   * third parties. Idempotent: saving an already-saved post re-asserts
+   * `saved:true`.
+   * `POST /v1/{account_id}/saved-posts`
+   *
+   * @param postId - the post to save. Accepts `urn:li:activity:<id>` or a
+   *   bare numeric `<id>` — both normalize to the same target. Any other
+   *   shape (`urn:li:ugcPost:…`, `urn:li:share:…`, a URL) is rejected with
+   *   `400 INVALID_REQUEST`.
+   */
+  save(postId) {
+    const body = { post_id: postId };
+    return this.ctx.request({
+      method: "POST",
+      path: "/v1/{account_id}/saved-posts",
+      body
+    });
+  }
+  /**
+   * Unsave a post — the reverse of {@link save}, over the SAME underlying
+   * save-state call (a distinct product endpoint, one substrate call).
+   * Idempotent: unsaving a not-currently-saved post re-asserts
+   * `saved:false`.
+   * `DELETE /v1/{account_id}/saved-posts/{post_id}`
+   *
+   * @param postId - the post to unsave, same accepted shapes as {@link save}.
+   */
+  unsave(postId) {
+    return this.ctx.request({
+      method: "DELETE",
+      path: `/v1/{account_id}/saved-posts/${postId}`
+    });
+  }
 };
 
 // src/resources/comments.ts
@@ -1094,6 +1251,320 @@ var CommentsResource = class {
   }
 };
 
+// src/resources/profile.ts
+var ProfileResource = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  /**
+   * Read the connected account's premium subscription — its full entitlement
+   * inventory, primary plan title, and LinkedIn management links.
+   * `GET /v1/{account_id}/profile/subscription`
+   *
+   * A free account is a valid, non-error result: `has_premium` is `false`,
+   * `plan_title` is `null`, and `subscriptions` is empty. Read
+   * `subscriptions` for the complete set of active plans; the flat fields
+   * mirror the primary plan only.
+   */
+  subscription() {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/{account_id}/profile/subscription`
+    });
+  }
+  /**
+   * Read the connected account's performance headline metrics — profile
+   * viewers, followers, post impressions, and search appearances.
+   * `GET /v1/{account_id}/profile/analytics`
+   *
+   * Each metric is a headline scalar over a fixed reporting window set by
+   * LinkedIn (viewers 90d, impressions 7d, search last completed week,
+   * followers running total); there is no window selector. A `count` of `0`
+   * is a real zero; a per-metric `null` means that one card was unavailable.
+   */
+  analytics() {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/{account_id}/profile/analytics`
+    });
+  }
+  /**
+   * List the people who recently viewed the connected account's profile,
+   * cursor-paginated and classified by disclosure fidelity.
+   * `GET /v1/{account_id}/profile/visitors`
+   *
+   * Each item's `kind` is `identified`, `semi-anonymous`, or `aggregate` —
+   * a Premium account sees identified viewers, a free account is capped at a
+   * lower fidelity (still a `200`, never a permission error). Page with the
+   * returned `cursor`: a non-null `cursor` means more may exist, even if a
+   * page held zero identified individuals; `cursor: null` means exhausted.
+   *
+   * @param params - `limit` (1–100, default 20) and an opaque `cursor` from
+   *   a prior response.
+   */
+  visitors(params) {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/{account_id}/profile/visitors`,
+      ...params ? { query: params } : {}
+    });
+  }
+  /**
+   * Read the connected account's Social Selling Index — the overall score,
+   * its four pillar breakdowns, and industry/network percentile ranks.
+   * `GET /v1/{account_id}/profile/ssi`
+   *
+   * A low score on a low-activity account is a normal `200`; a genuine
+   * zero-activity account returns all scalars `null` with `active_seat`
+   * `false`. Scores preserve full float precision.
+   */
+  ssi() {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/{account_id}/profile/ssi`
+    });
+  }
+};
+
+// src/resources/groups.ts
+var GroupsResource = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  /**
+   * List the LinkedIn groups a member belongs to, each enriched to full
+   * group detail. `GET /v1/{account_id}/profile/groups`
+   *
+   * Reads the connected account's own groups by default; pass `{ profile }`
+   * (a member's public identifier) to read another member's group set. The
+   * `id` on each returned group is the same id `members()` consumes.
+   *
+   * @param params - optional `{ profile }` to target another member, plus
+   *   `limit` and an opaque `cursor` for pagination.
+   */
+  list(params) {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/{account_id}/profile/groups`,
+      ...params ? { query: params } : {}
+    });
+  }
+  /**
+   * Retrieve a single LinkedIn group's full detail — its name, description,
+   * member count, membership status, and admin contact.
+   * `GET /v1/{account_id}/groups/{group}`
+   *
+   * @param group - the group's id or LinkedIn group URL.
+   */
+  get(group) {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/{account_id}/groups/${group}`
+    });
+  }
+  /**
+   * List a group's members, cursor-paginated, each carrying its profile URL,
+   * name, and headline. `GET /v1/{account_id}/groups/{group}/members`
+   *
+   * Pass `{ name }` to search the roster by member name — the folded-in
+   * member search, not a separate endpoint.
+   *
+   * @param group - the group's id or LinkedIn group URL.
+   * @param params - optional `{ name }` filter plus `limit` and an opaque
+   *   `cursor` for pagination.
+   */
+  members(group, params) {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/{account_id}/groups/${group}/members`,
+      ...params ? { query: params } : {}
+    });
+  }
+};
+
+// src/resources/feed.ts
+var FeedResource = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  /**
+   * Read the connected account's LinkedIn home feed as agent-actionable posts.
+   * `GET /v1/{account_id}/feed/home`
+   *
+   * Pass `{ sort }` to choose the order: `recent` (reverse-chronological,
+   * the default) or `relevant` (LinkedIn's ranked "top" feed). The feed is an
+   * unbounded, reordering stream with no total count — walk it with the
+   * returned `cursor` until `cursor` is null. When a `cursor` is supplied its
+   * carrier is authoritative and `sort` is ignored.
+   *
+   * @param params - optional `{ sort }`, `limit` (1–100, default 20), and an
+   *   opaque `cursor` from a prior response.
+   */
+  home(params) {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/{account_id}/feed/home`,
+      ...params ? { query: params } : {}
+    });
+  }
+};
+
+// src/resources/inboxes.ts
+var InboxesResource = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  /**
+   * List the account's inboxes: its own personal inbox, plus, when the
+   * company product is attached, one entry per company page (id like
+   * `"COMPANY_83734124_PRIMARY"`). `GET /v1/{account_id}/inboxes`
+   *
+   * Company inboxes carry `reply_only: true`: reply to an existing
+   * conversation via `messaging.sendMessage()`, never `startChat()`.
+   * `company_id` is resolved by correlating the page name against the
+   * account's managed pages. An uncorrelatable page reports
+   * `company_id: null`, never a fabricated id. When no company inbox
+   * exists, `hint` names the Company Pages reconnect requirement instead of
+   * an empty list.
+   *
+   * Beta.
+   *
+   * @param params - optional `{ kind }` (`"personal"` or `"company"`)
+   *   and/or `{ company_id }` filters. Omit to list every inbox.
+   *
+   * @example
+   * const acc = curviate.account("acc_YOUR_ACCOUNT_ID");
+   * const { items, hint } = await acc.inboxes.list({ kind: "company" });
+   * const companyPage = (items ?? []).find((i) => i.kind === "company");
+   * console.log(companyPage?.id, companyPage?.name, hint);
+   * // companyPage?.id is what you pass to listChats(), e.g. "COMPANY_83734124_PRIMARY"
+   */
+  list(params) {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/{account_id}/inboxes`,
+      ...params ? { query: params } : {}
+    });
+  }
+  /**
+   * List an inbox's conversations, newest-activity-first, cursor-paginated.
+   * `GET /v1/{account_id}/inboxes/{inbox_id}/chats`
+   *
+   * Every chat's `id` is already send-ready: pass it directly to
+   * `messaging.sendMessage(chatId, { text })` to reply. A company inbox's
+   * chat id (e.g. `"COMPANY_83734124_2-YTQ3ODU3Njgt"`) replies AS THE PAGE,
+   * no separate parameter needed. This is the full reply-as-a-page flow:
+   *
+   * ```ts
+   * const { items: inboxes } = await acc.inboxes.list({ kind: "company" });
+   * const pageInbox = inboxes[0]!; // e.g. id "COMPANY_83734124_PRIMARY", reply_only: true
+   *
+   * const { items: chats } = await acc.inboxes.listChats(pageInbox.id);
+   * const chatId = chats[0]!.id as string; // e.g. "COMPANY_83734124_2-YTQ3ODU3Njgt"
+   *
+   * const sent = await acc.messaging.sendMessage(chatId, { text: "Thanks for reaching out!" });
+   * console.log(sent.sent_as); // { kind: "company", company_id: "112013061", name: "Acme Inc" }
+   * ```
+   *
+   * Works identically for personal (`CLASSIC_`) inboxes: pass a `CLASSIC_`
+   * chat id and the send goes out as the connected member. An unknown
+   * `inbox_id` returns `RESOURCE_NOT_FOUND` (404). Beta.
+   *
+   * @param inboxId - the inbox id from `list()` (e.g. `"CLASSIC_PRIMARY"`
+   *   or `"COMPANY_83734124_PRIMARY"`).
+   * @param params - optional `limit` (1–25, default 20) and an opaque
+   *   `cursor` for pagination.
+   */
+  listChats(inboxId, params) {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/{account_id}/inboxes/${inboxId}/chats`,
+      ...params ? { query: params } : {}
+    });
+  }
+};
+
+// src/resources/notifications.ts
+var NotificationsResource = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  /**
+   * List the connected account's notification cards — newest first, plus
+   * the account-level `unread_count` (the unseen badge — NOT a count of
+   * `items`) and `latest_published_at` (a cheap poll watermark). Injected
+   * promo/suggestion cards are included and flagged (`injected:true`),
+   * never filtered.
+   * `GET /v1/{account_id}/notifications`
+   *
+   * @param params - optional `filter` (7-token enum, default `all`),
+   *   `limit` (1-100, default 20), and an opaque `cursor` from a prior
+   *   response. Page until the returned `cursor` is `null`.
+   */
+  list(params) {
+    return this.ctx.request({
+      method: "GET",
+      path: "/v1/{account_id}/notifications",
+      ...params ? { query: params } : {}
+    });
+  }
+  /**
+   * Delete one of the connected account's own notification cards by its
+   * card urn. A self-action — no third party is notified. This cannot be
+   * undone.
+   *
+   * **Safe to retry.** Idempotent: deleting a card you already deleted
+   * succeeds with `200`, not an error — a client that retries after a
+   * timeout is never punished for it. Only a `card_urn` that never existed
+   * on this account 404s.
+   *
+   * **Timing.** The removal takes effect within a few seconds; a
+   * {@link list} read immediately after this call may still include the
+   * card for a moment. That is not a failure signal — the `200` is already
+   * confirmation the card was resolved and the removal accepted. Re-read
+   * after a short delay, not instantly, if you need to visually confirm.
+   *
+   * `DELETE /v1/{account_id}/notifications/{card_urn}`
+   *
+   * @param cardUrn - the card's entity urn, raw/unencoded (the `card_urn`
+   *   field of a {@link list} item — `urn:li:fsd_notificationCard:(…)`,
+   *   NOT `object_urn`, which targets the wrong notification). The SDK
+   *   percent-encodes it into the path.
+   */
+  delete(cardUrn) {
+    return this.ctx.request({
+      method: "DELETE",
+      path: `/v1/{account_id}/notifications/${encodeURIComponent(cardUrn)}`
+    });
+  }
+  /**
+   * Apply "show less like this" to the source of one of the connected
+   * account's own notification cards — a self-action, same card handle and
+   * timing/retry contract as {@link delete}. For network-activity cards (a
+   * repost, comment, or reaction by your network) this **removes the
+   * card**, the same effect as `delete` — LinkedIn exposes no separate,
+   * softer signal for these cards; this method exists so the calling
+   * intent reads clearly, not because it behaves differently. This cannot
+   * be undone.
+   *
+   * **Safe to retry**, same timing as {@link delete}: idempotent (a repeat
+   * is a `200`, not an error), effective within a few seconds — a
+   * still-visible card on an immediate {@link list} re-read is not a
+   * failure signal.
+   *
+   * `POST /v1/{account_id}/notifications/{card_urn}/show-less`
+   *
+   * @param cardUrn - the card's entity urn, raw/unencoded (see
+   *   {@link delete}). The SDK percent-encodes it into the path.
+   */
+  showLess(cardUrn) {
+    return this.ctx.request({
+      method: "POST",
+      path: `/v1/{account_id}/notifications/${encodeURIComponent(cardUrn)}/show-less`
+    });
+  }
+};
+
 // src/resources/sales-navigator.ts
 var SalesNavigatorResource = class {
   constructor(ctx) {
@@ -1764,6 +2235,122 @@ var CompaniesResource = class {
       ...params ? { query: params } : {}
     });
   }
+  /**
+   * List the pages the connected account administers.
+   * `GET /v1/{account_id}/companies/managed`
+   *
+   * The `id` on each returned page is the numeric provider_id `followers()`,
+   * `invitableFollowers()`, `employees()`, `posts()`, and `jobs()` consume.
+   * An empty `items[]` is valid — the account administers no pages.
+   */
+  managed(params) {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/{account_id}/companies/managed`,
+      ...params ? { query: params } : {}
+    });
+  }
+  /**
+   * List a company page's followers, newest first.
+   * `GET /v1/{account_id}/companies/{identifier}/followers`
+   *
+   * The connected account must administer the page (see `managed()`).
+   * `identifier` must be the company's numeric provider_id.
+   */
+  followers(identifier, params) {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/{account_id}/companies/${identifier}/followers`,
+      ...params ? { query: params } : {}
+    });
+  }
+  /**
+   * List the connected account's connections who are invitable to follow the
+   * company page. `GET /v1/{account_id}/companies/{identifier}/invitable-followers`
+   *
+   * The connected account must administer the page. `identifier` must be the
+   * company's numeric provider_id. An empty `items[]` is valid — nobody is
+   * currently invitable.
+   */
+  invitableFollowers(identifier, params) {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/{account_id}/companies/${identifier}/invitable-followers`,
+      ...params ? { query: params } : {}
+    });
+  }
+  /**
+   * List the conversations in a company page's admin message inbox,
+   * newest-activity-first.
+   * `GET /v1/{account_id}/companies/{identifier}/chats`
+   *
+   * The connected account must administer the page. `identifier` must be the
+   * company's numeric provider_id. Content passes through verbatim and is
+   * never stored. Beta — single-page listing and termination are verified;
+   * deep pagination (many pages / large cursor round-trips) is provisional
+   * until validated against a busier inbox.
+   */
+  chats(identifier, params) {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/{account_id}/companies/${identifier}/chats`,
+      ...params ? { query: params } : {}
+    });
+  }
+  /**
+   * Retrieve one conversation from a company page's admin inbox.
+   * `GET /v1/{account_id}/companies/{identifier}/chats/{chat_id}`
+   *
+   * The connected account must administer the page. Beta — see `chats()`.
+   */
+  chat(identifier, chatId) {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/{account_id}/companies/${identifier}/chats/${chatId}`
+    });
+  }
+  /**
+   * List a company-inbox conversation's messages, newest first.
+   * `GET /v1/{account_id}/companies/{identifier}/chats/{chat_id}/messages`
+   *
+   * The connected account must administer the page. Content passes through
+   * verbatim and is never stored. Beta — see `chats()`.
+   */
+  messages(identifier, chatId, params) {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/{account_id}/companies/${identifier}/chats/${chatId}/messages`,
+      ...params ? { query: params } : {}
+    });
+  }
+  /**
+   * Retrieve one message from a company-inbox conversation.
+   * `GET /v1/{account_id}/companies/{identifier}/chats/{chat_id}/messages/{message_id}`
+   *
+   * The connected account must administer the page. Beta — see `chats()`.
+   */
+  message(identifier, chatId, messageId) {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/{account_id}/companies/${identifier}/chats/${chatId}/messages/${messageId}`
+    });
+  }
+  /**
+   * Search or filter a company page's admin inbox.
+   * `GET /v1/{account_id}/companies/{identifier}/chats/search`
+   *
+   * Exactly one mode per call: free-text `query` (matches participant names
+   * and message content), a `topic` card, or `unread`-only — the three are
+   * mutually exclusive and enforced server-side. The connected account must
+   * administer the page. Beta — see `chats()`.
+   */
+  searchChats(identifier, params) {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/{account_id}/companies/${identifier}/chats/search`,
+      ...params ? { query: params } : {}
+    });
+  }
 };
 
 // src/resources/webhooks.ts
@@ -1850,6 +2437,11 @@ function buildNamespaces(ctx) {
     search: new SearchResource(ctx),
     posts: new PostsResource(ctx),
     comments: new CommentsResource(ctx),
+    profile: new ProfileResource(ctx),
+    groups: new GroupsResource(ctx),
+    feed: new FeedResource(ctx),
+    inboxes: new InboxesResource(ctx),
+    notifications: new NotificationsResource(ctx),
     salesNavigator: new SalesNavigatorResource(ctx),
     recruiter: new RecruiterResource(ctx),
     jobs: new JobsResource(ctx),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@curviate/sdk",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "private": false,
   "description": "TypeScript SDK for the Curviate API.",
   "license": "MIT",