vintrace-sdk 0.0.5

package/dist/index.cjs

@@ -0,0 +1,870 @@
+'use strict';
+
+var zod = require('zod');
+
+// src/client/config.ts
+var DEFAULT_OPTIONS = {
+  timeout: 3e4,
+  maxRetries: 3,
+  parallelLimit: 5,
+  validateRequests: true,
+  validateResponses: true
+};
+
+// src/client/errors.ts
+var VintraceError = class extends Error {
+  constructor(message, status, correlationId, body) {
+    super(message);
+    this.name = "VintraceError";
+    this.status = status;
+    this.correlationId = correlationId;
+    this.body = body;
+    Error.captureStackTrace(this, this.constructor);
+  }
+};
+var VintraceAuthenticationError = class extends VintraceError {
+  constructor(message = "Authentication failed", correlationId, body) {
+    super(message, 401, correlationId, body);
+    this.name = "VintraceAuthenticationError";
+  }
+};
+var VintraceRateLimitError = class extends VintraceError {
+  constructor(message = "Rate limit exceeded", retryAfter, correlationId, body) {
+    super(message, 429, correlationId, body);
+    this.name = "VintraceRateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var VintraceNotFoundError = class extends VintraceError {
+  constructor(message = "Resource not found", correlationId, body) {
+    super(message, 404, correlationId, body);
+    this.name = "VintraceNotFoundError";
+  }
+};
+var VintraceValidationError = class extends VintraceError {
+  constructor(message = "Validation failed", status = 400, correlationId, body) {
+    super(message, status, correlationId, body);
+    this.name = "VintraceValidationError";
+  }
+};
+var VintraceServerError = class extends VintraceError {
+  constructor(message = "Server error", status, correlationId, body) {
+    super(message, status, correlationId, body);
+    this.name = "VintraceServerError";
+  }
+};
+var VintraceAggregateError = class extends VintraceError {
+  constructor(errors) {
+    const message = errors.length === 1 ? errors[0].message : `${errors.length} errors occurred: ${errors.map((e) => e.message).join("; ")}`;
+    super(
+      message,
+      errors[0]?.status ?? 0,
+      errors[0]?.correlationId,
+      errors.map((e) => e.body)
+    );
+    this.name = "VintraceAggregateError";
+    this.errors = errors;
+  }
+};
+function isRetryableStatus(status) {
+  return [408, 429, 500, 502, 503, 504].includes(status);
+}
+var VintraceValidationSchemaError = class extends VintraceError {
+  constructor(message, errors, correlationId) {
+    super(message, 422, correlationId);
+    this.errors = errors;
+    this.name = "VintraceValidationSchemaError";
+  }
+};
+function validateResponse(schema, data, correlationId) {
+  try {
+    const validated = schema.parse(data);
+    return [validated, null];
+  } catch (error) {
+    if (error instanceof zod.ZodError) {
+      const message = error.issues.map((e) => `${e.path.join(".")}: ${e.message}`).join("; ");
+      return [null, new VintraceValidationSchemaError(message, error.issues, correlationId)];
+    }
+    return [null, new VintraceError("Response validation failed", 500, correlationId)];
+  }
+}
+function validateRequest(schema, data, correlationId) {
+  try {
+    const validated = schema.parse(data);
+    return [validated, null];
+  } catch (error) {
+    if (error instanceof zod.ZodError) {
+      const message = error.issues.map((e) => `${e.path.join(".")}: ${e.message}`).join("; ");
+      return [null, new VintraceValidationSchemaError(message, error.issues, correlationId)];
+    }
+    return [null, new VintraceError("Request validation failed", 500, correlationId)];
+  }
+}
+
+// src/http/fetch.ts
+function generateCorrelationId() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+function getRetryAfterFromHeaders(headers) {
+  const retryAfter = headers.get("retry-after");
+  if (retryAfter) {
+    const parsed = parseInt(retryAfter, 10);
+    return isNaN(parsed) ? void 0 : parsed;
+  }
+  return void 0;
+}
+var VintraceFetchError = class extends VintraceError {
+  constructor(message, status, correlationId, body) {
+    super(message, status, correlationId, body);
+    this.name = "VintraceFetchError";
+  }
+};
+async function vintraceFetch(baseUrl, organization, token, endpoint, method, options = {}, body) {
+  const timeout = options.timeout ?? DEFAULT_OPTIONS.timeout;
+  const maxRetries = options.maxRetries ?? DEFAULT_OPTIONS.maxRetries;
+  const isBodylessMethod = method === "GET" || method === "DELETE";
+  let url = `${baseUrl}/${organization}/api/${endpoint}`;
+  const correlationId = generateCorrelationId();
+  if (isBodylessMethod && body && typeof body === "object") {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(body)) {
+      if (value !== void 0 && value !== null) {
+        params.set(key, String(value));
+      }
+    }
+    const qs = params.toString();
+    if (qs) url = `${url}?${qs}`;
+  }
+  const headers = {
+    Authorization: `Bearer ${token}`,
+    "correlation-id": correlationId,
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  };
+  if (options.validateRequest && options.requestSchema && body) {
+    const [validatedBody, requestError] = validateRequest(options.requestSchema, body, correlationId);
+    if (requestError) {
+      return [null, requestError];
+    }
+    body = validatedBody;
+  }
+  try {
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      try {
+        const response = await fetch(url, {
+          method,
+          headers,
+          body: isBodylessMethod ? void 0 : body ? JSON.stringify(body) : void 0,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        const responseCorrelationId = response.headers.get("correlation-id") || correlationId;
+        if (!response.ok) {
+          let responseBody;
+          const contentType = response.headers.get("content-type");
+          try {
+            if (contentType?.includes("application/json")) {
+              responseBody = await response.json();
+            } else {
+              responseBody = await response.text();
+            }
+          } catch {
+          }
+          const retryAfter = getRetryAfterFromHeaders(response.headers);
+          let error;
+          if (response.status === 401) {
+            error = new VintraceAuthenticationError(
+              "Authentication failed",
+              responseCorrelationId,
+              responseBody
+            );
+          } else if (response.status === 404) {
+            error = new VintraceNotFoundError(
+              "Resource not found",
+              responseCorrelationId,
+              responseBody
+            );
+          } else if (response.status === 429) {
+            error = new VintraceRateLimitError(
+              "Rate limit exceeded",
+              retryAfter,
+              responseCorrelationId,
+              responseBody
+            );
+          } else if (response.status >= 400 && response.status < 500) {
+            error = new VintraceValidationError(
+              "Request validation failed",
+              response.status,
+              responseCorrelationId,
+              responseBody
+            );
+          } else if (response.status >= 500) {
+            error = new VintraceServerError(
+              "Server error",
+              response.status,
+              responseCorrelationId,
+              responseBody
+            );
+          } else {
+            error = new VintraceError(
+              `Request failed with status ${response.status}`,
+              response.status,
+              responseCorrelationId,
+              responseBody
+            );
+          }
+          if (error instanceof VintraceRateLimitError && attempt < maxRetries) {
+            const delay = error.retryAfter ?? Math.pow(2, attempt) * 1e3;
+            await new Promise((resolve) => setTimeout(resolve, delay));
+            continue;
+          }
+          if (error instanceof VintraceAuthenticationError) {
+            return [null, error];
+          }
+          if (isRetryableStatus(error.status) && attempt < maxRetries) {
+            const delay = Math.pow(2, attempt) * 1e3;
+            await new Promise((resolve) => setTimeout(resolve, delay));
+            continue;
+          }
+          return [null, error];
+        }
+        if (response.status === 204) {
+          return [null, null];
+        }
+        const data = await response.json();
+        if (options.validateResponse && options.responseSchema) {
+          const [validatedData, responseError] = validateResponse(
+            options.responseSchema,
+            data,
+            responseCorrelationId
+          );
+          if (responseError) {
+            return [null, responseError];
+          }
+          return [validatedData, null];
+        }
+        return [data, null];
+      } catch (error) {
+        clearTimeout(timeoutId);
+        if (error instanceof VintraceError) {
+          throw error;
+        }
+        if (error instanceof Error) {
+          if (error.name === "AbortError") {
+            if (attempt < maxRetries) {
+              const delay = Math.pow(2, attempt) * 1e3;
+              await new Promise((resolve) => setTimeout(resolve, delay));
+              continue;
+            }
+            return [null, new VintraceError("Request timeout", 408, correlationId)];
+          }
+          return [null, new VintraceFetchError(error.message, 0, correlationId)];
+        }
+        return [null, new VintraceFetchError("Unknown error", 0, correlationId)];
+      }
+    }
+    return [null, new VintraceError("Max retries exceeded", 0, correlationId)];
+  } catch (error) {
+    if (error instanceof VintraceError) {
+      return [null, error];
+    }
+    return [
+      null,
+      new VintraceFetchError(
+        error instanceof Error ? error.message : "Unknown error",
+        0,
+        correlationId
+      )
+    ];
+  }
+}
+
+// src/client/VintraceClient.ts
+var VintraceClient = class {
+  constructor(config) {
+    this.baseUrl = config.baseUrl;
+    this.organization = config.organization;
+    this.token = config.token;
+    this.options = { ...DEFAULT_OPTIONS, ...config.options };
+    this.v6 = new VintraceV6Api(this);
+    this.v7 = new VintraceV7Api(this);
+  }
+  request(endpoint, method, options, body) {
+    return vintraceFetch(
+      this.baseUrl,
+      this.organization,
+      this.token,
+      endpoint,
+      method,
+      {
+        timeout: options?.timeout ?? this.options.timeout,
+        maxRetries: options?.maxRetries ?? this.options.maxRetries,
+        validateRequest: options?.validateRequest ?? this.options.validateRequests,
+        validateResponse: options?.validateResponse ?? this.options.validateResponses
+      },
+      body
+    );
+  }
+};
+var VintraceV6Api = class {
+  constructor(client) {
+    this.client = client;
+  }
+  get workOrders() {
+    return new WorkOrdersClient(this.client);
+  }
+  get salesOrders() {
+    return new SalesOrdersClient(this.client);
+  }
+  get refunds() {
+    return new RefundsClient(this.client);
+  }
+  get parties() {
+    return new PartiesClient(this.client);
+  }
+  get products() {
+    return new ProductsClient(this.client);
+  }
+  get transactions() {
+    return new TransactionsClient(this.client);
+  }
+  get intakeOperations() {
+    return new IntakeOperationsClient(this.client);
+  }
+  get sampleOperations() {
+    return new SampleOperationsClient(this.client);
+  }
+  get blockAssessments() {
+    return new BlockAssessmentsClient(this.client);
+  }
+  get mrpStock() {
+    return new MrpStockClient(this.client);
+  }
+  get inventory() {
+    return new InventoryClient(this.client);
+  }
+  get search() {
+    return new SearchClient(this.client);
+  }
+  get productAnalysis() {
+    return new ProductAnalysisClient(this.client);
+  }
+  get productComposition() {
+    return new ProductCompositionClient(this.client);
+  }
+};
+var VintraceV7Api = class {
+  constructor(client) {
+    this.client = client;
+  }
+  get blocks() {
+    return new BlocksClient(this.client);
+  }
+  get bookings() {
+    return new BookingsClient(this.client);
+  }
+  get vesselDetailsReport() {
+    return new VesselDetailsReportClient(this.client);
+  }
+};
+var WorkOrdersClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  getAll(params) {
+    return this.client.request("v6/workorders/list", "GET", {}, params);
+  }
+  get(id) {
+    return this.client.request(`v6/workorders/${id}`, "GET");
+  }
+  getByCode(code) {
+    return this.client.request("v6/workorders", "GET", {}, { code });
+  }
+  getJob(jobId) {
+    return this.client.request(`v6/workorders/jobs/${jobId}`, "GET");
+  }
+  assign(workOrderId) {
+    return this.client.request("v6/workorders/assign", "POST", {}, { workOrderId });
+  }
+  submit(data) {
+    return this.client.request("v6/workorders/submit", "POST", {}, data);
+  }
+  getMany(ids) {
+    return this.batchGet(ids, (id) => this.get(id));
+  }
+  async batchGet(ids, fetchFn) {
+    const results = await Promise.allSettled(ids.map((id) => fetchFn(id)));
+    const errors = [];
+    const data = [];
+    for (const result of results) {
+      if (result.status === "fulfilled") {
+        const [item, error] = result.value;
+        if (error) {
+          errors.push(error);
+        } else if (item !== null) {
+          data.push(item);
+        }
+      } else {
+        errors.push(new VintraceError(result.reason?.message ?? "Unknown error", 0));
+      }
+    }
+    if (errors.length > 0) {
+      return [null, new VintraceAggregateError(errors)];
+    }
+    return [data, null];
+  }
+};
+var SalesOrdersClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  getAll(params) {
+    return this.client.request("v6/sales-order/list", "GET", {}, params);
+  }
+  get(id) {
+    return this.client.request(`v6/sales-order/${id}`, "GET");
+  }
+  getByCode(code) {
+    return this.client.request("v6/sales-order", "GET", {}, { code });
+  }
+  create(data) {
+    return this.client.request("v6/sales-order", "POST", {}, data);
+  }
+  update(id, data) {
+    return this.client.request(`v6/sales-order/${id}`, "PUT", {}, data);
+  }
+  getMany(ids) {
+    return this.batchGet(ids, (id) => this.get(id));
+  }
+  async batchGet(ids, fetchFn) {
+    const results = await Promise.allSettled(ids.map((id) => fetchFn(id)));
+    const errors = [];
+    const data = [];
+    for (const result of results) {
+      if (result.status === "fulfilled") {
+        const [item, error] = result.value;
+        if (error) {
+          errors.push(error);
+        } else if (item !== null) {
+          data.push(item);
+        }
+      } else {
+        errors.push(new VintraceError(result.reason?.message ?? "Unknown error", 0));
+      }
+    }
+    if (errors.length > 0) {
+      return [null, new VintraceAggregateError(errors)];
+    }
+    return [data, null];
+  }
+};
+var RefundsClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  getAll(params) {
+    return this.client.request("v6/refund/list", "GET", {}, params);
+  }
+  get(id) {
+    return this.client.request(`v6/refund/${id}`, "GET");
+  }
+  getByCode(code) {
+    return this.client.request("v6/refund", "GET", {}, { code });
+  }
+  create(data) {
+    return this.client.request("v6/refund", "POST", {}, data);
+  }
+  update(id, data) {
+    return this.client.request(`v6/refund/${id}`, "PUT", {}, data);
+  }
+  getMany(ids) {
+    return this.batchGet(ids, (id) => this.get(id));
+  }
+  async batchGet(ids, fetchFn) {
+    const results = await Promise.allSettled(ids.map((id) => fetchFn(id)));
+    const errors = [];
+    const data = [];
+    for (const result of results) {
+      if (result.status === "fulfilled") {
+        const [item, error] = result.value;
+        if (error) {
+          errors.push(error);
+        } else if (item !== null) {
+          data.push(item);
+        }
+      } else {
+        errors.push(new VintraceError(result.reason?.message ?? "Unknown error", 0));
+      }
+    }
+    if (errors.length > 0) {
+      return [null, new VintraceAggregateError(errors)];
+    }
+    return [data, null];
+  }
+};
+var PartiesClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  getAll(params) {
+    return this.client.request("v6/party/list", "GET", {}, params);
+  }
+  get(id) {
+    return this.client.request(`v6/party/${id}`, "GET");
+  }
+  getByName(name) {
+    return this.client.request("v6/party", "GET", {}, { name });
+  }
+  create(data) {
+    return this.client.request("v6/party", "POST", {}, data);
+  }
+  getMany(ids) {
+    return this.batchGet(ids, (id) => this.get(id));
+  }
+  async batchGet(ids, fetchFn) {
+    const results = await Promise.allSettled(ids.map((id) => fetchFn(id)));
+    const errors = [];
+    const data = [];
+    for (const result of results) {
+      if (result.status === "fulfilled") {
+        const [item, error] = result.value;
+        if (error) {
+          errors.push(error);
+        } else if (item !== null) {
+          data.push(item);
+        }
+      } else {
+        errors.push(new VintraceError(result.reason?.message ?? "Unknown error", 0));
+      }
+    }
+    if (errors.length > 0) {
+      return [null, new VintraceAggregateError(errors)];
+    }
+    return [data, null];
+  }
+};
+var ProductsClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  getAll(params) {
+    return this.client.request("v6/products/list", "GET", {}, params);
+  }
+  get(id) {
+    return this.client.request(`v6/products/${id}`, "GET");
+  }
+  getMany(ids) {
+    return this.batchGet(ids, (id) => this.get(id));
+  }
+  create(data) {
+    return this.client.request("v6/products", "POST", {}, data);
+  }
+  update(id, data) {
+    return this.client.request(`v6/products/${id}`, "PUT", {}, data);
+  }
+  updateFields(data) {
+    return this.client.request("v6/product-update", "POST", {}, data);
+  }
+  async batchGet(ids, fetchFn) {
+    const results = await Promise.allSettled(ids.map((id) => fetchFn(id)));
+    const errors = [];
+    const data = [];
+    for (const result of results) {
+      if (result.status === "fulfilled") {
+        const [item, error] = result.value;
+        if (error) {
+          errors.push(error);
+        } else if (item !== null) {
+          data.push(item);
+        }
+      } else {
+        errors.push(new VintraceError(result.reason?.message ?? "Unknown error", 0));
+      }
+    }
+    if (errors.length > 0) {
+      return [null, new VintraceAggregateError(errors)];
+    }
+    return [data, null];
+  }
+};
+var BlocksClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  getAll(params) {
+    return this.client.request("v7/harvest/blocks", "GET", {}, params);
+  }
+  get(id) {
+    return this.client.request(`v7/harvest/blocks/${id}`, "GET");
+  }
+  getMany(ids) {
+    return this.batchGet(ids, (id) => this.get(id));
+  }
+  post(data) {
+    return this.client.request("v7/harvest/blocks", "POST", {}, data);
+  }
+  patch(id, data) {
+    return this.client.request(`v7/harvest/blocks/${id}`, "PATCH", {}, data);
+  }
+  async batchGet(ids, fetchFn) {
+    const results = await Promise.allSettled(ids.map((id) => fetchFn(id)));
+    const errors = [];
+    const data = [];
+    for (const result of results) {
+      if (result.status === "fulfilled") {
+        const [item, error] = result.value;
+        if (error) {
+          errors.push(error);
+        } else if (item !== null) {
+          data.push(item);
+        }
+      } else {
+        errors.push(new VintraceError(result.reason?.message ?? "Unknown error", 0));
+      }
+    }
+    if (errors.length > 0) {
+      return [null, new VintraceAggregateError(errors)];
+    }
+    return [data, null];
+  }
+};
+var BookingsClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  post(data) {
+    return this.client.request("v7/operation/bookings", "POST", {}, data);
+  }
+  deactivate(id) {
+    return this.client.request(`v7/operation/bookings/${id}/deactivation`, "POST");
+  }
+};
+var VesselDetailsReportClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  get(params) {
+    return this.client.request("v7/report/vessel-details-report", "GET", {}, params);
+  }
+};
+var TransactionsClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  search(params) {
+    return this.client.request("v6/transaction/search", "GET", {}, params);
+  }
+};
+var IntakeOperationsClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  search(params) {
+    return this.client.request("v6/intake-operations/search", "GET", {}, params);
+  }
+};
+var SampleOperationsClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  search(params) {
+    return this.client.request("v6/sample-operations/search", "GET", {}, params);
+  }
+};
+var BlockAssessmentsClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  create(data) {
+    return this.client.request("v6/block-assessments/create", "POST", {}, data);
+  }
+};
+var MrpStockClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  get(id, expand) {
+    return this.client.request(`v6/mrp/stock/${id}`, "GET", {}, expand ? { expand } : void 0);
+  }
+  getFields(id) {
+    return this.client.request(`v6/mrp/stock/${id}/fields`, "GET");
+  }
+  getDistributions(id) {
+    return this.client.request(`v6/mrp/stock/${id}/distributions`, "GET");
+  }
+  getHistoryItems(id, params) {
+    return this.client.request(`v6/mrp/stock/${id}/history-items`, "GET", {}, params);
+  }
+  getRawComponents(id) {
+    return this.client.request(`v6/mrp/stock/${id}/raw-components`, "GET");
+  }
+  getNotes(id, params) {
+    return this.client.request(`v6/mrp/stock/${id}/notes`, "GET", {}, params);
+  }
+  postNote(id, data) {
+    return this.client.request(`v6/mrp/stock/${id}/notes`, "POST", {}, data);
+  }
+  getNote(id, noteId) {
+    return this.client.request(`v6/mrp/stock/${id}/notes/${noteId}`, "GET");
+  }
+  updateNote(id, noteId, data) {
+    return this.client.request(`v6/mrp/stock/${id}/notes/${noteId}/updates`, "POST", {}, data);
+  }
+  getBulkInfo(id) {
+    return this.client.request(`v6/mrp/stock/${id}/bulk-info`, "GET");
+  }
+};
+var InventoryClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  getAll(params) {
+    return this.client.request("v6/inventory", "GET", {}, params);
+  }
+};
+var SearchClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  list(params) {
+    return this.client.request("v6/search/list", "GET", {}, params);
+  }
+};
+var ProductAnalysisClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get analysis data for a product by its numeric ID.
+   * The endpoint path matches the `productAnalysisEndpoint` field returned on a Product.
+   * e.g. GET v6/product-analysis/{productId}
+   */
+  get(productId, params) {
+    return this.client.request(
+      `v6/product-analysis/${productId}`,
+      "GET",
+      {},
+      params
+    );
+  }
+  /**
+   * Fetch analysis for multiple product IDs in parallel.
+   * Respects the client's `parallelLimit` option (default 5 concurrent).
+   * Returns `VintraceAggregateError` if any individual request fails.
+   */
+  getMany(productIds, params) {
+    return this.batchGet(productIds, (id) => this.get(id, params));
+  }
+  async batchGet(ids, fetchFn) {
+    const limit = this.client.options.parallelLimit;
+    const errors = [];
+    const data = [];
+    for (let i = 0; i < ids.length; i += limit) {
+      const chunk = ids.slice(i, i + limit);
+      const results = await Promise.allSettled(chunk.map((id) => fetchFn(id)));
+      for (const result of results) {
+        if (result.status === "fulfilled") {
+          const [item, error] = result.value;
+          if (error) {
+            errors.push(error);
+          } else if (item !== null) {
+            data.push(item);
+          }
+        } else {
+          errors.push(new VintraceError(result.reason?.message ?? "Unknown error", 0));
+        }
+      }
+    }
+    if (errors.length > 0) {
+      return [null, new VintraceAggregateError(errors)];
+    }
+    return [data, null];
+  }
+};
+var ProductCompositionClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get composition (blend components) for a product by its numeric ID.
+   * The endpoint path matches the `productCompositionEndpoint` field returned on a Product.
+   * e.g. GET v6/product-composition/{productId}
+   */
+  get(productId) {
+    return this.client.request(
+      `v6/product-composition/${productId}`,
+      "GET"
+    );
+  }
+};
+
+// src/http/pagination.ts
+async function* paginate(fetchFn, options = {}) {
+  const limit = options.limit ?? 100;
+  let offset = 0;
+  let hasMore = true;
+  while (hasMore) {
+    const [response, error] = await fetchFn(offset, limit);
+    if (error) {
+      throw error;
+    }
+    if (response === null) {
+      break;
+    }
+    for (const item of response.results) {
+      yield item;
+    }
+    offset += limit;
+    hasMore = response.next !== null;
+  }
+}
+async function batchGet(ids, fetchFn, options = {}) {
+  const concurrency = options.concurrency ?? 5;
+  const errors = [];
+  const results = [];
+  for (let i = 0; i < ids.length; i += concurrency) {
+    const batch = ids.slice(i, i + concurrency);
+    const batchResults = await Promise.allSettled(batch.map((id) => fetchFn(id)));
+    for (const result of batchResults) {
+      if (result.status === "fulfilled") {
+        const [data, error] = result.value;
+        if (error) {
+          errors.push(error);
+        } else if (data !== null) {
+          results.push(data);
+        }
+      } else {
+        errors.push(new VintraceError(result.reason?.message ?? "Unknown error", 0));
+      }
+    }
+  }
+  if (errors.length > 0) {
+    return [null, new VintraceAggregateError(errors)];
+  }
+  return [results, null];
+}
+
+exports.DEFAULT_OPTIONS = DEFAULT_OPTIONS;
+exports.VintraceAggregateError = VintraceAggregateError;
+exports.VintraceAuthenticationError = VintraceAuthenticationError;
+exports.VintraceClient = VintraceClient;
+exports.VintraceError = VintraceError;
+exports.VintraceFetchError = VintraceFetchError;
+exports.VintraceNotFoundError = VintraceNotFoundError;
+exports.VintraceRateLimitError = VintraceRateLimitError;
+exports.VintraceServerError = VintraceServerError;
+exports.VintraceValidationError = VintraceValidationError;
+exports.VintraceValidationSchemaError = VintraceValidationSchemaError;
+exports.batchGet = batchGet;
+exports.paginate = paginate;
+exports.validateRequest = validateRequest;
+exports.validateResponse = validateResponse;
+exports.vintraceFetch = vintraceFetch;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map