@curviate/sdk 0.40.1 → 0.42.0

package/dist/index.js

@@ -79,6 +79,19 @@ var ERROR_CODES = [
   "CHECKPOINT_ALREADY_RESOLVED",
   "CHECKPOINT_UNSUPPORTED",
   "CONNECTION_IN_PROGRESS",
+  // Connection location (where LinkedIn sees the account connecting from).
+  // `CONNECTION_LOCATION_REQUIRED` (400): a new connect named no location, or
+  // a PATCH cleared your own proxy (`proxy: null`) without a `country`. Send
+  // exactly one of `country`, `ip` or `proxy`. user_fixable, never retryable
+  // as sent.
+  // `CONNECTION_LOCATION_UNAVAILABLE` (422): no connection is free in that
+  // country right now (strict), or the change landed elsewhere. When a change
+  // was applied, {@link CurviateError.connectionLocation} says where the
+  // account connects from now, which may mean your own proxy is already gone.
+  // Try a nearby country, or allow fallback. user_fixable, never retryable as
+  // sent.
+  "CONNECTION_LOCATION_REQUIRED",
+  "CONNECTION_LOCATION_UNAVAILABLE",
   // 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,
@@ -167,6 +180,28 @@ var ERROR_CODES = [
   // was charged. Stop and surface it to a human (or support) rather than
   // backing off.
   "STRIPE_DRIFT_DETECTED",
+  // Drafts and scheduled posts (`/v1/drafts`). Each is user_fixable and none
+  // clears on an unchanged retry; read the code, then change the request.
+  //
+  // - `DRAFT_LIMIT_REACHED` (422): the bucket (one account, or "no account")
+  //   already holds 50 Drafts. Delete one, or use another account.
+  // - `MEDIA_QUOTA_EXCEEDED` (422): the file would take the bucket past its
+  //   media quota; nothing was stored. Delete media first.
+  // - `ACCOUNT_REQUIRED` (422): publishing or scheduling needs an account on the
+  //   Draft (also `account_id: null` on a scheduled Draft: unschedule first).
+  // - `DRAFT_NOT_PUBLISHABLE` (422): a content gap (empty text, ...); the
+  //   message names the field.
+  // - `SCHEDULE_CONFLICT` (422): another scheduled Draft on the same account is
+  //   within 5 minutes of this `scheduled_at`; the message names it.
+  // - `DRAFT_PUBLISHING` (409): a publish of this Draft is in flight (or its
+  //   outcome is being settled). Read the Draft again in a few seconds; if it
+  //   says to check the account's posts first, do that before retrying.
+  "DRAFT_LIMIT_REACHED",
+  "MEDIA_QUOTA_EXCEEDED",
+  "ACCOUNT_REQUIRED",
+  "DRAFT_NOT_PUBLISHABLE",
+  "SCHEDULE_CONFLICT",
+  "DRAFT_PUBLISHING",
   // Generic
   "INTERNAL"
 ];
@@ -187,6 +222,7 @@ var CurviateError = class _CurviateError extends Error {
     this.safetyHint = init.safetyHint;
     this.safetyReason = init.safetyReason;
     this.blocked = init.blocked;
+    this.connectionLocation = init.connectionLocation;
     Object.setPrototypeOf(this, _CurviateError.prototype);
   }
   /**
@@ -211,6 +247,7 @@ var CurviateError = class _CurviateError extends Error {
     if (this.safetyHint !== void 0) json.safetyHint = this.safetyHint;
     if (this.safetyReason !== void 0) json.safetyReason = this.safetyReason;
     if (this.blocked !== void 0) json.blocked = this.blocked;
+    if (this.connectionLocation !== void 0) json.connectionLocation = this.connectionLocation;
     return json;
   }
 };
@@ -325,7 +362,8 @@ async function errorFromResponse(res) {
     ...typeof env?.reset_at === "string" || env?.reset_at === null ? { resetAt: env.reset_at } : {},
     ...safetyHint !== void 0 ? { safetyHint } : {},
     ...safetyReason !== void 0 ? { safetyReason } : {},
-    ...typeof env?.blocked === "boolean" ? { blocked: env.blocked } : {}
+    ...typeof env?.blocked === "boolean" ? { blocked: env.blocked } : {},
+    ...env?.connection_location !== null && typeof env?.connection_location === "object" ? { connectionLocation: env.connection_location } : {}
   });
   return { err, refusesRetry: env?.retry_likely_to_succeed === false };
 }
@@ -341,6 +379,11 @@ function buildInit(method, opts, signal) {
     authorization: `Bearer ${opts.apiKey}`
   };
   const init = { method, headers, signal };
+  if (opts.rawBody !== void 0 && method !== "GET" && method !== "HEAD") {
+    headers["content-type"] = opts.rawBody.contentType;
+    init.body = opts.rawBody.data;
+    return init;
+  }
   if (method === "GET" || method === "HEAD" || opts.body === void 0) {
     return init;
   }
@@ -471,7 +514,8 @@ function createContext(config, accountId) {
       maxRetries: config.maxRetries,
       ...config.fetch ? { fetch: config.fetch } : {},
       ...args.query !== void 0 ? { query: args.query } : {},
-      ...args.body !== void 0 ? { body: args.body } : {}
+      ...args.body !== void 0 ? { body: args.body } : {},
+      ...args.rawBody !== void 0 ? { rawBody: args.rawBody } : {}
     });
   };
   return { request, accountId };
@@ -543,7 +587,7 @@ var AccountsResource = class {
    * const { items } = await curviate.accounts.listSeats();
    * const free = items.find((seat) => !seat.occupied);
    * if (!free) throw new Error("No seat is free to connect to right now (add a seat, or check billing).");
-   * await curviate.auth.intent({ seat_id: free.seat_id, auth_method: "cookie", cookie: { li_at }, user_agent });
+   * await curviate.auth.intent({ seat_id: free.seat_id, auth_method: "cookie", cookie: { li_at }, user_agent, country: "US" });
    */
   listSeats() {
     return this.ctx.request({ method: "GET", path: "/v1/accounts/seats" });
@@ -597,13 +641,30 @@ var AccountsResource = class {
    * `metadata` is a flat string->string map (at most 16 keys, key 40 chars,
    * value 500) that **replaces** the stored map wholesale; `null` clears it.
    * Both are stored by Curviate, read back on `get`/`list`, and a PATCH
-   * carrying only them makes no LinkedIn call. `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.
+   * carrying only them makes no LinkedIn call.
+   *
+   * `country` moves the account's connection location to that supported ISO
+   * country. LinkedIn sees a new IP there and may ask the owner to verify, so
+   * change it only when the current location is wrong. Strict unless
+   * `allow_country_fallback: true`; `allow_country_fallback` alone changes the
+   * strictness of the configured country. `proxy` sets your own proxy; `null`
+   * returns to a managed location and **requires** a `country` in the same
+   * call (else `CONNECTION_LOCATION_REQUIRED`), and an account on your own
+   * proxy can only take a `country` together with `proxy: null`. The
+   * `proxy.password`, if given, is never returned.
+   *
+   * Returns the account (as `get` returns it, without `quotas` and
+   * `event_log`). After a location change its `connection_location` is re-read,
+   * so it shows where the account really connects from now. A change that did
+   * not land where asked throws `CONNECTION_LOCATION_UNAVAILABLE`, whose
+   * `connectionLocation` carries the actual location.
    *
    * @example
    * await curviate.accounts.update("acc_123", { external_id: "usr_42", metadata: { plan: "pro" } });
+   *
+   * @example
+   * const account = await curviate.accounts.update("acc_123", { country: "DE" });
+   * console.log(account.connection_location?.country); // "DE"
    */
   update(accountId, body) {
     return this.ctx.request({
@@ -623,7 +684,7 @@ var AccountsResource = class {
   }
   /**
    * Buy seats on the workspace's active subscription. Returns the new
-   * `seat_ids`; connect an account into one with `auth.intent({ seat_id })`.
+   * `seat_ids`; connect an account into one with `auth.intent({ seat_id, country, ... })`.
    *
    * Every call buys the `qty` it asks for, so a repeated call buys again.
    * The SDK never retries it for you. A
@@ -728,8 +789,30 @@ var AuthResource = class {
    * LinkedIn account does not hold throws
    * `CurviateError(code: "LINKEDIN_FEATURE_NOT_SUBSCRIBED")` (403); the remedy
    * is to activate the subscription on LinkedIn or to point `linkedin_premium`
-   * at the premium the account really has. Pin a managed proxy with the
-   * optional `country`/`ip`, or supply `proxy` to override it entirely.
+   * at the premium the account really has.
+   *
+   * **Connection location.** A NEW connect must say where LinkedIn sees the
+   * account connecting from, with exactly one of: `country` (a supported ISO
+   * code such as `"US"`; pick the one the owner normally signs in from), `ip`
+   * (a public IPv4 whose country is used) or your own `proxy`. Without one the
+   * API throws `CurviateError(code: "CONNECTION_LOCATION_REQUIRED")`, and the
+   * {@link AuthIntentBody} type refuses it at compile time. `country` and `ip`
+   * are strict by default: the connect fails with
+   * `CONNECTION_LOCATION_UNAVAILABLE` rather than use another country, unless
+   * you send `allow_country_fallback: true`. A reconnect may omit the location
+   * to keep the account's configured one. The account's `connection_location`
+   * says where it connects from; when a connect re-attached an account you
+   * already had and moved it, `connection_location.previous_country` names
+   * where it was.
+   *
+   * @example
+   * const result = await curviate.auth.intent({
+   *   seat_id: "YOUR_SEAT_ID",
+   *   auth_method: "credentials",
+   *   credentials: { email: "YOUR_EMAIL", password: "YOUR_PASSWORD" },
+   *   country: "US",
+   * });
+   * console.log(result.account_id);
    */
   intent(body) {
     return this.ctx.request({
@@ -777,7 +860,7 @@ var AuthResource = class {
    * @param body - optional `{ challenge }` for a `challenge_selection` checkpoint.
    *
    * @example
-   * const cp = await curviate.auth.intent({ seat_id, auth_method: "credentials", credentials });
+   * const cp = await curviate.auth.intent({ seat_id, auth_method: "credentials", credentials, country: "US" });
    * if (cp.object === "checkpoint" && cp.challenge_type === "challenge_selection") {
    *   const next = await curviate.auth.requestCheckpoint(cp.account_id!, { challenge: cp.challenges![0]!.id });
    * }
@@ -1387,15 +1470,15 @@ var PostsResource = class {
    * Get a single post. `GET /v1/{account_id}/posts/{post_id}`
    *
    * @param postId - the post's `id` as returned by {@link listUserPosts} or
-   *   {@link create}. A bare numeric id (`7332661864792854528`), a URN
-   *   (`urn:li:activity:N`, `urn:li:ugcPost:N`, `urn:li:share:N`), and a full
-   *   share URL (`https://www.linkedin.com/posts/...` or
+   *   {@link create}, or a post search result's `id`. A bare numeric id
+   *   (`7332661864792854528`), a URN (`urn:li:activity:N`, `urn:li:ugcPost:N`,
+   *   `urn:li:share:N`), and a full post URL (`https://www.linkedin.com/posts/...`
+   *   with an `activity-`, `ugcPost-` or `share-` slug, or
    *   `https://www.linkedin.com/feed/update/urn:li:activity:N`) all resolve to
    *   the same post. Pass the value as-is; it is percent-encoded into the path
    *   for you, so do not encode it yourself.
    *
-   *   {@link listComments} and the reaction operations are stricter: they take
-   *   the opaque `id` form only.
+   *   {@link listComments} and the reaction operations accept the same forms.
    */
   get(postId) {
     return this.ctx.request({
@@ -3034,6 +3117,145 @@ var WebhooksResource = class {
   }
 };
 
+// src/resources/drafts.ts
+var DraftsResource = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  /**
+   * Store a Draft. Every field is optional, `account_id` and `text` included.
+   * `POST /v1/drafts`
+   *
+   * With `scheduled_at` (ISO 8601 with offset, between 5 minutes and 365 days
+   * ahead) the Draft is scheduled in the same call and needs an account and
+   * publishable text. Up to 50 Drafts and 2 GiB of media per account, and per
+   * no-account. A retry creates a second Draft.
+   *
+   * @example
+   * const draft = await curviate.drafts.create({
+   *   account_id: "acc_01J8Z3K9P0Q1R2S3T4V5W6X7Y8",
+   *   text: "Three things we learned shipping our first agent integration.",
+   *   scheduled_at: "2026-10-12T09:00:00+02:00",
+   * });
+   * // draft.status === "scheduled"
+   */
+  create(body = {}) {
+    return this.ctx.request({
+      method: "POST",
+      path: "/v1/drafts",
+      body
+    });
+  }
+  /**
+   * List Drafts, cursor-paginated. `GET /v1/drafts`
+   *
+   * `status` defaults to `["draft", "scheduled", "failed"]`; add `"published"`
+   * to include publish records (`object: "publish_record"`, never Drafts).
+   * `account_id` is an `acc_` id or `"none"`. `from`/`to` are a half-open
+   * `[from, to)` range on each item's own date.
+   *
+   * @example
+   * const page = await curviate.drafts.list({ status: ["scheduled"], order: "asc" });
+   */
+  list(params) {
+    const { status, ...rest } = params ?? {};
+    return this.ctx.request({
+      method: "GET",
+      path: "/v1/drafts",
+      query: { ...rest, ...status !== void 0 ? { status: status.join(",") } : {} }
+    });
+  }
+  /**
+   * Return one Draft, with a fresh signed link (valid 1 hour) per attachment.
+   * `GET /v1/drafts/{id}`
+   *
+   * @example
+   * const draft = await curviate.drafts.get("drf_01J8Z3K9P0Q1R2S3T4V5W6X7Y8");
+   */
+  get(id) {
+    return this.ctx.request({
+      method: "GET",
+      path: apiPath`/v1/drafts/${id}`
+    });
+  }
+  /**
+   * Partial update: an omitted field is left as is, `null` clears it.
+   * `PATCH /v1/drafts/{id}`
+   *
+   * `attachments` replaces the whole list (`{ id }` keeps a file, a base64
+   * object adds one, anything left out is deleted). `scheduled_at` schedules,
+   * reschedules or, with `null`, unschedules. Editing a `failed` Draft clears
+   * its `failure`. A Draft being published answers `409 DRAFT_PUBLISHING`.
+   *
+   * @example
+   * await curviate.drafts.update(id, { scheduled_at: null }); // unschedule
+   */
+  update(id, body) {
+    return this.ctx.request({
+      method: "PATCH",
+      path: apiPath`/v1/drafts/${id}`,
+      body
+    });
+  }
+  /**
+   * Delete the Draft and its stored media (bodyless, 204).
+   * `DELETE /v1/drafts/{id}`
+   *
+   * @example
+   * await curviate.drafts.delete(id);
+   */
+  async delete(id) {
+    await this.ctx.request({
+      method: "DELETE",
+      path: apiPath`/v1/drafts/${id}`
+    });
+  }
+  /**
+   * Publish the Draft now, under the same rules and safety limits as
+   * `posts.create`. `POST /v1/drafts/{id}/publish`
+   *
+   * Success deletes the Draft and its media, writes a publish record and
+   * returns `{ object: "post_created", id }`; no webhook is sent. A known
+   * failure leaves the Draft unchanged. A `504` or `502` whose message says
+   * the outcome is unknown means the post may be live: check the account's
+   * posts before retrying.
+   *
+   * @example
+   * const { id: postId } = await curviate.drafts.publish(draftId);
+   */
+  publish(id) {
+    return this.ctx.request({
+      method: "POST",
+      path: apiPath`/v1/drafts/${id}/publish`
+    });
+  }
+  /**
+   * Add one file to the Draft as the raw request body, for media too large to
+   * send inline: an MP4 video or a PDF, each up to 50 MiB. An image is capped at 5 MiB on
+   * every route. One file per call.
+   * `POST /v1/drafts/{id}/attachments?filename=...`
+   *
+   * Small files (up to 5 MiB) can instead ride inline in `create` / `update`
+   * as base64. Resolves with the Draft, the new attachment last.
+   *
+   * @example
+   * const bytes = await readFile("clip.mp4");
+   * const draft = await curviate.drafts.uploadAttachment(id, bytes, {
+   *   filename: "clip.mp4",
+   *   contentType: "video/mp4",
+   * });
+   */
+  uploadAttachment(id, data, options) {
+    const contentType = options.contentType ?? (data instanceof Blob ? data.type : "");
+    return this.ctx.request({
+      method: "POST",
+      path: apiPath`/v1/drafts/${id}/attachments`,
+      query: { filename: options.filename },
+      rawBody: { data, contentType }
+    });
+  }
+};
+
 // src/resources/index.ts
 function buildNamespaces(ctx) {
   return {
@@ -3054,14 +3276,16 @@ function buildNamespaces(ctx) {
     recruiter: new RecruiterResource(ctx),
     jobs: new JobsResource(ctx),
     companies: new CompaniesResource(ctx),
-    webhooks: new WebhooksResource(ctx)
+    webhooks: new WebhooksResource(ctx),
+    drafts: new DraftsResource(ctx)
   };
 }
 function buildRootNamespaces(ctx) {
   return {
     accounts: new AccountsResource(ctx),
     auth: new AuthResource(ctx),
-    webhooks: new WebhooksResource(ctx)
+    webhooks: new WebhooksResource(ctx),
+    drafts: new DraftsResource(ctx)
   };
 }
 function buildAccountScopedNamespaces(ctx) {
@@ -3069,11 +3293,13 @@ function buildAccountScopedNamespaces(ctx) {
     accounts: _accounts,
     auth: _auth,
     webhooks: _webhooks,
+    drafts: _drafts,
     ...rest
   } = buildNamespaces(ctx);
   void _accounts;
   void _auth;
   void _webhooks;
+  void _drafts;
   return rest;
 }
 
@@ -3086,6 +3312,7 @@ var Curviate = class {
     this.accounts = ns.accounts;
     this.auth = ns.auth;
     this.webhooks = ns.webhooks;
+    this.drafts = ns.drafts;
   }
   /**
    * Return an account-scoped accessor that fixes `account_id` on every call,

package/package.json

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