@curviate/sdk 0.14.1 → 0.16.0

package/dist/index.js

@@ -1,4 +1,82 @@
 // src/errors.ts
+var ERROR_CODES = [
+  // Authentication / authorization
+  "UNAUTHORIZED",
+  "INVALID_REQUEST",
+  "UNSUPPORTED_MEDIA_TYPE",
+  "PAYLOAD_TOO_LARGE",
+  // Account state
+  "ACCOUNT_NOT_FOUND",
+  "ACCOUNT_RESTRICTED",
+  // Duplicate connect — reconnect or adopt the existing account instead of
+  // linking again. Not retryable.
+  "ACCOUNT_ALREADY_LINKED",
+  "RESOURCE_NOT_FOUND",
+  "RESOURCE_ACCESS_RESTRICTED",
+  // Tier / subscription gating
+  "TIER_NOT_ACTIVE",
+  "LINKEDIN_FEATURE_NOT_SUBSCRIBED",
+  // Rate limits
+  "RATE_LIMIT_ACCOUNT",
+  "RATE_LIMIT_TENANT",
+  "PLATFORM_RATE_LIMIT",
+  // LinkedIn-platform-level throttling on the Recruiter / Sales Navigator read
+  // surface (carries dedicated RateLimit-Policy / RateLimit / Retry-After
+  // response headers). Distinct from the account/tenant/platform trio above.
+  // Always retry-safe (retry_likely_to_succeed: true) — see RETRYABLE_CODES.
+  "RATE_LIMITED",
+  // Platform errors
+  "PLATFORM_ERROR",
+  "PLATFORM_NOT_IMPLEMENTED",
+  // Permanent LinkedIn platform limitation for the attempted operation (e.g.
+  // listing a non-self user's following list). Not a transient failure —
+  // retrying will not help.
+  "LINKEDIN_OPERATION_NOT_SUPPORTED",
+  // Checkpoint (account connect flow)
+  "CHECKPOINT_NOT_FOUND",
+  "CHECKPOINT_EXPIRED",
+  "CHECKPOINT_INVALID_CODE",
+  "CHECKPOINT_MAX_ATTEMPTS",
+  "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",
+  "LINKEDIN_COOKIE_INVALID",
+  "LINKEDIN_SERVICE_UNAVAILABLE",
+  // Messaging / connect-request mutation
+  "MESSAGE_WINDOW_EXPIRED",
+  "RECIPIENT_UNREACHABLE",
+  // Duplicate / already-connected connect-request conflict: a send to a
+  // recipient who already has a pending request from this account, or is already
+  // a first-degree connection. user_fixable, never retryable — do not re-send.
+  "CONNECTION_REQUEST_CONFLICT",
+  // Billing (surface: tenant-management)
+  "PAYMENT_REQUIRED",
+  "PAYMENT_FAILED",
+  "SUBSCRIPTION_BUSY",
+  "SUBSCRIPTION_NOT_FOUND",
+  "SEAT_NOT_FOUND",
+  "SEAT_CANCELLED",
+  // Generic
+  "INTERNAL"
+];
+var KNOWN_ERROR_CODES = new Set(ERROR_CODES);
+var REQUIRED_TIERS = ["core", "sn", "sales_nav", "recruiter"];
+var KNOWN_REQUIRED_TIERS = new Set(REQUIRED_TIERS);
 var CurviateError = class _CurviateError extends Error {
   constructor(init) {
     super(init.message);
@@ -66,53 +144,10 @@ var RETRYABLE_CODES = /* @__PURE__ */ new Set([
   "PLATFORM_ERROR",
   "PLATFORM_RATE_LIMIT",
   "RATE_LIMIT_ACCOUNT",
-  "RATE_LIMIT_TENANT"
-]);
-var WRITE_METHODS = /* @__PURE__ */ new Set(["POST", "PATCH", "PUT", "DELETE"]);
-var KNOWN_CODES = /* @__PURE__ */ new Set([
-  "UNAUTHORIZED",
-  "INVALID_REQUEST",
-  "UNSUPPORTED_MEDIA_TYPE",
-  "PAYLOAD_TOO_LARGE",
-  "ACCOUNT_NOT_FOUND",
-  "ACCOUNT_RESTRICTED",
-  "ACCOUNT_ALREADY_LINKED",
-  "RESOURCE_NOT_FOUND",
-  "RESOURCE_ACCESS_RESTRICTED",
-  "TIER_NOT_ACTIVE",
-  "LINKEDIN_FEATURE_NOT_SUBSCRIBED",
-  "RATE_LIMIT_ACCOUNT",
   "RATE_LIMIT_TENANT",
-  "PLATFORM_RATE_LIMIT",
-  "PLATFORM_ERROR",
-  "PLATFORM_NOT_IMPLEMENTED",
-  "CHECKPOINT_NOT_FOUND",
-  "CHECKPOINT_EXPIRED",
-  "CHECKPOINT_INVALID_CODE",
-  "CHECKPOINT_MAX_ATTEMPTS",
-  "CHECKPOINT_ALREADY_RESOLVED",
-  "CHECKPOINT_UNSUPPORTED",
-  "CONNECTION_IN_PROGRESS",
-  "LINKEDIN_AUTH_FAILED",
-  "LINKEDIN_RATE_LIMITED",
-  "LINKEDIN_COOKIE_INVALID",
-  "LINKEDIN_SERVICE_UNAVAILABLE",
-  "MESSAGE_WINDOW_EXPIRED",
-  "RECIPIENT_UNREACHABLE",
-  "PAYMENT_REQUIRED",
-  "PAYMENT_FAILED",
-  "SUBSCRIPTION_BUSY",
-  "SUBSCRIPTION_NOT_FOUND",
-  "SEAT_NOT_FOUND",
-  "SEAT_CANCELLED",
-  "INTERNAL"
-]);
-var REQUIRED_TIERS = /* @__PURE__ */ new Set([
-  "core",
-  "sn",
-  "sales_nav",
-  "recruiter"
+  "RATE_LIMITED"
 ]);
+var WRITE_METHODS = /* @__PURE__ */ new Set(["POST", "PATCH", "PUT", "DELETE"]);
 function defaultSleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -127,7 +162,7 @@ function backoffDelay(n, jitter) {
   return exp + jitter;
 }
 function toErrorCode(code) {
-  return code && KNOWN_CODES.has(code) ? code : "INTERNAL";
+  return code && KNOWN_ERROR_CODES.has(code) ? code : "INTERNAL";
 }
 function toRetryHint(hint) {
   if (!hint || typeof hint !== "object") return null;
@@ -145,7 +180,7 @@ async function errorFromResponse(res) {
   } catch {
     env = void 0;
   }
-  const requiredTier = env?.required_tier && REQUIRED_TIERS.has(env.required_tier) ? env.required_tier : void 0;
+  const requiredTier = env?.required_tier && KNOWN_REQUIRED_TIERS.has(env.required_tier) ? env.required_tier : void 0;
   return new CurviateError({
     code: toErrorCode(env?.code),
     message: env?.message ?? `Request failed with status ${res.status}.`,
@@ -216,7 +251,7 @@ async function execute(method, path, opts) {
     let res;
     try {
       res = await doFetch(url, buildInit(method, opts, controller.signal));
-    } catch (cause) {
+    } catch {
       clearTimeout(timer);
       const aborted = controller.signal.aborted;
       const err2 = new CurviateError({
@@ -251,37 +286,22 @@ async function execute(method, path, opts) {
 }
 
 // src/internal/context.ts
-function injectAccountIdIntoBody(body, accountId) {
-  if (body instanceof FormData) {
-    if (!body.has("account_id")) body.append("account_id", accountId);
-    return body;
-  }
-  if (body !== null && typeof body === "object") {
-    const obj = body;
-    return "account_id" in obj ? obj : { account_id: accountId, ...obj };
-  }
-  return body;
+var ACCOUNT_ID_PLACEHOLDER = "{account_id}";
+function injectAccountIdIntoPath(path, accountId) {
+  if (accountId === void 0) return path;
+  return path.split(ACCOUNT_ID_PLACEHOLDER).join(accountId);
 }
 function createContext(config, accountId) {
   const request = (args) => {
-    const target = args.accountIdIn ?? "query";
-    let { query, body } = args;
-    if (accountId !== void 0) {
-      if (target === "body") {
-        body = injectAccountIdIntoBody(body, accountId);
-      } else if (target === "none") {
-      } else {
-        query = { account_id: accountId, ...args.query };
-      }
-    }
-    return execute(args.method, args.path, {
+    const path = injectAccountIdIntoPath(args.path, accountId);
+    return execute(args.method, path, {
       apiKey: config.apiKey,
       baseUrl: config.baseUrl,
       timeout: config.timeout,
       maxRetries: config.maxRetries,
       ...config.fetch ? { fetch: config.fetch } : {},
-      ...query !== void 0 ? { query } : {},
-      ...body !== void 0 ? { body } : {}
+      ...args.query !== void 0 ? { query: args.query } : {},
+      ...args.body !== void 0 ? { body: args.body } : {}
     });
   };
   return { request, accountId };
@@ -330,450 +350,438 @@ var AccountsResource = class {
     });
   }
   /**
-   * Connect a LinkedIn account to an empty seat.
-   *
-   * Returns an account (201) or a checkpoint challenge (202) when LinkedIn
-   * requires verification. Callers discriminate on `result.object`; resolve a
-   * 202 with {@link solveCheckpoint} (code) or {@link pollCheckpoint}
-   * (mobile-app approval).
-   *
-   * For `auth_method: "cookie"`, `user_agent` is **required** — connecting by
-   * session cookie without one is rejected with `INVALID_REQUEST`. It stays
-   * optional for `auth_method: "credentials"`.
+   * Return metadata and current state for one connected account, including the
+   * central `quotas[]` view for all tracked quota families and `seat_id` (the
+   * seat this account occupies, `null` for an admin seatless account).
    *
-   * On a 201 account, `recovered` is `true` only when the connect reclaimed a
-   * 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. Its `status` reflects the account's real observed state: as well as
-   * `active` it may be `reconnect_needed`, `restricted`, or `disconnected` (a
-   * recovered identity often needs a reconnect).
+   * This is a stale-while-revalidate read — it always returns immediately
+   * from the cached row (never blocks on a live substrate call). The cached
+   * enrichment fields `full_name` and `substrate_created_at` are populated by
+   * a background enrichment pass; `username`, `premium_id`,
+   * `public_identifier`, `signatures`, and `groups` are not sourced on the
+   * current connection surface and read `null`/`[]`.
    */
-  link(body) {
+  get(accountId) {
     return this.ctx.request({
-      method: "POST",
-      path: "/v1/accounts/link",
-      body
+      method: "GET",
+      path: `/v1/accounts/${accountId}`
     });
   }
   /**
-   * Solve a checkpoint challenge by submitting an OTP or 2FA code.
-   *
-   * The account is addressed by `accountId` (the provisional `account_id`
-   * returned on the 202 `checkpoint_required` response); the body carries the
-   * `code`. Returns the connected account (201) or, when LinkedIn chains a
-   * second challenge, another checkpoint (202) — resolve that one with a
-   * further `solveCheckpoint` call for the same `accountId`.
-   *
-   * On the 201 account, `recovered` is `true` only when solving the challenge
-   * reclaimed a LinkedIn identity already present on the workspace (rather than
-   * connecting a brand-new one); it is absent otherwise. Its `status` reflects
-   * the account's real observed state — as well as `active` it may be
-   * `reconnect_needed`, `restricted`, or `disconnected`.
+   * Update an account's configuration.
    *
-   * @param accountId - the provisional `account_id` from the 202 response.
-   * @param body - the verification `code`.
+   * `metadata` is a flat string→string map that **replaces** the account's
+   * custom-data store wholesale (keys not provided are removed). `proxy` sets a
+   * custom egress proxy, or clears it (reverting to automatic proxy protection)
+   * when passed as `null`. The `proxy.password`, if given, is stored securely
+   * and never returned.
    */
-  solveCheckpoint(accountId, body) {
+  update(accountId, body) {
     return this.ctx.request({
-      method: "POST",
-      path: `/v1/accounts/${accountId}/checkpoint/solve`,
+      method: "PATCH",
+      path: `/v1/accounts/${accountId}`,
       body
     });
   }
   /**
-   * Re-request the pending verification challenge notification for an account.
-   *
-   * Useful when the end user says they never received the code or push
-   * notification for a pending checkpoint. `resent` echoes the outcome
-   * honestly: `true` once the notification was actually re-sent, `false` when
-   * there was nothing to re-send for that challenge type (this call never
-   * throws just because a re-send wasn't applicable). Does not reset the
-   * checkpoint's expiry.
-   *
-   * @param accountId - the provisional `account_id` from the 202 response.
+   * Hard-disconnect a LinkedIn account; releases the attached seat.
    */
-  requestCheckpoint(accountId) {
+  disconnect(accountId) {
     return this.ctx.request({
-      method: "POST",
-      path: `/v1/accounts/${accountId}/checkpoint/request`
+      method: "DELETE",
+      path: `/v1/accounts/${accountId}`
     });
   }
+};
+
+// src/resources/auth.ts
+var AuthResource = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
   /**
-   * Poll for mobile-app approval of a pending checkpoint challenge.
+   * Authenticate a LinkedIn account with credentials or a session cookie.
    *
-   * The account is addressed by `accountId` (the provisional `account_id`
-   * from the 202 response). `status` is `pending` until the end user approves
-   * on their device, then `active` (the account is connected), or
-   * `expired` / `failed`. Poll until it leaves `pending`.
+   * Omit `account_id` to connect a NEW account into an empty seat; include it
+   * to re-authenticate an EXISTING account in place. Returns the account on
+   * success (200 re-authenticated in place / 201 new), or a checkpoint
+   * challenge (202) when LinkedIn requires verification — resolve it with
+   * {@link solveCheckpoint} (code) or {@link pollCheckpoint} (mobile-app
+   * approval).
    *
-   * On `status: "expired"` (the approval timed out), the response carries
-   * `challenge_type` (`"mobile_app_approval"`) and a human-readable
-   * `recovery_hint` — the actionable next step — so a client can render the
-   * right recovery guidance without parsing prose.
+   * For `auth_method: "cookie"`, `user_agent` is **required** — connecting by
+   * session cookie without one is rejected with `INVALID_REQUEST`. It stays
+   * optional for `auth_method: "credentials"`.
    *
-   * @param accountId - the provisional `account_id` from the 202 response.
-   */
-  pollCheckpoint(accountId) {
-    return this.ctx.request({
-      method: "POST",
-      path: `/v1/accounts/${accountId}/checkpoint/poll`
-    });
-  }
-  /**
-   * Generate a one-time hosted connection link the end user opens to authorize
-   * a new LinkedIn connection without credentials transiting the API or LLM
-   * context. Poll completion with {@link getConnectSession} using the returned
-   * `session_id`. To re-authorize an existing account, use
-   * {@link createReconnectLink} instead.
-   */
-  createConnectLink(body) {
+   * On a 201 account, `recovered` is `true` only when the connect reclaimed a
+   * 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({
       method: "POST",
-      path: "/v1/accounts/connect-link",
+      path: "/v1/auth/intent",
       body
     });
   }
   /**
-   * Generate a one-time hosted **re-authorization** link for an existing
-   * account that became disconnected — the hosted counterpart of
-   * {@link reconnect}. The end user opens the returned `url`; poll completion
-   * with {@link getConnectSession} using the returned `session_id`. The account
-   * keeps its `account_id` and seat.
+   * Solve a checkpoint challenge by submitting an OTP / 2FA code (or the
+   * special value `TRY_ANOTHER_WAY` to switch challenge method).
    *
-   * @param accountId - the account to re-authorize.
-   * @param body - optional `expires_in_seconds` and `redirect_url`.
+   * Returns the connected account (201) or, when LinkedIn chains a second
+   * challenge, another checkpoint (202) — resolve that one with a further
+   * `solveCheckpoint` call for the same `accountId`.
+   *
+   * @param accountId - the (provisional) `account_id` from the 202 response.
+   * @param body - the verification `code`.
    */
-  createReconnectLink(accountId, body) {
+  solveCheckpoint(accountId, body) {
     return this.ctx.request({
       method: "POST",
-      path: `/v1/accounts/${accountId}/reconnect-link`,
-      ...body !== void 0 ? { body } : {}
+      path: "/v1/auth/checkpoint/solve",
+      body: { account_id: accountId, ...body }
     });
   }
   /**
-   * Poll a hosted connect session minted by {@link createConnectLink} or
-   * {@link createReconnectLink} (its `session_id`).
-   *
-   * A pure status read — it makes no external call and does not itself complete
-   * the connection. `status` is `pending` until the end user finishes the
-   * hosted flow, then `resolved` (with `account_id`), or `expired` / `failed`.
-   * Poll until it leaves `pending`.
+   * Re-request the pending checkpoint notification (OTP / 2FA / mobile-app
+   * push). `resent` is honest: `true` once the notification was actually
+   * re-sent, `false` when there was nothing to re-send for that challenge
+   * type (e.g. an authenticator-app code) — this call never throws just
+   * because a re-send wasn't applicable. Does not reset the checkpoint's
+   * expiry.
    *
-   * @param sessionId - the `session_id` returned on the connect-link 201 body.
-   * @returns the session's current `status` and, once `resolved`, `account_id`.
+   * @param accountId - the (provisional) `account_id` from the 202 response.
    */
-  getConnectSession(sessionId) {
+  requestCheckpoint(accountId) {
     return this.ctx.request({
-      method: "GET",
-      path: `/v1/accounts/connect-sessions/${sessionId}`
+      method: "POST",
+      path: "/v1/auth/checkpoint/request",
+      body: { account_id: accountId }
     });
   }
   /**
-   * Return metadata and current state for one connected account, including the
-   * central `quotas[]` view for all tracked quota families and `seat_id` (the
-   * seat this account occupies, `null` for an admin seatless account).
+   * Poll for mobile-app approval of a pending checkpoint challenge until it
+   * leaves `pending`.
    *
-   * This is a stale-while-revalidate read — it always returns immediately
-   * from the cached row (never blocks on a live substrate call). The cached
-   * enrichment fields `full_name` and `substrate_created_at` are populated by
-   * a background enrichment pass; `username`, `premium_id`,
-   * `public_identifier`, `signatures`, and `groups` are not sourced on the
-   * current connection surface and read `null`/`[]`.
-   */
-  get(accountId) {
-    return this.ctx.request({
-      method: "GET",
-      path: `/v1/accounts/${accountId}`
-    });
-  }
-  /**
-   * Re-authorize a disconnected account in place (same `account_id`, same
-   * seat). Returns the reconnected account (200) or a checkpoint challenge
-   * (202) when LinkedIn requires verification — resolve a 202 with
-   * {@link solveCheckpoint} / {@link pollCheckpoint}, exactly like {@link link}.
+   * On `status: "expired"`, the response carries `challenge_type`
+   * (`"mobile_app_approval"`) and a human-readable `recovery_hint`.
    *
-   * For `auth_method: "cookie"`, `user_agent` is **required** (as on
-   * {@link link}). For the hosted re-auth flow, use {@link createReconnectLink}.
+   * @param accountId - the (provisional) `account_id` from the 202 response.
    */
-  reconnect(accountId, body) {
+  pollCheckpoint(accountId) {
     return this.ctx.request({
       method: "POST",
-      path: `/v1/accounts/${accountId}/reconnect`,
-      body
+      path: "/v1/auth/checkpoint/poll",
+      body: { account_id: accountId }
     });
   }
   /**
-   * Update an account's configuration.
+   * Poll a credential connect session by its account id — a pure status read
+   * that makes no external call and does not itself complete the connection.
+   * `status` is `checkpoint_required` until resolved, then `done` (with
+   * `account_id`), or `expired` / `failed`.
    *
-   * `metadata` is a flat string→string map that **replaces** the account's
-   * custom-data store wholesale (keys not provided are removed). `proxy` sets a
-   * custom egress proxy, or clears it (reverting to automatic proxy protection)
-   * when passed as `null`. The `proxy.password`, if given, is stored securely
-   * and never returned.
+   * @param sessionId - the acc_… id returned by {@link intent} or a checkpoint response.
    */
-  update(accountId, body) {
-    return this.ctx.request({
-      method: "PATCH",
-      path: `/v1/accounts/${accountId}`,
-      body
-    });
-  }
-  /**
-   * Hard-disconnect a LinkedIn account; releases the attached seat.
-   */
-  disconnect(accountId) {
+  getSession(sessionId) {
     return this.ctx.request({
-      method: "DELETE",
-      path: `/v1/accounts/${accountId}`
+      method: "GET",
+      path: `/v1/auth/sessions/${sessionId}`
     });
   }
 };
 
 // src/resources/messaging.ts
-function buildFormData(scalars, attachments) {
-  const form = new FormData();
-  for (const [key, value] of Object.entries(scalars)) {
-    if (value !== void 0 && value !== null) {
-      form.append(key, String(value));
-    }
-  }
-  for (const attachment of attachments) {
-    if (attachment instanceof File) {
-      form.append("attachments", attachment);
-    } else {
-      form.append("attachments", new Blob([attachment]));
-    }
-  }
-  return form;
-}
 var MessagingResource = class {
   constructor(ctx) {
     this.ctx = ctx;
   }
-  /** List paginated chats for the account. `GET /v1/chats` */
+  /** List paginated chats for the account. `GET /v1/{account_id}/chats` */
   listChats(params) {
     return this.ctx.request({
       method: "GET",
-      path: "/v1/chats",
+      path: "/v1/{account_id}/chats",
       ...params ? { query: params } : {}
     });
   }
   /**
-   * Start a new chat. Accepts optional `attachments[]` — when present, the
-   * request is sent as `multipart/form-data`. `POST /v1/chats`
+   * Start a new chat with one or more members. `POST /v1/{account_id}/chats`
+   * `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) {
-    const { attachments, ...scalars } = body;
-    if (attachments && attachments.length > 0) {
-      return this.ctx.request({
-        method: "POST",
-        path: "/v1/chats",
-        body: buildFormData(scalars, attachments),
-        accountIdIn: "body"
-      });
-    }
     return this.ctx.request({
       method: "POST",
-      path: "/v1/chats",
-      body: scalars,
-      accountIdIn: "body"
+      path: "/v1/{account_id}/chats",
+      body
     });
   }
-  /** Get details of a single chat. `GET /v1/chats/{chat_id}` */
+  /** Get details of a single chat. `GET /v1/{account_id}/chats/{chat_id}` */
   getChat(chatId) {
     return this.ctx.request({
       method: "GET",
-      path: `/v1/chats/${chatId}`
+      path: `/v1/{account_id}/chats/${chatId}`
+    });
+  }
+  /**
+   * Mark a chat read or unread. `PATCH /v1/{account_id}/chats/{chat_id}`
+   * Body: `{read}`.
+   */
+  markChatRead(chatId, body) {
+    return this.ctx.request({
+      method: "PATCH",
+      path: `/v1/{account_id}/chats/${chatId}`,
+      body
     });
   }
-  /** List messages in a chat, cursor-paginated. `GET /v1/chats/{chat_id}/messages` */
+  /**
+   * List messages in a chat, cursor-paginated.
+   * `GET /v1/{account_id}/chats/{chat_id}/messages`
+   */
   listMessages(chatId, params) {
     return this.ctx.request({
       method: "GET",
-      path: `/v1/chats/${chatId}/messages`,
+      path: `/v1/{account_id}/chats/${chatId}/messages`,
       ...params ? { query: params } : {}
     });
   }
   /**
-   * Send a message in a chat. Multipart when `attachments[]` are provided.
-   * `POST /v1/chats/{chat_id}/messages`
+   * Send a message in a chat. `POST /v1/{account_id}/chats/{chat_id}/messages`
+   * `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) {
-    const { attachments, ...scalars } = body;
-    if (attachments && attachments.length > 0) {
-      return this.ctx.request({
-        method: "POST",
-        path: `/v1/chats/${chatId}/messages`,
-        body: buildFormData(scalars, attachments),
-        accountIdIn: "body"
-      });
-    }
     return this.ctx.request({
       method: "POST",
-      path: `/v1/chats/${chatId}/messages`,
-      body: scalars,
-      accountIdIn: "body"
-    });
-  }
-  /** Trigger a re-sync of a specific chat's message history. `GET /v1/chats/{chat_id}/sync` */
-  syncChat(chatId) {
-    return this.ctx.request({
-      method: "GET",
-      path: `/v1/chats/${chatId}/sync`
+      path: `/v1/{account_id}/chats/${chatId}/messages`,
+      body
     });
   }
-  /** Get a single message by ID. `GET /v1/messages/{message_id}` */
-  getMessage(messageId) {
+  /**
+   * Get a single message by ID, re-homed under its chat.
+   * `GET /v1/{account_id}/chats/{chat_id}/messages/{message_id}`
+   */
+  getMessage(chatId, messageId) {
     return this.ctx.request({
       method: "GET",
-      path: `/v1/messages/${messageId}`
+      path: `/v1/{account_id}/chats/${chatId}/messages/${messageId}`
     });
   }
-  /** Edit a message within the ~60-minute edit window. `PATCH /v1/messages/{message_id}` */
-  editMessage(messageId, body) {
+  /**
+   * Edit a message within the ~60-minute edit window.
+   * `PATCH /v1/{account_id}/chats/{chat_id}/messages/{message_id}`
+   */
+  editMessage(chatId, messageId, body) {
     return this.ctx.request({
       method: "PATCH",
-      path: `/v1/messages/${messageId}`,
+      path: `/v1/{account_id}/chats/${chatId}/messages/${messageId}`,
       body
     });
   }
-  /** Delete a message within the delete window. `DELETE /v1/messages/{message_id}` */
-  deleteMessage(messageId) {
+  /**
+   * Delete a message within the delete window (bodyless).
+   * `DELETE /v1/{account_id}/chats/{chat_id}/messages/{message_id}`
+   */
+  deleteMessage(chatId, messageId) {
     return this.ctx.request({
       method: "DELETE",
-      path: `/v1/messages/${messageId}`,
-      accountIdIn: "none"
-      // server resolves owning account from message id
+      path: `/v1/{account_id}/chats/${chatId}/messages/${messageId}`
     });
   }
   /**
-   * Download a message attachment. Returns raw binary.
-   * `GET /v1/messages/{message_id}/attachments/{attachment_id}`
-   * Returns `ArrayBuffer` — binary response; the SDK does not cache or store it.
+   * Add a reaction to a message.
+   * `POST /v1/{account_id}/chats/{chat_id}/messages/{message_id}/reactions`
    */
-  getAttachment(messageId, attachmentId) {
+  addReaction(chatId, messageId, body) {
     return this.ctx.request({
-      method: "GET",
-      path: `/v1/messages/${messageId}/attachments/${attachmentId}`
+      method: "POST",
+      path: `/v1/{account_id}/chats/${chatId}/messages/${messageId}/reactions`,
+      body
     });
   }
-  /** Add a reaction to a message. `POST /v1/messages/{message_id}/reactions` */
-  addReaction(messageId, body) {
+  /**
+   * Download a message attachment. Returns raw binary.
+   * `GET /v1/{account_id}/chats/{chat_id}/messages/{message_id}/attachments/{attachment_id}`
+   * Returns `ArrayBuffer` — binary response; the SDK does not cache or store it.
+   */
+  getAttachment(chatId, messageId, attachmentId) {
     return this.ctx.request({
-      method: "POST",
-      path: `/v1/messages/${messageId}/reactions`,
-      body,
-      accountIdIn: "none"
-      // server resolves owning account from message id
+      method: "GET",
+      path: `/v1/{account_id}/chats/${chatId}/messages/${messageId}/attachments/${attachmentId}`
     });
   }
-  /** Send an InMail. `POST /v1/messages/inmail` */
+  /** Send an InMail. `POST /v1/{account_id}/messages/inmail` */
   sendInMail(body) {
     return this.ctx.request({
       method: "POST",
-      path: "/v1/messages/inmail",
-      body,
-      accountIdIn: "body"
-    });
-  }
-  /** Get the account's InMail credit balance. `GET /v1/messaging/inmail-balance` */
-  getInMailBalance(params) {
-    return this.ctx.request({
-      method: "GET",
-      path: "/v1/messaging/inmail-balance",
-      ...params ? { query: params } : {}
+      path: "/v1/{account_id}/messages/inmail",
+      body
     });
   }
-  /** Re-sync account message history. `GET /v1/messages/sync` */
-  syncMessages(params) {
+  /**
+   * 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/messages/sync",
-      ...params ? { query: params } : {}
+      path: "/v1/{account_id}/chats/search",
+      query: params
     });
   }
 };
 
-// src/resources/profiles.ts
-var ProfilesResource = class {
+// src/resources/users.ts
+var UsersResource = class {
   constructor(ctx) {
     this.ctx = ctx;
   }
   /**
-   * Get the account's own LinkedIn profile. `GET /v1/profiles/me`
-   * Pass `{ linkedin_sections: ['about', 'experience', ...] }` to request enriched sections.
-   * The `account_id` is injected by the account-scoped context.
+   * Retrieve a user's profile. `GET /v1/{account_id}/users/{user_id}`
+   * Pass `userId: "me"` for the caller's own account (folds in the old
+   * standalone `getMe()`). Pass `{ linkedin_sections: [...] }` to request
+   * enriched sections.
    */
-  getMe(params) {
+  get(userId, params) {
     return this.ctx.request({
       method: "GET",
-      path: "/v1/profiles/me",
+      path: `/v1/{account_id}/users/${userId}`,
       ...params ? { query: params } : {}
     });
   }
   /**
-   * Get a LinkedIn member profile by id or public handle.
-   * `GET /v1/profiles/{profile_id}`
-   * Pass `{ notify: true }` to signal a profile view.
-   * The `account_id` is injected by the account-scoped context.
+   * Update the caller's own profile. `PATCH /v1/{account_id}/users/{user_id}`
+   * Only `first_name`, `last_name`, `bio`, `headline`, `skills`, `picture`,
+   * `background_picture` are accepted — there is no `description` key.
+   * `description` is not part of the update contract: TypeScript already
+   * rejects it at the call site, but an untyped/JS caller (or an `as`-cast)
+   * could still smuggle it onto the object, so it is also stripped
+   * defensively at runtime before the request goes out — the caller's
+   * object is never mutated.
    */
-  get(profileId, params) {
+  update(userId, body) {
+    const { description: _description, ...safeBody } = body;
     return this.ctx.request({
-      method: "GET",
-      path: `/v1/profiles/${profileId}`,
-      ...params ? { query: params } : {}
+      method: "PATCH",
+      path: `/v1/{account_id}/users/${userId}`,
+      body: safeBody
     });
   }
-  /** List the account's 1st-degree connections. `GET /v1/profiles/relations` */
-  listConnections(params) {
+  /**
+   * List the account's 1st-degree connections.
+   * `GET /v1/{account_id}/profiles/relations` (served URL keeps `profiles/`).
+   * Was `profiles.listConnections`.
+   */
+  listRelations(params) {
     return this.ctx.request({
       method: "GET",
-      path: "/v1/profiles/relations",
+      path: "/v1/{account_id}/profiles/relations",
       ...params ? { query: params } : {}
     });
   }
-  /** List a profile's followers. `GET /v1/profiles/{profile_id}/followers` */
-  listFollowers(profileId, params) {
+  /** List a user's followers. `GET /v1/{account_id}/users/{user_id}/followers` */
+  listFollowers(userId, params) {
     return this.ctx.request({
       method: "GET",
-      path: `/v1/profiles/${profileId}/followers`,
+      path: `/v1/{account_id}/users/${userId}/followers`,
       ...params ? { query: params } : {}
     });
   }
-  /**
-   * List a profile's posts. `GET /v1/profiles/{profile_id}/posts`
-   * Pass `{ is_company: true }` for company posts.
-   */
-  listPosts(profileId, params) {
+  /** List who a user follows. `GET /v1/{account_id}/users/{user_id}/following` */
+  listFollowing(userId, params) {
     return this.ctx.request({
       method: "GET",
-      path: `/v1/profiles/${profileId}/posts`,
+      path: `/v1/{account_id}/users/${userId}/following`,
       ...params ? { query: params } : {}
     });
   }
-  /** List a profile's comments. `GET /v1/profiles/{profile_id}/comments` */
-  listComments(profileId, params) {
+  /**
+   * Follow a user (bodyless). `POST /v1/{account_id}/users/{user_id}/follow`
+   * If the target's profile is private, sends a connect request instead and
+   * returns `connect_request_sent`.
+   */
+  follow(userId) {
     return this.ctx.request({
-      method: "GET",
-      path: `/v1/profiles/${profileId}/comments`,
-      ...params ? { query: params } : {}
+      method: "POST",
+      path: `/v1/{account_id}/users/${userId}/follow`
+    });
+  }
+  /**
+   * Unfollow a user (bodyless). `DELETE /v1/{account_id}/users/{user_id}/follow`
+   * Idempotent — unfollowing a user this account does not currently follow
+   * still returns 200.
+   */
+  unfollow(userId) {
+    return this.ctx.request({
+      method: "DELETE",
+      path: `/v1/{account_id}/users/${userId}/follow`
     });
   }
-  /** List a profile's reactions. `GET /v1/profiles/{profile_id}/reactions` */
-  listReactions(profileId, params) {
+  /**
+   * Get remaining InMail credits across subscribed LinkedIn premium products.
+   * `GET /v1/{account_id}/inmail-credits`
+   * Relocated from `messaging.getInMailBalance`.
+   */
+  getInMailCredits(params) {
     return this.ctx.request({
       method: "GET",
-      path: `/v1/profiles/${profileId}/reactions`,
+      path: "/v1/{account_id}/inmail-credits",
       ...params ? { query: params } : {}
     });
   }
-  /** Endorse a skill on a profile. `POST /v1/profiles/{profile_id}/endorse` */
-  endorse(profileId, body) {
+  /**
+   * Endorse one specific skill on a target member's profile.
+   * `POST /v1/{account_id}/users/{user_id}/endorse-skill`
+   * Body key is `endorsement_id` (was `skill_endorsement_id` on `profiles.endorse`).
+   * Obtain it from `GET /v1/{account_id}/users/{user_id}?linkedin_sections=linkedin_skills`.
+   */
+  endorseSkill(userId, body) {
     return this.ctx.request({
       method: "POST",
-      path: `/v1/profiles/${profileId}/endorse`,
-      body,
-      accountIdIn: "body"
+      path: `/v1/{account_id}/users/${userId}/endorse-skill`,
+      body
     });
   }
 };
@@ -783,398 +791,876 @@ var InvitesResource = class {
   constructor(ctx) {
     this.ctx = ctx;
   }
-  /** Send a connection invitation. `POST /v1/invites` */
+  /** Send a connect-request. `POST /v1/{account_id}/invites` */
   send(body) {
     return this.ctx.request({
       method: "POST",
-      path: "/v1/invites",
-      body,
-      accountIdIn: "body"
+      path: "/v1/{account_id}/invites",
+      body
     });
   }
-  /** List sent invitations. `GET /v1/invites/sent` */
+  /** List sent connect-requests. `GET /v1/{account_id}/invites/sent` */
   listSent(params) {
     return this.ctx.request({
       method: "GET",
-      path: "/v1/invites/sent",
+      path: "/v1/{account_id}/invites/sent",
       ...params ? { query: params } : {}
     });
   }
-  /** List received invitations. `GET /v1/invites/received` */
+  /** List received connect-requests. `GET /v1/{account_id}/invites/received` */
   listReceived(params) {
     return this.ctx.request({
       method: "GET",
-      path: "/v1/invites/received",
+      path: "/v1/{account_id}/invites/received",
       ...params ? { query: params } : {}
     });
   }
   /**
-   * Accept or decline a received invitation.
-   * `POST /v1/invites/received/{invitation_id}`
+   * Accept a received connect-request (bodyless). An unrecognized or
+   * non-pending `invitationId` returns `status: "not_found"`, not an error.
+   * `POST /v1/{account_id}/invites/received/{invitation_id}/accept`
    */
-  respond(invitationId, body) {
+  accept(invitationId) {
     return this.ctx.request({
       method: "POST",
-      path: `/v1/invites/received/${invitationId}`,
-      body,
-      accountIdIn: "body"
+      path: `/v1/{account_id}/invites/received/${invitationId}/accept`
+    });
+  }
+  /**
+   * Decline a received connect-request (bodyless). An unrecognized or
+   * non-pending `invitationId` returns `status: "not_found"`, not an error.
+   * `POST /v1/{account_id}/invites/received/{invitation_id}/decline`
+   */
+  decline(invitationId) {
+    return this.ctx.request({
+      method: "POST",
+      path: `/v1/{account_id}/invites/received/${invitationId}/decline`
     });
   }
-  /** Cancel a sent invitation. `DELETE /v1/invites/{invitation_id}` */
+  /**
+   * Withdraw a sent connect-request (bodyless). An already-absent or
+   * unrecognized `invitationId` returns `status: "not_found"`, not an error.
+   * `DELETE /v1/{account_id}/invites/sent/{invitation_id}`
+   */
   cancel(invitationId) {
     return this.ctx.request({
       method: "DELETE",
-      path: `/v1/invites/${invitationId}`
+      path: `/v1/{account_id}/invites/sent/${invitationId}`
     });
   }
 };
 
 // src/resources/search.ts
+function splitPagination(merged) {
+  const { cursor, limit, offset, ...body } = merged;
+  const hasQuery = cursor !== void 0 || limit !== void 0 || offset !== void 0;
+  return {
+    body,
+    ...hasQuery ? {
+      query: {
+        ...cursor !== void 0 ? { cursor } : {},
+        ...limit !== void 0 ? { limit } : {},
+        ...offset !== void 0 ? { offset } : {}
+      }
+    } : {}
+  };
+}
 var SearchResource = class {
   constructor(ctx) {
     this.ctx = ctx;
   }
   /**
    * Resolve human-readable terms to opaque filter IDs for structured search.
-   * `GET /v1/search/parameters`
+   * `GET /v1/{account_id}/search/parameters`
    */
   getParameters(query) {
     return this.ctx.request({
       method: "GET",
-      path: "/v1/search/parameters",
+      path: "/v1/{account_id}/search/parameters",
       query
     });
   }
   /**
-   * Search people with structured filters or a pasted URL.
-   * `POST /v1/search/people`
-   * Cursor passed via query param (not body) — matches the OpenAPI spec.
+   * Search people with structured filters.
+   * `POST /v1/{account_id}/search/people`
+   * `offset`/`limit`/`cursor` are top-level query params, never in the body.
    */
   people(body) {
-    const { cursor, limit, ...rest } = body;
+    const split = splitPagination(body);
     return this.ctx.request({
       method: "POST",
-      path: "/v1/search/people",
-      body: rest,
-      ...cursor !== void 0 || limit !== void 0 ? { query: { ...cursor !== void 0 ? { cursor } : {}, ...limit !== void 0 ? { limit } : {} } } : {}
+      path: "/v1/{account_id}/search/people",
+      body: split.body,
+      ...split.query ? { query: split.query } : {}
     });
   }
   /**
-   * Search companies.
-   * `POST /v1/search/companies`
+   * Search companies with structured filters.
+   * `POST /v1/{account_id}/search/companies`
    */
   companies(body) {
-    const { cursor, limit, ...rest } = body;
+    const split = splitPagination(body);
     return this.ctx.request({
       method: "POST",
-      path: "/v1/search/companies",
-      body: rest,
-      ...cursor !== void 0 || limit !== void 0 ? { query: { ...cursor !== void 0 ? { cursor } : {}, ...limit !== void 0 ? { limit } : {} } } : {}
+      path: "/v1/{account_id}/search/companies",
+      body: split.body,
+      ...split.query ? { query: split.query } : {}
     });
   }
   /**
-   * Search posts.
-   * `POST /v1/search/posts`
+   * Search posts with structured filters.
+   * `POST /v1/{account_id}/search/posts`
    */
   posts(body) {
-    const { cursor, limit, ...rest } = body;
+    const split = splitPagination(body);
     return this.ctx.request({
       method: "POST",
-      path: "/v1/search/posts",
-      body: rest,
-      ...cursor !== void 0 || limit !== void 0 ? { query: { ...cursor !== void 0 ? { cursor } : {}, ...limit !== void 0 ? { limit } : {} } } : {}
+      path: "/v1/{account_id}/search/posts",
+      body: split.body,
+      ...split.query ? { query: split.query } : {}
     });
   }
   /**
-   * Search jobs.
-   * `POST /v1/search/jobs`
+   * Search jobs with structured filters.
+   * `POST /v1/{account_id}/search/jobs`
    */
   jobs(body) {
-    const { cursor, limit, ...rest } = body;
+    const split = splitPagination(body);
+    return this.ctx.request({
+      method: "POST",
+      path: "/v1/{account_id}/search/jobs",
+      body: split.body,
+      ...split.query ? { query: split.query } : {}
+    });
+  }
+  /**
+   * Run a pasted LinkedIn search/saved-search/lead-list URL directly.
+   * `POST /v1/{account_id}/search`
+   * `url` is the ONLY accepted body field — the sole home of URL-mode search;
+   * the structured endpoints above no longer accept `url`. The response is
+   * polymorphic, each item discriminated individually by its own `object`.
+   */
+  fromUrl(body) {
+    const { cursor, limit, offset, url } = body;
+    const hasQuery = cursor !== void 0 || limit !== void 0 || offset !== void 0;
     return this.ctx.request({
       method: "POST",
-      path: "/v1/search/jobs",
-      body: rest,
-      ...cursor !== void 0 || limit !== void 0 ? { query: { ...cursor !== void 0 ? { cursor } : {}, ...limit !== void 0 ? { limit } : {} } } : {}
+      path: "/v1/{account_id}/search",
+      body: { url },
+      ...hasQuery ? {
+        query: {
+          ...cursor !== void 0 ? { cursor } : {},
+          ...limit !== void 0 ? { limit } : {},
+          ...offset !== void 0 ? { offset } : {}
+        }
+      } : {}
+    });
+  }
+  /**
+   * 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
-function buildFormData2(scalars, attachments) {
-  const form = new FormData();
-  for (const [key, value] of Object.entries(scalars)) {
-    if (value !== void 0 && value !== null) {
-      form.append(key, String(value));
-    }
-  }
-  for (const attachment of attachments ?? []) {
-    if (attachment instanceof File) {
-      form.append("attachments", attachment);
-    } else {
-      form.append("attachments", new Blob([attachment]));
-    }
-  }
-  return form;
-}
 var PostsResource = class {
   constructor(ctx) {
     this.ctx = ctx;
   }
-  /** List the account's own posts. `GET /v1/posts` */
-  list(params) {
+  /** List comments on a post. `GET /v1/{account_id}/posts/{post_id}/comments` */
+  listComments(postId, params) {
     return this.ctx.request({
       method: "GET",
-      path: "/v1/posts",
+      path: `/v1/{account_id}/posts/${postId}/comments`,
       ...params ? { query: params } : {}
     });
   }
+  /** Get a single post. `GET /v1/{account_id}/posts/{post_id}` */
+  get(postId) {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/{account_id}/posts/${postId}`
+    });
+  }
+  /** Delete a post (bodyless, 204). `DELETE /v1/{account_id}/posts/{post_id}` */
+  delete(postId) {
+    return this.ctx.request({
+      method: "DELETE",
+      path: `/v1/{account_id}/posts/${postId}`
+    });
+  }
   /**
-   * Create a new post. Always sent as multipart/form-data (the API only accepts
-   * multipart for this endpoint). `POST /v1/posts`
+   * Publish a new post. Always `application/json` — attachments (if any) are
+   * base64-encoded objects, never `FormData`/multipart.
+   * `POST /v1/{account_id}/posts`
    */
   create(body) {
-    const { attachments, video_thumbnail, ...scalars } = body;
-    const form = buildFormData2(scalars, attachments);
-    if (video_thumbnail) {
-      if (video_thumbnail instanceof File) {
-        form.append("video_thumbnail", video_thumbnail);
-      } else {
-        form.append("video_thumbnail", new Blob([video_thumbnail]));
-      }
-    }
     return this.ctx.request({
       method: "POST",
-      path: "/v1/posts",
-      body: form,
-      accountIdIn: "body"
+      path: "/v1/{account_id}/posts",
+      body
     });
   }
-  /** Get a single post. `GET /v1/posts/{post_id}` */
-  get(postId) {
+  /**
+   * List a user's own posts. `GET /v1/{account_id}/users/{user_id}/posts`
+   * Was `profiles.listPosts`.
+   */
+  listUserPosts(userId, params) {
     return this.ctx.request({
       method: "GET",
-      path: `/v1/posts/${postId}`
+      path: `/v1/{account_id}/users/${userId}/posts`,
+      ...params ? { query: params } : {}
     });
   }
-  /** List comments on a post. `GET /v1/posts/{post_id}/comments` */
-  listComments(postId, params) {
+  /** List reactions on a post. `GET /v1/{account_id}/posts/{post_id}/reactions` */
+  listReactions(postId, params) {
     return this.ctx.request({
       method: "GET",
-      path: `/v1/posts/${postId}/comments`,
+      path: `/v1/{account_id}/posts/${postId}/reactions`,
       ...params ? { query: params } : {}
     });
   }
+  /** React to a post. `POST /v1/{account_id}/posts/{post_id}/reactions` */
+  react(postId, body) {
+    return this.ctx.request({
+      method: "POST",
+      path: `/v1/{account_id}/posts/${postId}/reactions`,
+      body
+    });
+  }
+  /**
+   * Remove this account's reaction from a post — a **DELETE-with-body**:
+   * the reaction value to remove travels in the JSON body, not the path.
+   * `DELETE /v1/{account_id}/posts/{post_id}/reactions`
+   */
+  unreact(postId, body) {
+    return this.ctx.request({
+      method: "DELETE",
+      path: `/v1/{account_id}/posts/${postId}/reactions`,
+      body
+    });
+  }
   /**
-   * Comment on a post. Always sent as multipart/form-data. `POST /v1/posts/{post_id}/comments`
+   * List a user's reactions. `GET /v1/{account_id}/users/{user_id}/reactions`
+   * Was `profiles.listReactions`.
    */
-  comment(postId, body) {
-    const { attachments, ...scalars } = body;
+  listUserReactions(userId, params) {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/{account_id}/users/${userId}/reactions`,
+      ...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/posts/${postId}/comments`,
-      body: buildFormData2(scalars, attachments),
-      accountIdIn: "body"
+      path: "/v1/{account_id}/saved-posts",
+      body
     });
   }
-  /** List reactions on a post. `GET /v1/posts/{post_id}/reactions` */
-  listReactions(postId, params) {
+  /**
+   * 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
+var CommentsResource = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  /**
+   * List comments authored by a user, each embedding the post it was made
+   * on. `GET /v1/{account_id}/users/{user_id}/comments`
+   * Was `profiles.listComments`.
+   */
+  listUserComments(userId, params) {
     return this.ctx.request({
       method: "GET",
-      path: `/v1/posts/${postId}/reactions`,
+      path: `/v1/{account_id}/users/${userId}/comments`,
       ...params ? { query: params } : {}
     });
   }
-  /** React to a post. `POST /v1/posts/{post_id}/reactions` */
-  react(postId, body) {
+  /**
+   * Publish a comment on a post. `POST /v1/{account_id}/posts/{post_id}/comments`
+   * Was `posts.comment`. Attachments (at most one) travel as a base64
+   * object, never `FormData`.
+   */
+  create(postId, body) {
     return this.ctx.request({
       method: "POST",
-      path: `/v1/posts/${postId}/reactions`,
-      body,
-      accountIdIn: "body"
+      path: `/v1/{account_id}/posts/${postId}/comments`,
+      body
+    });
+  }
+  /**
+   * Edit the text of this account's own comment.
+   * `PATCH /v1/{account_id}/posts/{post_id}/comments/{comment_id}`
+   */
+  edit(postId, commentId, body) {
+    return this.ctx.request({
+      method: "PATCH",
+      path: `/v1/{account_id}/posts/${postId}/comments/${commentId}`,
+      body
+    });
+  }
+  /**
+   * Delete this account's own comment (bodyless, 204).
+   * `DELETE /v1/{account_id}/posts/{post_id}/comments/{comment_id}`
+   */
+  delete(postId, commentId) {
+    return this.ctx.request({
+      method: "DELETE",
+      path: `/v1/{account_id}/posts/${postId}/comments/${commentId}`
+    });
+  }
+  /**
+   * Reply to a comment. Shares its path with `edit` — POST creates a reply
+   * under the target comment, PATCH edits the target comment's own text.
+   * `POST /v1/{account_id}/posts/{post_id}/comments/{comment_id}`
+   */
+  reply(postId, commentId, body) {
+    return this.ctx.request({
+      method: "POST",
+      path: `/v1/{account_id}/posts/${postId}/comments/${commentId}`,
+      body
+    });
+  }
+  /**
+   * List replies to a comment, most-recent-first.
+   * `GET /v1/{account_id}/posts/{post_id}/comments/{comment_id}/replies`
+   */
+  listReplies(postId, commentId, params) {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/{account_id}/posts/${postId}/comments/${commentId}/replies`,
+      ...params ? { query: params } : {}
+    });
+  }
+  /**
+   * List reactions on a comment.
+   * `GET /v1/{account_id}/posts/{post_id}/comments/{comment_id}/reactions`
+   */
+  listReactions(postId, commentId, params) {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/{account_id}/posts/${postId}/comments/${commentId}/reactions`,
+      ...params ? { query: params } : {}
+    });
+  }
+  /**
+   * React to a comment. `POST /v1/{account_id}/posts/{post_id}/comments/{comment_id}/reactions`
+   */
+  addReaction(postId, commentId, body) {
+    return this.ctx.request({
+      method: "POST",
+      path: `/v1/{account_id}/posts/${postId}/comments/${commentId}/reactions`,
+      body
+    });
+  }
+  /**
+   * Remove this account's reaction from a comment — a **DELETE-with-body**:
+   * the reaction value to remove travels in the JSON body, not the path.
+   * `DELETE /v1/{account_id}/posts/{post_id}/comments/{comment_id}/reactions`
+   */
+  removeReaction(postId, commentId, body) {
+    return this.ctx.request({
+      method: "DELETE",
+      path: `/v1/{account_id}/posts/${postId}/comments/${commentId}/reactions`,
+      body
     });
   }
 };
 
-// src/resources/sales-navigator.ts
-function buildFormData3(scalars, attachments, voice_message, video_message) {
-  const form = new FormData();
-  for (const [key, value] of Object.entries(scalars)) {
-    if (value !== void 0 && value !== null) {
-      if (Array.isArray(value)) {
-        for (const item of value) {
-          form.append(key, String(item));
-        }
-      } else {
-        form.append(key, String(value));
-      }
-    }
+// src/resources/profile.ts
+var ProfileResource = class {
+  constructor(ctx) {
+    this.ctx = ctx;
   }
-  for (const attachment of attachments ?? []) {
-    if (attachment instanceof File) {
-      form.append("attachments", attachment);
-    } else {
-      form.append("attachments", new Blob([attachment]));
-    }
+  /**
+   * 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`
+    });
   }
-  if (voice_message) {
-    if (voice_message instanceof File) {
-      form.append("voice_message", voice_message);
-    } else {
-      form.append("voice_message", new Blob([voice_message]));
-    }
+  /**
+   * 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`
+    });
   }
-  if (video_message) {
-    if (video_message instanceof File) {
-      form.append("video_message", video_message);
-    } else {
-      form.append("video_message", new Blob([video_message]));
-    }
+  /**
+   * 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 } : {}
+    });
   }
-  return form;
-}
-var SalesNavigatorResource = class {
+  /**
+   * 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;
   }
   /**
-   * Search LinkedIn members using the full Sales Navigator filter set.
-   * `POST /v1/sales-navigator/search/people`
-   * Requires tier `sn`. Returns `TIER_NOT_ACTIVE` (403) when the seat lacks it.
+   * 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.
    */
-  searchPeople(body, params) {
+  list(params) {
     return this.ctx.request({
-      method: "POST",
-      path: "/v1/sales-navigator/search/people",
-      body,
+      method: "GET",
+      path: `/v1/{account_id}/profile/groups`,
       ...params ? { query: params } : {}
     });
   }
   /**
-   * Search LinkedIn companies using the full Sales Navigator company filter set.
-   * `POST /v1/sales-navigator/search/companies`
+   * 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.
    */
-  searchCompanies(body, params) {
+  get(group) {
     return this.ctx.request({
-      method: "POST",
-      path: "/v1/sales-navigator/search/companies",
-      body,
+      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;
+  }
   /**
-   * Resolve human-readable terms to opaque Sales Navigator filter IDs.
-   * `GET /v1/sales-navigator/search/parameters`
+   * 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.
    */
-  getParameters(params) {
+  home(params) {
     return this.ctx.request({
       method: "GET",
-      path: "/v1/sales-navigator/search/parameters",
-      query: params
+      path: `/v1/{account_id}/feed/home`,
+      ...params ? { query: params } : {}
     });
   }
+};
+
+// src/resources/inboxes.ts
+var InboxesResource = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
   /**
-   * Start a new Sales Navigator chat. Accepts optional `attachments[]`,
-   * `voice_message`, and `video_message` — when present, the request is sent
-   * as `multipart/form-data`. `POST /v1/sales-navigator/chats`
+   * 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"
    */
-  startChat(body) {
-    const { attachments, voice_message, video_message, ...scalars } = body;
-    const hasFiles = attachments && attachments.length > 0 || voice_message || video_message;
-    if (hasFiles) {
-      return this.ctx.request({
-        method: "POST",
-        path: "/v1/sales-navigator/chats",
-        body: buildFormData3(
-          scalars,
-          attachments,
-          voice_message,
-          video_message
-        ),
-        accountIdIn: "body"
-      });
-    }
+  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/sales-navigator/chats",
-      body: scalars,
-      accountIdIn: "body"
+      path: `/v1/{account_id}/notifications/${encodeURIComponent(cardUrn)}/show-less`
     });
   }
+};
+
+// src/resources/sales-navigator.ts
+var SalesNavigatorResource = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
   /**
-   * Retrieve a LinkedIn profile with Sales Navigator enrichment.
-   * `GET /v1/sales-navigator/profiles/{identifier}`
+   * Search LinkedIn members using the full Sales Navigator filter set.
+   * `POST /v1/{account_id}/sales-navigator/search/people`
+   * Requires tier `sn`. Returns `TIER_NOT_ACTIVE` (403) when the seat lacks it.
+   */
+  searchPeople(body, query) {
+    return this.ctx.request({
+      method: "POST",
+      path: "/v1/{account_id}/sales-navigator/search/people",
+      body,
+      ...query ? { query } : {}
+    });
+  }
+  /**
+   * Search LinkedIn companies using the full Sales Navigator company filter set.
+   * `POST /v1/{account_id}/sales-navigator/search/companies`
+   */
+  searchCompanies(body, query) {
+    return this.ctx.request({
+      method: "POST",
+      path: "/v1/{account_id}/sales-navigator/search/companies",
+      body,
+      ...query ? { query } : {}
+    });
+  }
+  /**
+   * Resolve human-readable terms to opaque Sales Navigator filter IDs.
+   * `GET /v1/{account_id}/sales-navigator/search/parameters`
    */
-  getProfile(identifier, params) {
+  getParameters(query) {
     return this.ctx.request({
       method: "GET",
-      path: `/v1/sales-navigator/profiles/${identifier}`,
-      // cast needed: linkedin_sections is string[] but transport encodes arrays as repeated params
-      ...params ? { query: params } : {}
+      path: "/v1/{account_id}/sales-navigator/search/parameters",
+      query
     });
   }
   /**
-   * Save a Sales Navigator member into a lead list.
-   * `POST /v1/sales-navigator/lead-lists/{list_id}/save`
-   *
-   * **BREAKING (2026-07-04):** replaces the retired v1
-   * `saveLead(userId, { account_id, list_id? })` — there is no alias. The
-   * list is now mandatory and addresses the path; the member id travels in
-   * the body alongside `account_id` (the save endpoints carry no query
-   * params, so `account_id` has nowhere else to go).
+   * Start a new Sales Navigator chat. `attachments[]`, when supplied, carry
+   * base64-encoded file bytes — always sent as JSON, never multipart.
+   * `POST /v1/{account_id}/sales-navigator/chats`
    */
-  saveLead(input) {
-    const { list_id, ...body } = input;
+  startChat(body) {
     return this.ctx.request({
       method: "POST",
-      path: `/v1/sales-navigator/lead-lists/${list_id}/save`,
-      body,
-      accountIdIn: "body"
+      path: "/v1/{account_id}/sales-navigator/chats",
+      body
     });
   }
   /**
-   * Trigger a re-sync of the account's Sales Navigator message history.
-   * `GET /v1/sales-navigator/messages/sync`
+   * Retrieve a LinkedIn profile with Sales Navigator enrichment.
+   * `GET /v1/{account_id}/sales-navigator/profiles/{identifier}`
    */
-  syncMessages(params) {
+  getProfile(identifier, query) {
     return this.ctx.request({
       method: "GET",
-      path: "/v1/sales-navigator/messages/sync",
-      query: params
+      path: `/v1/{account_id}/sales-navigator/profiles/${identifier}`,
+      // cast needed: with_sections is string[] but transport encodes arrays as repeated params
+      ...query ? { query } : {}
     });
   }
-  // ─── v2 list surface ──────────────────────────────────────────────────────
   /**
    * List the saved-account (company) lists on the operator's Sales Navigator seat.
-   * `GET /v1/sales-navigator/account-lists`
+   * `GET /v1/{account_id}/sales-navigator/account-lists`
    */
   accountLists(query) {
     return this.ctx.request({
       method: "GET",
-      path: "/v1/sales-navigator/account-lists",
+      path: "/v1/{account_id}/sales-navigator/account-lists",
       ...query ? { query } : {}
     });
   }
   /**
    * List the saved-lead (member) lists on the operator's Sales Navigator seat.
-   * `GET /v1/sales-navigator/lead-lists`
+   * `GET /v1/{account_id}/sales-navigator/lead-lists`
    */
   leadLists(query) {
     return this.ctx.request({
       method: "GET",
-      path: "/v1/sales-navigator/lead-lists",
+      path: "/v1/{account_id}/sales-navigator/lead-lists",
       ...query ? { query } : {}
     });
   }
   /**
    * Browse the saved accounts (companies) in one account list. Pass optional
    * `persona` / `filter` / `sort_by` / `sort_order` filters in the body.
-   * `POST /v1/sales-navigator/account-lists/{list_id}`
+   * `POST /v1/{account_id}/sales-navigator/account-lists/{list_id}`
    */
   browseAccountList(listId, body, query) {
     return this.ctx.request({
       method: "POST",
-      path: `/v1/sales-navigator/account-lists/${listId}`,
+      path: `/v1/{account_id}/sales-navigator/account-lists/${listId}`,
       body: body ?? {},
       ...query ? { query } : {}
     });
@@ -1182,19 +1668,20 @@ var SalesNavigatorResource = class {
   /**
    * Browse the saved leads (members) in one lead list. Pass optional
    * `spotlight` / `sort_by` / `sort_order` filters in the body.
-   * `POST /v1/sales-navigator/lead-lists/{list_id}`
+   * `POST /v1/{account_id}/sales-navigator/lead-lists/{list_id}`
    */
   browseLeadList(listId, body, query) {
     return this.ctx.request({
       method: "POST",
-      path: `/v1/sales-navigator/lead-lists/${listId}`,
+      path: `/v1/{account_id}/sales-navigator/lead-lists/${listId}`,
       body: body ?? {},
       ...query ? { query } : {}
     });
   }
   /**
-   * Save a LinkedIn company into an account list.
-   * `POST /v1/sales-navigator/account-lists/{list_id}/save`
+   * Save a LinkedIn company into an account list. Body is just `{company_id}`
+   * — `account_id` lives in the path, not the body.
+   * `POST /v1/{account_id}/sales-navigator/account-lists/{list_id}/save`
    *
    * No `saved` boolean is invented — a `2xx` response body is the success
    * signal (the substrate returns no success flag).
@@ -1203,9 +1690,35 @@ var SalesNavigatorResource = class {
     const { list_id, ...body } = input;
     return this.ctx.request({
       method: "POST",
-      path: `/v1/sales-navigator/account-lists/${list_id}/save`,
+      path: `/v1/{account_id}/sales-navigator/account-lists/${list_id}/save`,
+      body
+    });
+  }
+  /**
+   * Save a Sales Navigator member into a lead list. Body is just `{user_id}`
+   * — `account_id` lives in the path, not the body.
+   * `POST /v1/{account_id}/sales-navigator/lead-lists/{list_id}/save`
+   */
+  saveLead(input) {
+    const { list_id, ...body } = input;
+    return this.ctx.request({
+      method: "POST",
+      path: `/v1/{account_id}/sales-navigator/lead-lists/${list_id}/save`,
+      body
+    });
+  }
+  /**
+   * Run a pasted Sales Navigator search/list URL directly.
+   * `POST /v1/{account_id}/sales-navigator/search`
+   * `url` is the only accepted body field. Response items are polymorphic,
+   * each discriminated individually by its own `object`.
+   */
+  searchFromUrl(body, query) {
+    return this.ctx.request({
+      method: "POST",
+      path: "/v1/{account_id}/sales-navigator/search",
       body,
-      accountIdIn: "body"
+      ...query ? { query } : {}
     });
   }
 };
@@ -1226,268 +1739,295 @@ function resolveJobId(idOrUrl) {
 }
 
 // src/resources/recruiter.ts
-function buildFormData4(scalars, attachments, voice_message, video_message) {
-  const form = new FormData();
-  for (const [key, value] of Object.entries(scalars)) {
-    if (value !== void 0 && value !== null) {
-      if (Array.isArray(value)) {
-        for (const item of value) {
-          form.append(key, String(item));
-        }
-      } else {
-        form.append(key, String(value));
-      }
-    }
-  }
-  for (const attachment of attachments ?? []) {
-    if (attachment instanceof File) {
-      form.append("attachments", attachment);
-    } else {
-      form.append("attachments", new Blob([attachment]));
-    }
-  }
-  if (voice_message) {
-    if (voice_message instanceof File) {
-      form.append("voice_message", voice_message);
-    } else {
-      form.append("voice_message", new Blob([voice_message]));
-    }
-  }
-  if (video_message) {
-    if (video_message instanceof File) {
-      form.append("video_message", video_message);
-    } else {
-      form.append("video_message", new Blob([video_message]));
-    }
-  }
-  return form;
-}
 var RecruiterResource = class {
   constructor(ctx) {
     this.ctx = ctx;
   }
   /**
-   * Trigger a re-sync of the account's Recruiter message history.
-   * `GET /v1/recruiter/messages/sync`
+   * Retrieve a Recruiter-enriched profile. `{identifier}` is `'me'`, the
+   * target's public identifier, or a member id. Request specific profile
+   * sections via `with_sections` (repeatable query param).
+   * `GET /v1/{account_id}/recruiter/profiles/{user_id}`
    */
-  syncMessages(params) {
+  getProfile(identifier, params) {
     return this.ctx.request({
       method: "GET",
-      path: "/v1/recruiter/messages/sync",
-      query: params
+      path: `/v1/{account_id}/recruiter/profiles/${identifier}`,
+      ...params ? { query: params } : {}
     });
   }
   /**
-   * Start a Recruiter chat (InMail). Accepts optional `attachments[]`,
-   * `voice_message`, and `video_message` — when present, the request is sent
-   * as `multipart/form-data`. `POST /v1/recruiter/chats`
+   * Start a Recruiter chat (InMail). JSON-only — `subject` and `signature`
+   * are REQUIRED; optional attachments ride the body as base64-encoded
+   * objects (no multipart). `POST /v1/{account_id}/recruiter/chats`
    */
   startChat(body) {
-    const { attachments, voice_message, video_message, ...scalars } = body;
-    const hasFiles = attachments && attachments.length > 0 || voice_message || video_message;
-    if (hasFiles) {
-      return this.ctx.request({
-        method: "POST",
-        path: "/v1/recruiter/chats",
-        body: buildFormData4(
-          scalars,
-          attachments,
-          voice_message,
-          video_message
-        ),
-        accountIdIn: "body"
-      });
-    }
     return this.ctx.request({
       method: "POST",
-      path: "/v1/recruiter/chats",
-      body: scalars,
-      accountIdIn: "body"
+      path: "/v1/{account_id}/recruiter/chats",
+      body
     });
   }
   /**
-   * Retrieve a LinkedIn profile with Recruiter enrichment.
-   * `GET /v1/recruiter/profiles/{identifier}`
+   * Search LinkedIn members using Recruiter filters. `limit`/`cursor` stay
+   * TOP-LEVEL query params. `POST /v1/{account_id}/recruiter/search/people`
    */
-  getProfile(identifier, params) {
+  searchPeople(body, params) {
     return this.ctx.request({
-      method: "GET",
-      path: `/v1/recruiter/profiles/${identifier}`,
-      // cast needed: linkedin_sections is string[] but transport encodes arrays as repeated params
+      method: "POST",
+      path: "/v1/{account_id}/recruiter/search/people",
+      body,
       ...params ? { query: params } : {}
     });
   }
   /**
-   * Search LinkedIn members using Recruiter filters.
-   * `POST /v1/recruiter/search/people`
+   * Resolve human-readable terms to opaque Recruiter filter ids. POST (was
+   * GET): the body is a `source`-discriminated oneOf — `APPLICANTS`/`PIPELINE`
+   * require `project_id`. `POST /v1/{account_id}/recruiter/search/parameters`
    */
-  searchPeople(body, params) {
+  searchParameters(body, params) {
     return this.ctx.request({
       method: "POST",
-      path: "/v1/recruiter/search/people",
+      path: "/v1/{account_id}/recruiter/search/parameters",
       body,
       ...params ? { query: params } : {}
     });
   }
   /**
-   * Resolve human-readable terms to opaque Recruiter filter IDs.
-   * `GET /v1/recruiter/search/parameters`
+   * Search a project's talent pool. `channel_id` (the project's own
+   * `RECRUITER_SEARCH` talent-pool channel) is REQUIRED. `limit`/`cursor` stay
+   * TOP-LEVEL query params.
+   * `POST /v1/{account_id}/recruiter/projects/{project_id}/talent-pool/search`
    */
-  getParameters(params) {
+  searchTalentPool(projectId, body, params) {
     return this.ctx.request({
-      method: "GET",
-      path: "/v1/recruiter/search/parameters",
-      query: params
+      method: "POST",
+      path: `/v1/{account_id}/recruiter/projects/${projectId}/talent-pool/search`,
+      body,
+      ...params ? { query: params } : {}
+    });
+  }
+  /**
+   * Search from a pasted Recruiter search / talent-pool / applicant URL —
+   * nothing else in the body. The response is a 3-way oneOf (people-search,
+   * job-applicant list, or pipeline-candidate list) keyed by the URL kind.
+   * `POST /v1/{account_id}/recruiter/search`
+   */
+  searchFromUrl(body, params) {
+    return this.ctx.request({
+      method: "POST",
+      path: "/v1/{account_id}/recruiter/search",
+      body,
+      ...params ? { query: params } : {}
     });
   }
   /**
-   * List Recruiter hiring projects. `GET /v1/recruiter/projects`
+   * List Recruiter hiring projects visible to the account.
+   * `GET /v1/{account_id}/recruiter/projects`
    */
   listProjects(params) {
     return this.ctx.request({
       method: "GET",
-      path: "/v1/recruiter/projects",
+      path: "/v1/{account_id}/recruiter/projects",
       ...params ? { query: params } : {}
     });
   }
   /**
-   * Get a single Recruiter hiring project. `GET /v1/recruiter/projects/{project_id}`
+   * Get a single Recruiter hiring project (owner, metadata, talent_pool,
+   * pipeline). `GET /v1/{account_id}/recruiter/projects/{project_id}`
    */
   getProject(projectId) {
     return this.ctx.request({
       method: "GET",
-      path: `/v1/recruiter/projects/${projectId}`
+      path: `/v1/{account_id}/recruiter/projects/${projectId}`
     });
   }
   /**
-   * Add a member to a hiring project pipeline as a candidate.
-   * `POST /v1/recruiter/projects/candidates/{user_id}`
+   * Edit a Recruiter project's config — all fields optional; omitted fields
+   * are left unchanged. Returns a thin acknowledgement only.
+   * `PATCH /v1/{account_id}/recruiter/projects/{project_id}`
    */
-  addCandidate(userId, body) {
+  updateProject(projectId, body) {
     return this.ctx.request({
-      method: "POST",
-      path: `/v1/recruiter/projects/candidates/${userId}`,
-      body,
-      accountIdIn: "body"
+      method: "PATCH",
+      path: `/v1/{account_id}/recruiter/projects/${projectId}`,
+      body
     });
   }
   /**
-   * Add a member to a hiring project pipeline as an applicant.
-   * `POST /v1/recruiter/projects/applicants/{user_id}`
+   * List candidates in a project's pipeline (POST-as-list; the body carries
+   * an all-optional filter set, no state mutates). `limit`/`cursor` stay
+   * TOP-LEVEL query params.
+   * `POST /v1/{account_id}/recruiter/projects/{project_id}/pipeline`
    */
-  addApplicant(userId, body) {
+  listPipeline(projectId, body = {}, params) {
     return this.ctx.request({
       method: "POST",
-      path: `/v1/recruiter/projects/applicants/${userId}`,
+      path: `/v1/{account_id}/recruiter/projects/${projectId}/pipeline`,
       body,
-      accountIdIn: "body"
+      ...params ? { query: params } : {}
     });
   }
   /**
-   * Reject an applicant from a hiring project.
-   * `POST /v1/recruiter/projects/applicants/{user_id}/reject`
+   * Get the single job posting attached to a Recruiter project (the surface
+   * returns one posting, not a list — a project with no attached job 404s).
+   * `GET /v1/{account_id}/recruiter/projects/{project_id}/jobs`
    */
-  rejectApplicant(userId, body) {
+  getProjectJob(projectId) {
     return this.ctx.request({
-      method: "POST",
-      path: `/v1/recruiter/projects/applicants/${userId}/reject`,
-      body,
-      accountIdIn: "body"
+      method: "GET",
+      path: `/v1/{account_id}/recruiter/projects/${projectId}/jobs`
     });
   }
   /**
-   * List Recruiter job postings. `GET /v1/recruiter/jobs`
+   * Create a job-posting DRAFT attached to an EXISTING project — `project_name`
+   * is not accepted (the project comes from the path). Never publishes, never
+   * spends money. `POST /v1/{account_id}/recruiter/projects/{project_id}/jobs`
    */
-  listJobs(params) {
+  createProjectJob(projectId, body) {
     return this.ctx.request({
-      method: "GET",
-      path: "/v1/recruiter/jobs",
-      ...params ? { query: params } : {}
+      method: "POST",
+      path: `/v1/{account_id}/recruiter/projects/${projectId}/jobs`,
+      body
     });
   }
   /**
-   * Create a Recruiter job posting draft. `POST /v1/recruiter/jobs`
+   * Get pricing to publish a project's job posting — price a publish before
+   * committing any money.
+   * `GET /v1/{account_id}/recruiter/projects/{project_id}/jobs/{job_id}/budget`
    */
-  createJob(body) {
+  getProjectJobBudget(projectId, jobId) {
     return this.ctx.request({
-      method: "POST",
-      path: "/v1/recruiter/jobs",
-      body,
-      accountIdIn: "body"
+      method: "GET",
+      path: `/v1/{account_id}/recruiter/projects/${projectId}/jobs/${jobId}/budget`
     });
   }
   /**
-   * Publish a Recruiter job posting draft.
-   * `POST /v1/recruiter/jobs/{job_id}/publish`
+   * Create a job-posting DRAFT together with a brand-new hiring project —
+   * `project_name` is REQUIRED; `description` must be ≥ 200 characters. Never
+   * publishes, never spends money. `POST /v1/{account_id}/recruiter/jobs`
    */
-  publishJob(jobId, body) {
+  createJob(body) {
     return this.ctx.request({
       method: "POST",
-      path: `/v1/recruiter/jobs/${jobId}/publish`,
-      body,
-      accountIdIn: "body"
+      path: "/v1/{account_id}/recruiter/jobs",
+      body
     });
   }
   /**
-   * Solve a publish verification checkpoint.
-   * `POST /v1/recruiter/jobs/{job_id}/checkpoint`
+   * List Recruiter job postings. `limit`/`cursor` stay TOP-LEVEL query params.
+   * `GET /v1/{account_id}/recruiter/jobs`
    */
-  solveJobCheckpoint(jobId, body) {
+  listJobs(params) {
     return this.ctx.request({
-      method: "POST",
-      path: `/v1/recruiter/jobs/${jobId}/checkpoint`,
-      body,
-      accountIdIn: "body"
+      method: "GET",
+      path: "/v1/{account_id}/recruiter/jobs",
+      ...params ? { query: params } : {}
     });
   }
   /**
-   * Get a job posting via the Recruiter lens (any public posting, not only
-   * the operator's own). `GET /v1/recruiter/jobs/{job_id}`
+   * Get one Recruiter job posting's full detail (the recruiter-specific
+   * `recruiter_job_posting` shape, carrying `project_id`).
+   * `GET /v1/{account_id}/recruiter/jobs/{job_id}`
    *
-   * Accepts a bare numeric job id or a full job URL
+   * Accepts a bare numeric job id or a full LinkedIn job URL
    * (`https://www.linkedin.com/jobs/view/{id}`) — the id is extracted
-   * client-side, mirroring `jobs.get()`. Throws
+   * client-side; the wire request always carries the numeric id. Throws
    * `CurviateError({ code: 'INVALID_REQUEST' })` synchronously if neither
-   * form can be recognized. Returns the same `JobPosting` shape as
-   * `jobs.get()`.
+   * form can be recognized.
    */
   getJob(jobIdOrUrl) {
     const jobId = resolveJobId(jobIdOrUrl);
     return this.ctx.request({
       method: "GET",
-      path: `/v1/recruiter/jobs/${jobId}`
+      path: `/v1/{account_id}/recruiter/jobs/${jobId}`
     });
   }
   /**
-   * List applicants for a job posting.
-   * `GET /v1/recruiter/jobs/{job_id}/applicants`
+   * Apply a partial update to a project's job posting — only included fields
+   * change. MONEY WARNING: editing an already-published (LISTED) posting
+   * mutates a live, money-spending listing.
+   * `PATCH /v1/{account_id}/recruiter/projects/{project_id}/jobs/{job_id}`
    */
-  listApplicants(jobId, params) {
+  updateProjectJob(projectId, jobId, body) {
     return this.ctx.request({
-      method: "GET",
-      path: `/v1/recruiter/jobs/${jobId}/applicants`,
-      // cast needed: include_degree / exclude_degree can be string[] but transport encodes arrays as repeated params
+      method: "PATCH",
+      path: `/v1/{account_id}/recruiter/projects/${projectId}/jobs/${jobId}`,
+      body
+    });
+  }
+  /**
+   * Publish a project's job posting draft. `mode` is a discriminated oneOf:
+   * `FREE` (requires free-posting eligibility, spends nothing) or
+   * `PROMOTED`/`PROMOTED_PLUS` (requires `budget` — THIS SPENDS REAL MONEY on
+   * the connected account's LinkedIn payment method; supplying `budget` IS the
+   * explicit opt-in).
+   * `POST /v1/{account_id}/recruiter/projects/{project_id}/jobs/{job_id}/publish`
+   */
+  publishJob(projectId, jobId, body) {
+    return this.ctx.request({
+      method: "POST",
+      path: `/v1/{account_id}/recruiter/projects/${projectId}/jobs/${jobId}/publish`,
+      body
+    });
+  }
+  /**
+   * Close a project's job posting so it stops accepting applications
+   * (bodyless). Closing an already-published (LISTED) posting cannot be
+   * undone — there is no re-open operation.
+   * `POST /v1/{account_id}/recruiter/projects/{project_id}/jobs/{job_id}/close`
+   */
+  closeJob(projectId, jobId) {
+    return this.ctx.request({
+      method: "POST",
+      path: `/v1/{account_id}/recruiter/projects/${projectId}/jobs/${jobId}/close`
+    });
+  }
+  /**
+   * Save a candidate (or user profile) to a project's pipeline at the given
+   * stage — the sole surviving pipeline write.
+   * `POST /v1/{account_id}/recruiter/projects/{project_id}/pipeline/candidate/save`
+   */
+  saveCandidate(projectId, body) {
+    return this.ctx.request({
+      method: "POST",
+      path: `/v1/{account_id}/recruiter/projects/${projectId}/pipeline/candidate/save`,
+      body
+    });
+  }
+  /**
+   * List applicants in a project's talent pool (POST-as-list; the body carries
+   * filters, no state mutates). `channel_id` (a `JOB_POSTING` talent-pool
+   * channel) is REQUIRED. `limit`/`cursor` stay TOP-LEVEL query params.
+   * `POST /v1/{account_id}/recruiter/projects/{project_id}/talent-pool/applicants`
+   */
+  listApplicants(projectId, body, params) {
+    return this.ctx.request({
+      method: "POST",
+      path: `/v1/{account_id}/recruiter/projects/${projectId}/talent-pool/applicants`,
+      body,
       ...params ? { query: params } : {}
     });
   }
   /**
-   * Get one job applicant. `GET /v1/recruiter/jobs/applicants/{applicant_id}`
+   * Get full detail for one talent-pool applicant (profile guaranteed full,
+   * includes PII). `GET /v1/{account_id}/recruiter/projects/{project_id}/talent-pool/applicants/{applicant_id}`
    */
-  getApplicant(applicantId) {
+  getApplicant(projectId, applicantId) {
     return this.ctx.request({
       method: "GET",
-      path: `/v1/recruiter/jobs/applicants/${applicantId}`
+      path: `/v1/{account_id}/recruiter/projects/${projectId}/talent-pool/applicants/${applicantId}`
     });
   }
   /**
-   * Download an applicant's resume as raw binary.
-   * `GET /v1/recruiter/jobs/applicants/{applicant_id}/resume`
-   * Returns `ArrayBuffer` — binary response; the SDK does not cache or store it.
+   * Download a talent-pool applicant's résumé as raw binary.
+   * `GET /v1/{account_id}/recruiter/projects/{project_id}/talent-pool/applicants/{applicant_id}/resume`
+   * Returns `ArrayBuffer` — the SDK does not cache or store it.
    */
-  downloadResume(applicantId) {
+  downloadResume(projectId, applicantId) {
     return this.ctx.request({
       method: "GET",
-      path: `/v1/recruiter/jobs/applicants/${applicantId}/resume`
+      path: `/v1/{account_id}/recruiter/projects/${projectId}/talent-pool/applicants/${applicantId}/resume`
     });
   }
 };
@@ -1498,24 +2038,137 @@ var JobsResource = class {
     this.ctx = ctx;
   }
   /**
-   * Retrieve one public LinkedIn job posting's full detail.
-   * `GET /v1/jobs/{job_id}`
+   * List the connected account's own classic job postings.
+   * `GET /v1/{account_id}/jobs`
+   * `state` is REQUIRED — filtering is LinkedIn-side and best-effort (see
+   * the generated type's own field description).
+   */
+  list(params) {
+    return this.ctx.request({
+      method: "GET",
+      path: "/v1/{account_id}/jobs",
+      query: params
+    });
+  }
+  /**
+   * Create a classic job posting DRAFT. Never publishes, never spends money.
+   * `POST /v1/{account_id}/jobs`
+   */
+  create(body) {
+    return this.ctx.request({
+      method: "POST",
+      path: "/v1/{account_id}/jobs",
+      body
+    });
+  }
+  /**
+   * Retrieve one classic LinkedIn job posting's full detail.
+   * `GET /v1/{account_id}/jobs/{job_id}`
    *
    * Accepts a bare numeric job id or a full job URL
    * (`https://www.linkedin.com/jobs/view/{id}`) — the id is extracted
    * client-side; the wire request always carries the numeric id. Throws
    * `CurviateError({ code: 'INVALID_REQUEST' })` synchronously if neither
    * form can be recognized.
-   * The `account_id` is injected by the account-scoped context.
    */
   get(jobIdOrUrl, params) {
     const jobId = resolveJobId(jobIdOrUrl);
     return this.ctx.request({
       method: "GET",
-      path: `/v1/jobs/${jobId}`,
+      path: `/v1/{account_id}/jobs/${jobId}`,
       ...params ? { query: params } : {}
     });
   }
+  /**
+   * Apply a partial update to a job posting this account owns — only
+   * included fields change. Can affect real money on an already-published
+   * (LISTED) posting. `PATCH /v1/{account_id}/jobs/{job_id}`
+   */
+  update(jobId, body) {
+    return this.ctx.request({
+      method: "PATCH",
+      path: `/v1/{account_id}/jobs/${jobId}`,
+      body
+    });
+  }
+  /**
+   * Get pricing to publish a job posting — price a publish before
+   * committing any money. `GET /v1/{account_id}/jobs/{job_id}/budget`
+   */
+  getBudget(jobId) {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/{account_id}/jobs/${jobId}/budget`
+    });
+  }
+  /**
+   * Publish a classic job posting draft. `mode` is a discriminated oneOf:
+   * `FREE` (requires free-posting eligibility, spends nothing) or
+   * `PROMOTED`/`PROMOTED_PLUS` (requires `budget` — THIS SPENDS REAL MONEY
+   * on the connected account's LinkedIn payment method; supplying `budget`
+   * IS the explicit opt-in). `POST /v1/{account_id}/jobs/{job_id}/publish`
+   */
+  publish(jobId, body) {
+    return this.ctx.request({
+      method: "POST",
+      path: `/v1/{account_id}/jobs/${jobId}/publish`,
+      body
+    });
+  }
+  /**
+   * Close a job posting so it stops accepting applications (bodyless).
+   * Closing an already-published (LISTED) posting cannot be undone.
+   * `POST /v1/{account_id}/jobs/{job_id}/close`
+   */
+  close(jobId) {
+    return this.ctx.request({
+      method: "POST",
+      path: `/v1/{account_id}/jobs/${jobId}/close`
+    });
+  }
+  /**
+   * List applicants to a job posting this account owns — a read; POST
+   * carries the filter body, matching the `/search/*` convention. Omit
+   * `ratings` to see the full applicant funnel. `limit`/`cursor` stay
+   * TOP-LEVEL query params, never in the body.
+   * `POST /v1/{account_id}/jobs/{job_id}/applicants`
+   */
+  listApplicants(jobId, params = {}) {
+    const { cursor, limit, ...body } = params;
+    const hasQuery = cursor !== void 0 || limit !== void 0;
+    return this.ctx.request({
+      method: "POST",
+      path: `/v1/{account_id}/jobs/${jobId}/applicants`,
+      body,
+      ...hasQuery ? {
+        query: {
+          ...cursor !== void 0 ? { cursor } : {},
+          ...limit !== void 0 ? { limit } : {}
+        }
+      } : {}
+    });
+  }
+  /**
+   * Get full detail for one applicant, including contact information.
+   * `GET /v1/{account_id}/jobs/{job_id}/applicants/{applicant_id}`
+   */
+  getApplicant(jobId, applicantId) {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/{account_id}/jobs/${jobId}/applicants/${applicantId}`
+    });
+  }
+  /**
+   * Download an applicant's résumé. Returns raw binary.
+   * `GET /v1/{account_id}/jobs/{job_id}/applicants/{applicant_id}/resume`
+   * Returns `ArrayBuffer` — the SDK does not cache or store it.
+   */
+  downloadResume(jobId, applicantId) {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/{account_id}/jobs/${jobId}/applicants/${applicantId}/resume`
+    });
+  }
 };
 
 // src/resources/companies.ts
@@ -1525,21 +2178,20 @@ var CompaniesResource = class {
   }
   /**
    * Retrieve a company's full LinkedIn profile.
-   * `GET /v1/companies/{identifier}`
+   * `GET /v1/{account_id}/companies/{identifier}`
    *
    * Accepts a public handle (the slug in `linkedin.com/company/<handle>`,
    * e.g. `t-systems`) or a numeric id (e.g. `1234567`). A URN is not accepted.
-   * The `account_id` is injected by the account-scoped context.
    */
   get(identifier) {
     return this.ctx.request({
       method: "GET",
-      path: `/v1/companies/${identifier}`
+      path: `/v1/{account_id}/companies/${identifier}`
     });
   }
   /**
    * List people who currently work at the company.
-   * `GET /v1/companies/{identifier}/employees`
+   * `GET /v1/{account_id}/companies/{identifier}/employees`
    *
    * A facade over people search with the company filter applied — filter
    * further with `keywords` or `location`. `identifier` must be the
@@ -1549,13 +2201,13 @@ var CompaniesResource = class {
   employees(identifier, params) {
     return this.ctx.request({
       method: "GET",
-      path: `/v1/companies/${identifier}/employees`,
+      path: `/v1/{account_id}/companies/${identifier}/employees`,
       ...params ? { query: params } : {}
     });
   }
   /**
    * List the company's posts.
-   * `GET /v1/companies/{identifier}/posts`
+   * `GET /v1/{account_id}/companies/{identifier}/posts`
    *
    * A facade over post search with the company filter applied. `identifier`
    * must be the company's numeric provider_id.
@@ -1563,13 +2215,13 @@ var CompaniesResource = class {
   posts(identifier, params) {
     return this.ctx.request({
       method: "GET",
-      path: `/v1/companies/${identifier}/posts`,
+      path: `/v1/{account_id}/companies/${identifier}/posts`,
       ...params ? { query: params } : {}
     });
   }
   /**
    * List the company's open job postings.
-   * `GET /v1/companies/{identifier}/jobs`
+   * `GET /v1/{account_id}/companies/{identifier}/jobs`
    *
    * A facade over job search with the company filter applied — filter
    * further with `keywords`. An empty `items[]` is a valid result (the
@@ -1579,22 +2231,123 @@ var CompaniesResource = class {
   jobs(identifier, params) {
     return this.ctx.request({
       method: "GET",
-      path: `/v1/companies/${identifier}/jobs`,
+      path: `/v1/{account_id}/companies/${identifier}/jobs`,
+      ...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 the company's followers.
-   * `GET /v1/companies/{identifier}/followers`
+   * List a company page's followers, newest first.
+   * `GET /v1/{account_id}/companies/{identifier}/followers`
    *
-   * Native — reuses the same seam that backs `profiles.listFollowers()`.
-   * You must be an administrator of the target company page.
+   * 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/companies/${identifier}/followers`,
+      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 } : {}
     });
   }
@@ -1671,29 +2424,24 @@ var WebhooksResource = class {
       path: `/v1/webhooks/${id}`
     });
   }
-  /**
-   * Return the set of changes since the last known version for a connected account.
-   * Enables event-driven state sync without polling the account endpoint.
-   * `GET /v1/accounts/{id}/state-diff`
-   */
-  getStateDiff(accountId, params) {
-    return this.ctx.request({
-      method: "GET",
-      path: `/v1/accounts/${accountId}/state-diff`,
-      ...params ? { query: params } : {}
-    });
-  }
 };
 
 // src/resources/index.ts
 function buildNamespaces(ctx) {
   return {
     accounts: new AccountsResource(ctx),
+    auth: new AuthResource(ctx),
     messaging: new MessagingResource(ctx),
-    profiles: new ProfilesResource(ctx),
+    users: new UsersResource(ctx),
     invites: new InvitesResource(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),
@@ -1701,9 +2449,23 @@ function buildNamespaces(ctx) {
     webhooks: new WebhooksResource(ctx)
   };
 }
+function buildRootNamespaces(ctx) {
+  return {
+    accounts: new AccountsResource(ctx),
+    auth: new AuthResource(ctx),
+    webhooks: new WebhooksResource(ctx)
+  };
+}
 function buildAccountScopedNamespaces(ctx) {
-  const { accounts: _accounts, ...rest } = buildNamespaces(ctx);
+  const {
+    accounts: _accounts,
+    auth: _auth,
+    webhooks: _webhooks,
+    ...rest
+  } = buildNamespaces(ctx);
   void _accounts;
+  void _auth;
+  void _webhooks;
   return rest;
 }
 
@@ -1712,17 +2474,9 @@ var Curviate = class {
   constructor(config) {
     this.config = resolveConfig(config);
     const ctx = createContext(this.config);
-    const ns = buildNamespaces(ctx);
+    const ns = buildRootNamespaces(ctx);
     this.accounts = ns.accounts;
-    this.messaging = ns.messaging;
-    this.profiles = ns.profiles;
-    this.invites = ns.invites;
-    this.search = ns.search;
-    this.posts = ns.posts;
-    this.salesNavigator = ns.salesNavigator;
-    this.recruiter = ns.recruiter;
-    this.jobs = ns.jobs;
-    this.companies = ns.companies;
+    this.auth = ns.auth;
     this.webhooks = ns.webhooks;
   }
   /**
@@ -1753,15 +2507,15 @@ var Curviate = class {
    * Calls `fn` repeatedly, injecting the `cursor` from each response into the
    * next call, yielding individual items until `cursor` is null.
    *
-   * @param fn     - a bound resource method (e.g. `profiles.listConnections.bind(profiles)`)
+   * @param fn     - a bound resource method (e.g. `users.listRelations.bind(users)`)
    * @param params - the initial params (minus cursor)
    *
    * @example
-   * for await (const profile of curviate.paginate(
-   *   curviate.account('acc_123').profiles.listConnections,
+   * for await (const relation of curviate.paginate(
+   *   curviate.account('acc_123').users.listRelations,
    *   { limit: 50 }
    * )) {
-   *   console.log(profile);
+   *   console.log(relation);
    * }
    */
   paginate(fn, params) {