@bagelink/sdk 0.0.1286 → 0.0.1288

package/dist/index.mjs

@@ -1,46 +1,655 @@
-import 'axios';
-export { B as Bagel, f as formatAPIErrorMessage, i as openAPI } from './shared/sdk.BJ23wlaP.mjs';
-import 'node:fs';
-import 'node:path';
-import 'node:process';
-import 'node:fs/promises';
-import 'util';
-import 'path';
-import 'tty';
-import 'os';
-import 'fs';
-import 'module';
-import 'assert';
-import 'url';
-import 'node:url';
-import 'crypto';
-import 'events';
-import 'node:util';
-import 'node:assert';
-import 'process';
-import 'fs/promises';
-import 'v8';
-import 'node:perf_hooks';
-import 'node:module';
-import 'node:crypto';
-import 'child_process';
-import 'node:child_process';
-import 'node:http';
-import 'node:https';
-import 'net';
-import 'http';
-import 'stream';
-import 'node:os';
-import 'node:net';
-import 'node:dns';
-import 'node:readline';
-import 'node:buffer';
-import 'node:events';
-import 'node:v8';
-import 'node:worker_threads';
-import 'zlib';
-import 'buffer';
-import 'https';
-import 'tls';
-import 'node:querystring';
-import 'node:zlib';
+import axios$1 from 'axios';
+
+function toCamelCase(str) {
+  return str?.replaceAll(/[-._\s]+(.)?/g, (_, c) => c?.toUpperCase() || "").replace(/^./, (str2) => str2.toLowerCase()) || str || "";
+}
+function toPascalCase(str) {
+  return str?.replaceAll(/[-_\s]+(.)?/g, (_, c) => c?.toUpperCase() || "").replace(/^./, (str2) => str2.toUpperCase()) || str || "";
+}
+function formatType(typeName) {
+  typeName = typeName.replaceAll("-", "").replaceAll(/post|put$/gi, "").replaceAll(/^body_/gi, "");
+  return toPascalCase(typeName);
+}
+function resolveReference(ref) {
+  const t = ref.split("/").pop();
+  if (!t) return "any";
+  return formatType(t);
+}
+function schemaToType(schema) {
+  if (!schema) return "any";
+  if (schema.anyOf) {
+    let _t = schema.anyOf.map((s) => schemaToType(s)).filter((p) => p !== "any").join(" | ");
+    if (_t === "" || _t === "null") _t = "any";
+    return _t;
+  }
+  if (schema.allOf) {
+    return schema.allOf.map((s) => schemaToType(s)).filter((p) => p !== "any").join(" & ");
+  }
+  if (schema.$ref) return resolveReference(schema.$ref);
+  switch (schema.type) {
+    case "object":
+      return "{ [key: string]: any }";
+    case "string":
+      return "string";
+    case "integer":
+      return "number";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "array":
+      return `${schemaToType(schema.items)}[]`;
+    case "undefined":
+      return "undefined";
+    case "null":
+      return "null";
+    case void 0:
+      return "any";
+    default:
+      console.log("Unknown type", schema.type);
+      return "any";
+  }
+}
+function isOptional(schema) {
+  const type = schemaToType(schema);
+  const splitType = type.split(/\s+\|\s+/);
+  const includesNull = splitType.includes("null");
+  const includesUndefined = splitType.includes("undefined");
+  return includesNull || includesUndefined || schema.default !== void 0;
+}
+function cleanOptionals(str) {
+  return str.split(" | ").filter((t) => t !== "null" && t !== "undefined").join(" | ");
+}
+function formatVarType({
+  varName,
+  schema,
+  required = false,
+  defaultValue
+}) {
+  let type = schemaToType(schema);
+  type = cleanOptionals(type);
+  let defaultStr = "";
+  if (defaultValue) {
+    if (typeof defaultValue === "string") {
+      defaultStr = ` = '${defaultValue}'`;
+    } else if (typeof defaultValue === "object") {
+      defaultStr = ` = ${JSON.stringify(defaultValue)}`;
+    } else {
+      defaultStr = ` = ${defaultValue}`;
+    }
+  }
+  let optionalStr = !required && isOptional(schema) ? "?" : "";
+  if (defaultStr) optionalStr = "";
+  return `${varName}${optionalStr}: ${type}${defaultStr}`;
+}
+function cleanPath(path) {
+  return path.split("/").filter((p) => p && !/\{|\}/.test(p)).join("/");
+}
+
+const allTypes = [];
+const primitiveTypes = [
+  "string",
+  "number",
+  "boolean",
+  "null",
+  "void",
+  "any",
+  "Record<string, any>",
+  "undefined",
+  "{ [key: string]: any }"
+];
+function collectTypeForImportStatement(typeName) {
+  typeName = typeName.trim().replace("[]", "");
+  if (typeName.includes("|")) {
+    typeName.split("|").forEach((singleType) => {
+      collectTypeForImportStatement(singleType);
+    });
+    return;
+  }
+  const isPrimitive = primitiveTypes.includes(typeName);
+  typeName = formatType(typeName);
+  if (!typeName || isPrimitive) return;
+  if (!allTypes.includes(typeName)) allTypes.push(typeName);
+}
+function schemaToTypeWithCollection(schema) {
+  const type = schemaToType(schema);
+  collectTypeForImportStatement(type);
+  return type;
+}
+function getResponseType(response) {
+  const mediaTypeObject = response.content?.["application/json"];
+  if (!mediaTypeObject || !mediaTypeObject.schema) return;
+  const responseType = schemaToTypeWithCollection(mediaTypeObject.schema);
+  return responseType;
+}
+function generateResponseType(responses) {
+  if (!responses) return "";
+  const types = [];
+  for (const [statusCode, response] of Object.entries(responses)) {
+    if (statusCode.startsWith("2")) {
+      const responseType = getResponseType(response);
+      if (responseType && responseType !== "any") {
+        types.push(responseType);
+      }
+    }
+  }
+  return types.join(" | ");
+}
+function generateAxiosFunction(method, formattedPath, allParams, responseTypeStr, parameters, requestBodyPayload) {
+  if (allParams === "undefined") allParams = "";
+  let axiosFunction = `async (${allParams})${responseTypeStr} => {`;
+  if (requestBodyPayload === "formData") {
+    const paramStr = parameters?.config?.params ? `params: {${parameters.config.params}}` : "";
+    axiosFunction += `
+		const formData = new FormData()
+		formData.append('upload', file)
+		return axios.${method}(${formattedPath}, formData, {
+			headers: { 'Content-Type': 'multipart/form-data' },
+			onUploadProgress: options?.onUploadProgress${paramStr ? `,
+            ${paramStr}` : ""}
+		})`;
+  } else {
+    const paramStr = parameters?.config?.params ? `, { params: {${parameters.config.params}} }` : "";
+    const bodyVar = requestBodyPayload ? `${requestBodyPayload}` : "{}";
+    axiosFunction += `return axios.${method}(${formattedPath}${["get", "delete"].includes(method) ? paramStr : `, ${bodyVar}${paramStr}`})`;
+  }
+  axiosFunction += "}";
+  return axiosFunction;
+}
+const pathParamRegex = /\{([^}]+)\}/g;
+function getParamsFromPath(path) {
+  const params = path.match(pathParamRegex)?.map((p) => p.slice(1, -1));
+  return params;
+}
+function formatPathWithParams(path) {
+  const params = getParamsFromPath(path);
+  const formattedPath = params ? `\`${path.replace(pathParamRegex, (v) => `$${toCamelCase(v)}`)}\`` : `'${path}'`;
+  return formattedPath;
+}
+function generateRequestBody(requestBody) {
+  if (!requestBody?.content)
+    return { requestBodyParam: "", requestBodyPayload: "" };
+  const { content } = requestBody;
+  const multipartFormData = content["multipart/form-data"] || {};
+  if (multipartFormData.schema?.$ref?.includes("Body_upload_files")) {
+    return {
+      requestBodyParam: "file: File, options?: UploadOptions & { dirPath?: string, tags?: string[] }",
+      requestBodyPayload: "formData"
+    };
+  }
+  const jsonContent = requestBody.content["application/json"];
+  if (!jsonContent || !jsonContent.schema) {
+    return { requestBodyParam: "", requestBodyPayload: "" };
+  }
+  const bodySchema = jsonContent.schema;
+  const requestBodyType = schemaToType(bodySchema);
+  collectTypeForImportStatement(requestBodyType);
+  const requestBodyPayload = toCamelCase(bodySchema.title) || toCamelCase(requestBodyType) || "requestBody";
+  const requestBodyParam = formatVarType({
+    varName: requestBodyPayload,
+    schema: bodySchema,
+    defaultValue: bodySchema.default
+  });
+  return { requestBodyParam, requestBodyPayload };
+}
+function combineAllParams(parameters, requestBodyParam) {
+  let allParamsArray = [];
+  if (parameters && parameters.params)
+    allParamsArray = parameters.params.split(",").map((p) => p.trim());
+  if (requestBodyParam) allParamsArray.push(requestBodyParam.trim());
+  allParamsArray = allParamsArray.filter((p) => p).sort((a, b) => (a.includes("?") ? 1 : -1) - (b.includes("?") ? 1 : -1));
+  return allParamsArray.join(", ");
+}
+function generateFunctionParameters(params, isFileUpload = false) {
+  if (!params?.length) return {};
+  if (isFileUpload) {
+    return {
+      config: {
+        params: "dir_path: options?.dirPath, tags: options?.tags"
+      },
+      params: ""
+      // Empty string to ensure file is the first parameter
+    };
+  }
+  const functionParams = [];
+  const paramList = [];
+  for (const param of params) {
+    const paramType = schemaToType(param.schema);
+    collectTypeForImportStatement(paramType);
+    const paramName = param.name;
+    const varName = toCamelCase(param.name);
+    if (param.in === "path" || param.in === "query" || param.in === "header") {
+      functionParams.push(
+        formatVarType({
+          varName,
+          schema: param.schema,
+          required: param.required,
+          defaultValue: param.schema.default
+        })
+      );
+    }
+    if (param.in === "query" || param.in === "header") {
+      paramList.push(
+        paramName === varName ? paramName : `'${paramName}': ${varName}`
+      );
+    }
+  }
+  return {
+    params: functionParams.join(", "),
+    config: paramList.length ? { params: paramList.join(", ") } : {}
+  };
+}
+function generateFunctionForOperation(method, path, operation) {
+  if (!operation) return "";
+  const isFileUpload = operation.requestBody?.content["multipart/form-data"]?.schema?.$ref?.includes("Body_upload_files");
+  const parameters = generateFunctionParameters(
+    operation.parameters,
+    isFileUpload
+  );
+  const { requestBodyParam, requestBodyPayload } = generateRequestBody(
+    operation.requestBody
+  );
+  const allParams = isFileUpload ? "file: File, options?: UploadOptions & { dirPath?: string, tags?: string[] }" : combineAllParams(parameters, requestBodyParam);
+  const responseType = generateResponseType(operation.responses);
+  const responseTypeStr = responseType ? `: Promise<AxiosResponse<${responseType}>>` : "";
+  return generateAxiosFunction(
+    method,
+    formatPathWithParams(path),
+    allParams,
+    responseTypeStr,
+    parameters,
+    requestBodyPayload
+  );
+}
+const generateRandomString = () => Math.random().toString(36).slice(7);
+const DOUBLE_QUOTE_REGEX = /"([^"]+)":/g;
+function fileTemplate(tsString, typeForImport, baseURL) {
+  const templateCode = `import ax from 'axios';
+		 import type { AxiosResponse } from 'axios';
+		 import type {${typeForImport.join(", ")}} from './types.d';
+
+	interface UploadOptions {
+		onUploadProgress?: (progressEvent: any) => void
+		dirPath?: string
+		tags?: string[]
+	}
+
+	export const axios = ax.create({baseURL:${baseURL}});
+	${tsString}`;
+  return templateCode.replace(DOUBLE_QUOTE_REGEX, "$1:");
+}
+const functionsInventory = {};
+const pathOperations = [];
+function hasConflict(path, method) {
+  const cleanPathName = path.split("/").filter((p) => p && !/\{|\}/.test(p)).join("/");
+  const matchingPaths = pathOperations.filter(
+    (p) => p.path === cleanPathName && p.method === method
+  );
+  pathOperations.push({ path: cleanPathName, method });
+  return matchingPaths.length > 0;
+}
+function createFunctionPlaceholder(path, method, operation) {
+  const funcID = generateRandomString();
+  functionsInventory[funcID] = generateFunctionForOperation(
+    method,
+    path,
+    operation
+  );
+  return funcID;
+}
+function handlePathSegment(path, operation, existingObj = {}) {
+  const methods = Object.keys(operation);
+  const obj = {};
+  for (const method of methods) {
+    let functionName = method.toLowerCase();
+    if (hasConflict(path, method)) {
+      const params = getParamsFromPath(path);
+      functionName += params ? `By${toPascalCase(params.pop() || "")}` : "All";
+    }
+    obj[functionName] = createFunctionPlaceholder(
+      path,
+      method,
+      operation[method]
+    );
+  }
+  return { ...obj, ...existingObj };
+}
+function generateFunctions(paths, baseUrl) {
+  let tsString = "";
+  const body = {};
+  const allPathsClean = Object.keys(paths).map(cleanPath);
+  for (const [path, operation] of Object.entries(paths)) {
+    const splitPath = path.split("/").filter((p) => p && !/\{|\}/.test(p));
+    splitPath.reduce((acc, key, index, array) => {
+      const objFuncKey = toCamelCase(key);
+      if (!objFuncKey) return acc;
+      const methods = Object.keys(operation);
+      if (index === array.length - 1 && methods.length === 1 && allPathsClean.filter((p) => p === cleanPath(path)).length === 1) {
+        const method = methods[0];
+        const opp = { ...operation }[method];
+        acc[objFuncKey] = createFunctionPlaceholder(path, methods[0], opp);
+      } else if (index === array.length - 1) {
+        acc[objFuncKey] = handlePathSegment(path, operation, acc[objFuncKey]);
+      } else if (!acc[objFuncKey] || typeof acc[objFuncKey] !== "object") {
+        acc[objFuncKey] = {};
+      }
+      return acc[objFuncKey];
+    }, body);
+  }
+  for (const [parent, object] of Object.entries(body)) {
+    tsString += `export const ${parent} = ${JSON.stringify(object, void 0, 2)};
+`;
+  }
+  Object.entries(functionsInventory).forEach(([key, value]) => {
+    tsString = tsString.replace(`"${key}"`, value);
+  });
+  tsString = fileTemplate(tsString, allTypes, baseUrl);
+  return tsString;
+}
+
+function generateTypes(schemas) {
+  return Object.entries(schemas).map(([typeName, schema]) => {
+    typeName = formatType(typeName);
+    if (schema.enum) {
+      return `export type ${typeName} = ${schema.enum.map((item) => `'${item}'`).join(" | ")};
+`;
+    }
+    if (schema.type === "array" && schema.items) {
+      return `export type ${typeName} = ${schemaToType(schema.items)}[];
+`;
+    }
+    if (!schema.properties) {
+      return "";
+    }
+    const properties = Object.entries(schema.properties).map(([key, value]) => {
+      const varType = formatVarType({ varName: key, schema: value });
+      return `		${varType}`;
+    }).join(";\n ");
+    return `export type ${typeName} = {
+ ${properties};
+ };
+`;
+  }).join("\n");
+}
+
+const basicAuthHeader = { Authorization: "Basic YmFnZWxfdXNlcm5hbWU6Tm90U2VjdXJlQGJhZ2Vs" };
+const index = async (openApiUrl, baseUrl) => {
+  try {
+    const { data: openApi } = await axios$1.get(openApiUrl, { headers: basicAuthHeader });
+    const schemas = openApi.components?.schemas;
+    if (!schemas) throw new Error("No schemas found in OpenAPI document");
+    const types = generateTypes(schemas);
+    const { paths } = openApi;
+    if (!paths) throw new Error("No paths found in OpenAPI document");
+    const code = generateFunctions(paths, baseUrl);
+    return { types, code };
+  } catch (error) {
+    throw new Error(error);
+  }
+};
+
+function formatAPIErrorMessage(error) {
+  if (!error || !error.response) {
+    return "Network error occurred. Please check your connection.";
+  }
+  const { status, data } = error.response;
+  if (data?.detail && Array.isArray(data.detail)) {
+    return data.detail.map((err) => {
+      const fieldPath = err.loc.slice(1).join(".");
+      const field = fieldPath.split(".").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+      let message = err.msg.replace(/^(?:field|value|string|none) required$/i, "is required").replace(/^value is not a valid/i, "must be a valid").replace(/^ensure this value/i, "this value must").replace(/^str type expected$/i, "must be text").replace(/^value could not be parsed to/i, "must be a").replace(/^ensure this value has at least/i, "must have at least").replace(/^ensure this value has at most/i, "must have at most").replace(/^invalid datetime format/i, "must be a valid date/time").replace(/^value is not a valid email address/i, "must be a valid email address").replace(/^value is not a valid integer/i, "must be a whole number").replace(/^value is not a valid float/i, "must be a valid number");
+      return `${field} ${message.toLowerCase()}`;
+    }).join("\n");
+  }
+  switch (status) {
+    case 401:
+      return "Authentication required. Please log in.";
+    case 403:
+      return "You do not have permission to perform this action.";
+    case 404:
+      return "The requested resource was not found.";
+    case 429:
+      return "Too many requests. Please try again later.";
+    case 500:
+      return "An internal server error occurred. Please try again later.";
+  }
+  if (data?.detail && typeof data.detail === "string") {
+    return data.detail;
+  }
+  if (data?.message) {
+    return data.message;
+  }
+  return `An error occurred (Status ${status}): ${error.message || "Unknown error"}`;
+}
+
+const axios = axios$1.create({
+  withCredentials: true
+});
+class DataRequest {
+  data_table;
+  bagel;
+  itemID;
+  _filter = {};
+  constructor(table, bagel) {
+    this.data_table = table;
+    this.bagel = bagel;
+    this.itemID = "";
+  }
+  async post(item) {
+    if (!this.data_table) throw new Error("Data table not set");
+    const { data } = await axios.post(`/data/${this.data_table}`, item);
+    return data;
+  }
+  filter(filter) {
+    this._filter = filter;
+    return this;
+  }
+  async get() {
+    if (!this.data_table) throw new Error("Data table not set");
+    const filterStr = Object.keys(this._filter).length > 0 ? `?filter={${Object.entries(this._filter).map(([k, v]) => `${k}:${v}`).join(",")}}` : "";
+    const url = `/data/${this.data_table}${this.itemID ? `/${this.itemID}` : ""}${filterStr}`;
+    try {
+      const { data } = await axios.get(url);
+      return data;
+    } catch (err) {
+      console.log(err);
+      this.bagel.onError?.(err);
+      return void 0;
+    }
+  }
+  item(id) {
+    this.itemID = id;
+    return this;
+  }
+  async delete() {
+    if (!this.data_table) throw new Error("Data table not set");
+    const { data } = await axios.delete(
+      `/data/${this.data_table}/${this.itemID}`
+    );
+    return data;
+  }
+  async put(updatedItem) {
+    const { data_table, itemID } = this;
+    if (!data_table) throw new Error("Data table not set");
+    if (!itemID) throw new Error("Item ID not set");
+    const { data } = await axios.put(
+      `/data/${data_table}/${itemID}`,
+      updatedItem
+    );
+    return data;
+  }
+}
+function responses(key) {
+  const res = {
+    LOGIN_BAD_CREDENTIALS: "Invalid username or password",
+    RESET_PASSWORD_BAD_TOKEN: "This reset password link is invalid or expired."
+  };
+  return res[key] || key;
+}
+class BagelAuth {
+  constructor(bagel) {
+    this.bagel = bagel;
+    this.bagel = bagel;
+  }
+  user = void 0;
+  async validateUser() {
+    try {
+      const { data: usr } = await axios.get("/users/me", {
+        withCredentials: true
+      });
+      this.user = usr;
+      return usr;
+    } catch {
+    }
+  }
+  async resetPassword(ctx) {
+    return this.bagel.post("auth/reset-password", ctx).catch((err) => {
+      throw responses(err.response?.data?.detail);
+    });
+  }
+  async forgotPassword(email) {
+    try {
+      await this.bagel.post("auth/forgot-password", { email });
+    } catch (err) {
+      throw responses(err?.response?.data?.detail);
+    }
+  }
+  async login(user) {
+    const formData = new FormData();
+    formData.append("username", user.email || "");
+    formData.append("password", user.password || "");
+    console.log("Logging in");
+    try {
+      await axios.post("/auth/cookie/login", formData, {
+        headers: {
+          "withCredentials": true,
+          "Content-Type": "multipart/form-data"
+        }
+      });
+      axios.defaults.withCredentials = true;
+      return this.validateUser();
+    } catch (err) {
+      throw responses(err.response?.data?.detail || "LOGIN_BAD_CREDENTIALS");
+    }
+  }
+  async logout() {
+    try {
+      await axios.post("/auth/cookie/logout");
+    } catch (err) {
+      this.bagel.onError?.(err);
+      console.log(err);
+    }
+    this.user = void 0;
+  }
+  async acceptInvite(token, user) {
+    await axios.post(`/auth/accept-invite/${token}`, user);
+    await this.login(user);
+  }
+  async register(user, errors) {
+    try {
+      await axios.post("/auth/register", user);
+      return this.login(user);
+    } catch (err) {
+      console.error(err);
+      errors.email = err.response.data.detail;
+      throw err;
+    }
+  }
+}
+class Bagel {
+  host;
+  fileBaseUrl;
+  onError;
+  constructor({ host, fileBaseUrl, onError }) {
+    this.host = host?.replace(/\/$/, "");
+    this.fileBaseUrl = fileBaseUrl?.replace(/\/$/, "");
+    if (!this.host) {
+      return this;
+    }
+    axios.defaults.baseURL = this.host;
+    this.onError = onError;
+  }
+  read_table = void 0;
+  data(table) {
+    return new DataRequest(table, this);
+  }
+  auth = new BagelAuth(this);
+  _endpointCleaner(endpoint) {
+    const url = `${endpoint.replace(/^\//, "").replaceAll(/\/$/g, "")}`;
+    return url;
+  }
+  async api(endpoint, query) {
+    if (query) {
+      const queryParams = Object.entries(query).map(([key, value]) => `${key}=${value}`).join("&");
+      endpoint = `${endpoint}?${queryParams}`;
+    }
+    return axios.get(`/api/${endpoint}`).then(({ data }) => data);
+  }
+  async get(endpoint, query) {
+    this._setAuthorization();
+    endpoint = this._endpointCleaner(endpoint);
+    if (/undefined|null/.test(endpoint)) throw new Error(`Invalid endpoint: ${endpoint}`);
+    if (query) {
+      const queryParams = Object.entries(query).filter(([_, value]) => !!value).map(([key, value]) => `${key}=${value}`).join("&");
+      if (queryParams) endpoint = `${endpoint}?${queryParams}`;
+    }
+    const url = `/${endpoint}`;
+    return axios.get(url).then(({ data }) => data).catch((err) => {
+      this.onError?.(err);
+      throw err;
+    });
+  }
+  async delete(endpoint) {
+    this._setAuthorization();
+    endpoint = this._endpointCleaner(endpoint);
+    return axios.delete(`/${endpoint}`).then(({ data }) => data).catch((err) => {
+      this.onError?.(err);
+      throw err;
+    });
+  }
+  async put(endpoint, payload) {
+    endpoint = this._endpointCleaner(endpoint);
+    this._setAuthorization();
+    return axios.put(`/${endpoint}`, payload).then(({ data }) => data).catch((err) => {
+      this.onError?.(err);
+      throw err;
+    });
+  }
+  async patch(endpoint, payload = {}) {
+    endpoint = this._endpointCleaner(endpoint);
+    return axios.patch(`/${endpoint}`, payload).then(({ data }) => data).catch((err) => {
+      this.onError?.(err);
+      throw err;
+    });
+  }
+  _setAuthorization() {
+    const Authorization = localStorage.getItem("access_token");
+    if (Authorization) {
+      axios.defaults.headers.common.Authorization = `Bearer ${Authorization}`;
+    }
+  }
+  async post(endpoint, payload = {}) {
+    this._setAuthorization();
+    endpoint = this._endpointCleaner(endpoint);
+    return axios.post(`/${endpoint}`, payload).then(({ data }) => data).catch((err) => {
+      this.onError?.(err);
+      throw err;
+    });
+  }
+  async uploadFile(file, options) {
+    this._setAuthorization();
+    const formData = new FormData();
+    formData.append("file", file);
+    let url = "/static_files/upload";
+    if (options?.topic) url = `/static_files/upload?topic=${options.topic}`;
+    const { data } = await axios.post(url, formData, {
+      headers: {
+        "Content-Type": "multipart/form-data"
+      },
+      onUploadProgress: options?.onUploadProgress
+    });
+    return data;
+  }
+}
+
+export { Bagel, formatAPIErrorMessage, index as openAPI };