@curviate/sdk 0.12.0 → 0.13.0

package/dist/index.js

@@ -76,6 +76,7 @@ var KNOWN_CODES = /* @__PURE__ */ new Set([
   "PAYLOAD_TOO_LARGE",
   "ACCOUNT_NOT_FOUND",
   "ACCOUNT_RESTRICTED",
+  "ACCOUNT_ALREADY_LINKED",
   "RESOURCE_NOT_FOUND",
   "RESOURCE_ACCESS_RESTRICTED",
   "TIER_NOT_ACTIVE",
@@ -332,7 +333,20 @@ 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`.
+   * 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"`.
+   *
+   * 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).
    */
   link(body) {
     return this.ctx.request({
@@ -342,45 +356,75 @@ var AccountsResource = class {
     });
   }
   /**
-   * Submit an OTP or 2FA code to resolve a checkpoint challenge.
+   * 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`.
+   *
+   * @param accountId - the provisional `account_id` from the 202 response.
+   * @param body - the verification `code`.
    */
-  submitCheckpoint(body) {
+  solveCheckpoint(accountId, body) {
     return this.ctx.request({
       method: "POST",
-      path: "/v1/accounts/checkpoints/submit",
+      path: `/v1/accounts/${accountId}/checkpoint/solve`,
       body
     });
   }
   /**
-   * Poll for mobile-app approval of a pending checkpoint challenge.
+   * 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.
    */
-  pollCheckpoint(body) {
+  requestCheckpoint(accountId) {
     return this.ctx.request({
       method: "POST",
-      path: "/v1/accounts/checkpoints/poll",
-      body
+      path: `/v1/accounts/${accountId}/checkpoint/request`
     });
   }
   /**
-   * Re-send the pending verification challenge notification for an account.
+   * Poll for mobile-app approval of a pending checkpoint challenge.
    *
-   * Useful when the end user says they never received the code or push
-   * notification for a pending checkpoint. `resent` echoes the result
-   * 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 resend wasn't applicable). Does not reset
-   * the checkpoint's expiry.
+   * 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`.
+   *
+   * 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.
+   *
+   * @param accountId - the provisional `account_id` from the 202 response.
    */
-  resendCheckpoint(body) {
+  pollCheckpoint(accountId) {
     return this.ctx.request({
       method: "POST",
-      path: "/v1/accounts/checkpoints/resend",
-      body
+      path: `/v1/accounts/${accountId}/checkpoint/poll`
     });
   }
   /**
-   * Generate a one-time hosted connection link the end user opens to authorize a
-   * LinkedIn connection without credentials transiting the API or LLM context.
+   * 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) {
     return this.ctx.request({
@@ -390,8 +434,25 @@ var AccountsResource = class {
     });
   }
   /**
-   * Poll a hosted connect session minted by {@link createConnectLink} (its
-   * `session_id`).
+   * 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.
+   *
+   * @param accountId - the account to re-authorize.
+   * @param body - optional `expires_in_seconds` and `redirect_url`.
+   */
+  createReconnectLink(accountId, body) {
+    return this.ctx.request({
+      method: "POST",
+      path: `/v1/accounts/${accountId}/reconnect-link`,
+      ...body !== void 0 ? { 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
@@ -413,10 +474,11 @@ var AccountsResource = class {
    * seat this account occupies, `null` for an admin seatless account).
    *
    * This is a stale-while-revalidate read — it always returns immediately
-   * from the cached row (never blocks on a live substrate call), and the
-   * six cached enrichment fields (`username`, `premium_id`,
-   * `public_identifier`, `substrate_created_at`, `signatures`, `groups`) are
-   * `null`/`[]` until the account's first enrichment pass completes.
+   * 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({
@@ -425,7 +487,13 @@ var AccountsResource = class {
     });
   }
   /**
-   * Re-authorize a disconnected account in place (same account_id, same seat).
+   * 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}.
+   *
+   * For `auth_method: "cookie"`, `user_agent` is **required** (as on
+   * {@link link}). For the hosted re-auth flow, use {@link createReconnectLink}.
    */
   reconnect(accountId, body) {
     return this.ctx.request({
@@ -435,16 +503,13 @@ var AccountsResource = class {
     });
   }
   /**
-   * Refresh frozen account sources (re-sync conversations, connection lists, etc.).
-   */
-  refresh(accountId) {
-    return this.ctx.request({
-      method: "POST",
-      path: `/v1/accounts/${accountId}/refresh`
-    });
-  }
-  /**
-   * Update managed-proxy configuration for an account.
+   * Update an account's configuration.
+   *
+   * `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.
    */
   update(accountId, body) {
     return this.ctx.request({

package/package.json

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