@arcadeai/design-system 1.2.0 → 1.4.0

package/dist/arcade-CadnNaba.js

@@ -0,0 +1,1543 @@
+import { TOOLKIT_CATALOGUE as tt } from "./metadata/toolkits.js";
+import { r as pe } from "./utils-Db4QWi-E.js";
+let ye = !1, D, Re, Y, Se, Ee;
+function Pe(t, e = { auto: !1 }) {
+  if (ye)
+    throw new Error(`you must \`import '@arcadeai/arcadejs/shims/${t.kind}'\` before importing anything else from @arcadeai/arcadejs`);
+  if (D)
+    throw new Error(`can't \`import '@arcadeai/arcadejs/shims/${t.kind}'\` after \`import '@arcadeai/arcadejs/shims/${D}'\``);
+  ye = e.auto, D = t.kind, Re = t.fetch, t.Request, t.Response, t.Headers, t.FormData, t.Blob, Y = t.File, t.ReadableStream, t.getMultipartRequestOptions, Se = t.getDefaultAgent, Ee = t.fileFromPath, t.isFsReadStream;
+}
+class rt {
+  constructor(e) {
+    this.body = e;
+  }
+  get [Symbol.toStringTag]() {
+    return "MultipartBody";
+  }
+}
+function ke({ manuallyImported: t } = {}) {
+  const e = t ? "You may need to use polyfills" : "Add one of these imports before your first `import … from '@arcadeai/arcadejs'`:\n- `import '@arcadeai/arcadejs/shims/node'` (if you're running on Node)\n- `import '@arcadeai/arcadejs/shims/web'` (otherwise)\n";
+  let r, n, s, o;
+  try {
+    r = fetch, n = Request, s = Response, o = Headers;
+  } catch (i) {
+    throw new Error(`this environment is missing the following Web Fetch API type: ${i.message}. ${e}`);
+  }
+  return {
+    kind: "web",
+    fetch: r,
+    Request: n,
+    Response: s,
+    Headers: o,
+    FormData: (
+      // @ts-ignore
+      typeof FormData < "u" ? FormData : class {
+        // @ts-ignore
+        constructor() {
+          throw new Error(`file uploads aren't supported in this environment yet as 'FormData' is undefined. ${e}`);
+        }
+      }
+    ),
+    Blob: typeof Blob < "u" ? Blob : class {
+      constructor() {
+        throw new Error(`file uploads aren't supported in this environment yet as 'Blob' is undefined. ${e}`);
+      }
+    },
+    File: (
+      // @ts-ignore
+      typeof File < "u" ? File : class {
+        // @ts-ignore
+        constructor() {
+          throw new Error(`file uploads aren't supported in this environment yet as 'File' is undefined. ${e}`);
+        }
+      }
+    ),
+    ReadableStream: (
+      // @ts-ignore
+      typeof ReadableStream < "u" ? ReadableStream : class {
+        // @ts-ignore
+        constructor() {
+          throw new Error(`streaming isn't supported in this environment yet as 'ReadableStream' is undefined. ${e}`);
+        }
+      }
+    ),
+    getMultipartRequestOptions: async (i, l) => ({
+      ...l,
+      body: new rt(i)
+    }),
+    getDefaultAgent: (i) => {
+    },
+    fileFromPath: () => {
+      throw new Error("The `fileFromPath` function is only supported in Node. See the README for more details: https://www.github.com/ArcadeAI/arcade-js#file-uploads");
+    },
+    isFsReadStream: (i) => !1
+  };
+}
+Pe(ke({ manuallyImported: !0 }));
+const Z = "RFC3986", ee = {
+  RFC1738: (t) => String(t).replace(/%20/g, "+"),
+  RFC3986: (t) => String(t)
+}, nt = "RFC1738", st = Array.isArray, _ = (() => {
+  const t = [];
+  for (let e = 0; e < 256; ++e)
+    t.push("%" + ((e < 16 ? "0" : "") + e.toString(16)).toUpperCase());
+  return t;
+})(), V = 1024, ot = (t, e, r, n, s) => {
+  if (t.length === 0)
+    return t;
+  let o = t;
+  if (typeof t == "symbol" ? o = Symbol.prototype.toString.call(t) : typeof t != "string" && (o = String(t)), r === "iso-8859-1")
+    return escape(o).replace(/%u[0-9a-f]{4}/gi, function(l) {
+      return "%26%23" + parseInt(l.slice(2), 16) + "%3B";
+    });
+  let i = "";
+  for (let l = 0; l < o.length; l += V) {
+    const c = o.length >= V ? o.slice(l, l + V) : o, u = [];
+    for (let p = 0; p < c.length; ++p) {
+      let a = c.charCodeAt(p);
+      if (a === 45 || // -
+      a === 46 || // .
+      a === 95 || // _
+      a === 126 || // ~
+      a >= 48 && a <= 57 || // 0-9
+      a >= 65 && a <= 90 || // a-z
+      a >= 97 && a <= 122 || // A-Z
+      s === nt && (a === 40 || a === 41)) {
+        u[u.length] = c.charAt(p);
+        continue;
+      }
+      if (a < 128) {
+        u[u.length] = _[a];
+        continue;
+      }
+      if (a < 2048) {
+        u[u.length] = _[192 | a >> 6] + _[128 | a & 63];
+        continue;
+      }
+      if (a < 55296 || a >= 57344) {
+        u[u.length] = _[224 | a >> 12] + _[128 | a >> 6 & 63] + _[128 | a & 63];
+        continue;
+      }
+      p += 1, a = 65536 + ((a & 1023) << 10 | c.charCodeAt(p) & 1023), u[u.length] = _[240 | a >> 18] + _[128 | a >> 12 & 63] + _[128 | a >> 6 & 63] + _[128 | a & 63];
+    }
+    i += u.join("");
+  }
+  return i;
+};
+function it(t) {
+  return !t || typeof t != "object" ? !1 : !!(t.constructor && t.constructor.isBuffer && t.constructor.isBuffer(t));
+}
+function me(t, e) {
+  if (st(t)) {
+    const r = [];
+    for (let n = 0; n < t.length; n += 1)
+      r.push(e(t[n]));
+    return r;
+  }
+  return e(t);
+}
+const at = Object.prototype.hasOwnProperty, Te = {
+  brackets(t) {
+    return String(t) + "[]";
+  },
+  comma: "comma",
+  indices(t, e) {
+    return String(t) + "[" + e + "]";
+  },
+  repeat(t) {
+    return String(t);
+  }
+}, A = Array.isArray, ct = Array.prototype.push, ve = function(t, e) {
+  ct.apply(t, A(e) ? e : [e]);
+}, ut = Date.prototype.toISOString, y = {
+  addQueryPrefix: !1,
+  allowDots: !1,
+  allowEmptyArrays: !1,
+  arrayFormat: "indices",
+  charset: "utf-8",
+  charsetSentinel: !1,
+  delimiter: "&",
+  encode: !0,
+  encodeDotInKeys: !1,
+  encoder: ot,
+  encodeValuesOnly: !1,
+  format: Z,
+  formatter: ee[Z],
+  /** @deprecated */
+  indices: !1,
+  serializeDate(t) {
+    return ut.call(t);
+  },
+  skipNulls: !1,
+  strictNullHandling: !1
+};
+function lt(t) {
+  return typeof t == "string" || typeof t == "number" || typeof t == "boolean" || typeof t == "symbol" || typeof t == "bigint";
+}
+const Q = {};
+function Ce(t, e, r, n, s, o, i, l, c, u, p, a, h, m, x, E, R, X) {
+  let f = t, F = X, $ = 0, le = !1;
+  for (; (F = F.get(Q)) !== void 0 && !le; ) {
+    const g = F.get(t);
+    if ($ += 1, typeof g < "u") {
+      if (g === $)
+        throw new RangeError("Cyclic object value");
+      le = !0;
+    }
+    typeof F.get(Q) > "u" && ($ = 0);
+  }
+  if (typeof u == "function" ? f = u(e, f) : f instanceof Date ? f = h?.(f) : r === "comma" && A(f) && (f = me(f, function(g) {
+    return g instanceof Date ? h?.(g) : g;
+  })), f === null) {
+    if (o)
+      return c && !E ? (
+        // @ts-expect-error
+        c(e, y.encoder, R, "key", m)
+      ) : e;
+    f = "";
+  }
+  if (lt(f) || it(f)) {
+    if (c) {
+      const g = E ? e : c(e, y.encoder, R, "key", m);
+      return [
+        x?.(g) + "=" + // @ts-expect-error
+        x?.(c(f, y.encoder, R, "value", m))
+      ];
+    }
+    return [x?.(e) + "=" + x?.(String(f))];
+  }
+  const K = [];
+  if (typeof f > "u")
+    return K;
+  let I;
+  if (r === "comma" && A(f))
+    E && c && (f = me(f, c)), I = [{ value: f.length > 0 ? f.join(",") || null : void 0 }];
+  else if (A(u))
+    I = u;
+  else {
+    const g = Object.keys(f);
+    I = p ? g.sort(p) : g;
+  }
+  const fe = l ? String(e).replace(/\./g, "%2E") : String(e), j = n && A(f) && f.length === 1 ? fe + "[]" : fe;
+  if (s && A(f) && f.length === 0)
+    return j + "[]";
+  for (let g = 0; g < I.length; ++g) {
+    const k = I[g], de = (
+      // @ts-ignore
+      typeof k == "object" && typeof k.value < "u" ? k.value : f[k]
+    );
+    if (i && de === null)
+      continue;
+    const W = a && l ? k.replace(/\./g, "%2E") : k, et = A(f) ? typeof r == "function" ? r(j, W) : j : j + (a ? "." + W : "[" + W + "]");
+    X.set(t, $);
+    const he = /* @__PURE__ */ new WeakMap();
+    he.set(Q, X), ve(K, Ce(
+      de,
+      et,
+      r,
+      n,
+      s,
+      o,
+      i,
+      l,
+      // @ts-ignore
+      r === "comma" && E && A(f) ? null : c,
+      u,
+      p,
+      a,
+      h,
+      m,
+      x,
+      E,
+      R,
+      he
+    ));
+  }
+  return K;
+}
+function ft(t = y) {
+  if (typeof t.allowEmptyArrays < "u" && typeof t.allowEmptyArrays != "boolean")
+    throw new TypeError("`allowEmptyArrays` option can only be `true` or `false`, when provided");
+  if (typeof t.encodeDotInKeys < "u" && typeof t.encodeDotInKeys != "boolean")
+    throw new TypeError("`encodeDotInKeys` option can only be `true` or `false`, when provided");
+  if (t.encoder !== null && typeof t.encoder < "u" && typeof t.encoder != "function")
+    throw new TypeError("Encoder has to be a function.");
+  const e = t.charset || y.charset;
+  if (typeof t.charset < "u" && t.charset !== "utf-8" && t.charset !== "iso-8859-1")
+    throw new TypeError("The charset option must be either utf-8, iso-8859-1, or undefined");
+  let r = Z;
+  if (typeof t.format < "u") {
+    if (!at.call(ee, t.format))
+      throw new TypeError("Unknown format option provided.");
+    r = t.format;
+  }
+  const n = ee[r];
+  let s = y.filter;
+  (typeof t.filter == "function" || A(t.filter)) && (s = t.filter);
+  let o;
+  if (t.arrayFormat && t.arrayFormat in Te ? o = t.arrayFormat : "indices" in t ? o = t.indices ? "indices" : "repeat" : o = y.arrayFormat, "commaRoundTrip" in t && typeof t.commaRoundTrip != "boolean")
+    throw new TypeError("`commaRoundTrip` must be a boolean, or absent");
+  const i = typeof t.allowDots > "u" ? t.encodeDotInKeys ? !0 : y.allowDots : !!t.allowDots;
+  return {
+    addQueryPrefix: typeof t.addQueryPrefix == "boolean" ? t.addQueryPrefix : y.addQueryPrefix,
+    // @ts-ignore
+    allowDots: i,
+    allowEmptyArrays: typeof t.allowEmptyArrays == "boolean" ? !!t.allowEmptyArrays : y.allowEmptyArrays,
+    arrayFormat: o,
+    charset: e,
+    charsetSentinel: typeof t.charsetSentinel == "boolean" ? t.charsetSentinel : y.charsetSentinel,
+    commaRoundTrip: !!t.commaRoundTrip,
+    delimiter: typeof t.delimiter > "u" ? y.delimiter : t.delimiter,
+    encode: typeof t.encode == "boolean" ? t.encode : y.encode,
+    encodeDotInKeys: typeof t.encodeDotInKeys == "boolean" ? t.encodeDotInKeys : y.encodeDotInKeys,
+    encoder: typeof t.encoder == "function" ? t.encoder : y.encoder,
+    encodeValuesOnly: typeof t.encodeValuesOnly == "boolean" ? t.encodeValuesOnly : y.encodeValuesOnly,
+    filter: s,
+    format: r,
+    formatter: n,
+    serializeDate: typeof t.serializeDate == "function" ? t.serializeDate : y.serializeDate,
+    skipNulls: typeof t.skipNulls == "boolean" ? t.skipNulls : y.skipNulls,
+    // @ts-ignore
+    sort: typeof t.sort == "function" ? t.sort : null,
+    strictNullHandling: typeof t.strictNullHandling == "boolean" ? t.strictNullHandling : y.strictNullHandling
+  };
+}
+function dt(t, e = {}) {
+  let r = t;
+  const n = ft(e);
+  let s, o;
+  typeof n.filter == "function" ? (o = n.filter, r = o("", r)) : A(n.filter) && (o = n.filter, s = o);
+  const i = [];
+  if (typeof r != "object" || r === null)
+    return "";
+  const l = Te[n.arrayFormat], c = l === "comma" && n.commaRoundTrip;
+  s || (s = Object.keys(r)), n.sort && s.sort(n.sort);
+  const u = /* @__PURE__ */ new WeakMap();
+  for (let h = 0; h < s.length; ++h) {
+    const m = s[h];
+    n.skipNulls && r[m] === null || ve(i, Ce(
+      r[m],
+      m,
+      // @ts-expect-error
+      l,
+      c,
+      n.allowEmptyArrays,
+      n.strictNullHandling,
+      n.skipNulls,
+      n.encodeDotInKeys,
+      n.encode ? n.encoder : null,
+      n.filter,
+      n.sort,
+      n.allowDots,
+      n.serializeDate,
+      n.format,
+      n.formatter,
+      n.encodeValuesOnly,
+      n.charset,
+      u
+    ));
+  }
+  const p = i.join(n.delimiter);
+  let a = n.addQueryPrefix === !0 ? "?" : "";
+  return n.charsetSentinel && (n.charset === "iso-8859-1" ? a += "utf8=%26%2310003%3B&" : a += "utf8=%E2%9C%93&"), p.length > 0 ? a + p : "";
+}
+const T = "1.9.1";
+class P extends Error {
+}
+class w extends P {
+  constructor(e, r, n, s) {
+    super(`${w.makeMessage(e, r, n)}`), this.status = e, this.headers = s, this.error = r;
+  }
+  static makeMessage(e, r, n) {
+    const s = r?.message ? typeof r.message == "string" ? r.message : JSON.stringify(r.message) : r ? JSON.stringify(r) : n;
+    return e && s ? `${e} ${s}` : e ? `${e} status code (no body)` : s || "(no status code or body)";
+  }
+  static generate(e, r, n, s) {
+    if (!e || !s)
+      return new q({ message: n, cause: re(r) });
+    const o = r;
+    return e === 400 ? new De(e, o, n, s) : e === 401 ? new Le(e, o, n, s) : e === 403 ? new Oe(e, o, n, s) : e === 404 ? new Fe(e, o, n, s) : e === 409 ? new $e(e, o, n, s) : e === 422 ? new je(e, o, n, s) : e === 429 ? new Ue(e, o, n, s) : e >= 500 ? new Be(e, o, n, s) : new w(e, o, n, s);
+  }
+}
+class te extends w {
+  constructor({ message: e } = {}) {
+    super(void 0, void 0, e || "Request was aborted.", void 0);
+  }
+}
+class q extends w {
+  constructor({ message: e, cause: r }) {
+    super(void 0, void 0, e || "Connection error.", void 0), r && (this.cause = r);
+  }
+}
+class Ie extends q {
+  constructor({ message: e } = {}) {
+    super({ message: e ?? "Request timed out." });
+  }
+}
+class De extends w {
+}
+class Le extends w {
+}
+class Oe extends w {
+}
+class Fe extends w {
+}
+class $e extends w {
+}
+class je extends w {
+}
+class Ue extends w {
+}
+class Be extends w {
+}
+const Me = () => {
+  D || Pe(ke(), { auto: !0 });
+};
+Me();
+const ht = (t) => t != null && typeof t == "object" && typeof t.url == "string" && typeof t.blob == "function", pt = (t) => t != null && typeof t == "object" && typeof t.name == "string" && typeof t.lastModified == "number" && N(t), N = (t) => t != null && typeof t == "object" && typeof t.size == "number" && typeof t.type == "string" && typeof t.text == "function" && typeof t.slice == "function" && typeof t.arrayBuffer == "function";
+async function yt(t, e, r) {
+  if (t = await t, pt(t))
+    return t;
+  if (ht(t)) {
+    const s = await t.blob();
+    e || (e = new URL(t.url).pathname.split(/[\\/]/).pop() ?? "unknown_file");
+    const o = N(s) ? [await s.arrayBuffer()] : [s];
+    return new Y(o, e, r);
+  }
+  const n = await mt(t);
+  if (e || (e = wt(t) ?? "unknown_file"), !r?.type) {
+    const s = n[0]?.type;
+    typeof s == "string" && (r = { ...r, type: s });
+  }
+  return new Y(n, e, r);
+}
+async function mt(t) {
+  let e = [];
+  if (typeof t == "string" || ArrayBuffer.isView(t) || // includes Uint8Array, Buffer, etc.
+  t instanceof ArrayBuffer)
+    e.push(t);
+  else if (N(t))
+    e.push(await t.arrayBuffer());
+  else if (bt(t))
+    for await (const r of t)
+      e.push(r);
+  else
+    throw new Error(`Unexpected data type: ${typeof t}; constructor: ${t?.constructor?.name}; props: ${gt(t)}`);
+  return e;
+}
+function gt(t) {
+  return `[${Object.getOwnPropertyNames(t).map((r) => `"${r}"`).join(", ")}]`;
+}
+function wt(t) {
+  return G(t.name) || G(t.filename) || // For fs.ReadStream
+  G(t.path)?.split(/[\\/]/).pop();
+}
+const G = (t) => {
+  if (typeof t == "string")
+    return t;
+  if (typeof Buffer < "u" && t instanceof Buffer)
+    return String(t);
+}, bt = (t) => t != null && typeof t == "object" && typeof t[Symbol.asyncIterator] == "function", ge = (t) => t && typeof t == "object" && t.body && t[Symbol.toStringTag] === "MultipartBody";
+var qe = function(t, e, r, n, s) {
+  if (n === "m") throw new TypeError("Private method is not writable");
+  if (n === "a" && !s) throw new TypeError("Private accessor was defined without a setter");
+  if (typeof e == "function" ? t !== e || !s : !e.has(t)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+  return n === "a" ? s.call(t, r) : s ? s.value = r : e.set(t, r), r;
+}, Ne = function(t, e, r, n) {
+  if (r === "a" && !n) throw new TypeError("Private accessor was defined without a getter");
+  if (typeof e == "function" ? t !== e || !n : !e.has(t)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return r === "m" ? n : r === "a" ? n.call(t) : n ? n.value : e.get(t);
+}, M, U;
+Me();
+async function He(t) {
+  const { response: e } = t;
+  if (e.status === 204)
+    return null;
+  if (t.options.__binaryResponse)
+    return e;
+  const n = e.headers.get("content-type")?.split(";")[0]?.trim();
+  if (n?.includes("application/json") || n?.endsWith("+json")) {
+    const i = await e.json();
+    return L("response", e.status, e.url, e.headers, i), i;
+  }
+  const o = await e.text();
+  return L("response", e.status, e.url, e.headers, o), o;
+}
+class H extends Promise {
+  constructor(e, r = He) {
+    super((n) => {
+      n(null);
+    }), this.responsePromise = e, this.parseResponse = r;
+  }
+  _thenUnwrap(e) {
+    return new H(this.responsePromise, async (r) => e(await this.parseResponse(r), r));
+  }
+  /**
+   * 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()}.
+   *
+   * 👋 Getting the wrong TypeScript type for `Response`?
+   * Try setting `"moduleResolution": "NodeNext"` if you can,
+   * or add one of these imports before your first `import … from '@arcadeai/arcadejs'`:
+   * - `import '@arcadeai/arcadejs/shims/node'` (if you're running on Node)
+   * - `import '@arcadeai/arcadejs/shims/web'` (otherwise)
+   */
+  asResponse() {
+    return this.responsePromise.then((e) => e.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()}.
+   *
+   *
+   * 👋 Getting the wrong TypeScript type for `Response`?
+   * Try setting `"moduleResolution": "NodeNext"` if you can,
+   * or add one of these imports before your first `import … from '@arcadeai/arcadejs'`:
+   * - `import '@arcadeai/arcadejs/shims/node'` (if you're running on Node)
+   * - `import '@arcadeai/arcadejs/shims/web'` (otherwise)
+   */
+  async withResponse() {
+    const [e, r] = await Promise.all([this.parse(), this.asResponse()]);
+    return { data: e, response: r };
+  }
+  parse() {
+    return this.parsedPromise || (this.parsedPromise = this.responsePromise.then(this.parseResponse)), this.parsedPromise;
+  }
+  then(e, r) {
+    return this.parse().then(e, r);
+  }
+  catch(e) {
+    return this.parse().catch(e);
+  }
+  finally(e) {
+    return this.parse().finally(e);
+  }
+}
+class xt {
+  constructor({
+    baseURL: e,
+    baseURLOverridden: r,
+    maxRetries: n = 2,
+    timeout: s = 6e4,
+    // 1 minute
+    httpAgent: o,
+    fetch: i
+  }) {
+    M.set(this, void 0), this.baseURL = e, qe(this, M, r, "f"), this.maxRetries = J("maxRetries", n), this.timeout = J("timeout", s), this.httpAgent = o, this.fetch = i ?? Re;
+  }
+  authHeaders(e) {
+    return {};
+  }
+  /**
+   * Override this to add your own default headers, for example:
+   *
+   *  {
+   *    ...super.defaultHeaders(),
+   *    Authorization: 'Bearer 123',
+   *  }
+   */
+  defaultHeaders(e) {
+    return {
+      Accept: "application/json",
+      ...["head", "get"].includes(e.method) ? {} : { "Content-Type": "application/json" },
+      "User-Agent": this.getUserAgent(),
+      ...kt(),
+      ...this.authHeaders(e)
+    };
+  }
+  /**
+   * Override this to add your own headers validation:
+   */
+  validateHeaders(e, r) {
+  }
+  defaultIdempotencyKey() {
+    return `stainless-node-retry-${Dt()}`;
+  }
+  get(e, r) {
+    return this.methodRequest("get", e, r);
+  }
+  post(e, r) {
+    return this.methodRequest("post", e, r);
+  }
+  patch(e, r) {
+    return this.methodRequest("patch", e, r);
+  }
+  put(e, r) {
+    return this.methodRequest("put", e, r);
+  }
+  delete(e, r) {
+    return this.methodRequest("delete", e, r);
+  }
+  methodRequest(e, r, n) {
+    return this.request(Promise.resolve(n).then(async (s) => {
+      const o = s && N(s?.body) ? new DataView(await s.body.arrayBuffer()) : s?.body instanceof DataView ? s.body : s?.body instanceof ArrayBuffer ? new DataView(s.body) : s && ArrayBuffer.isView(s?.body) ? new DataView(s.body.buffer) : s?.body;
+      return { method: e, path: r, ...s, body: o };
+    }));
+  }
+  getAPIList(e, r, n) {
+    return this.requestAPIList(r, { method: "get", path: e, ...n });
+  }
+  calculateContentLength(e) {
+    if (typeof e == "string") {
+      if (typeof Buffer < "u")
+        return Buffer.byteLength(e, "utf8").toString();
+      if (typeof TextEncoder < "u")
+        return new TextEncoder().encode(e).length.toString();
+    } else if (ArrayBuffer.isView(e))
+      return e.byteLength.toString();
+    return null;
+  }
+  async buildRequest(e, { retryCount: r = 0 } = {}) {
+    const n = { ...e }, { method: s, path: o, query: i, defaultBaseURL: l, headers: c = {} } = n, u = ArrayBuffer.isView(n.body) || n.__binaryRequest && typeof n.body == "string" ? n.body : ge(n.body) ? n.body.body : n.body ? JSON.stringify(n.body, null, 2) : null, p = this.calculateContentLength(u), a = this.buildURL(o, i, l);
+    "timeout" in n && J("timeout", n.timeout), n.timeout = n.timeout ?? this.timeout;
+    const h = n.httpAgent ?? this.httpAgent ?? Se(a), m = n.timeout + 1e3;
+    typeof h?.options?.timeout == "number" && m > (h.options.timeout ?? 0) && (h.options.timeout = m), this.idempotencyHeader && s !== "get" && (e.idempotencyKey || (e.idempotencyKey = this.defaultIdempotencyKey()), c[this.idempotencyHeader] = e.idempotencyKey);
+    const x = this.buildHeaders({ options: n, headers: c, contentLength: p, retryCount: r });
+    return { req: {
+      method: s,
+      ...u && { body: u },
+      headers: x,
+      ...h && { agent: h },
+      // @ts-ignore node-fetch uses a custom AbortSignal type that is
+      // not compatible with standard web types
+      signal: n.signal ?? null
+    }, url: a, timeout: n.timeout };
+  }
+  buildHeaders({ options: e, headers: r, contentLength: n, retryCount: s }) {
+    const o = {};
+    n && (o["content-length"] = n);
+    const i = this.defaultHeaders(e);
+    return Ae(o, i), Ae(o, r), ge(e.body) && D !== "node" && delete o["content-type"], B(i, "x-stainless-retry-count") === void 0 && B(r, "x-stainless-retry-count") === void 0 && (o["x-stainless-retry-count"] = String(s)), B(i, "x-stainless-timeout") === void 0 && B(r, "x-stainless-timeout") === void 0 && e.timeout && (o["x-stainless-timeout"] = String(Math.trunc(e.timeout / 1e3))), this.validateHeaders(o, r), o;
+  }
+  /**
+   * Used as a callback for mutating the given `FinalRequestOptions` object.
+   */
+  async prepareOptions(e) {
+  }
+  /**
+   * Used as a callback for mutating the given `RequestInit` object.
+   *
+   * This is useful for cases where you want to add certain headers based off of
+   * the request properties, e.g. `method` or `url`.
+   */
+  async prepareRequest(e, { url: r, options: n }) {
+  }
+  parseHeaders(e) {
+    return e ? Symbol.iterator in e ? Object.fromEntries(Array.from(e).map((r) => [...r])) : { ...e } : {};
+  }
+  makeStatusError(e, r, n, s) {
+    return w.generate(e, r, n, s);
+  }
+  request(e, r = null) {
+    return new H(this.makeRequest(e, r));
+  }
+  async makeRequest(e, r) {
+    const n = await e, s = n.maxRetries ?? this.maxRetries;
+    r == null && (r = s), await this.prepareOptions(n);
+    const { req: o, url: i, timeout: l } = await this.buildRequest(n, {
+      retryCount: s - r
+    });
+    if (await this.prepareRequest(o, { url: i, options: n }), L("request", i, n, o.headers), n.signal?.aborted)
+      throw new te();
+    const c = new AbortController(), u = await this.fetchWithTimeout(i, o, l, c).catch(re);
+    if (u instanceof Error) {
+      if (n.signal?.aborted)
+        throw new te();
+      if (r)
+        return this.retryRequest(n, r);
+      throw u.name === "AbortError" ? new Ie() : new q({ cause: u });
+    }
+    const p = Rt(u.headers);
+    if (!u.ok) {
+      if (r && this.shouldRetry(u)) {
+        const R = `retrying, ${r} attempts remaining`;
+        return L(`response (error; ${R})`, u.status, i, p), this.retryRequest(n, r, p);
+      }
+      const a = await u.text().catch((R) => re(R).message), h = Tt(a), m = h ? void 0 : a;
+      throw L(`response (error; ${r ? "(error; no more retries left)" : "(error; not retryable)"})`, u.status, i, p, m), this.makeStatusError(u.status, h, m, p);
+    }
+    return { response: u, options: n, controller: c };
+  }
+  requestAPIList(e, r) {
+    const n = this.makeRequest(r, null);
+    return new At(this, n, e);
+  }
+  buildURL(e, r, n) {
+    const s = !Ne(this, M, "f") && n || this.baseURL, o = Ct(e) ? new URL(e) : new URL(s + (s.endsWith("/") && e.startsWith("/") ? e.slice(1) : e)), i = this.defaultQuery();
+    return ze(i) || (r = { ...i, ...r }), typeof r == "object" && r && !Array.isArray(r) && (o.search = this.stringifyQuery(r)), o.toString();
+  }
+  stringifyQuery(e) {
+    return Object.entries(e).filter(([r, n]) => typeof n < "u").map(([r, n]) => {
+      if (typeof n == "string" || typeof n == "number" || typeof n == "boolean")
+        return `${encodeURIComponent(r)}=${encodeURIComponent(n)}`;
+      if (n === null)
+        return `${encodeURIComponent(r)}=`;
+      throw new P(`Cannot stringify type ${typeof n}; Expected string, number, boolean, or null. If you need to pass nested query parameters, you can manually encode them, e.g. { query: { 'foo[key1]': value1, 'foo[key2]': value2 } }, and please open a GitHub issue requesting better support for your use case.`);
+    }).join("&");
+  }
+  async fetchWithTimeout(e, r, n, s) {
+    const { signal: o, ...i } = r || {};
+    o && o.addEventListener("abort", () => s.abort());
+    const l = setTimeout(() => s.abort(), n), c = {
+      signal: s.signal,
+      ...i
+    };
+    return c.method && (c.method = c.method.toUpperCase()), // use undefined this binding; fetch errors if bound to something else in browser/cloudflare
+    this.fetch.call(void 0, e, c).finally(() => {
+      clearTimeout(l);
+    });
+  }
+  shouldRetry(e) {
+    const r = e.headers.get("x-should-retry");
+    return r === "true" ? !0 : r === "false" ? !1 : e.status === 408 || e.status === 409 || e.status === 429 || e.status >= 500;
+  }
+  async retryRequest(e, r, n) {
+    let s;
+    const o = n?.["retry-after-ms"];
+    if (o) {
+      const l = parseFloat(o);
+      Number.isNaN(l) || (s = l);
+    }
+    const i = n?.["retry-after"];
+    if (i && !s) {
+      const l = parseFloat(i);
+      Number.isNaN(l) ? s = Date.parse(i) - Date.now() : s = l * 1e3;
+    }
+    if (!(s && 0 <= s && s < 60 * 1e3)) {
+      const l = e.maxRetries ?? this.maxRetries;
+      s = this.calculateDefaultRetryTimeoutMillis(r, l);
+    }
+    return await It(s), this.makeRequest(e, r - 1);
+  }
+  calculateDefaultRetryTimeoutMillis(e, r) {
+    const o = r - e, i = Math.min(0.5 * Math.pow(2, o), 8), l = 1 - Math.random() * 0.25;
+    return i * l * 1e3;
+  }
+  getUserAgent() {
+    return `${this.constructor.name}/JS ${T}`;
+  }
+}
+M = /* @__PURE__ */ new WeakMap();
+class _t {
+  constructor(e, r, n, s) {
+    U.set(this, void 0), qe(this, U, e, "f"), this.options = s, this.response = r, this.body = n;
+  }
+  hasNextPage() {
+    return this.getPaginatedItems().length ? this.nextPageInfo() != null : !1;
+  }
+  async getNextPage() {
+    const e = this.nextPageInfo();
+    if (!e)
+      throw new P("No next page expected; please check `.hasNextPage()` before calling `.getNextPage()`.");
+    const r = { ...this.options };
+    if ("params" in e && typeof r.query == "object")
+      r.query = { ...r.query, ...e.params };
+    else if ("url" in e) {
+      const n = [...Object.entries(r.query || {}), ...e.url.searchParams.entries()];
+      for (const [s, o] of n)
+        e.url.searchParams.set(s, o);
+      r.query = void 0, r.path = e.url.toString();
+    }
+    return await Ne(this, U, "f").requestAPIList(this.constructor, r);
+  }
+  async *iterPages() {
+    let e = this;
+    for (yield e; e.hasNextPage(); )
+      e = await e.getNextPage(), yield e;
+  }
+  async *[(U = /* @__PURE__ */ new WeakMap(), Symbol.asyncIterator)]() {
+    for await (const e of this.iterPages())
+      for (const r of e.getPaginatedItems())
+        yield r;
+  }
+}
+class At extends H {
+  constructor(e, r, n) {
+    super(r, async (s) => new n(e, s.response, await He(s), s.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 e = await this;
+    for await (const r of e)
+      yield r;
+  }
+}
+const Rt = (t) => new Proxy(Object.fromEntries(
+  // @ts-ignore
+  t.entries()
+), {
+  get(e, r) {
+    const n = r.toString();
+    return e[n.toLowerCase()] || e[n];
+  }
+}), St = {
+  method: !0,
+  path: !0,
+  query: !0,
+  body: !0,
+  headers: !0,
+  defaultBaseURL: !0,
+  maxRetries: !0,
+  stream: !0,
+  timeout: !0,
+  httpAgent: !0,
+  signal: !0,
+  idempotencyKey: !0,
+  __binaryRequest: !0,
+  __binaryResponse: !0
+}, S = (t) => typeof t == "object" && t !== null && !ze(t) && Object.keys(t).every((e) => Xe(St, e)), Et = () => {
+  if (typeof Deno < "u" && Deno.build != null)
+    return {
+      "X-Stainless-Lang": "js",
+      "X-Stainless-Package-Version": T,
+      "X-Stainless-OS": be(Deno.build.os),
+      "X-Stainless-Arch": we(Deno.build.arch),
+      "X-Stainless-Runtime": "deno",
+      "X-Stainless-Runtime-Version": typeof Deno.version == "string" ? Deno.version : Deno.version?.deno ?? "unknown"
+    };
+  if (typeof EdgeRuntime < "u")
+    return {
+      "X-Stainless-Lang": "js",
+      "X-Stainless-Package-Version": T,
+      "X-Stainless-OS": "Unknown",
+      "X-Stainless-Arch": `other:${EdgeRuntime}`,
+      "X-Stainless-Runtime": "edge",
+      "X-Stainless-Runtime-Version": process.version
+    };
+  if (Object.prototype.toString.call(typeof process < "u" ? process : 0) === "[object process]")
+    return {
+      "X-Stainless-Lang": "js",
+      "X-Stainless-Package-Version": T,
+      "X-Stainless-OS": be(process.platform),
+      "X-Stainless-Arch": we(process.arch),
+      "X-Stainless-Runtime": "node",
+      "X-Stainless-Runtime-Version": process.version
+    };
+  const t = Pt();
+  return t ? {
+    "X-Stainless-Lang": "js",
+    "X-Stainless-Package-Version": T,
+    "X-Stainless-OS": "Unknown",
+    "X-Stainless-Arch": "unknown",
+    "X-Stainless-Runtime": `browser:${t.browser}`,
+    "X-Stainless-Runtime-Version": t.version
+  } : {
+    "X-Stainless-Lang": "js",
+    "X-Stainless-Package-Version": T,
+    "X-Stainless-OS": "Unknown",
+    "X-Stainless-Arch": "unknown",
+    "X-Stainless-Runtime": "unknown",
+    "X-Stainless-Runtime-Version": "unknown"
+  };
+};
+function Pt() {
+  if (typeof navigator > "u" || !navigator)
+    return null;
+  const t = [
+    { key: "edge", pattern: /Edge(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+    { key: "ie", pattern: /MSIE(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+    { key: "ie", pattern: /Trident(?:.*rv\:(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+    { key: "chrome", pattern: /Chrome(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+    { key: "firefox", pattern: /Firefox(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+    { key: "safari", pattern: /(?:Version\W+(\d+)\.(\d+)(?:\.(\d+))?)?(?:\W+Mobile\S*)?\W+Safari/ }
+  ];
+  for (const { key: e, pattern: r } of t) {
+    const n = r.exec(navigator.userAgent);
+    if (n) {
+      const s = n[1] || 0, o = n[2] || 0, i = n[3] || 0;
+      return { browser: e, version: `${s}.${o}.${i}` };
+    }
+  }
+  return null;
+}
+const we = (t) => t === "x32" ? "x32" : t === "x86_64" || t === "x64" ? "x64" : t === "arm" ? "arm" : t === "aarch64" || t === "arm64" ? "arm64" : t ? `other:${t}` : "unknown", be = (t) => (t = t.toLowerCase(), t.includes("ios") ? "iOS" : t === "android" ? "Android" : t === "darwin" ? "MacOS" : t === "win32" ? "Windows" : t === "freebsd" ? "FreeBSD" : t === "openbsd" ? "OpenBSD" : t === "linux" ? "Linux" : t ? `Other:${t}` : "Unknown");
+let xe;
+const kt = () => xe ?? (xe = Et()), Tt = (t) => {
+  try {
+    return JSON.parse(t);
+  } catch {
+    return;
+  }
+}, vt = /^[a-z][a-z0-9+.-]*:/i, Ct = (t) => vt.test(t), It = (t) => new Promise((e) => setTimeout(e, t)), J = (t, e) => {
+  if (typeof e != "number" || !Number.isInteger(e))
+    throw new P(`${t} must be an integer`);
+  if (e < 0)
+    throw new P(`${t} must be a positive integer`);
+  return e;
+}, re = (t) => {
+  if (t instanceof Error)
+    return t;
+  if (typeof t == "object" && t !== null)
+    try {
+      return new Error(JSON.stringify(t));
+    } catch {
+    }
+  return new Error(t);
+}, _e = (t) => {
+  if (typeof process < "u")
+    return process.env?.[t]?.trim() ?? void 0;
+  if (typeof Deno < "u")
+    return Deno.env?.get?.(t)?.trim();
+};
+function ze(t) {
+  if (!t)
+    return !0;
+  for (const e in t)
+    return !1;
+  return !0;
+}
+function Xe(t, e) {
+  return Object.prototype.hasOwnProperty.call(t, e);
+}
+function Ae(t, e) {
+  for (const r in e) {
+    if (!Xe(e, r))
+      continue;
+    const n = r.toLowerCase();
+    if (!n)
+      continue;
+    const s = e[r];
+    s === null ? delete t[n] : s !== void 0 && (t[n] = s);
+  }
+}
+function L(t, ...e) {
+  typeof process < "u" && process?.env?.DEBUG === "true" && console.log(`Arcade:DEBUG:${t}`, ...e);
+}
+const Dt = () => "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (t) => {
+  const e = Math.random() * 16 | 0;
+  return (t === "x" ? e : e & 3 | 8).toString(16);
+}), Lt = (t) => typeof t?.get == "function", B = (t, e) => {
+  const r = e.toLowerCase();
+  if (Lt(t)) {
+    const n = e[0]?.toUpperCase() + e.substring(1).replace(/([^\w])(\w)/g, (s, o, i) => o + i.toUpperCase());
+    for (const s of [e, r, e.toUpperCase(), n]) {
+      const o = t.get(s);
+      if (o)
+        return o;
+    }
+  }
+  for (const [n, s] of Object.entries(t))
+    if (n.toLowerCase() === r)
+      return Array.isArray(s) ? (s.length <= 1 || console.warn(`Received ${s.length} entries for the ${e} header, using the first entry.`), s[0]) : s;
+};
+class O extends _t {
+  constructor(e, r, n, s) {
+    super(e, r, n, s), this.items = n.items || [], this.total_count = n.total_count || 0, this.offset = n.offset || 0;
+  }
+  getPaginatedItems() {
+    return this.items ?? [];
+  }
+  // @deprecated Please use `nextPageInfo()` instead
+  nextPageParams() {
+    const e = this.nextPageInfo();
+    if (!e)
+      return null;
+    if ("params" in e)
+      return e.params;
+    const r = Object.fromEntries(e.url.searchParams);
+    return Object.keys(r).length ? r : null;
+  }
+  nextPageInfo() {
+    const e = this.offset;
+    if (!e)
+      return null;
+    const r = this.getPaginatedItems().length, n = e + r, s = this.total_count;
+    return s && n < s ? { params: { offset: n } } : null;
+  }
+}
+class b {
+  constructor(e) {
+    this._client = e;
+  }
+}
+class Ke extends b {
+  /**
+   * Create a new auth provider
+   */
+  create(e, r) {
+    return this._client.post("/v1/admin/auth_providers", { body: e, ...r });
+  }
+  /**
+   * List a page of auth providers that are available to the caller
+   */
+  list(e) {
+    return this._client.get("/v1/admin/auth_providers", e);
+  }
+  /**
+   * Delete a specific auth provider
+   */
+  delete(e, r) {
+    return this._client.delete(`/v1/admin/auth_providers/${e}`, r);
+  }
+  /**
+   * Get the details of a specific auth provider
+   */
+  get(e, r) {
+    return this._client.get(`/v1/admin/auth_providers/${e}`, r);
+  }
+  /**
+   * Patch an existing auth provider
+   */
+  patch(e, r, n) {
+    return this._client.patch(`/v1/admin/auth_providers/${e}`, { body: r, ...n });
+  }
+}
+class We extends b {
+  /**
+   * List all secrets that are visible to the caller
+   */
+  list(e) {
+    return this._client.get("/v1/admin/secrets", e);
+  }
+  /**
+   * Delete a secret by its ID
+   */
+  delete(e, r) {
+    return this._client.delete(`/v1/admin/secrets/${e}`, {
+      ...r,
+      headers: { Accept: "*/*", ...r?.headers }
+    });
+  }
+}
+class ne extends b {
+  list(e = {}, r) {
+    return S(e) ? this.list({}, e) : this._client.getAPIList("/v1/admin/user_connections", se, {
+      query: e,
+      ...r
+    });
+  }
+  /**
+   * Delete a user/auth provider connection
+   */
+  delete(e, r) {
+    return this._client.delete(`/v1/admin/user_connections/${e}`, {
+      ...r,
+      headers: { Accept: "*/*", ...r?.headers }
+    });
+  }
+}
+class se extends O {
+}
+ne.UserConnectionResponsesOffsetPage = se;
+class v extends b {
+  constructor() {
+    super(...arguments), this.userConnections = new ne(this._client), this.authProviders = new Ke(this._client), this.secrets = new We(this._client);
+  }
+}
+v.UserConnections = ne;
+v.UserConnectionResponsesOffsetPage = se;
+v.AuthProviders = Ke;
+v.Secrets = We;
+const Ot = 45;
+class Ft extends Error {
+  constructor(e) {
+    super(e), this.name = "AuthorizationError";
+  }
+}
+class Ve extends b {
+  /**
+   * Starts the authorization process for a given provider and scopes.
+   * @param userId - The user ID for which authorization is being requested
+   * @param provider - The authorization provider (e.g., 'github', 'google', 'linkedin', 'microsoft', 'slack', 'spotify', 'x', 'zoom')
+   * @param options - Optional parameters
+   * @param options.providerType - The type of authorization provider. Defaults to 'oauth2'
+   * @param options.scopes - A list of scopes required for authorization, if any. Defaults to []
+   * @returns The authorization response
+   *
+   * Example:
+   * ```ts
+   * const authResponse = await client.auth.start("user@example.com", "github");
+   * ```
+   */
+  start(e, r, n = {}) {
+    const { providerType: s = "oauth2", scopes: o = [] } = n, i = {
+      provider_id: r,
+      provider_type: s,
+      oauth2: {
+        scopes: o
+      }
+    };
+    return this.authorize({
+      auth_requirement: i,
+      user_id: e
+    });
+  }
+  /**
+   * Starts the authorization process for given authorization requirements
+   */
+  authorize(e, r) {
+    return this._client.post("/v1/auth/authorize", { body: e, ...r });
+  }
+  /**
+   * Confirms a user's details during an authorization flow
+   */
+  confirmUser(e, r) {
+    return this._client.post("/v1/auth/confirm_user", { body: e, ...r });
+  }
+  /**
+   * Checks the status of an ongoing authorization process for a specific tool. If
+   * 'wait' param is present, does not respond until either the auth status becomes
+   * completed or the timeout is reached.
+   */
+  status(e, r) {
+    return this._client.get("/v1/auth/status", { query: e, ...r });
+  }
+  /**
+   * Waits for the authorization process to complete.
+   * @param authResponseOrId - The authorization response or ID to wait for completion
+   * @returns The completed authorization response
+   * @throws {AuthorizationError} When the authorization ID is missing or invalid
+   *
+   * Example:
+   * ```ts
+   * const authResponse = await client.auth.start("user@example.com", "github");
+   * try {
+   *   const completedAuth = await client.auth.waitForCompletion(authResponse);
+   *   console.log('Authorization completed:', completedAuth);
+   * } catch (error) {
+   *   if (error instanceof AuthorizationError) {
+   *     console.error('Authorization failed:', error.message);
+   *   }
+   * }
+   * ```
+   */
+  async waitForCompletion(e) {
+    let r, n;
+    if (typeof e == "string")
+      r = e, n = { status: "pending" };
+    else {
+      if (!e.id)
+        throw new Ft("Authorization ID is required");
+      r = e.id, n = e;
+    }
+    for (; n.status !== "completed"; )
+      n = await this.status({
+        id: r,
+        wait: Ot
+      });
+    return n;
+  }
+}
+class Qe extends b {
+  /**
+   * Talk to different LLM Chat APIs via OpenAI's API
+   */
+  create(e, r) {
+    return this._client.post("/v1/chat/completions", { body: e, ...r });
+  }
+}
+class oe extends b {
+  constructor() {
+    super(...arguments), this.completions = new Qe(this._client);
+  }
+}
+oe.Completions = Qe;
+class Ge extends b {
+  /**
+   * Engine Health
+   */
+  check(e) {
+    return this._client.get("/v1/health", e);
+  }
+}
+class ie extends b {
+  list(e = {}, r) {
+    return S(e) ? this.list({}, e) : this._client.getAPIList("/v1/formatted_tools", ae, {
+      query: e,
+      ...r
+    });
+  }
+  get(e, r = {}, n) {
+    return S(r) ? this.get(e, {}, r) : this._client.get(`/v1/formatted_tools/${e}`, { query: r, ...n });
+  }
+}
+class ae extends O {
+}
+ie.FormattedListResponsesOffsetPage = ae;
+class Je extends b {
+  list(e = {}, r) {
+    return S(e) ? this.list({}, e) : this._client.getAPIList("/v1/scheduled_tools", $t, { query: e, ...r });
+  }
+  /**
+   * Returns the details for a specific scheduled tool execution
+   */
+  get(e, r) {
+    return this._client.get(`/v1/scheduled_tools/${e}`, r);
+  }
+}
+class C extends b {
+  constructor() {
+    super(...arguments), this.scheduled = new Je(this._client), this.formatted = new ie(this._client);
+  }
+  list(e = {}, r) {
+    return S(e) ? this.list({}, e) : this._client.getAPIList("/v1/tools", z, { query: e, ...r });
+  }
+  /**
+   * Authorizes a user for a specific tool by name
+   */
+  authorize(e, r) {
+    return this._client.post("/v1/tools/authorize", { body: e, ...r });
+  }
+  /**
+   * Executes a tool by name and arguments
+   */
+  execute(e, r) {
+    return this._client.post("/v1/tools/execute", { body: e, ...r });
+  }
+  get(e, r = {}, n) {
+    return S(r) ? this.get(e, {}, r) : this._client.get(`/v1/tools/${e}`, { query: r, ...n });
+  }
+}
+class z extends O {
+}
+class $t extends O {
+}
+C.ToolDefinitionsOffsetPage = z;
+C.Scheduled = Je;
+C.Formatted = ie;
+C.FormattedListResponsesOffsetPage = ae;
+class ce extends b {
+  /**
+   * Create a worker
+   */
+  create(e, r) {
+    return this._client.post("/v1/workers", { body: e, ...r });
+  }
+  /**
+   * Update a worker
+   */
+  update(e, r, n) {
+    return this._client.patch(`/v1/workers/${e}`, { body: r, ...n });
+  }
+  list(e = {}, r) {
+    return S(e) ? this.list({}, e) : this._client.getAPIList("/v1/workers", ue, { query: e, ...r });
+  }
+  /**
+   * Delete a worker
+   */
+  delete(e, r) {
+    return this._client.delete(`/v1/workers/${e}`, {
+      ...r,
+      headers: { Accept: "*/*", ...r?.headers }
+    });
+  }
+  /**
+   * Get a worker by ID
+   */
+  get(e, r) {
+    return this._client.get(`/v1/workers/${e}`, r);
+  }
+  /**
+   * Get the health of a worker
+   */
+  health(e, r) {
+    return this._client.get(`/v1/workers/${e}/health`, r);
+  }
+  tools(e, r = {}, n) {
+    return S(r) ? this.tools(e, {}, r) : this._client.getAPIList(`/v1/workers/${e}/tools`, z, {
+      query: r,
+      ...n
+    });
+  }
+}
+class ue extends O {
+}
+ce.WorkerResponsesOffsetPage = ue;
+var Ye, Ze;
+class d extends xt {
+  /**
+   * API Client for interfacing with the Arcade API.
+   *
+   * @param {string | undefined} [opts.apiKey=process.env['ARCADE_API_KEY'] ?? undefined]
+   * @param {string} [opts.baseURL=process.env['ARCADE_BASE_URL'] ?? https://api.arcade.dev] - Override the default base URL for the API.
+   * @param {number} [opts.timeout=1 minute] - The maximum amount of time (in milliseconds) the client will wait for a response before timing out.
+   * @param {number} [opts.httpAgent] - An HTTP agent used to manage HTTP(s) connections.
+   * @param {Core.Fetch} [opts.fetch] - Specify a custom `fetch` function implementation.
+   * @param {number} [opts.maxRetries=2] - The maximum number of times the client will retry a request.
+   * @param {Core.Headers} opts.defaultHeaders - Default headers to include with every request to the API.
+   * @param {Core.DefaultQuery} opts.defaultQuery - Default query parameters to include with every request to the API.
+   */
+  constructor({ baseURL: e = _e("ARCADE_BASE_URL"), apiKey: r = _e("ARCADE_API_KEY"), ...n } = {}) {
+    if (r === void 0)
+      throw new P("The ARCADE_API_KEY environment variable is missing or empty; either provide it, or instantiate the Arcade client with an apiKey option, like new Arcade({ apiKey: 'My API Key' }).");
+    const s = {
+      apiKey: r,
+      ...n,
+      baseURL: e || "https://api.arcade.dev"
+    };
+    super({
+      baseURL: s.baseURL,
+      baseURLOverridden: e ? e !== "https://api.arcade.dev" : !1,
+      timeout: s.timeout ?? 6e4,
+      httpAgent: s.httpAgent,
+      maxRetries: s.maxRetries,
+      fetch: s.fetch
+    }), Ye.add(this), this.admin = new v(this), this.auth = new Ve(this), this.health = new Ge(this), this.chat = new oe(this), this.tools = new C(this), this.workers = new ce(this), this._options = s, this.idempotencyHeader = "Idempotency-Key", this.apiKey = r;
+  }
+  defaultQuery() {
+    return this._options.defaultQuery;
+  }
+  defaultHeaders(e) {
+    return {
+      ...super.defaultHeaders(e),
+      ...this._options.defaultHeaders
+    };
+  }
+  authHeaders(e) {
+    return { Authorization: this.apiKey };
+  }
+  stringifyQuery(e) {
+    return dt(e, { arrayFormat: "comma" });
+  }
+}
+Ze = d, Ye = /* @__PURE__ */ new WeakSet();
+d.Arcade = Ze;
+d.DEFAULT_TIMEOUT = 6e4;
+d.ArcadeError = P;
+d.APIError = w;
+d.APIConnectionError = q;
+d.APIConnectionTimeoutError = Ie;
+d.APIUserAbortError = te;
+d.NotFoundError = Fe;
+d.ConflictError = $e;
+d.RateLimitError = Ue;
+d.BadRequestError = De;
+d.AuthenticationError = Le;
+d.InternalServerError = Be;
+d.PermissionDeniedError = Oe;
+d.UnprocessableEntityError = je;
+d.toFile = yt;
+d.fileFromPath = Ee;
+d.Admin = v;
+d.Auth = Ve;
+d.Health = Ge;
+d.Chat = oe;
+d.Tools = C;
+d.ToolDefinitionsOffsetPage = z;
+d.Workers = ce;
+d.WorkerResponsesOffsetPage = ue;
+const jt = /[._\-\s]+/, Ut = /([a-z])([A-Z])/g, Bt = /\s+/;
+class Kt {
+  #e;
+  constructor(e) {
+    const { accessToken: r, apiKey: n, arcadeClientId: s, baseURL: o } = e, i = n ?? pe("ARCADE_API_KEY"), l = !!i, c = {};
+    s && (c["Arcade-Client-Id"] = s), !l && r && (c.Authorization = `Bearer ${r}`);
+    const u = {
+      baseURL: o ?? pe("ARCADE_BASE_URL"),
+      defaultHeaders: c,
+      apiKey: i ?? ""
+    };
+    this.#e = new d(u);
+  }
+  static create(e) {
+    return new d(e);
+  }
+  async getAllTools(e = {}) {
+    const { limit: r = 1e3, offset: n = 0, toolkit: s } = e;
+    return (await this.#e.tools.list({
+      limit: r,
+      offset: n,
+      toolkit: s
+    })).items;
+  }
+  async groupToolsBy(e) {
+    const r = await this.getAllTools(), n = /* @__PURE__ */ new Map();
+    for (const s of r) {
+      const o = s[e];
+      typeof o == "string" && n.set(o, s);
+    }
+    return n;
+  }
+  async getToolkits() {
+    const e = await this.getAllTools(), r = /* @__PURE__ */ new Map();
+    for (const n of e) {
+      const s = n.toolkit.name;
+      let o = r.get(s);
+      o || (o = {
+        ...n.toolkit,
+        tools: [],
+        requirements: {
+          met: !0,
+          secrets: [],
+          authorization: [],
+          scopes: {}
+        }
+      }, r.set(s, o)), o.tools.push(n), n.requirements && this.applyToolRequirements(o, n.requirements);
+    }
+    return r;
+  }
+  async getToolsForToolkit(e) {
+    return (await this.#e.tools.list({
+      toolkit: e,
+      limit: 1e3
+    })).items;
+  }
+  applyToolRequirements(e, r) {
+    if (!r)
+      return;
+    e.requirements.secrets = this.mergeSecrets(
+      r.secrets ?? [],
+      e.requirements.secrets ?? []
+    ), e.requirements.authorization = this.mergeAuthorizations(
+      r.authorization,
+      e.requirements.authorization ?? []
+    );
+    const n = r.authorization?.provider_id, s = r.authorization?.oauth2?.scopes ?? [];
+    n && s.length && (e.requirements.scopes = this.mergeScopes(
+      n,
+      s,
+      e.requirements.scopes ?? {}
+    )), e.requirements.met = !!(e.requirements.met && (r.met ?? !0));
+  }
+  mergeSecrets(e = [], r = []) {
+    if (e.length === 0)
+      return r;
+    const n = /* @__PURE__ */ new Map();
+    for (const s of r)
+      n.set(s.key, { ...s });
+    for (const s of e) {
+      const o = n.get(s.key);
+      if (!o) {
+        n.set(s.key, { ...s });
+        continue;
+      }
+      const i = !!(o.met || s.met), l = s.status_reason ?? o.status_reason;
+      n.set(s.key, { key: s.key, met: i, status_reason: l });
+    }
+    return Array.from(n.values());
+  }
+  mergeAuthorizations(e, r = []) {
+    if (!e?.provider_id)
+      return r;
+    const n = new Map(r.map((i) => [i.provider_id, { ...i }])), s = n.get(e.provider_id);
+    if (!s)
+      return n.set(e.provider_id, { ...e }), Array.from(n.values());
+    const o = new Set(s.oauth2?.scopes ?? []);
+    for (const i of e.oauth2?.scopes ?? [])
+      o.add(i);
+    return n.set(e.provider_id, {
+      ...s,
+      oauth2: {
+        ...s.oauth2 ?? {},
+        scopes: Array.from(o)
+      }
+    }), Array.from(n.values());
+  }
+  mergeScopes(e, r = [], n = {}) {
+    if (!e || r.length === 0)
+      return n;
+    const s = new Set(n[e] ?? []);
+    for (const o of r)
+      s.add(o);
+    return { ...n, [e]: Array.from(s) };
+  }
+  /**
+   * Pre-compute requirements summary for optimal UI performance.
+   * This eliminates the need for runtime transformation in UI components.
+   */
+  computeRequirementsSummary(e) {
+    const r = e?.secrets?.length ? {
+      configured: e.secrets.filter((s) => s.met === !0).map((s) => s.key),
+      pending: e.secrets.filter((s) => s.met === !1).map((s) => s.key)
+    } : void 0, n = e?.authorization?.length ? {
+      providers: e.authorization.filter((s) => s.provider_id || s.id).map((s) => ({
+        id: s.provider_id || s.id || "",
+        status: s.status,
+        scopes: s.oauth2?.scopes || []
+      }))
+    } : void 0;
+    return { secrets: r, oauth: n };
+  }
+  /**
+   * Process raw toolkit data into an optimized collection with pre-computed search indices.
+   *
+   * @returns ToolkitCollection with:
+   *   - Pre-computed searchable text for fast filtering
+   *   - Pre-computed requirement badges (no runtime processing needed)
+   *   - Search indices for O(1) lookups
+   *   - Toolkit/tool mapping for quick relationships
+   */
+  async getProcessedToolkitCollection() {
+    const e = await this.getToolkits(), r = [], n = [], s = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map(), i = {
+      toolkitsByName: /* @__PURE__ */ new Map(),
+      toolsByName: /* @__PURE__ */ new Map()
+    };
+    for (const [l, c] of e.entries()) {
+      const u = this.normalizeText([
+        c.name,
+        c.description ?? "",
+        c.version ?? ""
+      ]), p = this.computeRequirementsSummary(
+        c.requirements
+      ), a = {
+        ...c,
+        searchableText: u,
+        requirementsSummary: p,
+        metadata: tt[c.name]
+      };
+      r.push(a), s.set(l, a), i.toolkitsByName.set(l.toLowerCase(), a);
+      for (const h of c.tools) {
+        const m = this.normalizeText([
+          h.name,
+          h.fully_qualified_name,
+          h.description ?? "",
+          c.name,
+          c.description ?? ""
+        ]), x = {
+          ...h,
+          searchableText: m
+        };
+        n.push(x), o.set(h.fully_qualified_name, l), i.toolsByName.set(
+          h.fully_qualified_name.toLowerCase(),
+          x
+        );
+      }
+    }
+    return {
+      toolkits: r,
+      tools: n,
+      toolkitMap: s,
+      toolToToolkitMap: o,
+      searchIndex: i
+    };
+  }
+  /**
+   * Helper function to create normalized searchable text from multiple strings.
+   * Separates compound terms (like Gmail.List_emails) into individual searchable components.
+   * Handles camelCase, snake_case, kebab-case, and dot.notation.
+   */
+  normalizeText(e) {
+    const r = /* @__PURE__ */ new Set();
+    for (const n of e) {
+      if (!n)
+        continue;
+      const s = n.toLowerCase();
+      r.add(s);
+      const o = n.split(jt);
+      for (const i of o) {
+        if (i.length <= 1)
+          continue;
+        const c = i.replace(Ut, "$1 $2").split(Bt);
+        for (const u of c)
+          u.length > 1 && r.add(u.toLowerCase());
+      }
+    }
+    return Array.from(r).join(" ");
+  }
+}
+export {
+  Kt as A,
+  d as a
+};