@trigger.dev/core 0.0.0-v3-prerelease-20240813130521 → 0.0.0-v3-prerelease-20240912191953

package/dist/v3/zodfetch.js

@@ -1,834 +0,0 @@
-'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