@curviate/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,1504 @@
+// src/errors.ts
+var CurviateError = class _CurviateError extends Error {
+  constructor(init) {
+    super(init.message);
+    this.name = "CurviateError";
+    this.code = init.code;
+    this.httpStatus = init.httpStatus;
+    this.retryHint = init.retryHint ?? null;
+    this.userFixable = init.userFixable;
+    this.retryLikelyToSucceed = init.retryLikelyToSucceed;
+    this.requiredTier = init.requiredTier;
+    this.retryAfterMs = init.retryAfterMs;
+    Object.setPrototypeOf(this, _CurviateError.prototype);
+  }
+  /**
+   * Explicit, credential-safe serialization. Only the documented structured
+   * fields are emitted — never a credential, auth header, or any reference to
+   * the client. `JSON.stringify(error)` calls this automatically.
+   */
+  toJSON() {
+    const json = {
+      name: "CurviateError",
+      code: this.code,
+      message: this.message,
+      retryHint: this.retryHint,
+      userFixable: this.userFixable,
+      retryLikelyToSucceed: this.retryLikelyToSucceed
+    };
+    if (this.httpStatus !== void 0) json.httpStatus = this.httpStatus;
+    if (this.requiredTier !== void 0) json.requiredTier = this.requiredTier;
+    if (this.retryAfterMs !== void 0) json.retryAfterMs = this.retryAfterMs;
+    return json;
+  }
+};
+function isCurviateError(err) {
+  return err instanceof CurviateError;
+}
+
+// src/config.ts
+var DEFAULT_BASE_URL = "https://api.curviate.com";
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_RETRIES = 3;
+function resolveConfig(config) {
+  if (typeof config?.apiKey !== "string" || config.apiKey.length === 0) {
+    throw new CurviateError({
+      code: "INVALID_REQUEST",
+      message: "An apiKey is required to construct a Curviate client.",
+      userFixable: true,
+      retryLikelyToSucceed: false
+    });
+  }
+  return Object.freeze({
+    apiKey: config.apiKey,
+    baseUrl: config.baseUrl ?? DEFAULT_BASE_URL,
+    timeout: config.timeout ?? DEFAULT_TIMEOUT_MS,
+    maxRetries: config.maxRetries ?? DEFAULT_MAX_RETRIES,
+    fetch: config.fetch
+  });
+}
+
+// src/transport.ts
+var BASE_DELAY_MS = 500;
+var MAX_DELAY_MS = 3e4;
+var RETRYABLE_CODES = /* @__PURE__ */ new Set([
+  "INTERNAL",
+  "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",
+  "RESOURCE_NOT_FOUND",
+  "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"
+]);
+function defaultSleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function parseRetryAfterMs(header) {
+  if (header == null) return void 0;
+  const seconds = Number(header);
+  if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1e3;
+  return 3e4;
+}
+function backoffDelay(n, jitter) {
+  const exp = Math.min(BASE_DELAY_MS * 2 ** (n - 1), MAX_DELAY_MS);
+  return exp + jitter;
+}
+function toErrorCode(code) {
+  return code && KNOWN_CODES.has(code) ? code : "INTERNAL";
+}
+function toRetryHint(hint) {
+  if (!hint || typeof hint !== "object") return null;
+  const kind = hint.kind;
+  if (kind !== "delay" && kind !== "backoff" && kind !== "never") return null;
+  const out = { kind };
+  if (typeof hint.delay_ms === "number") out.delayMs = hint.delay_ms;
+  return out;
+}
+async function errorFromResponse(res) {
+  const retryAfterMs = parseRetryAfterMs(res.headers.get("Retry-After"));
+  let env;
+  try {
+    env = await res.clone().json();
+  } catch {
+    env = void 0;
+  }
+  const requiredTier = env?.required_tier && 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}.`,
+    httpStatus: res.status,
+    retryHint: toRetryHint(env?.retry_hint),
+    userFixable: env?.user_fixable ?? false,
+    retryLikelyToSucceed: env?.retry_likely_to_succeed ?? false,
+    ...requiredTier !== void 0 ? { requiredTier } : {},
+    ...retryAfterMs !== void 0 ? { retryAfterMs } : {}
+  });
+}
+function retryDelay(err, attempt, jitter) {
+  if (err.retryAfterMs !== void 0) return err.retryAfterMs;
+  if (err.retryHint?.kind === "delay" && err.retryHint.delayMs !== void 0) {
+    return err.retryHint.delayMs;
+  }
+  return backoffDelay(attempt, jitter);
+}
+function buildInit(method, opts, signal) {
+  const headers = {
+    authorization: `Bearer ${opts.apiKey}`
+  };
+  const init = { method, headers, signal };
+  if (method === "GET" || method === "HEAD" || opts.body === void 0) {
+    return init;
+  }
+  if (opts.body instanceof FormData) {
+    init.body = opts.body;
+    return init;
+  }
+  headers["content-type"] = "application/json";
+  init.body = JSON.stringify(opts.body);
+  return init;
+}
+function buildUrl(path, opts) {
+  const url = new URL(path, opts.baseUrl);
+  if (opts.query) {
+    for (const [key, value] of Object.entries(opts.query)) {
+      if (value !== void 0 && value !== null) url.searchParams.set(key, String(value));
+    }
+  }
+  return url.toString();
+}
+async function parseSuccess(res) {
+  const ct = res.headers.get("content-type") ?? "";
+  if (ct.includes("application/json")) {
+    return await res.json();
+  }
+  return await res.arrayBuffer();
+}
+async function execute(method, path, opts) {
+  const doFetch = opts.fetch ?? globalThis.fetch;
+  const sleep = opts._sleepFn ?? defaultSleep;
+  const jitterFn = opts._jitterFn ?? (() => Math.random() * 200);
+  const url = buildUrl(path, opts);
+  const isWrite = WRITE_METHODS.has(method);
+  let attempt = 0;
+  for (; ; ) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), opts.timeout);
+    let res;
+    try {
+      res = await doFetch(url, buildInit(method, opts, controller.signal));
+    } catch (cause) {
+      clearTimeout(timer);
+      const aborted = controller.signal.aborted;
+      const err2 = new CurviateError({
+        code: "INTERNAL",
+        message: aborted ? "Request timed out." : "Network error.",
+        userFixable: false,
+        retryLikelyToSucceed: true
+      });
+      if (!isWrite && attempt < opts.maxRetries) {
+        await sleep(backoffDelay(attempt + 1, jitterFn()));
+        attempt += 1;
+        continue;
+      }
+      throw err2;
+    }
+    clearTimeout(timer);
+    if (res.ok) {
+      return parseSuccess(res);
+    }
+    const err = await errorFromResponse(res);
+    const retryable = !isWrite && RETRYABLE_CODES.has(err.code) && attempt < opts.maxRetries;
+    if (retryable) {
+      await sleep(retryDelay(err, attempt + 1, jitterFn()));
+      attempt += 1;
+      continue;
+    }
+    if (isWrite && err.retryAfterMs !== void 0) {
+      await sleep(err.retryAfterMs);
+    }
+    throw err;
+  }
+}
+
+// src/internal/context.ts
+function createContext(config, accountId) {
+  const request = (args) => {
+    const query = accountId !== void 0 ? { account_id: accountId, ...args.query } : args.query;
+    return execute(args.method, args.path, {
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl,
+      timeout: config.timeout,
+      maxRetries: config.maxRetries,
+      ...config.fetch ? { fetch: config.fetch } : {},
+      ...query !== void 0 ? { query } : {},
+      ...args.body !== void 0 ? { body: args.body } : {}
+    });
+  };
+  return { request, accountId };
+}
+
+// src/internal/paginate.ts
+async function* paginate(fn, params) {
+  let cursor = void 0;
+  for (; ; ) {
+    const callParams = cursor != null ? { ...params, cursor } : { ...params };
+    const page = await fn(callParams);
+    const items = page.items ?? page.data ?? [];
+    for (const item of items) {
+      yield item;
+    }
+    cursor = page.cursor;
+    if (cursor == null) break;
+  }
+}
+
+// src/resources/accounts.ts
+var AccountsResource = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  /**
+   * List the tenant's connected LinkedIn accounts, cursor-paginated.
+   *
+   * @param params - optional `limit` (1–250) and `cursor` (from a prior page).
+   * @returns a page of accounts and the next-page `cursor` (null when exhausted).
+   *
+   * @example
+   * const page = await curviate.accounts.list({ limit: 50 });
+   * for (const acc of page.items ?? []) console.log(acc.account_id);
+   */
+  list(params) {
+    return this.ctx.request({
+      method: "GET",
+      path: "/v1/accounts",
+      ...params !== void 0 ? { query: params } : {}
+    });
+  }
+  /**
+   * 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`.
+   */
+  link(body) {
+    return this.ctx.request({
+      method: "POST",
+      path: "/v1/accounts/link",
+      body
+    });
+  }
+  /**
+   * Submit an OTP or 2FA code to resolve a checkpoint challenge.
+   */
+  submitCheckpoint(body) {
+    return this.ctx.request({
+      method: "POST",
+      path: "/v1/accounts/checkpoints/submit",
+      body
+    });
+  }
+  /**
+   * Poll for mobile-app approval of a pending checkpoint challenge.
+   */
+  pollCheckpoint(body) {
+    return this.ctx.request({
+      method: "POST",
+      path: "/v1/accounts/checkpoints/poll",
+      body
+    });
+  }
+  /**
+   * Generate a one-time hosted connection link the end user opens to authorize a
+   * LinkedIn connection without credentials transiting the API or LLM context.
+   */
+  createConnectLink(body) {
+    return this.ctx.request({
+      method: "POST",
+      path: "/v1/accounts/connect-link",
+      body
+    });
+  }
+  /**
+   * Return metadata and current state for one connected account, including the
+   * central `quotas[]` view for all tracked quota families.
+   */
+  get(accountId) {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/accounts/${accountId}`
+    });
+  }
+  /**
+   * Re-authorize a disconnected account in place (same account_id, same seat).
+   */
+  reconnect(accountId, body) {
+    return this.ctx.request({
+      method: "POST",
+      path: `/v1/accounts/${accountId}/reconnect`,
+      body
+    });
+  }
+  /**
+   * 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(accountId, body) {
+    return this.ctx.request({
+      method: "PATCH",
+      path: `/v1/accounts/${accountId}`,
+      body
+    });
+  }
+  /**
+   * Hard-disconnect a LinkedIn account; releases the attached seat.
+   */
+  disconnect(accountId) {
+    return this.ctx.request({
+      method: "DELETE",
+      path: `/v1/accounts/${accountId}`
+    });
+  }
+};
+
+// 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` */
+  listChats(params) {
+    return this.ctx.request({
+      method: "GET",
+      path: "/v1/chats",
+      ...params ? { query: params } : {}
+    });
+  }
+  /**
+   * Start a new chat. Accepts optional `attachments[]` — when present, the
+   * request is sent as `multipart/form-data`. `POST /v1/chats`
+   */
+  startChat(body) {
+    const { attachments, ...scalars } = body;
+    if (attachments && attachments.length > 0) {
+      return this.ctx.request({
+        method: "POST",
+        path: "/v1/chats",
+        body: buildFormData(scalars, attachments)
+      });
+    }
+    return this.ctx.request({
+      method: "POST",
+      path: "/v1/chats",
+      body: scalars
+    });
+  }
+  /** Get details of a single chat. `GET /v1/chats/{chat_id}` */
+  getChat(chatId) {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/chats/${chatId}`
+    });
+  }
+  /** List messages in a chat, cursor-paginated. `GET /v1/chats/{chat_id}/messages` */
+  listMessages(chatId, params) {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/chats/${chatId}/messages`,
+      ...params ? { query: params } : {}
+    });
+  }
+  /**
+   * Send a message in a chat. Multipart when `attachments[]` are provided.
+   * `POST /v1/chats/{chat_id}/messages`
+   */
+  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)
+      });
+    }
+    return this.ctx.request({
+      method: "POST",
+      path: `/v1/chats/${chatId}/messages`,
+      body: scalars
+    });
+  }
+  /** 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`
+    });
+  }
+  /** Get a single message by ID. `GET /v1/messages/{message_id}` */
+  getMessage(messageId) {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/messages/${messageId}`
+    });
+  }
+  /** Edit a message within the ~60-minute edit window. `PATCH /v1/messages/{message_id}` */
+  editMessage(messageId, body) {
+    return this.ctx.request({
+      method: "PATCH",
+      path: `/v1/messages/${messageId}`,
+      body
+    });
+  }
+  /** Delete a message within the delete window. `DELETE /v1/messages/{message_id}` */
+  deleteMessage(messageId) {
+    return this.ctx.request({
+      method: "DELETE",
+      path: `/v1/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.
+   */
+  getAttachment(messageId, attachmentId) {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/messages/${messageId}/attachments/${attachmentId}`
+    });
+  }
+  /** Add a reaction to a message. `POST /v1/messages/{message_id}/reactions` */
+  addReaction(messageId, body) {
+    return this.ctx.request({
+      method: "POST",
+      path: `/v1/messages/${messageId}/reactions`,
+      body
+    });
+  }
+  /** Send an InMail. `POST /v1/messages/inmail` */
+  sendInMail(body) {
+    return this.ctx.request({
+      method: "POST",
+      path: "/v1/messages/inmail",
+      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 } : {}
+    });
+  }
+  /** Re-sync account message history. `GET /v1/messages/sync` */
+  syncMessages(params) {
+    return this.ctx.request({
+      method: "GET",
+      path: "/v1/messages/sync",
+      ...params ? { query: params } : {}
+    });
+  }
+};
+
+// src/resources/profiles.ts
+var ProfilesResource = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  /** Get the account's own LinkedIn profile. `GET /v1/profiles/me` */
+  getMe() {
+    return this.ctx.request({
+      method: "GET",
+      path: "/v1/profiles/me"
+    });
+  }
+  /**
+   * 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.
+   */
+  get(profileId, params) {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/profiles/${profileId}`,
+      ...params ? { query: params } : {}
+    });
+  }
+  /** List the account's 1st-degree connections. `GET /v1/profiles/relations` */
+  listConnections(params) {
+    return this.ctx.request({
+      method: "GET",
+      path: "/v1/profiles/relations",
+      ...params ? { query: params } : {}
+    });
+  }
+  /** List a profile's followers. `GET /v1/profiles/{profile_id}/followers` */
+  listFollowers(profileId, params) {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/profiles/${profileId}/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) {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/profiles/${profileId}/posts`,
+      ...params ? { query: params } : {}
+    });
+  }
+  /** List a profile's comments. `GET /v1/profiles/{profile_id}/comments` */
+  listComments(profileId, params) {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/profiles/${profileId}/comments`,
+      ...params ? { query: params } : {}
+    });
+  }
+  /** List a profile's reactions. `GET /v1/profiles/{profile_id}/reactions` */
+  listReactions(profileId, params) {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/profiles/${profileId}/reactions`,
+      ...params ? { query: params } : {}
+    });
+  }
+  /** Get a company profile. `GET /v1/profiles/companies/{company_id}` */
+  getCompany(companyId) {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/profiles/companies/${companyId}`
+    });
+  }
+  /** Endorse a skill on a profile. `POST /v1/profiles/{profile_id}/endorse` */
+  endorse(profileId, body) {
+    return this.ctx.request({
+      method: "POST",
+      path: `/v1/profiles/${profileId}/endorse`,
+      body
+    });
+  }
+};
+
+// src/resources/invites.ts
+var InvitesResource = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  /** Send a connection invitation. `POST /v1/invites` */
+  send(body) {
+    return this.ctx.request({
+      method: "POST",
+      path: "/v1/invites",
+      body
+    });
+  }
+  /** List sent invitations. `GET /v1/invites/sent` */
+  listSent(params) {
+    return this.ctx.request({
+      method: "GET",
+      path: "/v1/invites/sent",
+      ...params ? { query: params } : {}
+    });
+  }
+  /** List received invitations. `GET /v1/invites/received` */
+  listReceived(params) {
+    return this.ctx.request({
+      method: "GET",
+      path: "/v1/invites/received",
+      ...params ? { query: params } : {}
+    });
+  }
+  /**
+   * Accept or decline a received invitation.
+   * `POST /v1/invites/received/{invitation_id}`
+   */
+  respond(invitationId, body) {
+    return this.ctx.request({
+      method: "POST",
+      path: `/v1/invites/received/${invitationId}`,
+      body
+    });
+  }
+  /** Cancel a sent invitation. `DELETE /v1/invites/{invitation_id}` */
+  cancel(invitationId) {
+    return this.ctx.request({
+      method: "DELETE",
+      path: `/v1/invites/${invitationId}`
+    });
+  }
+};
+
+// src/resources/search.ts
+var SearchResource = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  /**
+   * Resolve human-readable terms to opaque filter IDs for structured search.
+   * `GET /v1/search/parameters`
+   */
+  getParameters(query) {
+    return this.ctx.request({
+      method: "GET",
+      path: "/v1/search/parameters",
+      query
+    });
+  }
+  /**
+   * Search LinkedIn people with structured filters or a pasted URL.
+   * `POST /v1/search/people`
+   * Cursor passed via query param (not body) — matches the OpenAPI spec.
+   */
+  people(body) {
+    const { cursor, limit, ...rest } = 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 } : {} } } : {}
+    });
+  }
+  /**
+   * Search LinkedIn companies.
+   * `POST /v1/search/companies`
+   */
+  companies(body) {
+    const { cursor, limit, ...rest } = 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 } : {} } } : {}
+    });
+  }
+  /**
+   * Search LinkedIn posts.
+   * `POST /v1/search/posts`
+   */
+  posts(body) {
+    const { cursor, limit, ...rest } = 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 } : {} } } : {}
+    });
+  }
+  /**
+   * Search LinkedIn jobs.
+   * `POST /v1/search/jobs`
+   */
+  jobs(body) {
+    const { cursor, limit, ...rest } = body;
+    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 } : {} } } : {}
+    });
+  }
+};
+
+// 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) {
+    return this.ctx.request({
+      method: "GET",
+      path: "/v1/posts",
+      ...params ? { query: params } : {}
+    });
+  }
+  /**
+   * Create a new post. Always sent as multipart/form-data (the API only accepts
+   * multipart for this endpoint). `POST /v1/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
+    });
+  }
+  /** Get a single post. `GET /v1/posts/{post_id}` */
+  get(postId) {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/posts/${postId}`
+    });
+  }
+  /** List comments on a post. `GET /v1/posts/{post_id}/comments` */
+  listComments(postId, params) {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/posts/${postId}/comments`,
+      ...params ? { query: params } : {}
+    });
+  }
+  /**
+   * Comment on a post. Always sent as multipart/form-data. `POST /v1/posts/{post_id}/comments`
+   */
+  comment(postId, body) {
+    const { attachments, ...scalars } = body;
+    return this.ctx.request({
+      method: "POST",
+      path: `/v1/posts/${postId}/comments`,
+      body: buildFormData2(scalars, attachments)
+    });
+  }
+  /** List reactions on a post. `GET /v1/posts/{post_id}/reactions` */
+  listReactions(postId, params) {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/posts/${postId}/reactions`,
+      ...params ? { query: params } : {}
+    });
+  }
+  /** React to a post. `POST /v1/posts/{post_id}/reactions` */
+  react(postId, body) {
+    return this.ctx.request({
+      method: "POST",
+      path: `/v1/posts/${postId}/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));
+      }
+    }
+  }
+  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 SalesNavigatorResource = 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.
+   */
+  searchPeople(body, params) {
+    return this.ctx.request({
+      method: "POST",
+      path: "/v1/sales-navigator/search/people",
+      body,
+      ...params ? { query: params } : {}
+    });
+  }
+  /**
+   * Search LinkedIn companies using the full Sales Navigator company filter set.
+   * `POST /v1/sales-navigator/search/companies`
+   */
+  searchCompanies(body, params) {
+    return this.ctx.request({
+      method: "POST",
+      path: "/v1/sales-navigator/search/companies",
+      body,
+      ...params ? { query: params } : {}
+    });
+  }
+  /**
+   * Resolve human-readable terms to opaque Sales Navigator filter IDs.
+   * `GET /v1/sales-navigator/search/parameters`
+   */
+  getParameters(params) {
+    return this.ctx.request({
+      method: "GET",
+      path: "/v1/sales-navigator/search/parameters",
+      query: params
+    });
+  }
+  /**
+   * 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`
+   */
+  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
+        )
+      });
+    }
+    return this.ctx.request({
+      method: "POST",
+      path: "/v1/sales-navigator/chats",
+      body: scalars
+    });
+  }
+  /**
+   * Retrieve a LinkedIn profile with Sales Navigator enrichment.
+   * `GET /v1/sales-navigator/profiles/{identifier}`
+   */
+  getProfile(identifier, params) {
+    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 } : {}
+    });
+  }
+  /**
+   * Save a Sales Navigator member as a lead. `POST /v1/sales-navigator/leads/{user_id}`
+   */
+  saveLead(userId, body) {
+    return this.ctx.request({
+      method: "POST",
+      path: `/v1/sales-navigator/leads/${userId}`,
+      body
+    });
+  }
+  /**
+   * Trigger a re-sync of the account's Sales Navigator message history.
+   * `GET /v1/sales-navigator/messages/sync`
+   */
+  syncMessages(params) {
+    return this.ctx.request({
+      method: "GET",
+      path: "/v1/sales-navigator/messages/sync",
+      query: params
+    });
+  }
+};
+
+// 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`
+   */
+  syncMessages(params) {
+    return this.ctx.request({
+      method: "GET",
+      path: "/v1/recruiter/messages/sync",
+      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`
+   */
+  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
+        )
+      });
+    }
+    return this.ctx.request({
+      method: "POST",
+      path: "/v1/recruiter/chats",
+      body: scalars
+    });
+  }
+  /**
+   * Retrieve a LinkedIn profile with Recruiter enrichment.
+   * `GET /v1/recruiter/profiles/{identifier}`
+   */
+  getProfile(identifier, 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
+      ...params ? { query: params } : {}
+    });
+  }
+  /**
+   * Search LinkedIn members using Recruiter filters.
+   * `POST /v1/recruiter/search/people`
+   */
+  searchPeople(body, params) {
+    return this.ctx.request({
+      method: "POST",
+      path: "/v1/recruiter/search/people",
+      body,
+      ...params ? { query: params } : {}
+    });
+  }
+  /**
+   * Resolve human-readable terms to opaque Recruiter filter IDs.
+   * `GET /v1/recruiter/search/parameters`
+   */
+  getParameters(params) {
+    return this.ctx.request({
+      method: "GET",
+      path: "/v1/recruiter/search/parameters",
+      query: params
+    });
+  }
+  /**
+   * List Recruiter hiring projects. `GET /v1/recruiter/projects`
+   */
+  listProjects(params) {
+    return this.ctx.request({
+      method: "GET",
+      path: "/v1/recruiter/projects",
+      ...params ? { query: params } : {}
+    });
+  }
+  /**
+   * Get a single Recruiter hiring project. `GET /v1/recruiter/projects/{project_id}`
+   */
+  getProject(projectId) {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/recruiter/projects/${projectId}`
+    });
+  }
+  /**
+   * Add a member to a hiring project pipeline as a candidate.
+   * `POST /v1/recruiter/projects/candidates/{user_id}`
+   */
+  addCandidate(userId, body) {
+    return this.ctx.request({
+      method: "POST",
+      path: `/v1/recruiter/projects/candidates/${userId}`,
+      body
+    });
+  }
+  /**
+   * Add a member to a hiring project pipeline as an applicant.
+   * `POST /v1/recruiter/projects/applicants/{user_id}`
+   */
+  addApplicant(userId, body) {
+    return this.ctx.request({
+      method: "POST",
+      path: `/v1/recruiter/projects/applicants/${userId}`,
+      body
+    });
+  }
+  /**
+   * Reject an applicant from a hiring project.
+   * `POST /v1/recruiter/projects/applicants/{user_id}/reject`
+   */
+  rejectApplicant(userId, body) {
+    return this.ctx.request({
+      method: "POST",
+      path: `/v1/recruiter/projects/applicants/${userId}/reject`,
+      body
+    });
+  }
+  /**
+   * List Recruiter job postings. `GET /v1/recruiter/jobs`
+   */
+  listJobs(params) {
+    return this.ctx.request({
+      method: "GET",
+      path: "/v1/recruiter/jobs",
+      ...params ? { query: params } : {}
+    });
+  }
+  /**
+   * Create a Recruiter job posting draft. `POST /v1/recruiter/jobs`
+   */
+  createJob(body) {
+    return this.ctx.request({
+      method: "POST",
+      path: "/v1/recruiter/jobs",
+      body
+    });
+  }
+  /**
+   * Publish a Recruiter job posting draft.
+   * `POST /v1/recruiter/jobs/{job_id}/publish`
+   */
+  publishJob(jobId, body) {
+    return this.ctx.request({
+      method: "POST",
+      path: `/v1/recruiter/jobs/${jobId}/publish`,
+      body
+    });
+  }
+  /**
+   * Solve a publish verification checkpoint.
+   * `POST /v1/recruiter/jobs/{job_id}/checkpoint`
+   */
+  solveJobCheckpoint(jobId, body) {
+    return this.ctx.request({
+      method: "POST",
+      path: `/v1/recruiter/jobs/${jobId}/checkpoint`,
+      body
+    });
+  }
+  /**
+   * List applicants for a job posting.
+   * `GET /v1/recruiter/jobs/{job_id}/applicants`
+   */
+  listApplicants(jobId, params) {
+    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
+      ...params ? { query: params } : {}
+    });
+  }
+  /**
+   * Get one job applicant. `GET /v1/recruiter/jobs/applicants/{applicant_id}`
+   */
+  getApplicant(applicantId) {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/recruiter/jobs/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.
+   */
+  downloadResume(applicantId) {
+    return this.ctx.request({
+      method: "GET",
+      path: `/v1/recruiter/jobs/applicants/${applicantId}/resume`
+    });
+  }
+};
+
+// src/resources/webhooks.ts
+var WebhooksResource = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  /**
+   * Register a new webhook endpoint to receive real-time events.
+   * `POST /v1/webhooks`
+   * The HMAC signing secret is returned exactly once in the 201 response.
+   * `account_ids` is required (each webhook is scoped to specific accounts).
+   */
+  create(body) {
+    return this.ctx.request({
+      method: "POST",
+      path: "/v1/webhooks",
+      body
+    });
+  }
+  /**
+   * List the tenant's registered webhooks, cursor-paginated.
+   * `GET /v1/webhooks`
+   */
+  list(params) {
+    return this.ctx.request({
+      method: "GET",
+      path: "/v1/webhooks",
+      ...params ? { query: params } : {}
+    });
+  }
+  /**
+   * Return the complete canonical webhook event catalogue (21 events, grouped by source).
+   * `GET /v1/webhooks/events`
+   */
+  listEvents() {
+    return this.ctx.request({
+      method: "GET",
+      path: "/v1/webhooks/events"
+    });
+  }
+  /**
+   * Update a webhook in place. `source` is immutable.
+   * `PATCH /v1/webhooks/{id}`
+   */
+  update(id, body) {
+    return this.ctx.request({
+      method: "PATCH",
+      path: `/v1/webhooks/${id}`,
+      body
+    });
+  }
+  /**
+   * Permanently remove a webhook subscription.
+   * `DELETE /v1/webhooks/{id}`
+   */
+  delete(id) {
+    return this.ctx.request({
+      method: "DELETE",
+      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),
+    messaging: new MessagingResource(ctx),
+    profiles: new ProfilesResource(ctx),
+    invites: new InvitesResource(ctx),
+    search: new SearchResource(ctx),
+    posts: new PostsResource(ctx),
+    salesNavigator: new SalesNavigatorResource(ctx),
+    recruiter: new RecruiterResource(ctx),
+    webhooks: new WebhooksResource(ctx)
+  };
+}
+function buildAccountScopedNamespaces(ctx) {
+  const { accounts: _accounts, ...rest } = buildNamespaces(ctx);
+  void _accounts;
+  return rest;
+}
+
+// src/client.ts
+var Curviate = class {
+  constructor(config) {
+    this.config = resolveConfig(config);
+    const ctx = createContext(this.config);
+    const ns = buildNamespaces(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.webhooks = ns.webhooks;
+  }
+  /**
+   * Return an account-scoped accessor that fixes `account_id` on every call,
+   * so callers need not repeat it per method.
+   *
+   * @param accountId - a Curviate account id (`acc_…`). Empty throws
+   *   `CurviateError({ code: 'INVALID_REQUEST' })` synchronously, no network call.
+   *
+   * @example
+   * await curviate.account("acc_123").messaging.listChats();
+   */
+  account(accountId) {
+    if (typeof accountId !== "string" || accountId.length === 0) {
+      throw new CurviateError({
+        code: "INVALID_REQUEST",
+        message: "account(accountId) requires a non-empty account id.",
+        userFixable: true,
+        retryLikelyToSucceed: false
+      });
+    }
+    const ctx = createContext(this.config, accountId);
+    return buildAccountScopedNamespaces(ctx);
+  }
+  /**
+   * Transparent cursor-pagination iterator.
+   *
+   * 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 params - the initial params (minus cursor)
+   *
+   * @example
+   * for await (const profile of curviate.paginate(
+   *   curviate.account('acc_123').profiles.listConnections,
+   *   { limit: 50 }
+   * )) {
+   *   console.log(profile);
+   * }
+   */
+  paginate(fn, params) {
+    return paginate(fn, params);
+  }
+};
+
+// src/webhooks.ts
+var WebhookSignatureError = class _WebhookSignatureError extends Error {
+  constructor(reason, message) {
+    super(message);
+    this.name = "WebhookSignatureError";
+    this.reason = reason;
+    Object.setPrototypeOf(this, _WebhookSignatureError.prototype);
+  }
+};
+function parseHeader(header) {
+  const parts = header.split(",");
+  let tStr;
+  let v1;
+  for (const part of parts) {
+    const eq = part.indexOf("=");
+    if (eq === -1) continue;
+    const key = part.slice(0, eq).trim();
+    const val = part.slice(eq + 1).trim();
+    if (key === "t") tStr = val;
+    else if (key === "v1") v1 = val;
+  }
+  if (tStr === void 0 || v1 === void 0) {
+    throw new WebhookSignatureError(
+      "malformed_header",
+      'Webhook signature header must contain both "t=<timestamp>" and "v1=<hmac>".'
+    );
+  }
+  const timestamp = Number(tStr);
+  if (!Number.isFinite(timestamp) || isNaN(timestamp)) {
+    throw new WebhookSignatureError(
+      "malformed_header",
+      "Webhook signature header timestamp is not a valid number."
+    );
+  }
+  return { timestamp, v1 };
+}
+function hexToBytes(hex) {
+  if (hex.length % 2 !== 0) {
+    throw new WebhookSignatureError("malformed_header", "HMAC hex has odd length.");
+  }
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    const byte = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    if (isNaN(byte)) {
+      throw new WebhookSignatureError("malformed_header", "HMAC hex contains non-hex character.");
+    }
+    bytes[i] = byte;
+  }
+  return bytes;
+}
+function bytesToHex(bytes) {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function constantTimeEqual(a, b) {
+  const len = Math.max(a.length, b.length);
+  let diff = a.length ^ b.length;
+  for (let i = 0; i < len; i++) {
+    const ai = i < a.length ? a[i] : 0;
+    const bi = i < b.length ? b[i] : 0;
+    diff |= ai ^ bi;
+  }
+  return diff === 0;
+}
+async function hmacWebCrypto(secret, payload) {
+  const enc = new TextEncoder();
+  const keyMaterial = await globalThis.crypto.subtle.importKey(
+    "raw",
+    enc.encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const sig = await globalThis.crypto.subtle.sign("HMAC", keyMaterial, enc.encode(payload));
+  return bytesToHex(new Uint8Array(sig));
+}
+function verifyAndParse(computedHex, v1, timestamp, bodyStr, replayWindowSecs) {
+  let providedBytes;
+  try {
+    providedBytes = hexToBytes(v1);
+  } catch {
+    throw new WebhookSignatureError(
+      "invalid_signature",
+      "Webhook signature v1 value is not valid hex."
+    );
+  }
+  const computedBytes = hexToBytes(computedHex);
+  if (!constantTimeEqual(computedBytes, providedBytes)) {
+    throw new WebhookSignatureError(
+      "invalid_signature",
+      "Webhook signature does not match. Verify your signing secret."
+    );
+  }
+  const nowSecs = Date.now() / 1e3;
+  const ageSecs = Math.abs(nowSecs - timestamp);
+  if (ageSecs > replayWindowSecs) {
+    throw new WebhookSignatureError(
+      "replay_detected",
+      `Webhook event is outside the replay window (${Math.floor(ageSecs)}s ago/ahead, window is ${replayWindowSecs}s).`
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(bodyStr);
+  } catch {
+    throw new WebhookSignatureError("malformed_header", "Webhook body is not valid JSON.");
+  }
+  if (typeof parsed !== "object" || parsed === null || typeof parsed["type"] !== "string") {
+    throw new WebhookSignatureError("malformed_header", 'Webhook payload missing "type" field.');
+  }
+  return parsed;
+}
+async function constructEvent(rawBody, signatureHeader, secret, opts) {
+  const replayWindowSecs = opts?.replayWindowSecs ?? 300;
+  const { timestamp, v1 } = parseHeader(signatureHeader);
+  const bodyStr = typeof rawBody === "string" ? rawBody : rawBody.toString("utf8");
+  const hmacPayload = `${timestamp}.${bodyStr}`;
+  const computedHex = await hmacWebCrypto(secret, hmacPayload);
+  return verifyAndParse(computedHex, v1, timestamp, bodyStr, replayWindowSecs);
+}
+export {
+  Curviate,
+  CurviateError,
+  WebhookSignatureError,
+  constructEvent,
+  isCurviateError
+};