@soat/sdk 0.3.4 → 0.4.4

package/dist/esm/index.js

@@ -5,20 +5,2679 @@ var __name = (target, value) => __defProp(target, "name", {
   configurable: true
 });
 
-// src/index.ts
-import createClient from "openapi-fetch";
-var createSoatClient = /* @__PURE__ */__name(args => {
-  const {
-    baseUrl,
-    token
-  } = args;
-  return createClient({
-    baseUrl,
-    ...(token && {
+// src/generated/core/bodySerializer.gen.ts
+var serializeFormDataPair = /* @__PURE__ */__name((data, key, value) => {
+  if (typeof value === "string" || value instanceof Blob) {
+    data.append(key, value);
+  } else if (value instanceof Date) {
+    data.append(key, value.toISOString());
+  } else {
+    data.append(key, JSON.stringify(value));
+  }
+}, "serializeFormDataPair");
+var formDataBodySerializer = {
+  bodySerializer: /* @__PURE__ */__name(body => {
+    const data = new FormData();
+    Object.entries(body).forEach(([key, value]) => {
+      if (value === void 0 || value === null) {
+        return;
+      }
+      if (Array.isArray(value)) {
+        value.forEach(v => serializeFormDataPair(data, key, v));
+      } else {
+        serializeFormDataPair(data, key, value);
+      }
+    });
+    return data;
+  }, "bodySerializer")
+};
+var jsonBodySerializer = {
+  bodySerializer: /* @__PURE__ */__name(body => JSON.stringify(body, (_key, value) => typeof value === "bigint" ? value.toString() : value), "bodySerializer")
+};
+
+// src/generated/core/params.gen.ts
+var extraPrefixesMap = {
+  $body_: "body",
+  $headers_: "headers",
+  $path_: "path",
+  $query_: "query"
+};
+var extraPrefixes = Object.entries(extraPrefixesMap);
+
+// src/generated/core/serverSentEvents.gen.ts
+function createSseClient({
+  onRequest,
+  onSseError,
+  onSseEvent,
+  responseTransformer,
+  responseValidator,
+  sseDefaultRetryDelay,
+  sseMaxRetryAttempts,
+  sseMaxRetryDelay,
+  sseSleepFn,
+  url,
+  ...options
+}) {
+  let lastEventId;
+  const sleep = sseSleepFn ?? (ms => new Promise(resolve => setTimeout(resolve, ms)));
+  const createStream = /* @__PURE__ */__name(async function* () {
+    let retryDelay = sseDefaultRetryDelay ?? 3e3;
+    let attempt = 0;
+    const signal = options.signal ?? new AbortController().signal;
+    while (true) {
+      if (signal.aborted) break;
+      attempt++;
+      const headers = options.headers instanceof Headers ? options.headers : new Headers(options.headers);
+      if (lastEventId !== void 0) {
+        headers.set("Last-Event-ID", lastEventId);
+      }
+      try {
+        const requestInit = {
+          redirect: "follow",
+          ...options,
+          body: options.serializedBody,
+          headers,
+          signal
+        };
+        let request = new Request(url, requestInit);
+        if (onRequest) {
+          request = await onRequest(url, requestInit);
+        }
+        const _fetch = options.fetch ?? globalThis.fetch;
+        const response = await _fetch(request);
+        if (!response.ok) throw new Error(`SSE failed: ${response.status} ${response.statusText}`);
+        if (!response.body) throw new Error("No body in SSE response");
+        const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
+        let buffer = "";
+        const abortHandler = /* @__PURE__ */__name(() => {
+          try {
+            reader.cancel();
+          } catch {}
+        }, "abortHandler");
+        signal.addEventListener("abort", abortHandler);
+        try {
+          while (true) {
+            const {
+              done,
+              value
+            } = await reader.read();
+            if (done) break;
+            buffer += value;
+            buffer = buffer.replace(/\r\n?/g, "\n");
+            const chunks = buffer.split("\n\n");
+            buffer = chunks.pop() ?? "";
+            for (const chunk of chunks) {
+              const lines = chunk.split("\n");
+              const dataLines = [];
+              let eventName;
+              for (const line of lines) {
+                if (line.startsWith("data:")) {
+                  dataLines.push(line.replace(/^data:\s*/, ""));
+                } else if (line.startsWith("event:")) {
+                  eventName = line.replace(/^event:\s*/, "");
+                } else if (line.startsWith("id:")) {
+                  lastEventId = line.replace(/^id:\s*/, "");
+                } else if (line.startsWith("retry:")) {
+                  const parsed = Number.parseInt(line.replace(/^retry:\s*/, ""), 10);
+                  if (!Number.isNaN(parsed)) {
+                    retryDelay = parsed;
+                  }
+                }
+              }
+              let data;
+              let parsedJson = false;
+              if (dataLines.length) {
+                const rawData = dataLines.join("\n");
+                try {
+                  data = JSON.parse(rawData);
+                  parsedJson = true;
+                } catch {
+                  data = rawData;
+                }
+              }
+              if (parsedJson) {
+                if (responseValidator) {
+                  await responseValidator(data);
+                }
+                if (responseTransformer) {
+                  data = await responseTransformer(data);
+                }
+              }
+              onSseEvent?.({
+                data,
+                event: eventName,
+                id: lastEventId,
+                retry: retryDelay
+              });
+              if (dataLines.length) {
+                yield data;
+              }
+            }
+          }
+        } finally {
+          signal.removeEventListener("abort", abortHandler);
+          reader.releaseLock();
+        }
+        break;
+      } catch (error) {
+        onSseError?.(error);
+        if (sseMaxRetryAttempts !== void 0 && attempt >= sseMaxRetryAttempts) {
+          break;
+        }
+        const backoff = Math.min(retryDelay * 2 ** (attempt - 1), sseMaxRetryDelay ?? 3e4);
+        await sleep(backoff);
+      }
+    }
+  }, "createStream");
+  const stream = createStream();
+  return {
+    stream
+  };
+}
+__name(createSseClient, "createSseClient");
+
+// src/generated/core/pathSerializer.gen.ts
+var separatorArrayExplode = /* @__PURE__ */__name(style => {
+  switch (style) {
+    case "label":
+      return ".";
+    case "matrix":
+      return ";";
+    case "simple":
+      return ",";
+    default:
+      return "&";
+  }
+}, "separatorArrayExplode");
+var separatorArrayNoExplode = /* @__PURE__ */__name(style => {
+  switch (style) {
+    case "form":
+      return ",";
+    case "pipeDelimited":
+      return "|";
+    case "spaceDelimited":
+      return "%20";
+    default:
+      return ",";
+  }
+}, "separatorArrayNoExplode");
+var separatorObjectExplode = /* @__PURE__ */__name(style => {
+  switch (style) {
+    case "label":
+      return ".";
+    case "matrix":
+      return ";";
+    case "simple":
+      return ",";
+    default:
+      return "&";
+  }
+}, "separatorObjectExplode");
+var serializeArrayParam = /* @__PURE__ */__name(({
+  allowReserved,
+  explode,
+  name,
+  style,
+  value
+}) => {
+  if (!explode) {
+    const joinedValues2 = (allowReserved ? value : value.map(v => encodeURIComponent(v))).join(separatorArrayNoExplode(style));
+    switch (style) {
+      case "label":
+        return `.${joinedValues2}`;
+      case "matrix":
+        return `;${name}=${joinedValues2}`;
+      case "simple":
+        return joinedValues2;
+      default:
+        return `${name}=${joinedValues2}`;
+    }
+  }
+  const separator = separatorArrayExplode(style);
+  const joinedValues = value.map(v => {
+    if (style === "label" || style === "simple") {
+      return allowReserved ? v : encodeURIComponent(v);
+    }
+    return serializePrimitiveParam({
+      allowReserved,
+      name,
+      value: v
+    });
+  }).join(separator);
+  return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+}, "serializeArrayParam");
+var serializePrimitiveParam = /* @__PURE__ */__name(({
+  allowReserved,
+  name,
+  value
+}) => {
+  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}=${allowReserved ? value : encodeURIComponent(value)}`;
+}, "serializePrimitiveParam");
+var serializeObjectParam = /* @__PURE__ */__name(({
+  allowReserved,
+  explode,
+  name,
+  style,
+  value,
+  valueOnly
+}) => {
+  if (value instanceof Date) {
+    return valueOnly ? value.toISOString() : `${name}=${value.toISOString()}`;
+  }
+  if (style !== "deepObject" && !explode) {
+    let values = [];
+    Object.entries(value).forEach(([key, v]) => {
+      values = [...values, key, allowReserved ? v : encodeURIComponent(v)];
+    });
+    const joinedValues2 = values.join(",");
+    switch (style) {
+      case "form":
+        return `${name}=${joinedValues2}`;
+      case "label":
+        return `.${joinedValues2}`;
+      case "matrix":
+        return `;${name}=${joinedValues2}`;
+      default:
+        return joinedValues2;
+    }
+  }
+  const separator = separatorObjectExplode(style);
+  const joinedValues = Object.entries(value).map(([key, v]) => serializePrimitiveParam({
+    allowReserved,
+    name: style === "deepObject" ? `${name}[${key}]` : key,
+    value: v
+  })).join(separator);
+  return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+}, "serializeObjectParam");
+
+// src/generated/core/utils.gen.ts
+var PATH_PARAM_RE = /\{[^{}]+\}/g;
+var defaultPathSerializer = /* @__PURE__ */__name(({
+  path,
+  url: _url
+}) => {
+  let url = _url;
+  const matches = _url.match(PATH_PARAM_RE);
+  if (matches) {
+    for (const match of matches) {
+      let explode = false;
+      let name = match.substring(1, match.length - 1);
+      let style = "simple";
+      if (name.endsWith("*")) {
+        explode = true;
+        name = name.substring(0, name.length - 1);
+      }
+      if (name.startsWith(".")) {
+        name = name.substring(1);
+        style = "label";
+      } else if (name.startsWith(";")) {
+        name = name.substring(1);
+        style = "matrix";
+      }
+      const value = path[name];
+      if (value === void 0 || value === null) {
+        continue;
+      }
+      if (Array.isArray(value)) {
+        url = url.replace(match, serializeArrayParam({
+          explode,
+          name,
+          style,
+          value
+        }));
+        continue;
+      }
+      if (typeof value === "object") {
+        url = url.replace(match, serializeObjectParam({
+          explode,
+          name,
+          style,
+          value,
+          valueOnly: true
+        }));
+        continue;
+      }
+      if (style === "matrix") {
+        url = url.replace(match, `;${serializePrimitiveParam({
+          name,
+          value
+        })}`);
+        continue;
+      }
+      const replaceValue = encodeURIComponent(style === "label" ? `.${value}` : value);
+      url = url.replace(match, replaceValue);
+    }
+  }
+  return url;
+}, "defaultPathSerializer");
+var getUrl = /* @__PURE__ */__name(({
+  baseUrl,
+  path,
+  query,
+  querySerializer,
+  url: _url
+}) => {
+  const pathUrl = _url.startsWith("/") ? _url : `/${_url}`;
+  let url = (baseUrl ?? "") + pathUrl;
+  if (path) {
+    url = defaultPathSerializer({
+      path,
+      url
+    });
+  }
+  let search = query ? querySerializer(query) : "";
+  if (search.startsWith("?")) {
+    search = search.substring(1);
+  }
+  if (search) {
+    url += `?${search}`;
+  }
+  return url;
+}, "getUrl");
+function getValidRequestBody(options) {
+  const hasBody = options.body !== void 0;
+  const isSerializedBody = hasBody && options.bodySerializer;
+  if (isSerializedBody) {
+    if ("serializedBody" in options) {
+      const hasSerializedBody = options.serializedBody !== void 0 && options.serializedBody !== "";
+      return hasSerializedBody ? options.serializedBody : null;
+    }
+    return options.body !== "" ? options.body : null;
+  }
+  if (hasBody) {
+    return options.body;
+  }
+  return void 0;
+}
+__name(getValidRequestBody, "getValidRequestBody");
+
+// src/generated/core/auth.gen.ts
+var getAuthToken = /* @__PURE__ */__name(async (auth, callback) => {
+  const token = typeof callback === "function" ? await callback(auth) : callback;
+  if (!token) {
+    return;
+  }
+  if (auth.scheme === "bearer") {
+    return `Bearer ${token}`;
+  }
+  if (auth.scheme === "basic") {
+    return `Basic ${btoa(token)}`;
+  }
+  return token;
+}, "getAuthToken");
+
+// src/generated/client/utils.gen.ts
+var createQuerySerializer = /* @__PURE__ */__name(({
+  parameters = {},
+  ...args
+} = {}) => {
+  const querySerializer = /* @__PURE__ */__name(queryParams => {
+    const search = [];
+    if (queryParams && typeof queryParams === "object") {
+      for (const name in queryParams) {
+        const value = queryParams[name];
+        if (value === void 0 || value === null) {
+          continue;
+        }
+        const options = parameters[name] || args;
+        if (Array.isArray(value)) {
+          const serializedArray = serializeArrayParam({
+            allowReserved: options.allowReserved,
+            explode: true,
+            name,
+            style: "form",
+            value,
+            ...options.array
+          });
+          if (serializedArray) search.push(serializedArray);
+        } else if (typeof value === "object") {
+          const serializedObject = serializeObjectParam({
+            allowReserved: options.allowReserved,
+            explode: true,
+            name,
+            style: "deepObject",
+            value,
+            ...options.object
+          });
+          if (serializedObject) search.push(serializedObject);
+        } else {
+          const serializedPrimitive = serializePrimitiveParam({
+            allowReserved: options.allowReserved,
+            name,
+            value
+          });
+          if (serializedPrimitive) search.push(serializedPrimitive);
+        }
+      }
+    }
+    return search.join("&");
+  }, "querySerializer");
+  return querySerializer;
+}, "createQuerySerializer");
+var getParseAs = /* @__PURE__ */__name(contentType => {
+  if (!contentType) {
+    return "stream";
+  }
+  const cleanContent = contentType.split(";")[0]?.trim();
+  if (!cleanContent) {
+    return;
+  }
+  if (cleanContent.startsWith("application/json") || cleanContent.endsWith("+json")) {
+    return "json";
+  }
+  if (cleanContent === "multipart/form-data") {
+    return "formData";
+  }
+  if (["application/", "audio/", "image/", "video/"].some(type => cleanContent.startsWith(type))) {
+    return "blob";
+  }
+  if (cleanContent.startsWith("text/")) {
+    return "text";
+  }
+  return;
+}, "getParseAs");
+var checkForExistence = /* @__PURE__ */__name((options, name) => {
+  if (!name) {
+    return false;
+  }
+  if (options.headers.has(name) || options.query?.[name] || options.headers.get("Cookie")?.includes(`${name}=`)) {
+    return true;
+  }
+  return false;
+}, "checkForExistence");
+var setAuthParams = /* @__PURE__ */__name(async ({
+  security,
+  ...options
+}) => {
+  for (const auth of security) {
+    if (checkForExistence(options, auth.name)) {
+      continue;
+    }
+    const token = await getAuthToken(auth, options.auth);
+    if (!token) {
+      continue;
+    }
+    const name = auth.name ?? "Authorization";
+    switch (auth.in) {
+      case "query":
+        if (!options.query) {
+          options.query = {};
+        }
+        options.query[name] = token;
+        break;
+      case "cookie":
+        options.headers.append("Cookie", `${name}=${token}`);
+        break;
+      case "header":
+      default:
+        options.headers.set(name, token);
+        break;
+    }
+  }
+}, "setAuthParams");
+var buildUrl = /* @__PURE__ */__name(options => getUrl({
+  baseUrl: options.baseUrl,
+  path: options.path,
+  query: options.query,
+  querySerializer: typeof options.querySerializer === "function" ? options.querySerializer : createQuerySerializer(options.querySerializer),
+  url: options.url
+}), "buildUrl");
+var mergeConfigs = /* @__PURE__ */__name((a, b) => {
+  const config = {
+    ...a,
+    ...b
+  };
+  if (config.baseUrl?.endsWith("/")) {
+    config.baseUrl = config.baseUrl.substring(0, config.baseUrl.length - 1);
+  }
+  config.headers = mergeHeaders(a.headers, b.headers);
+  return config;
+}, "mergeConfigs");
+var headersEntries = /* @__PURE__ */__name(headers => {
+  const entries = [];
+  headers.forEach((value, key) => {
+    entries.push([key, value]);
+  });
+  return entries;
+}, "headersEntries");
+var mergeHeaders = /* @__PURE__ */__name((...headers) => {
+  const mergedHeaders = new Headers();
+  for (const header of headers) {
+    if (!header) {
+      continue;
+    }
+    const iterator = header instanceof Headers ? headersEntries(header) : Object.entries(header);
+    for (const [key, value] of iterator) {
+      if (value === null) {
+        mergedHeaders.delete(key);
+      } else if (Array.isArray(value)) {
+        for (const v of value) {
+          mergedHeaders.append(key, v);
+        }
+      } else if (value !== void 0) {
+        mergedHeaders.set(key, typeof value === "object" ? JSON.stringify(value) : value);
+      }
+    }
+  }
+  return mergedHeaders;
+}, "mergeHeaders");
+var Interceptors = class Interceptors2 {
+  static {
+    __name(this, "Interceptors");
+  }
+  fns = [];
+  clear() {
+    this.fns = [];
+  }
+  eject(id) {
+    const index = this.getInterceptorIndex(id);
+    if (this.fns[index]) {
+      this.fns[index] = null;
+    }
+  }
+  exists(id) {
+    const index = this.getInterceptorIndex(id);
+    return Boolean(this.fns[index]);
+  }
+  getInterceptorIndex(id) {
+    if (typeof id === "number") {
+      return this.fns[id] ? id : -1;
+    }
+    return this.fns.indexOf(id);
+  }
+  update(id, fn) {
+    const index = this.getInterceptorIndex(id);
+    if (this.fns[index]) {
+      this.fns[index] = fn;
+      return id;
+    }
+    return false;
+  }
+  use(fn) {
+    this.fns.push(fn);
+    return this.fns.length - 1;
+  }
+};
+var createInterceptors = /* @__PURE__ */__name(() => ({
+  error: new Interceptors(),
+  request: new Interceptors(),
+  response: new Interceptors()
+}), "createInterceptors");
+var defaultQuerySerializer = createQuerySerializer({
+  allowReserved: false,
+  array: {
+    explode: true,
+    style: "form"
+  },
+  object: {
+    explode: true,
+    style: "deepObject"
+  }
+});
+var defaultHeaders = {
+  "Content-Type": "application/json"
+};
+var createConfig = /* @__PURE__ */__name((override = {}) => ({
+  ...jsonBodySerializer,
+  headers: defaultHeaders,
+  parseAs: "auto",
+  querySerializer: defaultQuerySerializer,
+  ...override
+}), "createConfig");
+
+// src/generated/client/client.gen.ts
+var createClient = /* @__PURE__ */__name((config = {}) => {
+  let _config = mergeConfigs(createConfig(), config);
+  const getConfig = /* @__PURE__ */__name(() => ({
+    ..._config
+  }), "getConfig");
+  const setConfig = /* @__PURE__ */__name(config2 => {
+    _config = mergeConfigs(_config, config2);
+    return getConfig();
+  }, "setConfig");
+  const interceptors = createInterceptors();
+  const beforeRequest = /* @__PURE__ */__name(async options => {
+    const opts = {
+      ..._config,
+      ...options,
+      fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+      headers: mergeHeaders(_config.headers, options.headers),
+      serializedBody: void 0
+    };
+    if (opts.security) {
+      await setAuthParams({
+        ...opts,
+        security: opts.security
+      });
+    }
+    if (opts.requestValidator) {
+      await opts.requestValidator(opts);
+    }
+    if (opts.body !== void 0 && opts.bodySerializer) {
+      opts.serializedBody = opts.bodySerializer(opts.body);
+    }
+    if (opts.body === void 0 || opts.serializedBody === "") {
+      opts.headers.delete("Content-Type");
+    }
+    const resolvedOpts = opts;
+    const url = buildUrl(resolvedOpts);
+    return {
+      opts: resolvedOpts,
+      url
+    };
+  }, "beforeRequest");
+  const request = /* @__PURE__ */__name(async options => {
+    const {
+      opts,
+      url
+    } = await beforeRequest(options);
+    const requestInit = {
+      redirect: "follow",
+      ...opts,
+      body: getValidRequestBody(opts)
+    };
+    let request2 = new Request(url, requestInit);
+    for (const fn of interceptors.request.fns) {
+      if (fn) {
+        request2 = await fn(request2, opts);
+      }
+    }
+    const _fetch = opts.fetch;
+    let response;
+    try {
+      response = await _fetch(request2);
+    } catch (error2) {
+      let finalError2 = error2;
+      for (const fn of interceptors.error.fns) {
+        if (fn) {
+          finalError2 = await fn(error2, void 0, request2, opts);
+        }
+      }
+      finalError2 = finalError2 || {};
+      if (opts.throwOnError) {
+        throw finalError2;
+      }
+      return opts.responseStyle === "data" ? void 0 : {
+        error: finalError2,
+        request: request2,
+        response: void 0
+      };
+    }
+    for (const fn of interceptors.response.fns) {
+      if (fn) {
+        response = await fn(response, request2, opts);
+      }
+    }
+    const result = {
+      request: request2,
+      response
+    };
+    if (response.ok) {
+      const parseAs = (opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json";
+      if (response.status === 204 || response.headers.get("Content-Length") === "0") {
+        let emptyData;
+        switch (parseAs) {
+          case "arrayBuffer":
+          case "blob":
+          case "text":
+            emptyData = await response[parseAs]();
+            break;
+          case "formData":
+            emptyData = new FormData();
+            break;
+          case "stream":
+            emptyData = response.body;
+            break;
+          case "json":
+          default:
+            emptyData = {};
+            break;
+        }
+        return opts.responseStyle === "data" ? emptyData : {
+          data: emptyData,
+          ...result
+        };
+      }
+      let data;
+      switch (parseAs) {
+        case "arrayBuffer":
+        case "blob":
+        case "formData":
+        case "text":
+          data = await response[parseAs]();
+          break;
+        case "json":
+          {
+            const text = await response.text();
+            data = text ? JSON.parse(text) : {};
+            break;
+          }
+        case "stream":
+          return opts.responseStyle === "data" ? response.body : {
+            data: response.body,
+            ...result
+          };
+      }
+      if (parseAs === "json") {
+        if (opts.responseValidator) {
+          await opts.responseValidator(data);
+        }
+        if (opts.responseTransformer) {
+          data = await opts.responseTransformer(data);
+        }
+      }
+      return opts.responseStyle === "data" ? data : {
+        data,
+        ...result
+      };
+    }
+    const textError = await response.text();
+    let jsonError;
+    try {
+      jsonError = JSON.parse(textError);
+    } catch {}
+    const error = jsonError ?? textError;
+    let finalError = error;
+    for (const fn of interceptors.error.fns) {
+      if (fn) {
+        finalError = await fn(error, response, request2, opts);
+      }
+    }
+    finalError = finalError || {};
+    if (opts.throwOnError) {
+      throw finalError;
+    }
+    return opts.responseStyle === "data" ? void 0 : {
+      error: finalError,
+      ...result
+    };
+  }, "request");
+  const makeMethodFn = /* @__PURE__ */__name(method => options => request({
+    ...options,
+    method
+  }), "makeMethodFn");
+  const makeSseFn = /* @__PURE__ */__name(method => async options => {
+    const {
+      opts,
+      url
+    } = await beforeRequest(options);
+    return createSseClient({
+      ...opts,
+      body: opts.body,
+      headers: opts.headers,
+      method,
+      onRequest: /* @__PURE__ */__name(async (url2, init) => {
+        let request2 = new Request(url2, init);
+        for (const fn of interceptors.request.fns) {
+          if (fn) {
+            request2 = await fn(request2, opts);
+          }
+        }
+        return request2;
+      }, "onRequest"),
+      serializedBody: getValidRequestBody(opts),
+      url
+    });
+  }, "makeSseFn");
+  const _buildUrl = /* @__PURE__ */__name(options => buildUrl({
+    ..._config,
+    ...options
+  }), "_buildUrl");
+  return {
+    buildUrl: _buildUrl,
+    connect: makeMethodFn("CONNECT"),
+    delete: makeMethodFn("DELETE"),
+    get: makeMethodFn("GET"),
+    getConfig,
+    head: makeMethodFn("HEAD"),
+    interceptors,
+    options: makeMethodFn("OPTIONS"),
+    patch: makeMethodFn("PATCH"),
+    post: makeMethodFn("POST"),
+    put: makeMethodFn("PUT"),
+    request,
+    setConfig,
+    sse: {
+      connect: makeSseFn("CONNECT"),
+      delete: makeSseFn("DELETE"),
+      get: makeSseFn("GET"),
+      head: makeSseFn("HEAD"),
+      options: makeSseFn("OPTIONS"),
+      patch: makeSseFn("PATCH"),
+      post: makeSseFn("POST"),
+      put: makeSseFn("PUT"),
+      trace: makeSseFn("TRACE")
+    },
+    trace: makeMethodFn("TRACE")
+  };
+}, "createClient");
+
+// src/generated/client.gen.ts
+var client = createClient(createConfig({
+  baseUrl: "/api/v1"
+}));
+
+// src/generated/sdk.gen.ts
+var Actors = class {
+  static {
+    __name(this, "Actors");
+  }
+  /**
+   * List actors
+   *
+   * Returns all actors the caller has access to. If projectId is provided, returns only actors in that project. project keys are scoped to a single project automatically. JWT users without projectId receive actors across all their accessible projects.
+   */
+  static listActors(options) {
+    return (options?.client ?? client).get({
+      url: "/actors",
+      ...options
+    });
+  }
+  /**
+   * Create an actor
+   *
+   * Creates a new actor. project keys automatically infer the project from the key's scope; JWT callers must supply projectId.
+   */
+  static createActor(options) {
+    return (options.client ?? client).post({
+      url: "/actors",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Delete an actor
+   *
+   * Deletes an actor by its ID
+   */
+  static deleteActor(options) {
+    return (options.client ?? client).delete({
+      url: "/actors/{id}",
+      ...options
+    });
+  }
+  /**
+   * Get an actor by ID
+   *
+   * Returns an actor by its ID
+   */
+  static getActor(options) {
+    return (options.client ?? client).get({
+      url: "/actors/{id}",
+      ...options
+    });
+  }
+  /**
+   * Update an actor
+   *
+   * Updates an actor's properties
+   */
+  static updateActor(options) {
+    return (options.client ?? client).patch({
+      url: "/actors/{id}",
+      ...options,
       headers: {
-        Authorization: `Bearer ${token}`
+        "Content-Type": "application/json",
+        ...options.headers
       }
-    })
+    });
+  }
+  /**
+   * Get actor tags
+   *
+   * Returns all tags attached to the actor
+   */
+  static getActorTags(options) {
+    return (options.client ?? client).get({
+      url: "/actors/{id}/tags",
+      ...options
+    });
+  }
+  /**
+   * Merge actor tags
+   *
+   * Merges provided tags with existing tags (existing tags are preserved unless overridden)
+   */
+  static mergeActorTags(options) {
+    return (options.client ?? client).patch({
+      url: "/actors/{id}/tags",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Replace actor tags
+   *
+   * Replaces all tags on the actor with the provided tags (not merged)
+   */
+  static replaceActorTags(options) {
+    return (options.client ?? client).put({
+      url: "/actors/{id}/tags",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+};
+var AgentTools = class {
+  static {
+    __name(this, "AgentTools");
+  }
+  /**
+   * List agent tools
+   *
+   * Returns all agent tools in the project.
+   */
+  static listAgentTools(options) {
+    return (options?.client ?? client).get({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/agents/tools",
+      ...options
+    });
+  }
+  /**
+   * Create an agent tool
+   *
+   * Creates a new agent tool in the project.
+   */
+  static createAgentTool(options) {
+    return (options.client ?? client).post({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/agents/tools",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Delete an agent tool
+   *
+   * Deletes an agent tool by ID.
+   */
+  static deleteAgentTool(options) {
+    return (options.client ?? client).delete({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/agents/tools/{tool_id}",
+      ...options
+    });
+  }
+  /**
+   * Get an agent tool
+   *
+   * Returns a single agent tool by ID.
+   */
+  static getAgentTool(options) {
+    return (options.client ?? client).get({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/agents/tools/{tool_id}",
+      ...options
+    });
+  }
+  /**
+   * Update an agent tool
+   *
+   * Updates an existing agent tool.
+   */
+  static updateAgentTool(options) {
+    return (options.client ?? client).put({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/agents/tools/{tool_id}",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+};
+var AgentTraces = class {
+  static {
+    __name(this, "AgentTraces");
+  }
+  /**
+   * List agent traces
+   *
+   * Returns all traces for the project.
+   */
+  static listAgentTraces(options) {
+    return (options?.client ?? client).get({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/agents/traces",
+      ...options
+    });
+  }
+  /**
+   * Get a trace
+   *
+   * Returns a single trace by ID.
+   */
+  static getAgentTrace(options) {
+    return (options.client ?? client).get({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/agents/traces/{trace_id}",
+      ...options
+    });
+  }
+};
+var Agents = class {
+  static {
+    __name(this, "Agents");
+  }
+  /**
+   * List agents
+   *
+   * Returns all agents in the project.
+   */
+  static listAgents(options) {
+    return (options?.client ?? client).get({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/agents",
+      ...options
+    });
+  }
+  /**
+   * Create an agent
+   *
+   * Creates a new agent bound to an AI provider.
+   */
+  static createAgent(options) {
+    return (options.client ?? client).post({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/agents",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Delete an agent
+   *
+   * Deletes an agent by ID.
+   */
+  static deleteAgent(options) {
+    return (options.client ?? client).delete({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/agents/{agent_id}",
+      ...options
+    });
+  }
+  /**
+   * Get an agent
+   *
+   * Returns a single agent by ID.
+   */
+  static getAgent(options) {
+    return (options.client ?? client).get({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/agents/{agent_id}",
+      ...options
+    });
+  }
+  /**
+   * Update an agent
+   *
+   * Updates an existing agent.
+   */
+  static updateAgent(options) {
+    return (options.client ?? client).put({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/agents/{agent_id}",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Run an agent generation
+   *
+   * Sends messages to the agent, resolves its tools, and runs the AI model loop. Supports streaming via `stream: true`. Client tools pause the generation and return `requires_action`.
+   *
+   */
+  static createAgentGeneration(options) {
+    return (options.client ?? client).post({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/agents/{agent_id}/generate",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Submit tool outputs for a paused generation
+   *
+   * Resumes a generation that was paused due to client tool calls. Provide tool outputs for each pending tool call.
+   *
+   */
+  static submitAgentToolOutputs(options) {
+    return (options.client ?? client).post({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/agents/{agent_id}/generate/{generation_id}/tool-outputs",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Create an actor for an agent
+   *
+   * Creates a new actor associated with the specified agent
+   */
+  static createAgentActor(options) {
+    return (options.client ?? client).post({
+      url: "/agents/{agent_id}/actors",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+};
+var AiProviders = class {
+  static {
+    __name(this, "AiProviders");
+  }
+  /**
+   * List AI providers
+   *
+   * Returns a list of AI provider configurations for a project
+   */
+  static listAiProviders(options) {
+    return (options?.client ?? client).get({
+      url: "/ai-providers",
+      ...options
+    });
+  }
+  /**
+   * Create an AI provider
+   *
+   * Creates a new LLM provider configuration
+   */
+  static createAiProvider(options) {
+    return (options.client ?? client).post({
+      url: "/ai-providers",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Delete an AI provider
+   *
+   * Deletes an AI provider configuration
+   */
+  static deleteAiProvider(options) {
+    return (options.client ?? client).delete({
+      url: "/ai-providers/{ai_provider_id}",
+      ...options
+    });
+  }
+  /**
+   * Get an AI provider
+   *
+   * Returns a specific AI provider configuration
+   */
+  static getAiProvider(options) {
+    return (options.client ?? client).get({
+      url: "/ai-providers/{ai_provider_id}",
+      ...options
+    });
+  }
+  /**
+   * Update an AI provider
+   *
+   * Updates an AI provider configuration
+   */
+  static updateAiProvider(options) {
+    return (options.client ?? client).patch({
+      url: "/ai-providers/{ai_provider_id}",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+};
+var ApiKeys = class {
+  static {
+    __name(this, "ApiKeys");
+  }
+  /**
+   * Create an API key
+   *
+   * Creates a new API key for the authenticated user. - If `project_id` is provided, the key is scoped to that project. - If `policy_ids` is provided, the key's effective permissions are the intersection of the user's policies and the key's policies. - If neither is provided, the key inherits the user's full permissions.
+   *
+   */
+  static createApiKey(options) {
+    return (options.client ?? client).post({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/api-keys",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Delete an API key
+   *
+   * Deletes an API key. Only the owner or an admin can delete it.
+   */
+  static deleteApiKey(options) {
+    return (options.client ?? client).delete({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/api-keys/{id}",
+      ...options
+    });
+  }
+  /**
+   * Get an API key
+   *
+   * Returns details of an API key. Only the owner or an admin can access it.
+   */
+  static getApiKey(options) {
+    return (options.client ?? client).get({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/api-keys/{id}",
+      ...options
+    });
+  }
+  /**
+   * Update an API key
+   *
+   * Updates an API key's name, project scope, or policies. Only the owner or an admin can update it.
+   */
+  static updateApiKey(options) {
+    return (options.client ?? client).put({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/api-keys/{id}",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+};
+var Chats = class {
+  static {
+    __name(this, "Chats");
+  }
+  /**
+   * List chats
+   *
+   * Returns all chats in the project.
+   */
+  static listChats(options) {
+    return (options?.client ?? client).get({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/chats",
+      ...options
+    });
+  }
+  /**
+   * Create a chat
+   *
+   * Creates a new chat resource bound to an AI provider.
+   */
+  static createChat(options) {
+    return (options.client ?? client).post({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/chats",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Delete a chat
+   *
+   * Deletes a chat by ID.
+   */
+  static deleteChat(options) {
+    return (options.client ?? client).delete({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/chats/{chat_id}",
+      ...options
+    });
+  }
+  /**
+   * Get a chat
+   *
+   * Returns a single chat by ID.
+   */
+  static getChat(options) {
+    return (options.client ?? client).get({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/chats/{chat_id}",
+      ...options
+    });
+  }
+  /**
+   * Create a chat completion for a stored chat
+   *
+   * Runs a completion using the AI provider and settings stored in the chat. Pass `stream: true` for SSE streaming. A system message in `messages` overrides the chat's stored system message for this call only. Messages may use `documentId` instead of `content`.
+   *
+   */
+  static createChatCompletionForChat(options) {
+    return (options.client ?? client).post({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/chats/{chat_id}/completions",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Create a chat completion (stateless)
+   *
+   * OpenAI Chat Completions-compatible endpoint. Resolves the AI provider from `aiProviderId`, decrypts its secret, and calls the appropriate Vercel AI SDK provider. Falls back to Ollama when `aiProviderId` is omitted.
+   *
+   */
+  static createChatCompletion(options) {
+    return (options.client ?? client).post({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/chats/completions",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Create an actor for a chat
+   *
+   * Creates a new actor associated with the specified chat
+   */
+  static createChatActor(options) {
+    return (options.client ?? client).post({
+      url: "/chats/{chat_id}/actors",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+};
+var Conversations = class {
+  static {
+    __name(this, "Conversations");
+  }
+  /**
+   * List conversations
+   *
+   * Returns all conversations the caller has access to. If projectId is provided, returns only conversations in that project. project keys are scoped to a single project automatically.
+   */
+  static listConversations(options) {
+    return (options?.client ?? client).get({
+      url: "/conversations",
+      ...options
+    });
+  }
+  /**
+   * Create a conversation
+   *
+   * Creates a new conversation. project keys automatically infer the project from the key's scope; JWT callers must supply projectId.
+   */
+  static createConversation(options) {
+    return (options.client ?? client).post({
+      url: "/conversations",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Delete a conversation
+   *
+   * Deletes a conversation by its ID
+   */
+  static deleteConversation(options) {
+    return (options.client ?? client).delete({
+      url: "/conversations/{id}",
+      ...options
+    });
+  }
+  /**
+   * Get a conversation by ID
+   *
+   * Returns a conversation by its ID
+   */
+  static getConversation(options) {
+    return (options.client ?? client).get({
+      url: "/conversations/{id}",
+      ...options
+    });
+  }
+  /**
+   * Update a conversation
+   *
+   * Updates the status of a conversation
+   */
+  static updateConversation(options) {
+    return (options.client ?? client).patch({
+      url: "/conversations/{id}",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * List conversation messages
+   *
+   * Returns all messages (documents) attached to a conversation, ordered by position
+   */
+  static listConversationMessages(options) {
+    return (options.client ?? client).get({
+      url: "/conversations/{id}/messages",
+      ...options
+    });
+  }
+  /**
+   * Add a message to a conversation
+   *
+   * Creates a document from the message text and attaches it to the conversation at the given position. If position is omitted, it is appended at the end.
+   */
+  static addConversationMessage(options) {
+    return (options.client ?? client).post({
+      url: "/conversations/{id}/messages",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Generate the next message in a conversation
+   *
+   * Generates the next message using the specified actor's linked agent or chat.
+   * On `completed`, the reply is persisted as a new ConversationMessage authored
+   * by that actor. On `requires_action`, nothing is persisted; the caller must
+   * submit tool outputs via the Agents module and re-invoke generate.
+   *
+   */
+  static generateConversationMessage(options) {
+    return (options.client ?? client).post({
+      url: "/conversations/{id}/generate",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * List actors in a conversation
+   *
+   * Returns all distinct actors who have sent at least one message in the conversation
+   */
+  static listConversationActors(options) {
+    return (options.client ?? client).get({
+      url: "/conversations/{id}/actors",
+      ...options
+    });
+  }
+  /**
+   * Remove a message from a conversation
+   *
+   * Removes a document from a conversation
+   */
+  static removeConversationMessage(options) {
+    return (options.client ?? client).delete({
+      url: "/conversations/{id}/messages/{document_id}",
+      ...options
+    });
+  }
+  /**
+   * Get conversation tags
+   *
+   * Returns all tags attached to the conversation
+   */
+  static getConversationTags(options) {
+    return (options.client ?? client).get({
+      url: "/conversations/{id}/tags",
+      ...options
+    });
+  }
+  /**
+   * Merge conversation tags
+   *
+   * Merges provided tags with existing tags
+   */
+  static mergeConversationTags(options) {
+    return (options.client ?? client).patch({
+      url: "/conversations/{id}/tags",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Replace conversation tags
+   *
+   * Replaces all tags on the conversation with the provided tags
+   */
+  static replaceConversationTags(options) {
+    return (options.client ?? client).put({
+      url: "/conversations/{id}/tags",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+};
+var Documents = class {
+  static {
+    __name(this, "Documents");
+  }
+  /**
+   * List documents
+   *
+   * Returns all documents the caller has access to. If projectId is provided, returns only documents in that project. project keys are scoped to a single project automatically. JWT users without projectId receive documents across all their accessible projects.
+   */
+  static listDocuments(options) {
+    return (options?.client ?? client).get({
+      url: "/documents",
+      ...options
+    });
+  }
+  /**
+   * Create a document
+   *
+   * Creates a new text document and generates an embedding vector for semantic search. project keys automatically infer the project from the key's scope; JWT callers must supply projectId.
+   */
+  static createDocument(options) {
+    return (options.client ?? client).post({
+      url: "/documents",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Delete a document
+   *
+   * Deletes a document and its underlying file
+   */
+  static deleteDocument(options) {
+    return (options.client ?? client).delete({
+      url: "/documents/{id}",
+      ...options
+    });
+  }
+  /**
+   * Get a document by ID
+   *
+   * Returns a document with its text content
+   */
+  static getDocument(options) {
+    return (options.client ?? client).get({
+      url: "/documents/{id}",
+      ...options
+    });
+  }
+  /**
+   * Update a document
+   *
+   * Updates document content, title, path, metadata, or tags. Supplying `path` moves the document to a new logical path within the project.
+   */
+  static updateDocument(options) {
+    return (options.client ?? client).patch({
+      url: "/documents/{id}",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Get document tags
+   *
+   * Returns all tags attached to the document
+   */
+  static getDocumentTags(options) {
+    return (options.client ?? client).get({
+      url: "/documents/{id}/tags",
+      ...options
+    });
+  }
+  /**
+   * Merge document tags
+   *
+   * Merges provided tags with existing tags (existing tags are preserved unless overridden)
+   */
+  static mergeDocumentTags(options) {
+    return (options.client ?? client).patch({
+      url: "/documents/{id}/tags",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Replace document tags
+   *
+   * Replaces all tags on the document with the provided tags (not merged)
+   */
+  static replaceDocumentTags(options) {
+    return (options.client ?? client).put({
+      url: "/documents/{id}/tags",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Semantic search over documents
+   *
+   * Searches documents using semantic search, file paths, or document IDs. At least one of search, paths, or document_ids must be provided. Returns results ordered by similarity score.
+   */
+  static searchDocuments(options) {
+    return (options.client ?? client).post({
+      url: "/documents/search",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+};
+var Files = class {
+  static {
+    __name(this, "Files");
+  }
+  /**
+   * List all files
+   *
+   * Returns a list of all stored files
+   */
+  static listFiles(options) {
+    return (options?.client ?? client).get({
+      url: "/files",
+      ...options
+    });
+  }
+  /**
+   * Create a file
+   *
+   * Creates a new file record in the system
+   */
+  static createFile(options) {
+    return (options.client ?? client).post({
+      url: "/files",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Upload a file
+   *
+   * Uploads a file to the server and stores it in the configured storage directory
+   */
+  static uploadFile(options) {
+    return (options.client ?? client).post({
+      ...formDataBodySerializer,
+      url: "/files/upload",
+      ...options,
+      headers: {
+        "Content-Type": null,
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Upload a file using base64 encoding
+   *
+   * Uploads a file to the server using base64-encoded content
+   */
+  static uploadFileBase64(options) {
+    return (options.client ?? client).post({
+      url: "/files/upload/base64",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Delete a file
+   *
+   * Removes a file from the system by ID
+   */
+  static deleteFile(options) {
+    return (options.client ?? client).delete({
+      url: "/files/{id}",
+      ...options
+    });
+  }
+  /**
+   * Get a file by ID
+   *
+   * Returns the data and metadata of a specific file
+   */
+  static getFile(options) {
+    return (options.client ?? client).get({
+      url: "/files/{id}",
+      ...options
+    });
+  }
+  /**
+   * Download a file
+   *
+   * Streams the file content to the client
+   */
+  static downloadFile(options) {
+    return (options.client ?? client).get({
+      url: "/files/{id}/download",
+      ...options
+    });
+  }
+  /**
+   * Update file metadata
+   *
+   * Updates the metadata field of a file
+   */
+  static updateFileMetadata(options) {
+    return (options.client ?? client).patch({
+      url: "/files/{id}/metadata",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Download file as base64
+   *
+   * Returns the file content encoded as base64
+   */
+  static downloadFileBase64(options) {
+    return (options.client ?? client).get({
+      url: "/files/{id}/download/base64",
+      ...options
+    });
+  }
+  /**
+   * Get file tags
+   *
+   * Returns all tags attached to the file
+   */
+  static getFileTags(options) {
+    return (options.client ?? client).get({
+      url: "/files/{id}/tags",
+      ...options
+    });
+  }
+  /**
+   * Merge file tags
+   *
+   * Merges provided tags with existing tags
+   */
+  static mergeFileTags(options) {
+    return (options.client ?? client).patch({
+      url: "/files/{id}/tags",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Replace file tags
+   *
+   * Replaces all tags on the file with the provided tags
+   */
+  static replaceFileTags(options) {
+    return (options.client ?? client).put({
+      url: "/files/{id}/tags",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+};
+var Policies = class {
+  static {
+    __name(this, "Policies");
+  }
+  /**
+   * List all policies
+   *
+   * Returns a list of all global policies. Requires admin role.
+   */
+  static listPolicies(options) {
+    return (options?.client ?? client).get({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/policies",
+      ...options
+    });
+  }
+  /**
+   * Create a policy
+   *
+   * Creates a new global policy. Requires admin role.
+   */
+  static createPolicy(options) {
+    return (options.client ?? client).post({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/policies",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Delete a policy
+   *
+   * Deletes a global policy. Requires admin role.
+   */
+  static deletePolicy(options) {
+    return (options.client ?? client).delete({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/policies/{policy_id}",
+      ...options
+    });
+  }
+  /**
+   * Get a policy
+   *
+   * Returns details of a specific policy. Requires admin role.
+   */
+  static getPolicy(options) {
+    return (options.client ?? client).get({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/policies/{policy_id}",
+      ...options
+    });
+  }
+  /**
+   * Update a policy
+   *
+   * Updates an existing global policy. Requires admin role.
+   */
+  static updatePolicy(options) {
+    return (options.client ?? client).put({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/policies/{policy_id}",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+};
+var Projects = class {
+  static {
+    __name(this, "Projects");
+  }
+  /**
+   * Create a project
+   *
+   * Creates a new project. Requires admin role.
+   */
+  static createProject(options) {
+    return (options.client ?? client).post({
+      url: "/projects",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Delete a project
+   *
+   * Deletes a project. Requires admin role.
+   */
+  static deleteProject(options) {
+    return (options.client ?? client).delete({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/projects/{project_id}",
+      ...options
+    });
+  }
+  /**
+   * Get a project
+   *
+   * Returns details of a specific project.
+   */
+  static getProject(options) {
+    return (options.client ?? client).get({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/projects/{project_id}",
+      ...options
+    });
+  }
+};
+var Secrets = class {
+  static {
+    __name(this, "Secrets");
+  }
+  /**
+   * List secrets
+   *
+   * Returns a list of secrets for a project
+   */
+  static listSecrets(options) {
+    return (options?.client ?? client).get({
+      url: "/secrets",
+      ...options
+    });
+  }
+  /**
+   * Create a secret
+   *
+   * Creates a new encrypted secret in a project
+   */
+  static createSecret(options) {
+    return (options.client ?? client).post({
+      url: "/secrets",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Delete a secret
+   *
+   * Deletes a secret
+   */
+  static deleteSecret(options) {
+    return (options.client ?? client).delete({
+      url: "/secrets/{secret_id}",
+      ...options
+    });
+  }
+  /**
+   * Get a secret
+   *
+   * Returns a specific secret
+   */
+  static getSecret(options) {
+    return (options.client ?? client).get({
+      url: "/secrets/{secret_id}",
+      ...options
+    });
+  }
+  /**
+   * Update a secret
+   *
+   * Updates a secret's name and/or value
+   */
+  static updateSecret(options) {
+    return (options.client ?? client).patch({
+      url: "/secrets/{secret_id}",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+};
+var Sessions = class {
+  static {
+    __name(this, "Sessions");
+  }
+  /**
+   * List sessions
+   *
+   * Returns sessions for the specified agent, optionally filtered by actorId and status.
+   */
+  static listAgentSessions(options) {
+    return (options.client ?? client).get({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/agents/{agent_id}/sessions",
+      ...options
+    });
+  }
+  /**
+   * Create a session
+   *
+   * Creates a new session for the specified agent. Internally creates a conversation and two actors (agent + user) so the caller only needs this single call to start interacting with the agent.
+   *
+   */
+  static createAgentSession(options) {
+    return (options.client ?? client).post({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/agents/{agent_id}/sessions",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Delete a session
+   *
+   * Deletes the session and its underlying conversation and actors.
+   */
+  static deleteAgentSession(options) {
+    return (options.client ?? client).delete({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/agents/{agent_id}/sessions/{session_id}",
+      ...options
+    });
+  }
+  /**
+   * Get a session
+   *
+   * Returns details of a single session.
+   */
+  static getAgentSession(options) {
+    return (options.client ?? client).get({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/agents/{agent_id}/sessions/{session_id}",
+      ...options
+    });
+  }
+  /**
+   * Update a session
+   *
+   * Updates the session name and/or status.
+   */
+  static updateSession(options) {
+    return (options.client ?? client).patch({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/agents/{agent_id}/sessions/{session_id}",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * List session messages
+   *
+   * Returns messages in the session with simplified roles (user/assistant) instead of raw actor IDs.
+   *
+   */
+  static listAgentSessionMessages(options) {
+    return (options.client ?? client).get({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/agents/{agent_id}/sessions/{session_id}/messages",
+      ...options
+    });
+  }
+  /**
+   * Add a user message
+   *
+   * Saves a user message to the session. When autoGenerate is enabled on the session and no generation is currently in progress, generation is triggered automatically and the response mirrors GenerateSessionResponse. Otherwise returns the saved user message.
+   *
+   */
+  static addSessionMessage(options) {
+    return (options.client ?? client).post({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/agents/{agent_id}/sessions/{session_id}/messages",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Trigger agent generation
+   *
+   * Triggers the agent to generate a response based on the current conversation. Returns the assistant reply or a requires_action status if the agent needs client tool outputs. Pass ?async=true for a 202 accepted response when you do not need to wait for the result.
+   *
+   */
+  static generateSessionResponse(options) {
+    return (options.client ?? client).post({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/agents/{agent_id}/sessions/{session_id}/generate",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Submit tool outputs
+   *
+   * Submits client tool outputs for a generation that returned requires_action. The agent continues its loop and returns the final or next requires_action result.
+   *
+   */
+  static submitSessionToolOutputs(options) {
+    return (options.client ?? client).post({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/agents/{agent_id}/sessions/{session_id}/tool-outputs",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Get session tags
+   *
+   * Returns the session's tags object.
+   */
+  static getSessionTags(options) {
+    return (options.client ?? client).get({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/agents/{agent_id}/sessions/{session_id}/tags",
+      ...options
+    });
+  }
+  /**
+   * Merge session tags
+   *
+   * Merges the provided tags into the session's existing tags.
+   */
+  static mergeSessionTags(options) {
+    return (options.client ?? client).patch({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/agents/{agent_id}/sessions/{session_id}/tags",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Replace session tags
+   *
+   * Replaces all tags on the session.
+   */
+  static replaceSessionTags(options) {
+    return (options.client ?? client).put({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/agents/{agent_id}/sessions/{session_id}/tags",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+};
+var Users = class {
+  static {
+    __name(this, "Users");
+  }
+  /**
+   * List all users
+   *
+   * Returns a list of all users
+   */
+  static listUsers(options) {
+    return (options?.client ?? client).get({
+      url: "/users",
+      ...options
+    });
+  }
+  /**
+   * Create a user
+   *
+   * Creates a new user in the system
+   */
+  static createUser(options) {
+    return (options.client ?? client).post({
+      url: "/users",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Delete a user by ID
+   *
+   * Deletes a specific user
+   */
+  static deleteUser(options) {
+    return (options.client ?? client).delete({
+      url: "/users/{id}",
+      ...options
+    });
+  }
+  /**
+   * Get a user by ID
+   *
+   * Returns the data of a specific user
+   */
+  static getUser(options) {
+    return (options.client ?? client).get({
+      url: "/users/{id}",
+      ...options
+    });
+  }
+  /**
+   * Create the first admin user
+   *
+   * Creates the first admin user. Returns 409 if any user already exists.
+   */
+  static bootstrapUser(options) {
+    return (options.client ?? client).post({
+      url: "/users/bootstrap",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Login user
+   *
+   * Authenticates a user and returns a JWT token
+   */
+  static loginUser(options) {
+    return (options.client ?? client).post({
+      url: "/users/login",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Get policies attached to a user
+   *
+   * Returns the list of policies attached to a user. Requires admin role.
+   */
+  static getUserPolicies(options) {
+    return (options.client ?? client).get({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/users/{user_id}/policies",
+      ...options
+    });
+  }
+  /**
+   * Attach policies to a user
+   *
+   * Replaces the user's policy list with the provided policy IDs. Requires admin role.
+   */
+  static attachUserPolicies(options) {
+    return (options.client ?? client).put({
+      security: [{
+        scheme: "bearer",
+        type: "http"
+      }],
+      url: "/users/{user_id}/policies",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+};
+var Webhooks = class {
+  static {
+    __name(this, "Webhooks");
+  }
+  /**
+   * List webhooks for a project
+   *
+   * Lists all webhooks configured for the specified project
+   */
+  static listWebhooks(options) {
+    return (options.client ?? client).get({
+      url: "/projects/{project_id}/webhooks",
+      ...options
+    });
+  }
+  /**
+   * Create a webhook
+   *
+   * Creates a new webhook for the specified project
+   */
+  static createWebhook(options) {
+    return (options.client ?? client).post({
+      url: "/projects/{project_id}/webhooks",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * Delete a webhook
+   *
+   * Deletes a webhook and stops all event deliveries
+   */
+  static deleteWebhook(options) {
+    return (options.client ?? client).delete({
+      url: "/projects/{project_id}/webhooks/{webhook_id}",
+      ...options
+    });
+  }
+  /**
+   * Get a webhook
+   *
+   * Retrieves the details of a specific webhook
+   */
+  static getWebhook(options) {
+    return (options.client ?? client).get({
+      url: "/projects/{project_id}/webhooks/{webhook_id}",
+      ...options
+    });
+  }
+  /**
+   * Update a webhook
+   *
+   * Updates an existing webhook's configuration
+   */
+  static updateWebhook(options) {
+    return (options.client ?? client).put({
+      url: "/projects/{project_id}/webhooks/{webhook_id}",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  /**
+   * List deliveries for a webhook
+   *
+   * Lists all event deliveries for a specific webhook
+   */
+  static listWebhookDeliveries(options) {
+    return (options.client ?? client).get({
+      url: "/projects/{project_id}/webhooks/{webhook_id}/deliveries",
+      ...options
+    });
+  }
+  /**
+   * Get a delivery
+   *
+   * Retrieves the details of a specific webhook delivery
+   */
+  static getWebhookDelivery(options) {
+    return (options.client ?? client).get({
+      url: "/projects/{project_id}/webhooks/{webhook_id}/deliveries/{delivery_id}",
+      ...options
+    });
+  }
+  /**
+   * Rotate webhook secret
+   *
+   * Rotates the secret key for the specified webhook
+   */
+  static rotateWebhookSecret(options) {
+    return (options.client ?? client).post({
+      url: "/projects/{project_id}/webhooks/{webhook_id}/rotate-secret",
+      ...options
+    });
+  }
+};
+
+// src/soatClient.ts
+var bindResource = /* @__PURE__ */__name((SdkClass, client2) => {
+  return new Proxy(SdkClass, {
+    get: /* @__PURE__ */__name((target, prop) => {
+      const value = target[prop];
+      if (typeof value === "function") {
+        return options => {
+          return value({
+            ...options,
+            client: client2
+          });
+        };
+      }
+      return value;
+    }, "get")
   });
-}, "createSoatClient");
-export { createSoatClient };
+}, "bindResource");
+var SoatClient = class {
+  static {
+    __name(this, "SoatClient");
+  }
+  actors;
+  agentTools;
+  agentTraces;
+  agents;
+  aiProviders;
+  apiKeys;
+  chats;
+  conversations;
+  documents;
+  files;
+  policies;
+  projects;
+  secrets;
+  sessions;
+  users;
+  webhooks;
+  constructor({
+    baseUrl,
+    token,
+    headers
+  } = {}) {
+    const authHeaders = token ? {
+      Authorization: `Bearer ${token}`
+    } : {};
+    const httpClient = createClient(createConfig({
+      baseUrl: baseUrl ?? "/api/v1",
+      headers: {
+        ...authHeaders,
+        ...headers
+      }
+    }));
+    this.actors = bindResource(Actors, httpClient);
+    this.agentTools = bindResource(AgentTools, httpClient);
+    this.agentTraces = bindResource(AgentTraces, httpClient);
+    this.agents = bindResource(Agents, httpClient);
+    this.aiProviders = bindResource(AiProviders, httpClient);
+    this.apiKeys = bindResource(ApiKeys, httpClient);
+    this.chats = bindResource(Chats, httpClient);
+    this.conversations = bindResource(Conversations, httpClient);
+    this.documents = bindResource(Documents, httpClient);
+    this.files = bindResource(Files, httpClient);
+    this.policies = bindResource(Policies, httpClient);
+    this.projects = bindResource(Projects, httpClient);
+    this.secrets = bindResource(Secrets, httpClient);
+    this.sessions = bindResource(Sessions, httpClient);
+    this.users = bindResource(Users, httpClient);
+    this.webhooks = bindResource(Webhooks, httpClient);
+  }
+};
+export { Actors, AgentTools, AgentTraces, Agents, AiProviders, ApiKeys, Chats, Conversations, Documents, Files, Policies, Projects, Secrets, Sessions, SoatClient, Users, Webhooks, createClient, createConfig };