@runpod/typescript-api-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,1323 @@
+// node_modules/.pnpm/openapi-fetch@0.17.0/node_modules/openapi-fetch/dist/index.mjs
+var PATH_PARAM_RE = /\{[^{}]+\}/g;
+var supportsRequestInitExt = () => {
+  return typeof process === "object" && Number.parseInt(process?.versions?.node?.substring(0, 2)) >= 18 && process.versions.undici;
+};
+function randomID() {
+  return Math.random().toString(36).slice(2, 11);
+}
+function createClient(clientOptions) {
+  let {
+    baseUrl = "",
+    Request: CustomRequest = globalThis.Request,
+    fetch: baseFetch = globalThis.fetch,
+    querySerializer: globalQuerySerializer,
+    bodySerializer: globalBodySerializer,
+    pathSerializer: globalPathSerializer,
+    headers: baseHeaders,
+    requestInitExt = void 0,
+    ...baseOptions
+  } = { ...clientOptions };
+  requestInitExt = supportsRequestInitExt() ? requestInitExt : void 0;
+  baseUrl = removeTrailingSlash(baseUrl);
+  const globalMiddlewares = [];
+  async function coreFetch(schemaPath, fetchOptions) {
+    const {
+      baseUrl: localBaseUrl,
+      fetch = baseFetch,
+      Request: Request2 = CustomRequest,
+      headers,
+      params = {},
+      parseAs = "json",
+      querySerializer: requestQuerySerializer,
+      bodySerializer = globalBodySerializer ?? defaultBodySerializer,
+      pathSerializer: requestPathSerializer,
+      body,
+      middleware: requestMiddlewares = [],
+      ...init
+    } = fetchOptions || {};
+    let finalBaseUrl = baseUrl;
+    if (localBaseUrl) {
+      finalBaseUrl = removeTrailingSlash(localBaseUrl) ?? baseUrl;
+    }
+    let querySerializer = typeof globalQuerySerializer === "function" ? globalQuerySerializer : createQuerySerializer(globalQuerySerializer);
+    if (requestQuerySerializer) {
+      querySerializer = typeof requestQuerySerializer === "function" ? requestQuerySerializer : createQuerySerializer({
+        ...typeof globalQuerySerializer === "object" ? globalQuerySerializer : {},
+        ...requestQuerySerializer
+      });
+    }
+    const pathSerializer = requestPathSerializer || globalPathSerializer || defaultPathSerializer;
+    const serializedBody = body === void 0 ? void 0 : bodySerializer(
+      body,
+      // Note: we declare mergeHeaders() both here and below because it’s a bit of a chicken-or-egg situation:
+      // bodySerializer() needs all headers so we aren’t dropping ones set by the user, however,
+      // the result of this ALSO sets the lowest-priority content-type header. So we re-merge below,
+      // setting the content-type at the very beginning to be overwritten.
+      // Lastly, based on the way headers work, it’s not a simple “present-or-not” check becauase null intentionally un-sets headers.
+      mergeHeaders(baseHeaders, headers, params.header)
+    );
+    const finalHeaders = mergeHeaders(
+      // with no body, we should not to set Content-Type
+      serializedBody === void 0 || // if serialized body is FormData; browser will correctly set Content-Type & boundary expression
+      serializedBody instanceof FormData ? {} : {
+        "Content-Type": "application/json"
+      },
+      baseHeaders,
+      headers,
+      params.header
+    );
+    const finalMiddlewares = [...globalMiddlewares, ...requestMiddlewares];
+    const requestInit = {
+      redirect: "follow",
+      ...baseOptions,
+      ...init,
+      body: serializedBody,
+      headers: finalHeaders
+    };
+    let id;
+    let options;
+    let request = new Request2(
+      createFinalURL(schemaPath, { baseUrl: finalBaseUrl, params, querySerializer, pathSerializer }),
+      requestInit
+    );
+    let response;
+    for (const key in init) {
+      if (!(key in request)) {
+        request[key] = init[key];
+      }
+    }
+    if (finalMiddlewares.length) {
+      id = randomID();
+      options = Object.freeze({
+        baseUrl: finalBaseUrl,
+        fetch,
+        parseAs,
+        querySerializer,
+        bodySerializer,
+        pathSerializer
+      });
+      for (const m of finalMiddlewares) {
+        if (m && typeof m === "object" && typeof m.onRequest === "function") {
+          const result = await m.onRequest({
+            request,
+            schemaPath,
+            params,
+            options,
+            id
+          });
+          if (result) {
+            if (result instanceof Request2) {
+              request = result;
+            } else if (result instanceof Response) {
+              response = result;
+              break;
+            } else {
+              throw new Error("onRequest: must return new Request() or Response() when modifying the request");
+            }
+          }
+        }
+      }
+    }
+    if (!response) {
+      try {
+        response = await fetch(request, requestInitExt);
+      } catch (error2) {
+        let errorAfterMiddleware = error2;
+        if (finalMiddlewares.length) {
+          for (let i = finalMiddlewares.length - 1; i >= 0; i--) {
+            const m = finalMiddlewares[i];
+            if (m && typeof m === "object" && typeof m.onError === "function") {
+              const result = await m.onError({
+                request,
+                error: errorAfterMiddleware,
+                schemaPath,
+                params,
+                options,
+                id
+              });
+              if (result) {
+                if (result instanceof Response) {
+                  errorAfterMiddleware = void 0;
+                  response = result;
+                  break;
+                }
+                if (result instanceof Error) {
+                  errorAfterMiddleware = result;
+                  continue;
+                }
+                throw new Error("onError: must return new Response() or instance of Error");
+              }
+            }
+          }
+        }
+        if (errorAfterMiddleware) {
+          throw errorAfterMiddleware;
+        }
+      }
+      if (finalMiddlewares.length) {
+        for (let i = finalMiddlewares.length - 1; i >= 0; i--) {
+          const m = finalMiddlewares[i];
+          if (m && typeof m === "object" && typeof m.onResponse === "function") {
+            const result = await m.onResponse({
+              request,
+              response,
+              schemaPath,
+              params,
+              options,
+              id
+            });
+            if (result) {
+              if (!(result instanceof Response)) {
+                throw new Error("onResponse: must return new Response() when modifying the response");
+              }
+              response = result;
+            }
+          }
+        }
+      }
+    }
+    const contentLength = response.headers.get("Content-Length");
+    if (response.status === 204 || request.method === "HEAD" || contentLength === "0" && !response.headers.get("Transfer-Encoding")?.includes("chunked")) {
+      return response.ok ? { data: void 0, response } : { error: void 0, response };
+    }
+    if (response.ok) {
+      const getResponseData = async () => {
+        if (parseAs === "stream") {
+          return response.body;
+        }
+        if (parseAs === "json" && !contentLength) {
+          const raw = await response.text();
+          return raw ? JSON.parse(raw) : void 0;
+        }
+        return await response[parseAs]();
+      };
+      return { data: await getResponseData(), response };
+    }
+    let error = await response.text();
+    try {
+      error = JSON.parse(error);
+    } catch {
+    }
+    return { error, response };
+  }
+  return {
+    request(method, url, init) {
+      return coreFetch(url, { ...init, method: method.toUpperCase() });
+    },
+    /** Call a GET endpoint */
+    GET(url, init) {
+      return coreFetch(url, { ...init, method: "GET" });
+    },
+    /** Call a PUT endpoint */
+    PUT(url, init) {
+      return coreFetch(url, { ...init, method: "PUT" });
+    },
+    /** Call a POST endpoint */
+    POST(url, init) {
+      return coreFetch(url, { ...init, method: "POST" });
+    },
+    /** Call a DELETE endpoint */
+    DELETE(url, init) {
+      return coreFetch(url, { ...init, method: "DELETE" });
+    },
+    /** Call a OPTIONS endpoint */
+    OPTIONS(url, init) {
+      return coreFetch(url, { ...init, method: "OPTIONS" });
+    },
+    /** Call a HEAD endpoint */
+    HEAD(url, init) {
+      return coreFetch(url, { ...init, method: "HEAD" });
+    },
+    /** Call a PATCH endpoint */
+    PATCH(url, init) {
+      return coreFetch(url, { ...init, method: "PATCH" });
+    },
+    /** Call a TRACE endpoint */
+    TRACE(url, init) {
+      return coreFetch(url, { ...init, method: "TRACE" });
+    },
+    /** Register middleware */
+    use(...middleware) {
+      for (const m of middleware) {
+        if (!m) {
+          continue;
+        }
+        if (typeof m !== "object" || !("onRequest" in m || "onResponse" in m || "onError" in m)) {
+          throw new Error("Middleware must be an object with one of `onRequest()`, `onResponse() or `onError()`");
+        }
+        globalMiddlewares.push(m);
+      }
+    },
+    /** Unregister middleware */
+    eject(...middleware) {
+      for (const m of middleware) {
+        const i = globalMiddlewares.indexOf(m);
+        if (i !== -1) {
+          globalMiddlewares.splice(i, 1);
+        }
+      }
+    }
+  };
+}
+function serializePrimitiveParam(name, value, options) {
+  if (value === void 0 || value === null) {
+    return "";
+  }
+  if (typeof value === "object") {
+    throw new Error(
+      "Deeply-nested arrays/objects aren\u2019t supported. Provide your own `querySerializer()` to handle these."
+    );
+  }
+  return `${name}=${options?.allowReserved === true ? value : encodeURIComponent(value)}`;
+}
+function serializeObjectParam(name, value, options) {
+  if (!value || typeof value !== "object") {
+    return "";
+  }
+  const values = [];
+  const joiner = {
+    simple: ",",
+    label: ".",
+    matrix: ";"
+  }[options.style] || "&";
+  if (options.style !== "deepObject" && options.explode === false) {
+    for (const k in value) {
+      values.push(k, options.allowReserved === true ? value[k] : encodeURIComponent(value[k]));
+    }
+    const final2 = values.join(",");
+    switch (options.style) {
+      case "form": {
+        return `${name}=${final2}`;
+      }
+      case "label": {
+        return `.${final2}`;
+      }
+      case "matrix": {
+        return `;${name}=${final2}`;
+      }
+      default: {
+        return final2;
+      }
+    }
+  }
+  for (const k in value) {
+    const finalName = options.style === "deepObject" ? `${name}[${k}]` : k;
+    values.push(serializePrimitiveParam(finalName, value[k], options));
+  }
+  const final = values.join(joiner);
+  return options.style === "label" || options.style === "matrix" ? `${joiner}${final}` : final;
+}
+function serializeArrayParam(name, value, options) {
+  if (!Array.isArray(value)) {
+    return "";
+  }
+  if (options.explode === false) {
+    const joiner2 = { form: ",", spaceDelimited: "%20", pipeDelimited: "|" }[options.style] || ",";
+    const final = (options.allowReserved === true ? value : value.map((v) => encodeURIComponent(v))).join(joiner2);
+    switch (options.style) {
+      case "simple": {
+        return final;
+      }
+      case "label": {
+        return `.${final}`;
+      }
+      case "matrix": {
+        return `;${name}=${final}`;
+      }
+      // case "spaceDelimited":
+      // case "pipeDelimited":
+      default: {
+        return `${name}=${final}`;
+      }
+    }
+  }
+  const joiner = { simple: ",", label: ".", matrix: ";" }[options.style] || "&";
+  const values = [];
+  for (const v of value) {
+    if (options.style === "simple" || options.style === "label") {
+      values.push(options.allowReserved === true ? v : encodeURIComponent(v));
+    } else {
+      values.push(serializePrimitiveParam(name, v, options));
+    }
+  }
+  return options.style === "label" || options.style === "matrix" ? `${joiner}${values.join(joiner)}` : values.join(joiner);
+}
+function createQuerySerializer(options) {
+  return function querySerializer(queryParams) {
+    const search = [];
+    if (queryParams && typeof queryParams === "object") {
+      for (const name in queryParams) {
+        const value = queryParams[name];
+        if (value === void 0 || value === null) {
+          continue;
+        }
+        if (Array.isArray(value)) {
+          if (value.length === 0) {
+            continue;
+          }
+          search.push(
+            serializeArrayParam(name, value, {
+              style: "form",
+              explode: true,
+              ...options?.array,
+              allowReserved: options?.allowReserved || false
+            })
+          );
+          continue;
+        }
+        if (typeof value === "object") {
+          search.push(
+            serializeObjectParam(name, value, {
+              style: "deepObject",
+              explode: true,
+              ...options?.object,
+              allowReserved: options?.allowReserved || false
+            })
+          );
+          continue;
+        }
+        search.push(serializePrimitiveParam(name, value, options));
+      }
+    }
+    return search.join("&");
+  };
+}
+function defaultPathSerializer(pathname, pathParams) {
+  let nextURL = pathname;
+  for (const match of pathname.match(PATH_PARAM_RE) ?? []) {
+    let name = match.substring(1, match.length - 1);
+    let explode = false;
+    let style = "simple";
+    if (name.endsWith("*")) {
+      explode = true;
+      name = name.substring(0, name.length - 1);
+    }
+    if (name.startsWith(".")) {
+      style = "label";
+      name = name.substring(1);
+    } else if (name.startsWith(";")) {
+      style = "matrix";
+      name = name.substring(1);
+    }
+    if (!pathParams || pathParams[name] === void 0 || pathParams[name] === null) {
+      continue;
+    }
+    const value = pathParams[name];
+    if (Array.isArray(value)) {
+      nextURL = nextURL.replace(match, serializeArrayParam(name, value, { style, explode }));
+      continue;
+    }
+    if (typeof value === "object") {
+      nextURL = nextURL.replace(match, serializeObjectParam(name, value, { style, explode }));
+      continue;
+    }
+    if (style === "matrix") {
+      nextURL = nextURL.replace(match, `;${serializePrimitiveParam(name, value)}`);
+      continue;
+    }
+    nextURL = nextURL.replace(match, style === "label" ? `.${encodeURIComponent(value)}` : encodeURIComponent(value));
+  }
+  return nextURL;
+}
+function defaultBodySerializer(body, headers) {
+  if (body instanceof FormData) {
+    return body;
+  }
+  if (headers) {
+    const contentType = headers.get instanceof Function ? headers.get("Content-Type") ?? headers.get("content-type") : headers["Content-Type"] ?? headers["content-type"];
+    if (contentType === "application/x-www-form-urlencoded") {
+      return new URLSearchParams(body).toString();
+    }
+  }
+  return JSON.stringify(body);
+}
+function createFinalURL(pathname, options) {
+  let finalURL = `${options.baseUrl}${pathname}`;
+  if (options.params?.path) {
+    finalURL = options.pathSerializer(finalURL, options.params.path);
+  }
+  let search = options.querySerializer(options.params.query ?? {});
+  if (search.startsWith("?")) {
+    search = search.substring(1);
+  }
+  if (search) {
+    finalURL += `?${search}`;
+  }
+  return finalURL;
+}
+function mergeHeaders(...allHeaders) {
+  const finalHeaders = new Headers();
+  for (const h of allHeaders) {
+    if (!h || typeof h !== "object") {
+      continue;
+    }
+    const iterator = h instanceof Headers ? h.entries() : Object.entries(h);
+    for (const [k, v] of iterator) {
+      if (v === null) {
+        finalHeaders.delete(k);
+      } else if (Array.isArray(v)) {
+        for (const v2 of v) {
+          finalHeaders.append(k, v2);
+        }
+      } else if (v !== void 0) {
+        finalHeaders.set(k, v);
+      }
+    }
+  }
+  return finalHeaders;
+}
+function removeTrailingSlash(url) {
+  if (url.endsWith("/")) {
+    return url.substring(0, url.length - 1);
+  }
+  return url;
+}
+
+// node_modules/.pnpm/structured-headers@2.1.0/node_modules/structured-headers/dist/util.js
+var asciiRe = /^[\x20-\x7E]*$/;
+var tokenRe = /^[a-zA-Z*][:/!#$%&'*+\-.^_`|~A-Za-z0-9]*$/;
+function isAscii(str) {
+  return asciiRe.test(str);
+}
+function isValidTokenStr(str) {
+  return tokenRe.test(str);
+}
+function base64ToArrayBuffer(b64) {
+  const binaryString = atob(b64);
+  const len = binaryString.length;
+  const bytes = new Uint8Array(len);
+  for (let i = 0; i < len; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  return bytes.buffer;
+}
+
+// node_modules/.pnpm/structured-headers@2.1.0/node_modules/structured-headers/dist/token.js
+var Token = class {
+  constructor(value) {
+    if (!isValidTokenStr(value)) {
+      throw new TypeError("Invalid character in Token string. Tokens must start with *, A-Z and the rest of the string may only contain a-z, A-Z, 0-9, :/!#$%&'*+-.^_`|~");
+    }
+    this.value = value;
+  }
+  toString() {
+    return this.value;
+  }
+};
+
+// node_modules/.pnpm/structured-headers@2.1.0/node_modules/structured-headers/dist/displaystring.js
+var DisplayString = class {
+  constructor(value) {
+    this.value = value;
+  }
+  toString() {
+    return this.value;
+  }
+};
+
+// node_modules/.pnpm/structured-headers@2.1.0/node_modules/structured-headers/dist/parser.js
+function parseList(input) {
+  const parser = new Parser(input);
+  return parser.parseList();
+}
+var ParseError = class extends Error {
+  constructor(position, message) {
+    super(`Parse error: ${message} at offset ${position}`);
+  }
+};
+var Parser = class {
+  constructor(input) {
+    this.input = input;
+    this.pos = 0;
+  }
+  parseDictionary() {
+    this.skipWS();
+    const dictionary = /* @__PURE__ */ new Map();
+    while (!this.eof()) {
+      const thisKey = this.parseKey();
+      let member;
+      if (this.lookChar() === "=") {
+        this.pos++;
+        member = this.parseItemOrInnerList();
+      } else {
+        member = [true, this.parseParameters()];
+      }
+      dictionary.set(thisKey, member);
+      this.skipOWS();
+      if (this.eof()) {
+        return dictionary;
+      }
+      this.expectChar(",");
+      this.pos++;
+      this.skipOWS();
+      if (this.eof()) {
+        throw new ParseError(this.pos, "Dictionary contained a trailing comma");
+      }
+    }
+    return dictionary;
+  }
+  parseList() {
+    this.skipWS();
+    const members = [];
+    while (!this.eof()) {
+      members.push(this.parseItemOrInnerList());
+      this.skipOWS();
+      if (this.eof()) {
+        return members;
+      }
+      this.expectChar(",");
+      this.pos++;
+      this.skipOWS();
+      if (this.eof()) {
+        throw new ParseError(this.pos, "A list may not end with a trailing comma");
+      }
+    }
+    return members;
+  }
+  parseItem(standaloneItem = true) {
+    if (standaloneItem)
+      this.skipWS();
+    const result = [
+      this.parseBareItem(),
+      this.parseParameters()
+    ];
+    if (standaloneItem)
+      this.checkTrail();
+    return result;
+  }
+  parseItemOrInnerList() {
+    if (this.lookChar() === "(") {
+      return this.parseInnerList();
+    } else {
+      return this.parseItem(false);
+    }
+  }
+  parseInnerList() {
+    this.expectChar("(");
+    this.pos++;
+    const innerList = [];
+    while (!this.eof()) {
+      this.skipWS();
+      if (this.lookChar() === ")") {
+        this.pos++;
+        return [
+          innerList,
+          this.parseParameters()
+        ];
+      }
+      innerList.push(this.parseItem(false));
+      const nextChar = this.lookChar();
+      if (nextChar !== " " && nextChar !== ")") {
+        throw new ParseError(this.pos, "Expected a whitespace or ) after every item in an inner list");
+      }
+    }
+    throw new ParseError(this.pos, "Could not find end of inner list");
+  }
+  parseBareItem() {
+    const char = this.lookChar();
+    if (char === void 0) {
+      throw new ParseError(this.pos, "Unexpected end of string");
+    }
+    if (char.match(/^[-0-9]/)) {
+      return this.parseIntegerOrDecimal();
+    }
+    if (char === '"') {
+      return this.parseString();
+    }
+    if (char.match(/^[A-Za-z*]/)) {
+      return this.parseToken();
+    }
+    if (char === ":") {
+      return this.parseByteSequence();
+    }
+    if (char === "?") {
+      return this.parseBoolean();
+    }
+    if (char === "@") {
+      return this.parseDate();
+    }
+    if (char === "%") {
+      return this.parseDisplayString();
+    }
+    throw new ParseError(this.pos, "Unexpected input");
+  }
+  parseParameters() {
+    const parameters = /* @__PURE__ */ new Map();
+    while (!this.eof()) {
+      const char = this.lookChar();
+      if (char !== ";") {
+        break;
+      }
+      this.pos++;
+      this.skipWS();
+      const key = this.parseKey();
+      let value = true;
+      if (this.lookChar() === "=") {
+        this.pos++;
+        value = this.parseBareItem();
+      }
+      parameters.set(key, value);
+    }
+    return parameters;
+  }
+  parseIntegerOrDecimal() {
+    let type = "integer";
+    let sign = 1;
+    let inputNumber = "";
+    if (this.lookChar() === "-") {
+      sign = -1;
+      this.pos++;
+    }
+    if (!isDigit(this.lookChar())) {
+      throw new ParseError(this.pos, "Expected a digit (0-9)");
+    }
+    while (!this.eof()) {
+      const char = this.getChar();
+      if (isDigit(char)) {
+        inputNumber += char;
+      } else if (type === "integer" && char === ".") {
+        if (inputNumber.length > 12) {
+          throw new ParseError(this.pos, "Exceeded maximum decimal length");
+        }
+        inputNumber += ".";
+        type = "decimal";
+      } else {
+        this.pos--;
+        break;
+      }
+      if (type === "integer" && inputNumber.length > 15) {
+        throw new ParseError(this.pos, "Exceeded maximum integer length");
+      }
+      if (type === "decimal" && inputNumber.length > 16) {
+        throw new ParseError(this.pos, "Exceeded maximum decimal length");
+      }
+    }
+    if (type === "integer") {
+      return parseInt(inputNumber, 10) * sign;
+    } else {
+      if (inputNumber.endsWith(".")) {
+        throw new ParseError(this.pos, "Decimal cannot end on a period");
+      }
+      if (inputNumber.split(".")[1].length > 3) {
+        throw new ParseError(this.pos, "Number of digits after the decimal point cannot exceed 3");
+      }
+      return parseFloat(inputNumber) * sign;
+    }
+  }
+  parseString() {
+    let outputString = "";
+    this.expectChar('"');
+    this.pos++;
+    while (!this.eof()) {
+      const char = this.getChar();
+      if (char === "\\") {
+        if (this.eof()) {
+          throw new ParseError(this.pos, "Unexpected end of input");
+        }
+        const nextChar = this.getChar();
+        if (nextChar !== "\\" && nextChar !== '"') {
+          throw new ParseError(this.pos, "A backslash must be followed by another backslash or double quote");
+        }
+        outputString += nextChar;
+      } else if (char === '"') {
+        return outputString;
+      } else if (!isAscii(char)) {
+        throw new ParseError(this.pos, "Strings must be in the ASCII range");
+      } else {
+        outputString += char;
+      }
+    }
+    throw new ParseError(this.pos, "Unexpected end of input");
+  }
+  parseDisplayString() {
+    const chars = this.getChars(2);
+    if (chars !== '%"') {
+      throw new ParseError(this.pos, "Unexpected character. Display strings should start with %=");
+    }
+    const result = [];
+    while (!this.eof()) {
+      const char = this.getChar();
+      if (char.charCodeAt(0) <= 31 || char.charCodeAt(0) >= 127 && char.charCodeAt(0) <= 255) {
+        throw new ParseError(this.pos, "Invalid char found in DisplayString. Did you forget to escape?");
+      }
+      if (char === "%") {
+        const hexChars = this.getChars(2);
+        if (/^[0-9a-f]{2}$/.test(hexChars)) {
+          result.push(parseInt(hexChars, 16));
+        } else {
+          throw new ParseError(this.pos, `Unexpected sequence after % in DispalyString: "${hexChars}". Note that hexidecimals must be lowercase`);
+        }
+        continue;
+      }
+      if (char === '"') {
+        const textDecoder = new TextDecoder("utf-8", {
+          fatal: true
+        });
+        try {
+          return new DisplayString(textDecoder.decode(new Uint8Array(result)));
+        } catch {
+          throw new ParseError(this.pos, "Fatal error decoding UTF-8 sequence in Display String");
+        }
+      }
+      result.push(char.charCodeAt(0));
+    }
+    throw new ParseError(this.pos, "Unexpected end of input");
+  }
+  parseToken() {
+    let outputString = "";
+    while (!this.eof()) {
+      const char = this.lookChar();
+      if (char === void 0 || !/^[:/!#$%&'*+\-.^_`|~A-Za-z0-9]$/.test(char)) {
+        return new Token(outputString);
+      }
+      outputString += this.getChar();
+    }
+    return new Token(outputString);
+  }
+  parseByteSequence() {
+    this.expectChar(":");
+    this.pos++;
+    const endPos = this.input.indexOf(":", this.pos);
+    if (endPos === -1) {
+      throw new ParseError(this.pos, 'Could not find a closing ":" character to mark end of Byte Sequence');
+    }
+    const b64Content = this.input.substring(this.pos, endPos);
+    this.pos += b64Content.length + 1;
+    if (!/^[A-Za-z0-9+/=]*$/.test(b64Content)) {
+      throw new ParseError(this.pos, "ByteSequence does not contain a valid base64 string");
+    }
+    try {
+      return base64ToArrayBuffer(b64Content);
+    } catch {
+      throw new ParseError(this.pos, "ByteSequence does not contain a valid base64 string");
+    }
+  }
+  parseBoolean() {
+    this.expectChar("?");
+    this.pos++;
+    const char = this.getChar();
+    if (char === "1") {
+      return true;
+    }
+    if (char === "0") {
+      return false;
+    }
+    throw new ParseError(this.pos, 'Unexpected character. Expected a "1" or a "0"');
+  }
+  parseDate() {
+    this.expectChar("@");
+    this.pos++;
+    let sign = 1;
+    let inputNumber = "";
+    if (this.lookChar() === "-") {
+      sign = -1;
+      this.pos++;
+    }
+    if (!isDigit(this.lookChar())) {
+      throw new ParseError(this.pos, "Expected a digit (0-9)");
+    }
+    while (!this.eof()) {
+      const char = this.getChar();
+      if (isDigit(char)) {
+        inputNumber += char;
+      } else {
+        throw new ParseError(this.pos, "Expected a digit (0-9), whitespace or EOL");
+      }
+    }
+    if (inputNumber.length > 15) {
+      throw new ParseError(this.pos, "Exceeded max length for a date value");
+    }
+    return new Date(parseInt(inputNumber, 10) * sign * 1e3);
+  }
+  parseKey() {
+    if (!this.lookChar()?.match(/^[a-z*]/)) {
+      throw new ParseError(this.pos, "A key must begin with an asterisk or letter (a-z)");
+    }
+    let outputString = "";
+    while (!this.eof()) {
+      const char = this.lookChar();
+      if (char === void 0 || !/^[a-z0-9_\-.*]$/.test(char)) {
+        return outputString;
+      }
+      outputString += this.getChar();
+    }
+    return outputString;
+  }
+  /**
+   * Looks at the next character without advancing the cursor.
+   *
+   * Returns undefined if we were at the end of the string.
+   */
+  lookChar() {
+    return this.input[this.pos];
+  }
+  /**
+   * Checks if the next character is 'char', and fail otherwise.
+   */
+  expectChar(char) {
+    if (this.lookChar() !== char) {
+      throw new ParseError(this.pos, `Expected ${char}`);
+    }
+  }
+  getChar() {
+    return this.input[this.pos++];
+  }
+  getChars(count) {
+    const result = this.input.substr(this.pos, count);
+    this.pos += count;
+    return result;
+  }
+  eof() {
+    return this.pos >= this.input.length;
+  }
+  // Advances the pointer to skip all whitespace.
+  skipOWS() {
+    while (true) {
+      const c = this.input.substr(this.pos, 1);
+      if (c === " " || c === "	") {
+        this.pos++;
+      } else {
+        break;
+      }
+    }
+  }
+  // Advances the pointer to skip all spaces
+  skipWS() {
+    while (this.lookChar() === " ") {
+      this.pos++;
+    }
+  }
+  // At the end of parsing, we need to make sure there are no bytes after the
+  // header except whitespace.
+  checkTrail() {
+    this.skipWS();
+    if (!this.eof()) {
+      throw new ParseError(this.pos, "Unexpected characters at end of input");
+    }
+  }
+};
+var isDigitRegex = /^[0-9]$/;
+function isDigit(char) {
+  if (char === void 0)
+    return false;
+  return isDigitRegex.test(char);
+}
+
+// src/rate-limit.ts
+function parseRetryAfter(header, now = Date.now()) {
+  if (header === null) return void 0;
+  const value = header.trim();
+  if (/^\d+$/.test(value)) {
+    const ms = Number(value) * 1e3;
+    return Number.isSafeInteger(ms) ? ms : void 0;
+  }
+  if (!/^[A-Za-z]{3},? /.test(value)) return void 0;
+  const date = Date.parse(value);
+  return Number.isFinite(date) ? Math.max(0, date - now) : void 0;
+}
+function secondsToMilliseconds(value) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) return void 0;
+  const milliseconds = value * 1e3;
+  return Number.isSafeInteger(milliseconds) ? milliseconds : void 0;
+}
+function getRateLimitInfo(headers, now = Date.now()) {
+  const retryAfter = headers.get("Retry-After");
+  const retryAfterMs = parseRetryAfter(retryAfter, now);
+  const info = {
+    windows: [],
+    retryAfterMs,
+    retryDelayMs: retryAfterMs,
+    incomplete: retryAfter !== null && retryAfterMs === void 0
+  };
+  const raw = headers.get("RateLimit");
+  if (raw === null) return info;
+  if (!raw.trim()) return { ...info, incomplete: true };
+  try {
+    for (const [value, params] of parseList(raw)) {
+      const name = value instanceof Token ? value.toString() : value;
+      const remaining = params.get("r");
+      if (typeof name !== "string" || typeof remaining !== "number" || !Number.isSafeInteger(remaining) || remaining < 0) {
+        info.incomplete = true;
+        continue;
+      }
+      const resetAfterMs = secondsToMilliseconds(params.get("t"));
+      info.windows.push({ name, remaining, resetAfterMs });
+      if (remaining !== 0) continue;
+      if (resetAfterMs === void 0) {
+        info.incomplete = true;
+        continue;
+      }
+      info.retryDelayMs = Math.max(info.retryDelayMs ?? 0, resetAfterMs);
+    }
+  } catch {
+    info.incomplete = true;
+  }
+  return info;
+}
+
+// src/retry.ts
+var DEFAULTS = {
+  maxAttempts: 4,
+  minBackoffMs: 1e3,
+  maxBackoffMs: 3e4,
+  maxRetryAfterMs: 6e4
+};
+var IDEMPOTENT_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "PUT", "DELETE", "OPTIONS"]);
+var RETRYABLE_STATUS = /* @__PURE__ */ new Set([500, 502, 503, 504]);
+function isAbortError(error) {
+  const name = error?.name;
+  return name === "AbortError" || name === "TimeoutError";
+}
+function shouldRetry(method, response) {
+  const idempotent = IDEMPOTENT_METHODS.has(method);
+  if (response === void 0) return idempotent;
+  if (response.status === 429) return true;
+  return idempotent && RETRYABLE_STATUS.has(response.status);
+}
+function sleepWithSignal(ms, signal, custom) {
+  return new Promise((resolve, reject) => {
+    let timer;
+    const cleanup = () => {
+      if (timer !== void 0) clearTimeout(timer);
+      signal.removeEventListener("abort", onAbort);
+    };
+    const onAbort = () => {
+      cleanup();
+      reject(signal.reason);
+    };
+    if (signal.aborted) {
+      reject(signal.reason);
+      return;
+    }
+    signal.addEventListener("abort", onAbort, { once: true });
+    const done = () => {
+      cleanup();
+      resolve();
+    };
+    if (custom) {
+      Promise.resolve().then(() => {
+        signal.throwIfAborted();
+        return custom(ms);
+      }).then(done, (error) => {
+        cleanup();
+        reject(error);
+      });
+    } else {
+      timer = setTimeout(done, ms);
+    }
+  });
+}
+function createRetryFetch(options = {}) {
+  const maxAttempts = options.maxAttempts ?? DEFAULTS.maxAttempts;
+  const minBackoffMs = options.minBackoffMs ?? DEFAULTS.minBackoffMs;
+  const maxBackoffMs = options.maxBackoffMs ?? DEFAULTS.maxBackoffMs;
+  const maxRetryAfterMs = options.maxRetryAfterMs ?? DEFAULTS.maxRetryAfterMs;
+  const baseFetch = options.fetch ?? globalThis.fetch;
+  const random = options.random ?? Math.random;
+  if (!Number.isSafeInteger(maxAttempts) || maxAttempts < 1) {
+    throw new RangeError("maxAttempts must be a positive safe integer");
+  }
+  for (const [name, value] of Object.entries({ minBackoffMs, maxBackoffMs, maxRetryAfterMs })) {
+    if (!Number.isFinite(value) || value < 0 || value > 2147483647) {
+      throw new RangeError(`${name} must be finite and between 0 and 2147483647`);
+    }
+  }
+  if (minBackoffMs > maxBackoffMs) {
+    throw new RangeError("minBackoffMs must not exceed maxBackoffMs");
+  }
+  return async (input, init) => {
+    const original = new Request(input, init);
+    for (let attempt = 1; ; attempt++) {
+      original.signal.throwIfAborted();
+      let response;
+      let networkError;
+      try {
+        response = await baseFetch(original.clone());
+      } catch (error) {
+        original.signal.throwIfAborted();
+        if (isAbortError(error)) throw error;
+        networkError = error;
+      }
+      if (response !== void 0 && !shouldRetry(original.method, response)) return response;
+      if (response === void 0 && !shouldRetry(original.method, void 0)) throw networkError;
+      if (attempt >= maxAttempts) {
+        if (response !== void 0) return response;
+        throw networkError;
+      }
+      const rateLimit = response ? getRateLimitInfo(response.headers) : void 0;
+      let delay = rateLimit?.retryDelayMs;
+      if (response && (rateLimit?.incomplete || delay !== void 0 && delay > maxRetryAfterMs)) return response;
+      if (delay === void 0) {
+        const shift = Math.min(attempt - 1, 20);
+        const backoff = Math.min(minBackoffMs * 2 ** shift, maxBackoffMs);
+        delay = backoff / 2 + random() * (backoff / 2);
+      }
+      await response?.body?.cancel();
+      await sleepWithSignal(delay, original.signal, options.sleep);
+    }
+  };
+}
+
+// src/abort.ts
+function abortable(operation, signal) {
+  if (!signal) return operation;
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(signal.reason);
+    const cleanup = () => signal.removeEventListener("abort", onAbort);
+    if (signal.aborted) onAbort();
+    else signal.addEventListener("abort", onAbort, { once: true });
+    operation.then(
+      (value) => {
+        cleanup();
+        resolve(value);
+      },
+      (error) => {
+        cleanup();
+        reject(error);
+      }
+    );
+  });
+}
+
+// src/deadline.ts
+function wrapResponse(response, signal, cleanup) {
+  const reader = response.body.getReader();
+  let finished = false;
+  let bodyController;
+  function finish() {
+    finished = true;
+    signal.removeEventListener("abort", onAbort);
+    cleanup();
+  }
+  function cancelReader(reason) {
+    void reader.cancel(reason).catch(() => {
+    });
+    reader.releaseLock();
+  }
+  function onAbort() {
+    if (finished) return;
+    finish();
+    bodyController.error(signal.reason);
+    cancelReader(signal.reason);
+  }
+  const body = new ReadableStream({
+    start(controller) {
+      bodyController = controller;
+      signal.addEventListener("abort", onAbort, { once: true });
+      if (signal.aborted) onAbort();
+    },
+    async pull(controller) {
+      try {
+        const chunk = await reader.read();
+        if (finished) return;
+        if (!chunk.done) {
+          controller.enqueue(chunk.value);
+          return;
+        }
+        finish();
+        reader.releaseLock();
+        controller.close();
+      } catch (error) {
+        if (finished) return;
+        finish();
+        reader.releaseLock();
+        controller.error(error);
+      }
+    },
+    cancel(reason) {
+      finish();
+      cancelReader(reason);
+    }
+  });
+  const wrapped = new Response(body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+  for (const key of ["url", "redirected", "type"]) {
+    Object.defineProperty(wrapped, key, { value: response[key] });
+  }
+  return wrapped;
+}
+function createDeadlineFetch(fetchImpl, timeoutMs) {
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0 || timeoutMs > 2147483647) {
+    throw new RangeError("timeoutMs must be positive and at most 2147483647");
+  }
+  return async (input, init) => {
+    const original = new Request(input, init);
+    original.signal.throwIfAborted();
+    const controller = new AbortController();
+    const onCallerAbort = () => controller.abort(original.signal.reason);
+    const timer = setTimeout(() => {
+      controller.abort(new DOMException(`Runpod request exceeded ${timeoutMs}ms`, "TimeoutError"));
+    }, timeoutMs);
+    const cleanup = () => {
+      clearTimeout(timer);
+      original.signal.removeEventListener("abort", onCallerAbort);
+    };
+    original.signal.addEventListener("abort", onCallerAbort, { once: true });
+    try {
+      const operation = Promise.resolve().then(async () => {
+        controller.signal.throwIfAborted();
+        const response2 = await fetchImpl(new Request(original, { signal: controller.signal }));
+        if (controller.signal.aborted) void response2.body?.cancel().catch(() => {
+        });
+        controller.signal.throwIfAborted();
+        return response2;
+      });
+      const response = await abortable(operation, controller.signal);
+      if (response.body) return wrapResponse(response, controller.signal, cleanup);
+      cleanup();
+      return response;
+    } catch (error) {
+      cleanup();
+      throw error;
+    }
+  };
+}
+
+// src/logs.ts
+function parseLogEntry(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return { raw };
+    const entry = parsed;
+    const valid = ["source", "line", "ts", "raw"].every(
+      (key) => !(key in entry) || typeof entry[key] === "string"
+    );
+    return valid ? entry : { raw };
+  } catch {
+    return { raw };
+  }
+}
+function utf8Size(character) {
+  const codePoint = character.codePointAt(0);
+  if (codePoint <= 127) return 1;
+  if (codePoint <= 2047) return 2;
+  return codePoint <= 65535 ? 3 : 4;
+}
+var LogEventParser = class {
+  constructor(maxEventBytes) {
+    this.maxEventBytes = maxEventBytes;
+  }
+  maxEventBytes;
+  line = "";
+  dataLines = [];
+  eventName = "";
+  lastEventId;
+  eventBytes = 0;
+  afterCR = false;
+  push(character) {
+    if (this.afterCR && character === "\n") {
+      this.afterCR = false;
+      return;
+    }
+    this.afterCR = character === "\r";
+    this.eventBytes += utf8Size(character);
+    if (this.eventBytes > this.maxEventBytes) {
+      throw new RangeError("SSE log event exceeds maxEventBytes");
+    }
+    if (character === "\r" || character === "\n") return this.consumeLine();
+    this.line += character;
+  }
+  consumeLine() {
+    const line = this.line;
+    this.line = "";
+    if (line === "") return this.finishEvent();
+    if (line.startsWith(":")) return;
+    const colon = line.indexOf(":");
+    const field = colon < 0 ? line : line.slice(0, colon);
+    const value = colon < 0 ? "" : line.slice(colon + 1).replace(/^ /, "");
+    switch (field) {
+      case "data":
+        this.dataLines.push(value);
+        break;
+      case "event":
+        this.eventName = value;
+        break;
+      case "id":
+        if (!value.includes("\0")) this.lastEventId = value;
+        break;
+    }
+  }
+  finishEvent() {
+    const event = this.dataLines.length ? {
+      event: this.eventName || "message",
+      id: this.lastEventId,
+      data: parseLogEntry(this.dataLines.join("\n"))
+    } : void 0;
+    this.dataLines = [];
+    this.eventName = "";
+    this.eventBytes = 0;
+    return event;
+  }
+};
+async function* iterateLogEvents(stream, options = {}) {
+  const maxEventBytes = options.maxEventBytes ?? 1048576;
+  if (!Number.isSafeInteger(maxEventBytes) || maxEventBytes <= 0) {
+    throw new RangeError("maxEventBytes must be a positive safe integer");
+  }
+  const parser = new LogEventParser(maxEventBytes);
+  const decoder = new TextDecoder();
+  const reader = stream.getReader();
+  const signal = options.signal;
+  const onAbort = () => {
+    void reader.cancel(signal?.reason).catch(() => {
+    });
+  };
+  let finished = false;
+  signal?.addEventListener("abort", onAbort, { once: true });
+  try {
+    while (true) {
+      signal?.throwIfAborted();
+      const chunk = await abortable(reader.read(), signal);
+      signal?.throwIfAborted();
+      if (chunk.done) {
+        finished = true;
+        return;
+      }
+      for (const character of decoder.decode(chunk.value, { stream: true })) {
+        signal?.throwIfAborted();
+        const event = parser.push(character);
+        if (event) yield event;
+      }
+    }
+  } finally {
+    signal?.removeEventListener("abort", onAbort);
+    if (!finished) void reader.cancel().catch(() => {
+    });
+    reader.releaseLock();
+  }
+}
+
+// src/index.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_BASE_URL = "https://api.runpod.io";
+function createRunpodClient(options = {}) {
+  const apiKey = options.apiKey ?? process.env.RUNPOD_API_KEY;
+  if (!apiKey) {
+    throw new Error("runpod: API key required (set RUNPOD_API_KEY or pass apiKey)");
+  }
+  const baseUrl = options.baseUrl?.trim() || process.env.RUNPOD_API_BASE_URL?.trim() || DEFAULT_BASE_URL;
+  const baseFetch = options.fetch ?? globalThis.fetch;
+  const retryFetch = options.retry === false ? baseFetch : createRetryFetch({ ...options.retry, fetch: baseFetch });
+  const requestFetch = options.timeoutMs === false ? retryFetch : createDeadlineFetch(retryFetch, options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+  return createClient({
+    baseUrl,
+    fetch: requestFetch,
+    // Generation rejects contracts with a different array query encoding.
+    querySerializer: { array: { style: "form", explode: false } },
+    headers: { Authorization: `Bearer ${apiKey}` }
+  });
+}
+export {
+  DEFAULT_BASE_URL,
+  DEFAULT_TIMEOUT_MS,
+  createDeadlineFetch,
+  createRetryFetch,
+  createRunpodClient,
+  getRateLimitInfo,
+  iterateLogEvents,
+  parseRetryAfter
+};