@viewrium/sdk 0.1.0 → 2.1.0

package/dist/index.js

@@ -1,438 +1,295 @@
 // src/errors.ts
 var ViewriumError = class extends Error {
+  /** HTTP status, or `null` for transport/connection failures. */
+  status;
+  /** Machine-readable code from the error envelope. */
+  code;
+  /** Optional structured details from the error envelope. */
+  details;
   constructor(message, options = {}) {
-    super(message);
-    this.name = "ViewriumError";
-    this.statusCode = options.statusCode;
-    this.responseBody = options.responseBody;
+    super(message, options.cause !== void 0 ? { cause: options.cause } : void 0);
+    this.name = new.target.name;
+    this.status = options.status ?? null;
+    this.code = options.code ?? "error";
+    this.details = options.details;
   }
 };
-var AuthError = class extends ViewriumError {
-  constructor(message, options = {}) {
-    super(message, options);
-    this.name = "AuthError";
-  }
+var BadRequestError = class extends ViewriumError {
+};
+var AuthenticationError = class extends ViewriumError {
+};
+var PaymentRequiredError = class extends ViewriumError {
+};
+var PermissionError = class extends ViewriumError {
 };
 var NotFoundError = class extends ViewriumError {
-  constructor(message, options = {}) {
-    super(message, options);
-    this.name = "NotFoundError";
-  }
 };
-var ValidationError = class extends ViewriumError {
-  constructor(message, options = {}) {
-    super(message, options);
-    this.name = "ValidationError";
-  }
+var ConflictError = class extends ViewriumError {
+};
+var UnprocessableEntityError = class extends ViewriumError {
 };
 var RateLimitError = class extends ViewriumError {
-  constructor(message, options = {}) {
-    super(message, options);
-    this.name = "RateLimitError";
-    this.retryAfter = options.retryAfter;
-  }
 };
-var APIError = class extends ViewriumError {
-  constructor(message, options = {}) {
-    super(message, options);
-    this.name = "APIError";
-  }
+var ServerError = class extends ViewriumError {
 };
-
-// src/resources/models.ts
-var BASE = "/v1/models";
-var ModelsResource = class {
-  constructor(client) {
-    this.client = client;
-  }
-  async create(params) {
-    const hasImages = Array.isArray(params.images) && params.images.length > 0;
-    const hasSource = typeof params.sourceUrl === "string" && params.sourceUrl.length > 0;
-    if (hasImages === hasSource) {
-      throw new Error(
-        "Provide exactly one of `images` (URL list) or `sourceUrl` to models.create()."
-      );
-    }
-    const body = stripUndefined({
-      custom_id: params.customId,
-      title: params.title,
-      description: params.description,
-      image_urls: params.images,
-      source_url: params.sourceUrl,
-      height: params.height,
-      size_unit: params.sizeUnit,
-      tags: params.tags,
-      price: params.price,
-      currency: params.currency,
-      metadata: params.metadata,
-      display_enabled: params.displayEnabled
-    });
-    return this.client.request({ method: "POST", path: BASE, json: body });
-  }
-  async createFromImages(images, params = {}) {
-    if (!Array.isArray(images) || images.length < 1) {
-      throw new Error("At least 1 image is required.");
-    }
-    const form = new FormData();
-    for (const image of images) {
-      const { blob, filename } = await toBlob(image, "image");
-      form.append("images", blob, filename);
-    }
-    appendMultipartCommon(form, params);
-    return this.client.request({
-      method: "POST",
-      path: `${BASE}/from-images`,
-      body: form
-    });
-  }
-  async createFromVideo(video, params = {}) {
-    const { blob, filename } = await toBlob(video, "video");
-    const form = new FormData();
-    form.append("video", blob, filename);
-    appendMultipartCommon(form, params);
-    return this.client.request({
-      method: "POST",
-      path: `${BASE}/from-video`,
-      body: form
-    });
-  }
-  async retrieve(modelId) {
-    return this.client.request({ method: "GET", path: `${BASE}/${encodeURIComponent(modelId)}` });
-  }
-  async list(params = {}) {
-    const query = {};
-    if (params.tag !== void 0) query.tag = params.tag;
-    if (params.tags !== void 0) {
-      query.tags = Array.isArray(params.tags) ? params.tags.join(",") : params.tags;
-    }
-    if (params.customId !== void 0) query.custom_id = params.customId;
-    if (params.status !== void 0) query.status = params.status;
-    if (params.limit !== void 0) query.limit = params.limit;
-    if (params.offset !== void 0) query.offset = params.offset;
-    return this.client.request({
-      method: "GET",
-      path: BASE,
-      query
-    });
-  }
-  async modify(modelId, params) {
-    const body = stripUndefined({
-      custom_id: params.customId,
-      title: params.title,
-      description: params.description,
-      price: params.price,
-      currency: params.currency,
-      height: params.height,
-      size_unit: params.sizeUnit,
-      tags: params.tags,
-      metadata: params.metadata,
-      display_enabled: params.displayEnabled
-    });
-    return this.client.request({
-      method: "PATCH",
-      path: `${BASE}/${encodeURIComponent(modelId)}`,
-      json: body
-    });
-  }
-  async delete(modelId) {
-    return this.client.request({
-      method: "DELETE",
-      path: `${BASE}/${encodeURIComponent(modelId)}`
-    });
-  }
-  async listEvents(modelId, params = {}) {
-    const query = {};
-    if (params.limit !== void 0) query.limit = params.limit;
-    if (params.offset !== void 0) query.offset = params.offset;
-    return this.client.request({
-      method: "GET",
-      path: `${BASE}/${encodeURIComponent(modelId)}/events`,
-      query
-    });
-  }
+var ConnectionError = class extends ViewriumError {
 };
-function stripUndefined(obj) {
-  const out = {};
-  for (const [key, value] of Object.entries(obj)) {
-    if (value !== void 0) out[key] = value;
-  }
-  return out;
-}
-function appendMultipartCommon(form, params) {
-  if (params.title !== void 0) form.append("title", params.title);
-  if (params.customId !== void 0) form.append("custom_id", params.customId);
-  if (params.description !== void 0) form.append("description", params.description);
-  if (params.height !== void 0) form.append("height", String(params.height));
-  if (params.sizeUnit !== void 0) form.append("size_unit", params.sizeUnit);
-  if (params.tags !== void 0) form.append("tags", JSON.stringify(params.tags));
-  if (params.displayEnabled !== void 0) {
-    form.append("display_enabled", params.displayEnabled ? "true" : "false");
-  }
-}
-async function toBlob(input, fallbackKind) {
-  if (typeof input === "string") {
-    const { readFile } = await import('fs/promises');
-    const { basename } = await import('path');
-    const data = await readFile(input);
-    const blob = new Blob([data]);
-    return { blob, filename: basename(input) };
-  }
-  if (input instanceof Blob) {
-    const filename = input.name && typeof input.name === "string" ? input.name : defaultFilename(fallbackKind);
-    return { blob: input, filename };
-  }
-  if (input && typeof input === "object" && "data" in input) {
-    const { data, filename, contentType } = input;
-    const part = data instanceof Blob ? data : data instanceof ArrayBuffer ? data : data;
-    const blob = new Blob([part], contentType ? { type: contentType } : void 0);
-    return { blob, filename: filename ?? defaultFilename(fallbackKind) };
-  }
-  throw new Error("Unsupported file input: expected string path, Blob, File, or {data, filename}.");
-}
-function defaultFilename(kind) {
-  return kind === "image" ? "image.bin" : "video.bin";
-}
-
-// src/resources/apiKeys.ts
-var BASE2 = "/v1/api_keys";
-var ApiKeysResource = class {
-  constructor(client) {
-    this.client = client;
-  }
-  async create(params = {}) {
-    const body = {};
-    if (params.name !== void 0) body.name = params.name;
-    if (params.keyType !== void 0) body.key_type = params.keyType;
-    return this.client.request({
-      method: "POST",
-      path: BASE2,
-      json: body
-    });
-  }
-  async list() {
-    return this.client.request({ method: "GET", path: BASE2 });
-  }
-  async delete(keyId) {
-    return this.client.request({
-      method: "DELETE",
-      path: `${BASE2}/${encodeURIComponent(keyId)}`
-    });
-  }
+var BY_STATUS = {
+  400: BadRequestError,
+  401: AuthenticationError,
+  402: PaymentRequiredError,
+  403: PermissionError,
+  404: NotFoundError,
+  409: ConflictError,
+  422: UnprocessableEntityError,
+  429: RateLimitError
 };
-
-// src/resources/usage.ts
-var BASE3 = "/v1/usage";
-var UsageResource = class {
-  constructor(client) {
-    this.client = client;
+function createApiError(status, payload) {
+  const options = { status, code: payload.code, details: payload.details };
+  const Specific = BY_STATUS[status];
+  if (Specific) {
+    return new Specific(payload.message, options);
   }
-  async retrieve(params = {}) {
-    const query = {};
-    if (params.since !== void 0) query.since = params.since;
-    if (params.until !== void 0) query.until = params.until;
-    return this.client.request({
-      method: "GET",
-      path: BASE3,
-      query
-    });
+  if (status >= 500) {
+    return new ServerError(payload.message, options);
   }
-};
-
-// src/resources/tags.ts
-var BASE4 = "/v1/tags";
-var TagsResource = class {
-  constructor(client) {
-    this.client = client;
-  }
-  async list() {
-    return this.client.request({ method: "GET", path: BASE4 });
-  }
-};
+  return new ViewriumError(payload.message, options);
+}
 
-// src/client.ts
-var DEFAULT_API_BASE = "https://api.viewrium.com";
-var DEFAULT_TIMEOUT_MS = 6e4;
-var DEFAULT_MAX_RETRIES = 3;
-var RETRYABLE_STATUSES = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
-var VERSION = "0.1.0";
-var Viewrium = class {
-  constructor(apiKey, options = {}) {
-    const envKey = typeof process !== "undefined" ? process.env?.VIEWRIUM_API_KEY : void 0;
-    const resolvedKey = options.apiKey ?? apiKey ?? envKey;
-    if (!resolvedKey) {
-      throw new AuthError(
-        "No API key configured. Pass `new Viewrium('sk_live_...')` or set VIEWRIUM_API_KEY."
-      );
-    }
-    this.apiKey = resolvedKey;
-    const envBase = typeof process !== "undefined" ? process.env?.VIEWRIUM_API_BASE : void 0;
-    this.apiBase = (options.apiBase ?? envBase ?? DEFAULT_API_BASE).replace(/\/+$/, "");
-    this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-    this.maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
-    const providedFetch = options.fetch;
-    if (providedFetch) {
-      this.fetchImpl = providedFetch;
-    } else if (typeof globalThis.fetch === "function") {
-      this.fetchImpl = globalThis.fetch.bind(globalThis);
-    } else {
-      throw new Error(
-        "No `fetch` implementation available. Use Node 18+ or pass `fetch` in options."
-      );
-    }
-    this.models = new ModelsResource(this);
-    this.apiKeys = new ApiKeysResource(this);
-    this.usage = new UsageResource(this);
-    this.tags = new TagsResource(this);
-  }
-  /** Low-level request. Resources delegate here. */
-  async request(options) {
-    const url = this.buildUrl(options.path, options.query);
-    const headers = this.buildHeaders(options);
-    const body = this.buildBody(options);
-    let attempt = 0;
-    let lastResponse;
-    while (true) {
-      lastResponse = void 0;
-      const controller = new AbortController();
-      const timeoutMs = options.timeoutMs ?? this.timeoutMs;
-      const timer = setTimeout(() => controller.abort(), timeoutMs);
-      try {
-        lastResponse = await this.fetchImpl(url, {
-          method: options.method,
-          headers,
-          body,
-          signal: controller.signal
-        });
-      } catch (err) {
-        clearTimeout(timer);
-        if (attempt >= this.maxRetries) throw err;
-        await sleep(backoffMs(void 0, attempt));
-        attempt += 1;
-        continue;
-      }
-      clearTimeout(timer);
-      if (RETRYABLE_STATUSES.has(lastResponse.status) && attempt < this.maxRetries) {
-        await sleep(backoffMs(lastResponse, attempt));
-        attempt += 1;
-        continue;
-      }
-      break;
-    }
-    if (!lastResponse.ok) {
-      await raiseForStatus(lastResponse);
-    }
-    return await parseResponse(lastResponse);
-  }
-  buildUrl(path, query) {
-    const full = path.startsWith("http://") || path.startsWith("https://") ? path : `${this.apiBase}${path.startsWith("/") ? path : `/${path}`}`;
-    if (!query) return full;
-    const params = new URLSearchParams();
+// src/index.ts
+var DEFAULT_BASE_URL = "https://api.viewrium.com";
+function buildUrl(baseUrl, path, query) {
+  const url = new URL(baseUrl + path);
+  if (query) {
     for (const [key, value] of Object.entries(query)) {
       if (value === void 0 || value === null) continue;
       if (Array.isArray(value)) {
-        for (const v of value) {
-          if (v !== void 0 && v !== null) params.append(key, String(v));
-        }
+        for (const item of value) url.searchParams.append(key, String(item));
       } else {
-        params.append(key, String(value));
+        url.searchParams.append(key, String(value));
       }
     }
-    const qs = params.toString();
-    return qs ? `${full}?${qs}` : full;
   }
-  buildHeaders(options) {
-    const headers = new Headers(options.headers);
-    headers.set("Authorization", `Bearer ${this.apiKey}`);
-    headers.set("Accept", "application/json");
-    if (!headers.has("User-Agent") && typeof process !== "undefined") {
-      try {
-        headers.set("User-Agent", `viewrium-js/${VERSION}`);
-      } catch {
+  return url.toString();
+}
+async function parseError(res) {
+  let code = "error";
+  let message = res.statusText || `HTTP ${res.status}`;
+  let details;
+  try {
+    const data = await res.json();
+    if (data && typeof data === "object" && "error" in data) {
+      const envelope = data.error;
+      if (envelope && typeof envelope === "object") {
+        const e = envelope;
+        if (typeof e.code === "string") code = e.code;
+        if (typeof e.message === "string") message = e.message;
+        details = e.details;
       }
     }
-    if (options.json !== void 0 && !headers.has("Content-Type")) {
-      headers.set("Content-Type", "application/json");
-    }
-    return headers;
-  }
-  buildBody(options) {
-    if (options.body !== void 0) return options.body;
-    if (options.json !== void 0) return JSON.stringify(options.json);
-    return void 0;
-  }
-};
-async function parseResponse(response) {
-  if (response.status === 204) return {};
-  const text = await response.text();
-  if (!text) return {};
-  try {
-    return JSON.parse(text);
-  } catch (e) {
-    throw new APIError(`Failed to parse JSON response: ${e.message}`, {
-      statusCode: response.status,
-      responseBody: text
-    });
+  } catch {
   }
+  return createApiError(res.status, { code, message, details });
 }
-async function raiseForStatus(response) {
-  const body = await parseBodyForError(response);
-  const detail = extractDetail(body, response);
-  const status = response.status;
-  const opts = { statusCode: status, responseBody: body };
-  if (status === 401) throw new AuthError(detail, opts);
-  if (status === 404) throw new NotFoundError(detail, opts);
-  if (status === 400 || status === 409 || status === 422) {
-    throw new ValidationError(detail, opts);
+async function send(transport, method, path, options) {
+  const headers = {
+    accept: "application/json",
+    authorization: `Bearer ${transport.apiKey}`
+  };
+  const init = { method, headers };
+  if (options?.body !== void 0) {
+    headers["content-type"] = "application/json";
+    init.body = JSON.stringify(options.body);
+  }
+  let res;
+  try {
+    res = await transport.fetch(buildUrl(transport.baseUrl, path, options?.query), init);
+  } catch (cause) {
+    throw new ConnectionError("The request to the Viewrium API could not be sent.", { cause });
   }
-  if (status === 429) {
-    throw new RateLimitError(detail, {
-      ...opts,
-      retryAfter: parseRetryAfter(response)
-    });
+  if (!res.ok) {
+    throw await parseError(res);
   }
-  throw new APIError(detail, opts);
+  return res;
 }
-async function parseBodyForError(response) {
-  const text = await response.text();
-  if (!text) return void 0;
-  try {
-    return JSON.parse(text);
-  } catch {
-    return text;
+async function doRequest(transport, method, path, options) {
+  const res = await send(transport, method, path, options);
+  if (res.status === 204) {
+    return void 0;
   }
+  const text = await res.text();
+  return text ? JSON.parse(text) : void 0;
 }
-function extractDetail(body, response) {
-  if (body && typeof body === "object" && !Array.isArray(body)) {
-    const obj = body;
-    const candidate = obj.detail ?? obj.error ?? obj.message;
-    if (typeof candidate === "string" && candidate) return candidate;
-    if (candidate !== void 0) return String(candidate);
-  }
-  if (typeof body === "string" && body) return body;
-  return `HTTP ${response.status}`;
+async function doBlobRequest(transport, method, path, options) {
+  const res = await send(transport, method, path, options);
+  if (res.status === 202) return await res.json();
+  return res.blob();
 }
-function parseRetryAfter(response) {
-  const raw = response.headers.get("Retry-After");
-  if (!raw) return void 0;
-  const n = Number(raw);
-  return Number.isFinite(n) ? n : void 0;
+var encode = encodeURIComponent;
+function createProducts(request, requestBlob) {
+  return {
+    /**
+     * POST /v1/products - the single generation entrypoint. Supply exactly one source
+     * (`image_paths` | `image_urls` | `video_url` | `source_url` | `model_url` |
+     * `resume_token`). A fresh request ALWAYS parks (200, `status === "parked"`, nothing
+     * written): the plan, the model verdict and the price come back inside `resume_token`,
+     * which you POST back to commit (202, `ProductCreated`). A `model_url` commits at once.
+     */
+    create: (params) => request("POST", "/v1/products", { body: params }),
+    /**
+     * GET /v1/products - the catalog: one org (`org_id`, or the caller's only org), or
+     * `scope: "all"` for every org an agency member or staff reaches. Filters AND together.
+     */
+    list: (params) => request("GET", "/v1/products", { query: params }),
+    /** GET /v1/products/{id} - the product with its assets (a `pk_` key gets `PublicProduct`). */
+    retrieve: (id) => request("GET", `/v1/products/${encode(id)}`),
+    /**
+     * PATCH /v1/products/{id} - the customer's fields, the user-set status and the publish
+     * toggle. 409 on a `custom_id` another product in the org already holds.
+     */
+    update: (id, params) => request("PATCH", `/v1/products/${encode(id)}`, { body: params }),
+    /** DELETE /v1/products/{id} */
+    delete: (id) => request("DELETE", `/v1/products/${encode(id)}`),
+    /** DELETE /v1/products?ids=... - per-id affected/not_found/forbidden buckets. */
+    batchDelete: (ids) => request("DELETE", "/v1/products", { query: { ids } }),
+    /** POST /v1/products/publish - the bulk publish toggle; one product toggles through `update`. */
+    publish: (params) => request("POST", "/v1/products/publish", { body: params }),
+    /** GET /v1/products/tags - distinct tags across the same scope the list takes. */
+    tags: (params) => request("GET", "/v1/products/tags", { query: params }),
+    /** POST /v1/products/{id}/review - the review flush: image and model decisions plus the
+     *  product's user-set status, validated together and applied in order. */
+    review: (id, params) => request("POST", `/v1/products/${encode(id)}/review`, { body: params }),
+    /** PATCH /v1/products/{id}/images/{image_id} - one image's decision and overrides. */
+    updateImage: (id, imageId, params) => request("PATCH", `/v1/products/${encode(id)}/images/${encode(imageId)}`, {
+      body: params
+    }),
+    /** PATCH /v1/products/{id}/model - the model's review decision. */
+    updateModel: (id, params) => request("PATCH", `/v1/products/${encode(id)}/model`, { body: params }),
+    /**
+     * POST /v1/products/{id}/model/rescale - re-apply real-world scale to the GLB in place.
+     * Every supplied axis is applied to the geometry; `unit` covers them (omitted = cm) and is
+     * remembered as the product's `display_unit`. The result carries the ACHIEVED dimensions.
+     */
+    rescale: (id, params) => request("POST", `/v1/products/${encode(id)}/model/rescale`, { body: params }),
+    /**
+     * POST /v1/products/{id}/tickets - a single-use URL for the product's 3D file, the ONLY way
+     * to its bytes (no response carries a model file URL). It works once, until `expires_at`
+     * (60 s for `view`, 30 s for `ar`); a `view` ticket only from its bound origin. With a `pk_`
+     * key the product must be published and the ticket is bound to the page's Origin; with an
+     * `sk_` key pass `origin` (the page that will load the model, one of your allowed domains).
+     */
+    createTicket: (id, params) => request("POST", `/v1/products/${encode(id)}/tickets`, { body: params }),
+    /** POST /v1/products/{id}/order - park the missing half (images or a model); commit the
+     *  returned `resume_token` with `create`. */
+    order: (id, params) => request("POST", `/v1/products/${encode(id)}/order`, { body: params }),
+    /** GET /v1/products/export - a ZIP of finished images (never the 3D model), resolved as a
+     *  `Blob`; or `ProductExportQueued` (202) when the images are being finished in the
+     *  background and a download link is emailed - repeat the request later to stream it. */
+    export: (params) => requestBlob("GET", "/v1/products/export", { query: params })
+  };
 }
-function backoffMs(response, attempt) {
-  if (response) {
-    const hinted = parseRetryAfter(response);
-    if (hinted !== void 0) return hinted * 1e3;
-  }
-  const base = Math.min(2 ** attempt, 30);
-  const jitter = Math.random() * 0.25;
-  return (base + jitter) * 1e3;
+function createApiKeys(request) {
+  return {
+    /** GET /v1/api_keys */
+    list: () => request("GET", "/v1/api_keys"),
+    /** POST /v1/api_keys - the full key is returned exactly once. */
+    create: (params) => request("POST", "/v1/api_keys", { body: params }),
+    /** DELETE /v1/api_keys/{id} - soft revoke. */
+    revoke: (id) => request("DELETE", `/v1/api_keys/${encode(id)}`)
+  };
 }
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+function createUsage(request) {
+  return {
+    /** GET /v1/usage - buckets and totals over the window; `group_by: "product"` adds the
+     *  window's best-performing products in `by_product`. */
+    get: (params) => request("GET", "/v1/usage", { query: params })
+  };
 }
-
-// src/index.ts
-var index_default = Viewrium;
-
-export { APIError, AuthError, NotFoundError, RateLimitError, ValidationError, Viewrium, ViewriumError, index_default as default };
-//# sourceMappingURL=index.js.map
+function createWebhooks(request) {
+  return {
+    /** GET /v1/webhooks */
+    list: () => request("GET", "/v1/webhooks"),
+    /** POST /v1/webhooks - includes the signing secret. */
+    create: (params) => request("POST", "/v1/webhooks", { body: params }),
+    /** GET /v1/webhooks/{id} */
+    retrieve: (id) => request("GET", `/v1/webhooks/${encode(id)}`),
+    /** PATCH /v1/webhooks/{id} */
+    update: (id, params) => request("PATCH", `/v1/webhooks/${encode(id)}`, { body: params }),
+    /** DELETE /v1/webhooks/{id} */
+    delete: (id) => request("DELETE", `/v1/webhooks/${encode(id)}`),
+    /** GET /v1/webhooks/{id}/deliveries */
+    listDeliveries: (id, params) => request("GET", `/v1/webhooks/${encode(id)}/deliveries`, {
+      query: params
+    })
+  };
+}
+function createProjects(request) {
+  return {
+    /** GET /v1/projects */
+    list: () => request("GET", "/v1/projects"),
+    /** GET /v1/projects/{id} */
+    retrieve: (id) => request("GET", `/v1/projects/${encode(id)}`)
+  };
+}
+function createBeacon(request) {
+  return {
+    /** POST /v1/beacon - ingest a view/AR analytics event (204). */
+    send: (params) => request("POST", "/v1/beacon", { body: params })
+  };
+}
+var Viewrium = class {
+  baseUrl;
+  products;
+  apiKeys;
+  usage;
+  webhooks;
+  projects;
+  beacon;
+  #request;
+  constructor(options) {
+    if (!options || !options.apiKey) {
+      throw new ViewriumError("A Viewrium client requires an `apiKey` (sk_ or pk_).");
+    }
+    this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    const provided = options.fetch;
+    const globalFetch = typeof globalThis.fetch === "function" ? globalThis.fetch.bind(globalThis) : void 0;
+    const fetchImpl = provided ?? globalFetch;
+    if (!fetchImpl) {
+      throw new ViewriumError("No fetch implementation available; pass `options.fetch`.");
+    }
+    const transport = { baseUrl: this.baseUrl, apiKey: options.apiKey, fetch: fetchImpl };
+    const request = (method, path, opts) => doRequest(transport, method, path, opts);
+    const requestBlob = (method, path, opts) => doBlobRequest(transport, method, path, opts);
+    this.#request = request;
+    this.products = createProducts(request, requestBlob);
+    this.apiKeys = createApiKeys(request);
+    this.usage = createUsage(request);
+    this.webhooks = createWebhooks(request);
+    this.projects = createProjects(request);
+    this.beacon = createBeacon(request);
+  }
+  /** GET /v1/health */
+  health() {
+    return this.#request("GET", "/v1/health");
+  }
+};
+function createViewrium(options) {
+  return new Viewrium(options);
+}
+export {
+  AuthenticationError,
+  BadRequestError,
+  ConflictError,
+  ConnectionError,
+  NotFoundError,
+  PaymentRequiredError,
+  PermissionError,
+  RateLimitError,
+  ServerError,
+  UnprocessableEntityError,
+  Viewrium,
+  ViewriumError,
+  createApiError,
+  createViewrium
+};
 //# sourceMappingURL=index.js.map