@trigger.dev/core 3.0.0-beta.5 → 3.0.0-beta.51

package/dist/v3/zodfetch.js

@@ -0,0 +1,834 @@
+'use strict';
+
+var zod = require('zod');
+var zodValidationError = require('zod-validation-error');
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
+
+// src/v3/utils/retries.ts
+var defaultRetryOptions = {
+  maxAttempts: 3,
+  factor: 2,
+  minTimeoutInMs: 1e3,
+  maxTimeoutInMs: 6e4,
+  randomize: true
+};
+function calculateNextRetryDelay(options, attempt) {
+  const opts = {
+    ...defaultRetryOptions,
+    ...options
+  };
+  if (attempt >= opts.maxAttempts) {
+    return;
+  }
+  const { factor, minTimeoutInMs, maxTimeoutInMs, randomize } = opts;
+  const random = randomize ? Math.random() + 1 : 1;
+  const timeout = Math.min(maxTimeoutInMs, random * minTimeoutInMs * Math.pow(factor, attempt - 1));
+  return Math.round(timeout);
+}
+__name(calculateNextRetryDelay, "calculateNextRetryDelay");
+
+// src/v3/apiClient/errors.ts
+var _ApiError = class _ApiError extends Error {
+  constructor(status, error, message, headers) {
+    super(`${_ApiError.makeMessage(status, error, message)}`);
+    this.name = "TriggerApiError";
+    this.status = status;
+    this.headers = headers;
+    const data = error;
+    this.error = data;
+    this.code = data?.["code"];
+    this.param = data?.["param"];
+    this.type = data?.["type"];
+  }
+  static makeMessage(status, error, message) {
+    const msg = error?.message ? typeof error.message === "string" ? error.message : JSON.stringify(error.message) : error ? JSON.stringify(error) : message;
+    if (status && msg) {
+      return `${status} ${msg}`;
+    }
+    if (status) {
+      return `${status} status code (no body)`;
+    }
+    if (msg) {
+      return msg;
+    }
+    return "(no status code or body)";
+  }
+  static generate(status, errorResponse, message, headers) {
+    if (!status) {
+      return new ApiConnectionError({
+        cause: castToError(errorResponse)
+      });
+    }
+    const error = errorResponse?.["error"];
+    if (status === 400) {
+      return new BadRequestError(status, error, message, headers);
+    }
+    if (status === 401) {
+      return new AuthenticationError(status, error, message, headers);
+    }
+    if (status === 403) {
+      return new PermissionDeniedError(status, error, message, headers);
+    }
+    if (status === 404) {
+      return new NotFoundError(status, error, message, headers);
+    }
+    if (status === 409) {
+      return new ConflictError(status, error, message, headers);
+    }
+    if (status === 422) {
+      return new UnprocessableEntityError(status, error, message, headers);
+    }
+    if (status === 429) {
+      return new RateLimitError(status, error, message, headers);
+    }
+    if (status >= 500) {
+      return new InternalServerError(status, error, message, headers);
+    }
+    return new _ApiError(status, error, message, headers);
+  }
+};
+__name(_ApiError, "ApiError");
+var ApiError = _ApiError;
+var _ApiConnectionError = class _ApiConnectionError extends ApiError {
+  constructor({ message, cause }) {
+    super(void 0, void 0, message || "Connection error.", void 0);
+    __publicField(this, "status");
+    if (cause)
+      this.cause = cause;
+  }
+};
+__name(_ApiConnectionError, "ApiConnectionError");
+var ApiConnectionError = _ApiConnectionError;
+var _BadRequestError = class _BadRequestError extends ApiError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 400);
+  }
+};
+__name(_BadRequestError, "BadRequestError");
+var BadRequestError = _BadRequestError;
+var _AuthenticationError = class _AuthenticationError extends ApiError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 401);
+  }
+};
+__name(_AuthenticationError, "AuthenticationError");
+var AuthenticationError = _AuthenticationError;
+var _PermissionDeniedError = class _PermissionDeniedError extends ApiError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 403);
+  }
+};
+__name(_PermissionDeniedError, "PermissionDeniedError");
+var PermissionDeniedError = _PermissionDeniedError;
+var _NotFoundError = class _NotFoundError extends ApiError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 404);
+  }
+};
+__name(_NotFoundError, "NotFoundError");
+var NotFoundError = _NotFoundError;
+var _ConflictError = class _ConflictError extends ApiError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 409);
+  }
+};
+__name(_ConflictError, "ConflictError");
+var ConflictError = _ConflictError;
+var _UnprocessableEntityError = class _UnprocessableEntityError extends ApiError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 422);
+  }
+};
+__name(_UnprocessableEntityError, "UnprocessableEntityError");
+var UnprocessableEntityError = _UnprocessableEntityError;
+var _RateLimitError = class _RateLimitError extends ApiError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "status", 429);
+  }
+  get millisecondsUntilReset() {
+    const resetAtUnixEpochMs = (this.headers ?? {})["x-ratelimit-reset"];
+    if (typeof resetAtUnixEpochMs === "string") {
+      const resetAtUnixEpoch = parseInt(resetAtUnixEpochMs, 10);
+      if (isNaN(resetAtUnixEpoch)) {
+        return;
+      }
+      return Math.max(resetAtUnixEpoch - Date.now() + Math.floor(Math.random() * 2e3), 0);
+    }
+  }
+};
+__name(_RateLimitError, "RateLimitError");
+var RateLimitError = _RateLimitError;
+var _InternalServerError = class _InternalServerError extends ApiError {
+};
+__name(_InternalServerError, "InternalServerError");
+var InternalServerError = _InternalServerError;
+function castToError(err) {
+  if (err instanceof Error)
+    return err;
+  return new Error(err);
+}
+__name(castToError, "castToError");
+
+// src/v3/semanticInternalAttributes.ts
+var SemanticInternalAttributes = {
+  ENVIRONMENT_ID: "ctx.environment.id",
+  ENVIRONMENT_TYPE: "ctx.environment.type",
+  ORGANIZATION_ID: "ctx.organization.id",
+  ORGANIZATION_SLUG: "ctx.organization.slug",
+  ORGANIZATION_NAME: "ctx.organization.name",
+  PROJECT_ID: "ctx.project.id",
+  PROJECT_REF: "ctx.project.ref",
+  PROJECT_NAME: "ctx.project.title",
+  PROJECT_DIR: "project.dir",
+  ATTEMPT_ID: "ctx.attempt.id",
+  ATTEMPT_NUMBER: "ctx.attempt.number",
+  RUN_ID: "ctx.run.id",
+  RUN_IS_TEST: "ctx.run.isTest",
+  BATCH_ID: "ctx.batch.id",
+  TASK_SLUG: "ctx.task.id",
+  TASK_PATH: "ctx.task.filePath",
+  TASK_EXPORT_NAME: "ctx.task.exportName",
+  QUEUE_NAME: "ctx.queue.name",
+  QUEUE_ID: "ctx.queue.id",
+  MACHINE_PRESET_NAME: "ctx.machine.name",
+  MACHINE_PRESET_CPU: "ctx.machine.cpu",
+  MACHINE_PRESET_MEMORY: "ctx.machine.memory",
+  MACHINE_PRESET_CENTS_PER_MS: "ctx.machine.centsPerMs",
+  SPAN_PARTIAL: "$span.partial",
+  SPAN_ID: "$span.span_id",
+  OUTPUT: "$output",
+  OUTPUT_TYPE: "$mime_type_output",
+  STYLE: "$style",
+  STYLE_ICON: "$style.icon",
+  STYLE_VARIANT: "$style.variant",
+  STYLE_ACCESSORY: "$style.accessory",
+  METADATA: "$metadata",
+  TRIGGER: "$trigger",
+  PAYLOAD: "$payload",
+  PAYLOAD_TYPE: "$mime_type_payload",
+  SHOW: "$show",
+  SHOW_ACTIONS: "$show.actions",
+  WORKER_ID: "worker.id",
+  WORKER_VERSION: "worker.version",
+  CLI_VERSION: "cli.version",
+  SDK_VERSION: "sdk.version",
+  SDK_LANGUAGE: "sdk.language",
+  RETRY_AT: "retry.at",
+  RETRY_DELAY: "retry.delay",
+  RETRY_COUNT: "retry.count",
+  LINK_TITLE: "$link.title",
+  IDEMPOTENCY_KEY: "ctx.run.idempotencyKey",
+  USAGE_DURATION_MS: "$usage.durationMs",
+  USAGE_COST_IN_CENTS: "$usage.costInCents",
+  RATE_LIMIT_LIMIT: "response.rateLimit.limit",
+  RATE_LIMIT_REMAINING: "response.rateLimit.remaining",
+  RATE_LIMIT_RESET: "response.rateLimit.reset"
+};
+
+// src/v3/utils/flattenAttributes.ts
+var NULL_SENTINEL = "$@null((";
+function flattenAttributes(obj, prefix) {
+  const result = {};
+  if (obj === void 0) {
+    return result;
+  }
+  if (obj === null) {
+    result[prefix || ""] = NULL_SENTINEL;
+    return result;
+  }
+  if (typeof obj === "string") {
+    result[prefix || ""] = obj;
+    return result;
+  }
+  if (typeof obj === "number") {
+    result[prefix || ""] = obj;
+    return result;
+  }
+  if (typeof obj === "boolean") {
+    result[prefix || ""] = obj;
+    return result;
+  }
+  for (const [key, value] of Object.entries(obj)) {
+    const newPrefix = `${prefix ? `${prefix}.` : ""}${Array.isArray(obj) ? `[${key}]` : key}`;
+    if (Array.isArray(value)) {
+      for (let i = 0; i < value.length; i++) {
+        if (typeof value[i] === "object" && value[i] !== null) {
+          Object.assign(result, flattenAttributes(value[i], `${newPrefix}.[${i}]`));
+        } else {
+          if (value[i] === null) {
+            result[`${newPrefix}.[${i}]`] = NULL_SENTINEL;
+          } else {
+            result[`${newPrefix}.[${i}]`] = value[i];
+          }
+        }
+      }
+    } else if (isRecord(value)) {
+      Object.assign(result, flattenAttributes(value, newPrefix));
+    } else {
+      if (typeof value === "number" || typeof value === "string" || typeof value === "boolean") {
+        result[newPrefix] = value;
+      } else if (value === null) {
+        result[newPrefix] = NULL_SENTINEL;
+      }
+    }
+  }
+  return result;
+}
+__name(flattenAttributes, "flattenAttributes");
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+__name(isRecord, "isRecord");
+
+// src/v3/utils/styleAttributes.ts
+function accessoryAttributes(accessory) {
+  return flattenAttributes(accessory, SemanticInternalAttributes.STYLE_ACCESSORY);
+}
+__name(accessoryAttributes, "accessoryAttributes");
+
+// src/v3/apiClient/pagination.ts
+var _CursorPage = class _CursorPage {
+  constructor(data, pagination, pageFetcher) {
+    this.pageFetcher = pageFetcher;
+    this.data = data;
+    this.pagination = pagination;
+  }
+  getPaginatedItems() {
+    return this.data ?? [];
+  }
+  hasNextPage() {
+    return !!this.pagination.next;
+  }
+  hasPreviousPage() {
+    return !!this.pagination.previous;
+  }
+  getNextPage() {
+    if (!this.pagination.next) {
+      throw new Error("No next page available");
+    }
+    return this.pageFetcher({
+      after: this.pagination.next
+    });
+  }
+  getPreviousPage() {
+    if (!this.pagination.previous) {
+      throw new Error("No previous page available");
+    }
+    return this.pageFetcher({
+      before: this.pagination.previous
+    });
+  }
+  async *iterPages() {
+    let page = this;
+    yield page;
+    while (page.hasNextPage()) {
+      page = await page.getNextPage();
+      yield page;
+    }
+  }
+  async *[Symbol.asyncIterator]() {
+    for await (const page of this.iterPages()) {
+      for (const item of page.getPaginatedItems()) {
+        yield item;
+      }
+    }
+  }
+};
+__name(_CursorPage, "CursorPage");
+var CursorPage = _CursorPage;
+var _OffsetLimitPage = class _OffsetLimitPage {
+  constructor(data, pagination, pageFetcher) {
+    this.pageFetcher = pageFetcher;
+    this.data = data;
+    this.pagination = pagination;
+  }
+  getPaginatedItems() {
+    return this.data ?? [];
+  }
+  hasNextPage() {
+    return this.pagination.currentPage < this.pagination.totalPages;
+  }
+  hasPreviousPage() {
+    return this.pagination.currentPage > 1;
+  }
+  getNextPage() {
+    if (!this.hasNextPage()) {
+      throw new Error("No next page available");
+    }
+    return this.pageFetcher({
+      page: this.pagination.currentPage + 1
+    });
+  }
+  getPreviousPage() {
+    if (!this.hasPreviousPage()) {
+      throw new Error("No previous page available");
+    }
+    return this.pageFetcher({
+      page: this.pagination.currentPage - 1
+    });
+  }
+  async *iterPages() {
+    let page = this;
+    yield page;
+    while (page.hasNextPage()) {
+      page = await page.getNextPage();
+      yield page;
+    }
+  }
+  async *[Symbol.asyncIterator]() {
+    for await (const page of this.iterPages()) {
+      for (const item of page.getPaginatedItems()) {
+        yield item;
+      }
+    }
+  }
+};
+__name(_OffsetLimitPage, "OffsetLimitPage");
+var OffsetLimitPage = _OffsetLimitPage;
+
+// src/v3/apiClient/core.ts
+var defaultRetryOptions2 = {
+  maxAttempts: 3,
+  factor: 2,
+  minTimeoutInMs: 1e3,
+  maxTimeoutInMs: 6e4,
+  randomize: false
+};
+var requestOptionsKeys = {
+  retry: true
+};
+var isRequestOptions = /* @__PURE__ */ __name((obj) => {
+  return typeof obj === "object" && obj !== null && !isEmptyObj(obj) && Object.keys(obj).every((k) => hasOwn(requestOptionsKeys, k));
+}, "isRequestOptions");
+function zodfetch(schema, url, requestInit, options) {
+  return new ApiPromise(_doZodFetch(schema, url, requestInit, options));
+}
+__name(zodfetch, "zodfetch");
+function zodfetchCursorPage(schema, url, params, requestInit, options) {
+  const query = new URLSearchParams(params.query);
+  if (params.limit) {
+    query.set("page[size]", String(params.limit));
+  }
+  if (params.after) {
+    query.set("page[after]", params.after);
+  }
+  if (params.before) {
+    query.set("page[before]", params.before);
+  }
+  const cursorPageSchema = zod.z.object({
+    data: zod.z.array(schema),
+    pagination: zod.z.object({
+      next: zod.z.string().optional(),
+      previous: zod.z.string().optional()
+    })
+  });
+  const $url = new URL(url);
+  $url.search = query.toString();
+  const fetchResult = _doZodFetch(cursorPageSchema, $url.href, requestInit, options);
+  return new CursorPagePromise(fetchResult, schema, url, params, requestInit, options);
+}
+__name(zodfetchCursorPage, "zodfetchCursorPage");
+function zodfetchOffsetLimitPage(schema, url, params, requestInit, options) {
+  const query = new URLSearchParams(params.query);
+  if (params.limit) {
+    query.set("perPage", String(params.limit));
+  }
+  if (params.page) {
+    query.set("page", String(params.page));
+  }
+  const offsetLimitPageSchema = zod.z.object({
+    data: zod.z.array(schema),
+    pagination: zod.z.object({
+      currentPage: zod.z.coerce.number(),
+      totalPages: zod.z.coerce.number(),
+      count: zod.z.coerce.number()
+    })
+  });
+  const $url = new URL(url);
+  $url.search = query.toString();
+  const fetchResult = _doZodFetch(offsetLimitPageSchema, $url.href, requestInit, options);
+  return new OffsetLimitPagePromise(fetchResult, schema, url, params, requestInit, options);
+}
+__name(zodfetchOffsetLimitPage, "zodfetchOffsetLimitPage");
+async function traceZodFetch(params, callback) {
+  if (!params.options?.tracer) {
+    return callback();
+  }
+  const url = new URL(params.url);
+  const method = params.requestInit?.method ?? "GET";
+  const name = params.options.name ?? `${method} ${url.pathname}`;
+  return await params.options.tracer.startActiveSpan(name, async (span) => {
+    return await callback(span);
+  }, {
+    attributes: {
+      [SemanticInternalAttributes.STYLE_ICON]: params.options?.icon ?? "api",
+      ...params.options.attributes
+    }
+  });
+}
+__name(traceZodFetch, "traceZodFetch");
+async function _doZodFetch(schema, url, requestInit, options) {
+  const $requestInit = await requestInit;
+  return traceZodFetch({
+    url,
+    requestInit: $requestInit,
+    options
+  }, async (span) => {
+    const result = await _doZodFetchWithRetries(schema, url, $requestInit, options);
+    if (options?.onResponseBody && span) {
+      options.onResponseBody(result.data, span);
+    }
+    return result;
+  });
+}
+__name(_doZodFetch, "_doZodFetch");
+async function _doZodFetchWithRetries(schema, url, requestInit, options, attempt = 1) {
+  try {
+    const response = await fetch(url, requestInitWithCache(requestInit));
+    const responseHeaders = createResponseHeaders(response.headers);
+    if (!response.ok) {
+      const retryResult = shouldRetry(response, attempt, options?.retry);
+      if (retryResult.retry) {
+        await waitForRetry(url, attempt + 1, retryResult.delay, options, requestInit, response);
+        return await _doZodFetchWithRetries(schema, url, requestInit, options, attempt + 1);
+      } else {
+        const errText = await response.text().catch((e) => castToError2(e).message);
+        const errJSON = safeJsonParse(errText);
+        const errMessage = errJSON ? void 0 : errText;
+        throw ApiError.generate(response.status, errJSON, errMessage, responseHeaders);
+      }
+    }
+    const jsonBody = await response.json();
+    const parsedResult = schema.safeParse(jsonBody);
+    if (parsedResult.success) {
+      return {
+        data: parsedResult.data,
+        response
+      };
+    }
+    throw zodValidationError.fromZodError(parsedResult.error);
+  } catch (error) {
+    if (error instanceof ApiError) {
+      throw error;
+    }
+    if (options?.retry) {
+      const retry = {
+        ...defaultRetryOptions2,
+        ...options.retry
+      };
+      const delay = calculateNextRetryDelay(retry, attempt);
+      if (delay) {
+        await waitForRetry(url, attempt + 1, delay, options, requestInit);
+        return await _doZodFetchWithRetries(schema, url, requestInit, options, attempt + 1);
+      }
+    }
+    throw new ApiConnectionError({
+      cause: castToError2(error)
+    });
+  }
+}
+__name(_doZodFetchWithRetries, "_doZodFetchWithRetries");
+function castToError2(err) {
+  if (err instanceof Error)
+    return err;
+  return new Error(err);
+}
+__name(castToError2, "castToError");
+function shouldRetry(response, attempt, retryOptions) {
+  function shouldRetryForOptions() {
+    const retry = {
+      ...defaultRetryOptions2,
+      ...retryOptions
+    };
+    const delay = calculateNextRetryDelay(retry, attempt);
+    if (delay) {
+      return {
+        retry: true,
+        delay
+      };
+    } else {
+      return {
+        retry: false
+      };
+    }
+  }
+  __name(shouldRetryForOptions, "shouldRetryForOptions");
+  const shouldRetryHeader = response.headers.get("x-should-retry");
+  if (shouldRetryHeader === "true")
+    return shouldRetryForOptions();
+  if (shouldRetryHeader === "false")
+    return {
+      retry: false
+    };
+  if (response.status === 408)
+    return shouldRetryForOptions();
+  if (response.status === 409)
+    return shouldRetryForOptions();
+  if (response.status === 429) {
+    if (attempt >= (typeof retryOptions?.maxAttempts === "number" ? retryOptions?.maxAttempts : 3)) {
+      return {
+        retry: false
+      };
+    }
+    const resetAtUnixEpochMs = response.headers.get("x-ratelimit-reset");
+    if (resetAtUnixEpochMs) {
+      const resetAtUnixEpoch = parseInt(resetAtUnixEpochMs, 10);
+      const delay = resetAtUnixEpoch - Date.now() + Math.floor(Math.random() * 1e3);
+      if (delay > 0) {
+        return {
+          retry: true,
+          delay
+        };
+      }
+    }
+    return shouldRetryForOptions();
+  }
+  if (response.status >= 500)
+    return shouldRetryForOptions();
+  return {
+    retry: false
+  };
+}
+__name(shouldRetry, "shouldRetry");
+function safeJsonParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch (e) {
+    return void 0;
+  }
+}
+__name(safeJsonParse, "safeJsonParse");
+function createResponseHeaders(headers) {
+  return new Proxy(Object.fromEntries(
+    // @ts-ignore
+    headers.entries()
+  ), {
+    get(target, name) {
+      const key = name.toString();
+      return target[key.toLowerCase()] || target[key];
+    }
+  });
+}
+__name(createResponseHeaders, "createResponseHeaders");
+function requestInitWithCache(requestInit) {
+  try {
+    const withCache = {
+      ...requestInit,
+      cache: "no-cache"
+    };
+    const _ = new Request("http://localhost", withCache);
+    return withCache;
+  } catch (error) {
+    return requestInit ?? {};
+  }
+}
+__name(requestInitWithCache, "requestInitWithCache");
+var _ApiPromise = class _ApiPromise extends Promise {
+  constructor(responsePromise) {
+    super((resolve) => {
+      resolve(null);
+    });
+    this.responsePromise = responsePromise;
+  }
+  /**
+  * Gets the raw `Response` instance instead of parsing the response
+  * data.
+  *
+  * If you want to parse the response body but still get the `Response`
+  * instance, you can use {@link withResponse()}.
+  */
+  asResponse() {
+    return this.responsePromise.then((p) => p.response);
+  }
+  /**
+  * Gets the parsed response data and the raw `Response` instance.
+  *
+  * If you just want to get the raw `Response` instance without parsing it,
+  * you can use {@link asResponse()}.
+  */
+  async withResponse() {
+    const [data, response] = await Promise.all([
+      this.parse(),
+      this.asResponse()
+    ]);
+    return {
+      data,
+      response
+    };
+  }
+  parse() {
+    return this.responsePromise.then((result) => result.data);
+  }
+  then(onfulfilled, onrejected) {
+    return this.parse().then(onfulfilled, onrejected);
+  }
+  catch(onrejected) {
+    return this.parse().catch(onrejected);
+  }
+  finally(onfinally) {
+    return this.parse().finally(onfinally);
+  }
+};
+__name(_ApiPromise, "ApiPromise");
+var ApiPromise = _ApiPromise;
+var _fetchPage, fetchPage_fn;
+var _CursorPagePromise = class _CursorPagePromise extends ApiPromise {
+  constructor(result, schema, url, params, requestInit, options) {
+    super(result.then((result2) => ({
+      data: new CursorPage(result2.data.data, result2.data.pagination, __privateMethod(this, _fetchPage, fetchPage_fn).bind(this)),
+      response: result2.response
+    })));
+    __privateAdd(this, _fetchPage);
+    this.schema = schema;
+    this.url = url;
+    this.params = params;
+    this.requestInit = requestInit;
+    this.options = options;
+  }
+  /**
+  * Allow auto-paginating iteration on an unawaited list call, eg:
+  *
+  *    for await (const item of client.items.list()) {
+  *      console.log(item)
+  *    }
+  */
+  async *[Symbol.asyncIterator]() {
+    const page = await this;
+    for await (const item of page) {
+      yield item;
+    }
+  }
+};
+_fetchPage = new WeakSet();
+fetchPage_fn = /* @__PURE__ */ __name(function(params) {
+  return zodfetchCursorPage(this.schema, this.url, {
+    ...this.params,
+    ...params
+  }, this.requestInit, this.options);
+}, "#fetchPage");
+__name(_CursorPagePromise, "CursorPagePromise");
+var CursorPagePromise = _CursorPagePromise;
+var _fetchPage2, fetchPage_fn2;
+var _OffsetLimitPagePromise = class _OffsetLimitPagePromise extends ApiPromise {
+  constructor(result, schema, url, params, requestInit, options) {
+    super(result.then((result2) => ({
+      data: new OffsetLimitPage(result2.data.data, result2.data.pagination, __privateMethod(this, _fetchPage2, fetchPage_fn2).bind(this)),
+      response: result2.response
+    })));
+    __privateAdd(this, _fetchPage2);
+    this.schema = schema;
+    this.url = url;
+    this.params = params;
+    this.requestInit = requestInit;
+    this.options = options;
+  }
+  /**
+  * Allow auto-paginating iteration on an unawaited list call, eg:
+  *
+  *    for await (const item of client.items.list()) {
+  *      console.log(item)
+  *    }
+  */
+  async *[Symbol.asyncIterator]() {
+    const page = await this;
+    for await (const item of page) {
+      yield item;
+    }
+  }
+};
+_fetchPage2 = new WeakSet();
+fetchPage_fn2 = /* @__PURE__ */ __name(function(params1) {
+  return zodfetchOffsetLimitPage(this.schema, this.url, {
+    ...this.params,
+    ...params1
+  }, this.requestInit, this.options);
+}, "#fetchPage");
+__name(_OffsetLimitPagePromise, "OffsetLimitPagePromise");
+var OffsetLimitPagePromise = _OffsetLimitPagePromise;
+async function waitForRetry(url, attempt, delay, options, requestInit, response) {
+  if (options?.tracer) {
+    const method = requestInit?.method ?? "GET";
+    return options.tracer.startActiveSpan(response ? `wait after ${response.status}` : `wait after error`, async (span) => {
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }, {
+      attributes: {
+        [SemanticInternalAttributes.STYLE_ICON]: "wait",
+        ...accessoryAttributes({
+          items: [
+            {
+              text: `retrying ${options?.name ?? method.toUpperCase()} in ${delay}ms`,
+              variant: "normal"
+            }
+          ],
+          style: "codepath"
+        })
+      }
+    });
+  }
+  await new Promise((resolve) => setTimeout(resolve, delay));
+}
+__name(waitForRetry, "waitForRetry");
+function isEmptyObj(obj) {
+  if (!obj)
+    return true;
+  for (const _k in obj)
+    return false;
+  return true;
+}
+__name(isEmptyObj, "isEmptyObj");
+function hasOwn(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+__name(hasOwn, "hasOwn");
+
+exports.ApiConnectionError = ApiConnectionError;
+exports.ApiError = ApiError;
+exports.ApiPromise = ApiPromise;
+exports.AuthenticationError = AuthenticationError;
+exports.BadRequestError = BadRequestError;
+exports.ConflictError = ConflictError;
+exports.CursorPage = CursorPage;
+exports.CursorPagePromise = CursorPagePromise;
+exports.InternalServerError = InternalServerError;
+exports.NotFoundError = NotFoundError;
+exports.OffsetLimitPage = OffsetLimitPage;
+exports.OffsetLimitPagePromise = OffsetLimitPagePromise;
+exports.PermissionDeniedError = PermissionDeniedError;
+exports.RateLimitError = RateLimitError;
+exports.UnprocessableEntityError = UnprocessableEntityError;
+exports.defaultRetryOptions = defaultRetryOptions2;
+exports.hasOwn = hasOwn;
+exports.isEmptyObj = isEmptyObj;
+exports.isRequestOptions = isRequestOptions;
+exports.zodfetch = zodfetch;
+exports.zodfetchCursorPage = zodfetchCursorPage;
+exports.zodfetchOffsetLimitPage = zodfetchOffsetLimitPage;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=zodfetch.js.map