@superartifacts/sdk 0.0.0-stage → 0.1.1

package/dist/index.cjs

@@ -0,0 +1,788 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AuthenticationError: () => AuthenticationError,
+  ConflictError: () => ConflictError,
+  ConnectionError: () => ConnectionError,
+  InternalError: () => InternalError,
+  InvalidArgumentsError: () => InvalidArgumentsError,
+  NotFoundError: () => NotFoundError,
+  OPERATIONS: () => OPERATIONS,
+  PayloadTooLargeError: () => PayloadTooLargeError,
+  PermissionError: () => PermissionError,
+  PlanLimitError: () => PlanLimitError,
+  RateLimitError: () => RateLimitError,
+  ScopeRequiredError: () => ScopeRequiredError,
+  SuperArtifacts: () => SuperArtifacts,
+  SuperArtifactsError: () => SuperArtifactsError,
+  TimeoutError: () => TimeoutError,
+  VERSION: () => VERSION,
+  default: () => SuperArtifacts,
+  errorFor: () => errorFor
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var SuperArtifactsError = class extends Error {
+  status;
+  /** Stable and machine-readable; `message` is for a person. */
+  code;
+  /** Seconds the API asked to wait. */
+  retryAfter;
+  /** Everything else the API said, e.g. `fix` or `approvalUrl`. */
+  details;
+  constructor(status, code, message, retryAfter, details = {}, options) {
+    super(message, options);
+    this.name = new.target.name;
+    if (status !== void 0) this.status = status;
+    if (code !== void 0) this.code = code;
+    if (retryAfter !== void 0) this.retryAfter = retryAfter;
+    this.details = details;
+  }
+};
+var InvalidArgumentsError = class extends SuperArtifactsError {
+};
+var AuthenticationError = class extends SuperArtifactsError {
+};
+var PlanLimitError = class extends SuperArtifactsError {
+};
+var PermissionError = class extends SuperArtifactsError {
+};
+var ScopeRequiredError = class extends SuperArtifactsError {
+};
+var NotFoundError = class extends SuperArtifactsError {
+};
+var ConflictError = class extends SuperArtifactsError {
+};
+var PayloadTooLargeError = class extends SuperArtifactsError {
+};
+var RateLimitError = class extends SuperArtifactsError {
+};
+var InternalError = class extends SuperArtifactsError {
+};
+var ConnectionError = class extends SuperArtifactsError {
+};
+var TimeoutError = class extends SuperArtifactsError {
+};
+function errorClass(status, code) {
+  if (status >= 500) return InternalError;
+  if (status === 403) return code === "scope_required" ? ScopeRequiredError : PermissionError;
+  const byStatus = {
+    400: InvalidArgumentsError,
+    401: AuthenticationError,
+    402: PlanLimitError,
+    404: NotFoundError,
+    409: ConflictError,
+    413: PayloadTooLargeError,
+    422: InvalidArgumentsError,
+    429: RateLimitError
+  };
+  return byStatus[status] ?? SuperArtifactsError;
+}
+function errorFor(status, text, retryAfterHeader) {
+  let error = {};
+  try {
+    const parsed = JSON.parse(text);
+    if (typeof parsed?.error === "object" && parsed.error !== null) {
+      error = parsed.error;
+    }
+  } catch {
+  }
+  const { code, message, retryAfterSeconds, ...details } = error;
+  const named = typeof code === "string" ? code : "http_error";
+  const seconds = Number(retryAfterHeader ?? retryAfterSeconds);
+  const retryAfter = (retryAfterHeader !== null || retryAfterSeconds !== void 0) && Number.isFinite(seconds) ? seconds : void 0;
+  return new (errorClass(status, named))(
+    status,
+    named,
+    typeof message === "string" ? message : `The API answered ${status} without an error body.`,
+    retryAfter,
+    details
+  );
+}
+
+// src/core.ts
+var VERSION = "0.1.1";
+var DEFAULT_BASE_URL = "https://superartifacts.app";
+var API_KEY_ENV = "SUPERARTIFACTS_API_KEY";
+var MAX_RETRY_AFTER_SECONDS = 60;
+var BACKOFF_BASE_MS = 500;
+var BACKOFF_MAX_MS = 8e3;
+var sleep = (ms, signal) => new Promise((resolve, reject) => {
+  const timer = setTimeout(resolve, ms);
+  signal?.addEventListener(
+    "abort",
+    () => {
+      clearTimeout(timer);
+      reject(signal.reason);
+    },
+    { once: true }
+  );
+});
+var backoff = (attempt) => {
+  const ceiling = Math.min(BACKOFF_MAX_MS, BACKOFF_BASE_MS * 2 ** attempt);
+  return ceiling / 2 + Math.random() * (ceiling / 2);
+};
+function isBrowser() {
+  const scope = globalThis;
+  return scope.window !== void 0 && scope.document !== void 0;
+}
+var Core = class {
+  #apiKey;
+  #baseUrl;
+  #timeout;
+  #maxRetries;
+  #fetch;
+  constructor(options = {}) {
+    if (isBrowser() && options.dangerouslyAllowBrowser !== true) {
+      throw new Error(
+        "The Super Artifacts API refuses requests from a browser, and a key on a page is a leaked key. Call it from your server. Behind your own proxy, pass dangerouslyAllowBrowser: true."
+      );
+    }
+    const apiKey = options.apiKey ?? globalThis.process?.env?.[API_KEY_ENV];
+    if (!apiKey) {
+      throw new AuthenticationError(
+        void 0,
+        void 0,
+        `No API key. Pass { apiKey } or set ${API_KEY_ENV}. Create one at https://superartifacts.app/settings/api-keys.`
+      );
+    }
+    this.#apiKey = apiKey;
+    this.#baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.#timeout = options.timeout ?? 6e4;
+    this.#maxRetries = options.maxRetries ?? 2;
+    this.#fetch = options.fetch ?? globalThis.fetch;
+  }
+  /** Call one operation with its fields in one object. The generated resources all land here. */
+  call(operation, params = {}, options = {}) {
+    const { method } = operation;
+    const rest = new Map(Object.entries(params).filter(([, value]) => value !== void 0));
+    const take = (name) => {
+      const value = rest.get(name);
+      rest.delete(name);
+      return value;
+    };
+    const pathNames = [];
+    const path = operation.path.replace(/\{(\w+)\}/g, (_, name) => {
+      const value = take(name);
+      if (value === null || value === void 0 || value === "") {
+        throw new TypeError(`${method} ${operation.path} needs ${name}.`);
+      }
+      pathNames.push(name);
+      return encodeURIComponent(String(value));
+    });
+    const url = new URL(`${this.#baseUrl}${path}`);
+    for (const name of operation.query) {
+      for (const value of [take(name)].flat()) {
+        if (value !== void 0) url.searchParams.append(name, String(value));
+      }
+    }
+    if (operation.confirm !== void 0) {
+      take("confirm");
+      url.searchParams.set("confirm", String(params[operation.confirm]));
+    }
+    const bodied = method !== "GET" && method !== "DELETE";
+    if (!bodied) for (const [name, value] of rest) url.searchParams.append(name, String(value));
+    const body = bodied && rest.size > 0 ? JSON.stringify(Object.fromEntries(rest)) : void 0;
+    const key = method === "POST" ? options.idempotencyKey ?? crypto.randomUUID() : options.idempotencyKey;
+    const headers = {
+      Authorization: `Bearer ${this.#apiKey}`,
+      "Content-Type": "application/json",
+      ...typeof key === "string" ? { "Idempotency-Key": key } : {},
+      ...options.headers
+    };
+    const repeatable = method === "GET" || method === "DELETE" || method === "POST" && !!key;
+    return this.send(url, { method, headers, ...body ? { body } : {} }, repeatable, options);
+  }
+  /**
+   * PUT staged bytes, one file at a time. The URL is the credential, so no key goes with
+   * it, and it takes the same bytes twice, so it is always safe to repeat.
+   */
+  async putFiles(targets, files, options) {
+    for (const [index, { url }] of targets.entries()) {
+      await this.send(url, { method: "PUT", body: files[index] ?? null }, true, options);
+    }
+  }
+  /** One request with the retry rules. A 429 ran nothing, so it repeats whatever `repeatable` says. */
+  async send(url, init, repeatable, options = {}) {
+    const headers = { "User-Agent": `superartifacts-typescript/${VERSION}`, ...init.headers };
+    for (let attempt = 0; ; attempt++) {
+      const left = attempt < this.#maxRetries;
+      let failure;
+      let delay = backoff(attempt);
+      let retry = left && repeatable;
+      try {
+        const timeout = AbortSignal.timeout(options.timeout ?? this.#timeout);
+        const signal = options.signal ? AbortSignal.any([timeout, options.signal]) : timeout;
+        const response = await this.#fetch(url, { ...init, headers, signal });
+        const text = await response.text();
+        if (response.ok) return parseAnswer(text, response.status);
+        failure = errorFor(response.status, text, response.headers.get("retry-after"));
+        const { status } = response;
+        const { retryAfter } = failure;
+        if (status === 429 || retry && [502, 503, 504].includes(status)) {
+          if (retryAfter !== void 0) delay = retryAfter * 1e3;
+          retry = left && (retryAfter ?? 0) <= MAX_RETRY_AFTER_SECONDS;
+        } else {
+          retry = false;
+        }
+      } catch (cause) {
+        if (options.signal?.aborted) throw options.signal.reason;
+        if (cause instanceof SuperArtifactsError) throw cause;
+        const timedOut = cause?.name === "TimeoutError";
+        const message = timedOut ? "The request timed out." : `Could not reach the API: ${cause?.message ?? "unknown error"}`;
+        const ErrorClass = timedOut ? TimeoutError : ConnectionError;
+        const code = timedOut ? "timeout" : "connection_error";
+        failure = new ErrorClass(0, code, message, void 0, {}, { cause });
+      }
+      if (!retry) throw failure;
+      await sleep(delay, options.signal);
+    }
+  }
+};
+function parseAnswer(text, status) {
+  if (text === "") return {};
+  try {
+    return JSON.parse(text);
+  } catch (cause) {
+    throw new SuperArtifactsError(
+      status,
+      "invalid_response",
+      "The API answered with something that is not JSON.",
+      void 0,
+      {},
+      { cause }
+    );
+  }
+}
+
+// src/generated/resources.ts
+var OPERATIONS = {
+  whoami: { method: "GET", path: "/v1/whoami", query: [] },
+  getHelp: { method: "GET", path: "/v1/help", query: ["topic"] },
+  listArtifacts: { method: "GET", path: "/v1/artifacts", query: [] },
+  publishArtifact: { method: "POST", path: "/v1/artifacts", query: [] },
+  getArtifact: { method: "GET", path: "/v1/artifacts/{artifact}", query: [] },
+  updateArtifact: { method: "PATCH", path: "/v1/artifacts/{artifact}", query: [] },
+  deleteArtifact: {
+    method: "DELETE",
+    path: "/v1/artifacts/{artifact}",
+    query: [],
+    confirm: "artifact"
+  },
+  readArtifactFile: {
+    method: "GET",
+    path: "/v1/artifacts/{artifact}/file",
+    query: ["path", "version"]
+  },
+  openArtifact: { method: "POST", path: "/v1/artifacts/{artifact}/open", query: [] },
+  serveVersion: {
+    method: "POST",
+    path: "/v1/artifacts/{artifact}/versions/{version}/serve",
+    query: []
+  },
+  startLiveRoom: { method: "POST", path: "/v1/artifacts/{artifact}/live", query: [] },
+  stopLiveRoom: { method: "DELETE", path: "/v1/artifacts/{artifact}/live", query: [] },
+  stageUploads: { method: "POST", path: "/v1/uploads", query: [] },
+  listArtifactRows: {
+    method: "GET",
+    path: "/v1/artifacts/{artifact}/data",
+    query: ["filter", "since", "until", "sort", "limit", "cursor", "fields"]
+  },
+  writeArtifactRows: { method: "POST", path: "/v1/artifacts/{artifact}/data/rows", query: [] },
+  listRows: {
+    method: "GET",
+    path: "/v1/data",
+    query: [
+      "dataset",
+      "collection",
+      "filter",
+      "since",
+      "until",
+      "sort",
+      "limit",
+      "cursor",
+      "fields"
+    ]
+  },
+  queryData: { method: "POST", path: "/v1/data/query", query: [] },
+  getSchema: {
+    method: "GET",
+    path: "/v1/schema",
+    query: ["series", "tags", "artifact", "compare", "since", "workspace"]
+  },
+  defineCollection: { method: "PUT", path: "/v1/schema", query: [] },
+  listEntries: {
+    method: "GET",
+    path: "/v1/collections/{collection}/entries",
+    query: ["workspace", "filter", "search", "sort", "direction", "page", "limit"]
+  },
+  createEntries: { method: "POST", path: "/v1/collections/{collection}/entries", query: [] },
+  useSecret: {
+    method: "POST",
+    path: "/v1/collections/{collection}/entries/{entry}/fields/{field}/use",
+    query: []
+  },
+  listTemplates: {
+    method: "GET",
+    path: "/v1/templates",
+    query: [
+      "request",
+      "scope",
+      "kind",
+      "sort",
+      "limit",
+      "jobs",
+      "audience",
+      "needs",
+      "cost",
+      "tier",
+      "mine"
+    ]
+  },
+  saveTemplate: { method: "POST", path: "/v1/templates", query: [] },
+  getTemplate: { method: "GET", path: "/v1/templates/{slug}", query: ["version"] },
+  getTemplateHistory: { method: "GET", path: "/v1/templates/{slug}/history", query: [] },
+  getTemplateFeedback: { method: "GET", path: "/v1/templates/{slug}/feedback", query: [] },
+  actOnTemplate: { method: "POST", path: "/v1/templates/{slug}/actions", query: [] },
+  releaseTemplate: { method: "POST", path: "/v1/templates/{slug}/release", query: [] },
+  listProjects: { method: "GET", path: "/v1/projects", query: ["workspace"] },
+  createProject: { method: "POST", path: "/v1/projects", query: [] },
+  getProject: { method: "GET", path: "/v1/projects/{project}", query: ["workspace"] },
+  updateProject: { method: "PATCH", path: "/v1/projects/{project}", query: [] },
+  deleteProject: {
+    method: "DELETE",
+    path: "/v1/projects/{project}",
+    query: [],
+    confirm: "project"
+  },
+  addProjectArtifacts: { method: "POST", path: "/v1/projects/{project}/artifacts", query: [] },
+  removeProjectArtifact: {
+    method: "DELETE",
+    path: "/v1/projects/{project}/artifacts/{remove}",
+    query: []
+  },
+  shareArtifact: { method: "POST", path: "/v1/artifacts/{artifact}/shares", query: [] },
+  shareProject: { method: "POST", path: "/v1/projects/{project}/shares", query: [] },
+  shareWorkspace: { method: "POST", path: "/v1/workspace/shares", query: [] },
+  listComments: {
+    method: "GET",
+    path: "/v1/artifacts/{artifact}/comments",
+    query: ["status", "page", "limit", "cursor"]
+  },
+  respondToComments: {
+    method: "POST",
+    path: "/v1/artifacts/{artifact}/comments/responses",
+    query: []
+  },
+  getCommentScreenshot: {
+    method: "GET",
+    path: "/v1/artifacts/{artifact}/comments/screenshots/{screenshot}",
+    query: []
+  },
+  listMentions: { method: "GET", path: "/v1/mentions", query: ["artifact", "limit", "cursor"] },
+  listSignatureRequests: { method: "GET", path: "/v1/signatures", query: ["artifact"] },
+  requestSignatures: { method: "POST", path: "/v1/signatures", query: [] },
+  getSignatureRequest: { method: "GET", path: "/v1/signatures/{request}", query: [] },
+  remindSigner: { method: "POST", path: "/v1/signatures/{request}/remind", query: [] },
+  withdrawSignatureRequest: {
+    method: "POST",
+    path: "/v1/signatures/{request}/withdraw",
+    query: []
+  }
+};
+var AccountResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** Who this key publishes as */
+  whoami(params, options) {
+    return this.client.call(OPERATIONS.whoami, params, options);
+  }
+  /** How the operations fit together */
+  help(params, options) {
+    return this.client.call(OPERATIONS.getHelp, params, options);
+  }
+};
+var ArtifactsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** List your artifacts, newest first */
+  list(params, options) {
+    return this.client.call(OPERATIONS.listArtifacts, params, options);
+  }
+  /** Publish an artifact, or a new version of one */
+  publish(params, options) {
+    return this.client.call(OPERATIONS.publishArtifact, params, options);
+  }
+  /** One artifact: its versions, published version and declaration */
+  get(params, options) {
+    return this.client.call(OPERATIONS.getArtifact, params, options);
+  }
+  /** Change visibility, gallery label, live phase or submission email */
+  update(params, options) {
+    return this.client.call(OPERATIONS.updateArtifact, params, options);
+  }
+  /** Delete an artifact with every version, permanently */
+  delete(params, options) {
+    return this.client.call(OPERATIONS.deleteArtifact, params, options);
+  }
+  /** Read one file of a version as text (default: the published index.html) */
+  readFile(params, options) {
+    return this.client.call(OPERATIONS.readArtifactFile, params, options);
+  }
+  /** A ten-minute viewer URL for an artifact, private included */
+  open(params, options) {
+    return this.client.call(OPERATIONS.openArtifact, params, options);
+  }
+  /** Serve an existing version again */
+  serveVersion(params, options) {
+    return this.client.call(OPERATIONS.serveVersion, params, options);
+  }
+};
+var LiveResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** Turn an artifact's live room on */
+  start(params, options) {
+    return this.client.call(OPERATIONS.startLiveRoom, params, options);
+  }
+  /** Turn an artifact's live room off, disconnecting every visitor */
+  stop(params, options) {
+    return this.client.call(OPERATIONS.stopLiveRoom, params, options);
+  }
+};
+var UploadsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** Stage big files for a publish; PUT each to its URL */
+  stage(params, options) {
+    return this.client.call(OPERATIONS.stageUploads, params, options);
+  }
+};
+var DataResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** Rows visitors submitted to one artifact, newest first */
+  listArtifactRows(params, options) {
+    return this.client.call(OPERATIONS.listArtifactRows, params, options);
+  }
+  /** Write rows into an artifact you may edit */
+  writeArtifactRows(params, options) {
+    return this.client.call(OPERATIONS.writeArtifactRows, params, options);
+  }
+  /** Rows submitted to a dataset or a gallery label */
+  listRows(params, options) {
+    return this.client.call(OPERATIONS.listRows, params, options);
+  }
+  /** Aggregate what was collected: numbers, never rows */
+  query(params, options) {
+    return this.client.call(OPERATIONS.queryData, params, options);
+  }
+};
+var SchemaResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** The data catalog: datasets and content collections, or a comparison */
+  get(params, options) {
+    return this.client.call(OPERATIONS.getSchema, params, options);
+  }
+  /** Create or replace a content collection */
+  defineCollection(params, options) {
+    return this.client.call(OPERATIONS.defineCollection, params, options);
+  }
+};
+var EntriesResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** One page of a content collection's entries */
+  list(params, options) {
+    return this.client.call(OPERATIONS.listEntries, params, options);
+  }
+  /** Create one entry, or a batch */
+  create(params, options) {
+    return this.client.call(OPERATIONS.createEntries, params, options);
+  }
+};
+var SecretsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** Call an approved API with a stored secret you cannot read (workspace keys) */
+  use(params, options) {
+    return this.client.call(OPERATIONS.useSecret, params, options);
+  }
+};
+var TemplatesResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** Find, rank or list templates */
+  list(params, options) {
+    return this.client.call(OPERATIONS.listTemplates, params, options);
+  }
+  /** Create or revise a template draft */
+  save(params, options) {
+    return this.client.call(OPERATIONS.saveTemplate, params, options);
+  }
+  /** One template in full, with its install prompt */
+  get(params, options) {
+    return this.client.call(OPERATIONS.getTemplate, params, options);
+  }
+  /** A template's changelog */
+  getHistory(params, options) {
+    return this.client.call(OPERATIONS.getTemplateHistory, params, options);
+  }
+  /** Comments on a template's artifacts, as themes */
+  getFeedback(params, options) {
+    return this.client.call(OPERATIONS.getTemplateFeedback, params, options);
+  }
+  /** Install, uninstall, rate, report, roll back or request verification */
+  act(params, options) {
+    return this.client.call(OPERATIONS.actOnTemplate, params, options);
+  }
+  /** Release one version of your template */
+  release(params, options) {
+    return this.client.call(OPERATIONS.releaseTemplate, params, options);
+  }
+};
+var ProjectsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** Your projects */
+  list(params, options) {
+    return this.client.call(OPERATIONS.listProjects, params, options);
+  }
+  /** Create a project, optionally seeded with artifacts */
+  create(params, options) {
+    return this.client.call(OPERATIONS.createProject, params, options);
+  }
+  /** One project and its items */
+  get(params, options) {
+    return this.client.call(OPERATIONS.getProject, params, options);
+  }
+  /** Rename, set visibility, reorder, move, fold groups or set a rule */
+  update(params, options) {
+    return this.client.call(OPERATIONS.updateProject, params, options);
+  }
+  /** Delete a project; its artifacts stay */
+  delete(params, options) {
+    return this.client.call(OPERATIONS.deleteProject, params, options);
+  }
+  /** Add artifacts to a project */
+  addArtifacts(params, options) {
+    return this.client.call(OPERATIONS.addProjectArtifacts, params, options);
+  }
+  /** Remove one artifact (or item) from a project */
+  removeArtifact(params, options) {
+    return this.client.call(OPERATIONS.removeProjectArtifact, params, options);
+  }
+};
+var SharesResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** Give named people access to an artifact */
+  addToArtifact(params, options) {
+    return this.client.call(OPERATIONS.shareArtifact, params, options);
+  }
+  /** Give named people access to a project */
+  addToProject(params, options) {
+    return this.client.call(OPERATIONS.shareProject, params, options);
+  }
+  /** Invite editors to a workspace (returns accept links) */
+  addToWorkspace(params, options) {
+    return this.client.call(OPERATIONS.shareWorkspace, params, options);
+  }
+};
+var CommentsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** Comment threads on an artifact, newest first */
+  list(params, options) {
+    return this.client.call(OPERATIONS.listComments, params, options);
+  }
+  /** Reply to and/or resolve threads, one outcome each */
+  respond(params, options) {
+    return this.client.call(OPERATIONS.respondToComments, params, options);
+  }
+  /** One message's screenshot, base64 in `image` */
+  getScreenshot(params, options) {
+    return this.client.call(OPERATIONS.getCommentScreenshot, params, options);
+  }
+};
+var MentionsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** Where people @mentioned you; listing marks them seen */
+  list(params, options) {
+    return this.client.call(OPERATIONS.listMentions, params, options);
+  }
+};
+var SignaturesResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** An artifact's signature requests, newest first */
+  list(params, options) {
+    return this.client.call(OPERATIONS.listSignatureRequests, params, options);
+  }
+  /** Ask named people to sign one version of an artifact */
+  request(params, options) {
+    return this.client.call(OPERATIONS.requestSignatures, params, options);
+  }
+  /** One signature request and its signers */
+  get(params, options) {
+    return this.client.call(OPERATIONS.getSignatureRequest, params, options);
+  }
+  /** Email a signer their link again */
+  remind(params, options) {
+    return this.client.call(OPERATIONS.remindSigner, params, options);
+  }
+  /** Close an open signature request */
+  withdraw(params, options) {
+    return this.client.call(OPERATIONS.withdrawSignatureRequest, params, options);
+  }
+};
+var Resources = class extends Core {
+  account = new AccountResource(this);
+  artifacts = new ArtifactsResource(this);
+  live = new LiveResource(this);
+  uploads = new UploadsResource(this);
+  data = new DataResource(this);
+  schema = new SchemaResource(this);
+  entries = new EntriesResource(this);
+  secrets = new SecretsResource(this);
+  templates = new TemplatesResource(this);
+  projects = new ProjectsResource(this);
+  shares = new SharesResource(this);
+  comments = new CommentsResource(this);
+  mentions = new MentionsResource(this);
+  signatures = new SignaturesResource(this);
+};
+
+// src/super-artifacts.ts
+async function* byCursor(read, start, items, next) {
+  let cursor = start;
+  do {
+    const page = await read(cursor);
+    yield* page[items] ?? [];
+    cursor = next(page) ?? void 0;
+  } while (cursor !== void 0);
+}
+var cursorNext = (page) => page.cursor?.next;
+var Data = class extends DataResource {
+  /** Every row `listArtifactRows` matches, page by page. */
+  iterArtifactRows(params, options) {
+    const read = (cursor) => this.listArtifactRows({ ...params, ...cursor && { cursor } }, options);
+    return byCursor(read, params.cursor, "responses", cursorNext);
+  }
+  /** Every row `listRows` matches, page by page. */
+  iterRows(params = {}, options) {
+    const read = (cursor) => this.listRows({ ...params, ...cursor && { cursor } }, options);
+    return byCursor(read, params.cursor, "responses", cursorNext);
+  }
+};
+var Entries = class extends EntriesResource {
+  /** Every entry `list` matches, page by page from `params.page` (0 by default). */
+  async *iter(params, options) {
+    for (let page = params.page ?? 0; ; page++) {
+      const answer = await this.list({ ...params, page }, options);
+      const entries = answer.entries ?? [];
+      yield* entries;
+      const { total, pageSize } = answer;
+      if (entries.length === 0 || (page + 1) * (pageSize ?? entries.length) >= (total ?? 0)) return;
+    }
+  }
+};
+var Mentions = class extends MentionsResource {
+  /** Every mention, page by page. Listing marks them seen. */
+  iter(params = {}, options) {
+    const read = (cursor) => this.list({ ...params, ...cursor && { cursor } }, options);
+    return byCursor(read, params.cursor, "mentions", (page) => page.cursorNext);
+  }
+};
+var Uploads = class extends UploadsResource {
+  /** Stage files and PUT their bytes. Pass the answer's `uploadId` to `artifacts.publish` as `uploads`. */
+  async upload(files, options) {
+    const blobs = files.map(
+      ({ data, contentType }) => data instanceof Blob ? data : new Blob([data], contentType === void 0 ? {} : { type: contentType })
+    );
+    const stage = files.map(({ path, contentType }, index) => ({
+      path,
+      bytes: blobs[index]?.size ?? 0,
+      ...contentType === void 0 ? {} : { contentType }
+    }));
+    const staged = await this.stage({ files: stage }, options);
+    await this.client.putFiles(staged.uploads, blobs, options);
+    return { uploadId: staged.uploadId, expiresAt: staged.expiresAt };
+  }
+};
+var SuperArtifacts = class extends Resources {
+  data = new Data(this);
+  entries = new Entries(this);
+  mentions = new Mentions(this);
+  uploads = new Uploads(this);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthenticationError,
+  ConflictError,
+  ConnectionError,
+  InternalError,
+  InvalidArgumentsError,
+  NotFoundError,
+  OPERATIONS,
+  PayloadTooLargeError,
+  PermissionError,
+  PlanLimitError,
+  RateLimitError,
+  ScopeRequiredError,
+  SuperArtifacts,
+  SuperArtifactsError,
+  TimeoutError,
+  VERSION,
+  errorFor
+});