@firela/api-types 0.0.0-canary.209966

package/dist/index.mjs

@@ -0,0 +1,1202 @@
+// src/generated/core/OpenAPI.ts
+var Interceptors = class {
+  constructor() {
+    this._fns = [];
+  }
+  eject(fn) {
+    const index = this._fns.indexOf(fn);
+    if (index !== -1) {
+      this._fns = [...this._fns.slice(0, index), ...this._fns.slice(index + 1)];
+    }
+  }
+  use(fn) {
+    this._fns = [...this._fns, fn];
+  }
+};
+var OpenAPI = {
+  BASE: "",
+  CREDENTIALS: "include",
+  ENCODE_PATH: void 0,
+  HEADERS: void 0,
+  PASSWORD: void 0,
+  TOKEN: void 0,
+  USERNAME: void 0,
+  VERSION: "dev",
+  WITH_CREDENTIALS: false,
+  interceptors: {
+    request: new Interceptors(),
+    response: new Interceptors()
+  }
+};
+
+// src/generated/core/ApiError.ts
+var ApiError = class extends Error {
+  constructor(request2, response, message) {
+    super(message);
+    this.name = "ApiError";
+    this.url = response.url;
+    this.status = response.status;
+    this.statusText = response.statusText;
+    this.body = response.body;
+    this.request = request2;
+  }
+};
+
+// src/generated/core/CancelablePromise.ts
+var CancelError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CancelError";
+  }
+  get isCancelled() {
+    return true;
+  }
+};
+var CancelablePromise = class {
+  constructor(executor) {
+    this._isResolved = false;
+    this._isRejected = false;
+    this._isCancelled = false;
+    this.cancelHandlers = [];
+    this.promise = new Promise((resolve2, reject) => {
+      this._resolve = resolve2;
+      this._reject = reject;
+      const onResolve = (value) => {
+        if (this._isResolved || this._isRejected || this._isCancelled) {
+          return;
+        }
+        this._isResolved = true;
+        if (this._resolve) this._resolve(value);
+      };
+      const onReject = (reason) => {
+        if (this._isResolved || this._isRejected || this._isCancelled) {
+          return;
+        }
+        this._isRejected = true;
+        if (this._reject) this._reject(reason);
+      };
+      const onCancel = (cancelHandler) => {
+        if (this._isResolved || this._isRejected || this._isCancelled) {
+          return;
+        }
+        this.cancelHandlers.push(cancelHandler);
+      };
+      Object.defineProperty(onCancel, "isResolved", {
+        get: () => this._isResolved
+      });
+      Object.defineProperty(onCancel, "isRejected", {
+        get: () => this._isRejected
+      });
+      Object.defineProperty(onCancel, "isCancelled", {
+        get: () => this._isCancelled
+      });
+      return executor(onResolve, onReject, onCancel);
+    });
+  }
+  get [Symbol.toStringTag]() {
+    return "Cancellable Promise";
+  }
+  then(onFulfilled, onRejected) {
+    return this.promise.then(onFulfilled, onRejected);
+  }
+  catch(onRejected) {
+    return this.promise.catch(onRejected);
+  }
+  finally(onFinally) {
+    return this.promise.finally(onFinally);
+  }
+  cancel() {
+    if (this._isResolved || this._isRejected || this._isCancelled) {
+      return;
+    }
+    this._isCancelled = true;
+    if (this.cancelHandlers.length) {
+      try {
+        for (const cancelHandler of this.cancelHandlers) {
+          cancelHandler();
+        }
+      } catch (error) {
+        console.warn("Cancellation threw an error", error);
+        return;
+      }
+    }
+    this.cancelHandlers.length = 0;
+    if (this._reject) this._reject(new CancelError("Request aborted"));
+  }
+  get isCancelled() {
+    return this._isCancelled;
+  }
+};
+
+// src/generated/core/request.ts
+var isString = (value) => {
+  return typeof value === "string";
+};
+var isStringWithValue = (value) => {
+  return isString(value) && value !== "";
+};
+var isBlob = (value) => {
+  return value instanceof Blob;
+};
+var isFormData = (value) => {
+  return value instanceof FormData;
+};
+var base64 = (str) => {
+  try {
+    return btoa(str);
+  } catch (err) {
+    return Buffer.from(str).toString("base64");
+  }
+};
+var getQueryString = (params) => {
+  const qs = [];
+  const append = (key, value) => {
+    qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+  };
+  const encodePair = (key, value) => {
+    if (value === void 0 || value === null) {
+      return;
+    }
+    if (value instanceof Date) {
+      append(key, value.toISOString());
+    } else if (Array.isArray(value)) {
+      value.forEach((v) => encodePair(key, v));
+    } else if (typeof value === "object") {
+      Object.entries(value).forEach(([k, v]) => encodePair(`${key}[${k}]`, v));
+    } else {
+      append(key, value);
+    }
+  };
+  Object.entries(params).forEach(([key, value]) => encodePair(key, value));
+  return qs.length ? `?${qs.join("&")}` : "";
+};
+var getUrl = (config, options) => {
+  const encoder = config.ENCODE_PATH || encodeURI;
+  const path = options.url.replace("{api-version}", config.VERSION).replace(/{(.*?)}/g, (substring, group) => {
+    if (options.path?.hasOwnProperty(group)) {
+      return encoder(String(options.path[group]));
+    }
+    return substring;
+  });
+  const url = config.BASE + path;
+  return options.query ? url + getQueryString(options.query) : url;
+};
+var getFormData = (options) => {
+  if (options.formData) {
+    const formData = new FormData();
+    const process = (key, value) => {
+      if (isString(value) || isBlob(value)) {
+        formData.append(key, value);
+      } else {
+        formData.append(key, JSON.stringify(value));
+      }
+    };
+    Object.entries(options.formData).filter(([, value]) => value !== void 0 && value !== null).forEach(([key, value]) => {
+      if (Array.isArray(value)) {
+        value.forEach((v) => process(key, v));
+      } else {
+        process(key, value);
+      }
+    });
+    return formData;
+  }
+  return void 0;
+};
+var resolve = async (options, resolver) => {
+  if (typeof resolver === "function") {
+    return resolver(options);
+  }
+  return resolver;
+};
+var getHeaders = async (config, options) => {
+  const [token, username, password, additionalHeaders] = await Promise.all([
+    resolve(options, config.TOKEN),
+    resolve(options, config.USERNAME),
+    resolve(options, config.PASSWORD),
+    resolve(options, config.HEADERS)
+  ]);
+  const headers = Object.entries({
+    Accept: "application/json",
+    ...additionalHeaders,
+    ...options.headers
+  }).filter(([, value]) => value !== void 0 && value !== null).reduce(
+    (headers2, [key, value]) => ({
+      ...headers2,
+      [key]: String(value)
+    }),
+    {}
+  );
+  if (isStringWithValue(token)) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  if (isStringWithValue(username) && isStringWithValue(password)) {
+    const credentials = base64(`${username}:${password}`);
+    headers["Authorization"] = `Basic ${credentials}`;
+  }
+  if (options.body !== void 0) {
+    if (options.mediaType) {
+      headers["Content-Type"] = options.mediaType;
+    } else if (isBlob(options.body)) {
+      headers["Content-Type"] = options.body.type || "application/octet-stream";
+    } else if (isString(options.body)) {
+      headers["Content-Type"] = "text/plain";
+    } else if (!isFormData(options.body)) {
+      headers["Content-Type"] = "application/json";
+    }
+  }
+  return new Headers(headers);
+};
+var getRequestBody = (options) => {
+  if (options.body !== void 0) {
+    if (options.mediaType?.includes("application/json") || options.mediaType?.includes("+json")) {
+      return JSON.stringify(options.body);
+    } else if (isString(options.body) || isBlob(options.body) || isFormData(options.body)) {
+      return options.body;
+    } else {
+      return JSON.stringify(options.body);
+    }
+  }
+  return void 0;
+};
+var sendRequest = async (config, options, url, body, formData, headers, onCancel) => {
+  const controller = new AbortController();
+  let request2 = {
+    headers,
+    body: body ?? formData,
+    method: options.method,
+    signal: controller.signal
+  };
+  if (config.WITH_CREDENTIALS) {
+    request2.credentials = config.CREDENTIALS;
+  }
+  for (const fn of config.interceptors.request._fns) {
+    request2 = await fn(request2);
+  }
+  onCancel(() => controller.abort());
+  return await fetch(url, request2);
+};
+var getResponseHeader = (response, responseHeader) => {
+  if (responseHeader) {
+    const content = response.headers.get(responseHeader);
+    if (isString(content)) {
+      return content;
+    }
+  }
+  return void 0;
+};
+var getResponseBody = async (response) => {
+  if (response.status !== 204) {
+    try {
+      const contentType = response.headers.get("Content-Type");
+      if (contentType) {
+        const binaryTypes = [
+          "application/octet-stream",
+          "application/pdf",
+          "application/zip",
+          "audio/",
+          "image/",
+          "video/"
+        ];
+        if (contentType.includes("application/json") || contentType.includes("+json")) {
+          return await response.json();
+        } else if (binaryTypes.some((type) => contentType.includes(type))) {
+          return await response.blob();
+        } else if (contentType.includes("multipart/form-data")) {
+          return await response.formData();
+        } else if (contentType.includes("text/")) {
+          return await response.text();
+        }
+      }
+    } catch (error) {
+      console.error(error);
+    }
+  }
+  return void 0;
+};
+var catchErrorCodes = (options, result) => {
+  const errors = {
+    400: "Bad Request",
+    401: "Unauthorized",
+    402: "Payment Required",
+    403: "Forbidden",
+    404: "Not Found",
+    405: "Method Not Allowed",
+    406: "Not Acceptable",
+    407: "Proxy Authentication Required",
+    408: "Request Timeout",
+    409: "Conflict",
+    410: "Gone",
+    411: "Length Required",
+    412: "Precondition Failed",
+    413: "Payload Too Large",
+    414: "URI Too Long",
+    415: "Unsupported Media Type",
+    416: "Range Not Satisfiable",
+    417: "Expectation Failed",
+    418: "Im a teapot",
+    421: "Misdirected Request",
+    422: "Unprocessable Content",
+    423: "Locked",
+    424: "Failed Dependency",
+    425: "Too Early",
+    426: "Upgrade Required",
+    428: "Precondition Required",
+    429: "Too Many Requests",
+    431: "Request Header Fields Too Large",
+    451: "Unavailable For Legal Reasons",
+    500: "Internal Server Error",
+    501: "Not Implemented",
+    502: "Bad Gateway",
+    503: "Service Unavailable",
+    504: "Gateway Timeout",
+    505: "HTTP Version Not Supported",
+    506: "Variant Also Negotiates",
+    507: "Insufficient Storage",
+    508: "Loop Detected",
+    510: "Not Extended",
+    511: "Network Authentication Required",
+    ...options.errors
+  };
+  const error = errors[result.status];
+  if (error) {
+    throw new ApiError(options, result, error);
+  }
+  if (!result.ok) {
+    const errorStatus = result.status ?? "unknown";
+    const errorStatusText = result.statusText ?? "unknown";
+    const errorBody = (() => {
+      try {
+        return JSON.stringify(result.body, null, 2);
+      } catch (e) {
+        return void 0;
+      }
+    })();
+    throw new ApiError(
+      options,
+      result,
+      `Generic Error: status: ${errorStatus}; status text: ${errorStatusText}; body: ${errorBody}`
+    );
+  }
+};
+var request = (config, options) => {
+  return new CancelablePromise(async (resolve2, reject, onCancel) => {
+    try {
+      const url = getUrl(config, options);
+      const formData = getFormData(options);
+      const body = getRequestBody(options);
+      const headers = await getHeaders(config, options);
+      if (!onCancel.isCancelled) {
+        let response = await sendRequest(
+          config,
+          options,
+          url,
+          body,
+          formData,
+          headers,
+          onCancel
+        );
+        for (const fn of config.interceptors.response._fns) {
+          response = await fn(response);
+        }
+        const responseBody = await getResponseBody(response);
+        const responseHeader = getResponseHeader(
+          response,
+          options.responseHeader
+        );
+        const result = {
+          url,
+          ok: response.ok,
+          status: response.status,
+          statusText: response.statusText,
+          body: responseHeader ?? responseBody
+        };
+        catchErrorCodes(options, result);
+        resolve2(result.body);
+      }
+    } catch (error) {
+      reject(error);
+    }
+  });
+};
+
+// src/generated/services.gen.ts
+var BeanAccountsService = class {
+  /**
+   * Create a new account
+   * Creates a new account (Beancount Open directive)
+   * @param data The data for the request.
+   * @param data.region Region code for tenant context
+   * @param data.requestBody
+   * @returns AccountResponseDto Account created successfully
+   * @throws ApiError
+   */
+  static accountControllerCreate(data) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/{region}/bean/accounts",
+      path: {
+        region: data.region
+      },
+      body: data.requestBody,
+      mediaType: "application/json",
+      errors: {
+        409: "Account already exists"
+      }
+    });
+  }
+  /**
+   * List accounts
+   * Returns all accounts with optional filtering
+   * @param data The data for the request.
+   * @param data.region Region code for tenant context
+   * @param data.type Filter by account type
+   * @param data.status Filter by status
+   * @param data.isCustom Filter by custom (user-created) accounts only
+   * @param data.search Search term for path or i18nKey
+   * @param data.limit Maximum number of results
+   * @param data.offset Number of results to skip
+   * @returns AccountListResponseDto Accounts retrieved successfully
+   * @throws ApiError
+   */
+  static accountControllerFindAll(data) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/{region}/bean/accounts",
+      path: {
+        region: data.region
+      },
+      query: {
+        type: data.type,
+        status: data.status,
+        isCustom: data.isCustom,
+        search: data.search,
+        limit: data.limit,
+        offset: data.offset
+      }
+    });
+  }
+  /**
+   * Get account by ID
+   * Returns a specific account
+   * @param data The data for the request.
+   * @param data.id Account UUID
+   * @param data.region Region code for tenant context
+   * @returns AccountResponseDto Account retrieved successfully
+   * @throws ApiError
+   */
+  static accountControllerFindOne(data) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/{region}/bean/accounts/{id}",
+      path: {
+        id: data.id,
+        region: data.region
+      },
+      errors: {
+        404: "Account not found"
+      }
+    });
+  }
+  /**
+   * Update account
+   * Updates account metadata (path cannot be changed)
+   * @param data The data for the request.
+   * @param data.id Account UUID
+   * @param data.region Region code for tenant context
+   * @param data.requestBody
+   * @returns AccountResponseDto Account updated successfully
+   * @throws ApiError
+   */
+  static accountControllerUpdate(data) {
+    return request(OpenAPI, {
+      method: "PUT",
+      url: "/api/v1/{region}/bean/accounts/{id}",
+      path: {
+        id: data.id,
+        region: data.region
+      },
+      body: data.requestBody,
+      mediaType: "application/json",
+      errors: {
+        404: "Account not found"
+      }
+    });
+  }
+  /**
+   * Delete account
+   * Deletes an account (only if no transactions)
+   * @param data The data for the request.
+   * @param data.id Account UUID
+   * @param data.region Region code for tenant context
+   * @returns void Account deleted successfully
+   * @throws ApiError
+   */
+  static accountControllerDelete(data) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/api/v1/{region}/bean/accounts/{id}",
+      path: {
+        id: data.id,
+        region: data.region
+      },
+      errors: {
+        404: "Account not found",
+        409: "Account has transactions and cannot be deleted"
+      }
+    });
+  }
+  /**
+   * Close account
+   * Closes an account (Beancount Close directive)
+   * @param data The data for the request.
+   * @param data.id Account UUID
+   * @param data.region Region code for tenant context
+   * @param data.requestBody
+   * @returns AccountResponseDto Account closed successfully
+   * @throws ApiError
+   */
+  static accountControllerClose(data) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/{region}/bean/accounts/{id}/close",
+      path: {
+        id: data.id,
+        region: data.region
+      },
+      body: data.requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: "Account is already closed",
+        404: "Account not found"
+      }
+    });
+  }
+  /**
+   * Reopen account
+   * Reopens a previously closed account
+   * @param data The data for the request.
+   * @param data.id Account UUID
+   * @param data.region Region code for tenant context
+   * @param data.requestBody
+   * @returns AccountResponseDto Account reopened successfully
+   * @throws ApiError
+   */
+  static accountControllerReopen(data) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/{region}/bean/accounts/{id}/reopen",
+      path: {
+        id: data.id,
+        region: data.region
+      },
+      body: data.requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: "Account is not closed",
+        404: "Account not found"
+      }
+    });
+  }
+};
+var BeanTransactionsService = class {
+  /**
+   * Create transaction
+   * Creates a new double-entry transaction. Missing accounts are auto-created by default.
+   * @param data The data for the request.
+   * @param data.region Region code for tenant context
+   * @param data.requestBody Transaction data with postings
+   * @returns TransactionResponseDto Transaction created successfully
+   * @throws ApiError
+   */
+  static transactionControllerCreate(data) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/{region}/bean/transactions",
+      path: {
+        region: data.region
+      },
+      body: data.requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: "Validation failed",
+        401: "Authentication required",
+        422: "Semantic validation failed (transaction does not balance, invalid accounts)",
+        500: "Unexpected server error"
+      }
+    });
+  }
+  /**
+   * List transactions
+   * Returns a paginated list of transactions with optional filters
+   * @param data The data for the request.
+   * @param data.region Region code for tenant context
+   * @param data.limit Number of items per page (1-100, default: 20)
+   * @param data.offset Number of items to skip (default: 0)
+   * @param data.dateFrom Filter by start date (inclusive), format: YYYY-MM-DD
+   * @param data.dateTo Filter by end date (inclusive), format: YYYY-MM-DD
+   * @param data.status Filter by transaction status
+   * @param data.search Search in narration and payee fields (max 200 chars)
+   * @param data.accountId Filter by account ID (transactions with postings to this account)
+   * @returns TransactionListResponseDto Transaction list
+   * @throws ApiError
+   */
+  static transactionControllerList(data) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/{region}/bean/transactions",
+      path: {
+        region: data.region
+      },
+      query: {
+        limit: data.limit,
+        offset: data.offset,
+        dateFrom: data.dateFrom,
+        dateTo: data.dateTo,
+        status: data.status,
+        search: data.search,
+        accountId: data.accountId
+      },
+      errors: {
+        401: "Authentication required"
+      }
+    });
+  }
+  /**
+   * @param data The data for the request.
+   * @param data.region Region code for tenant context
+   * @returns unknown
+   * @throws ApiError
+   */
+  static transactionController(data) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/{region}/bean/transactions/batch",
+      path: {
+        region: data.region
+      }
+    });
+  }
+  /**
+   * Get transaction detail
+   * Returns transaction details including all postings
+   * @param data The data for the request.
+   * @param data.id Transaction ID
+   * @param data.region Region code for tenant context
+   * @returns TransactionDetailDto Transaction detail
+   * @throws ApiError
+   */
+  static transactionControllerGetDetail(data) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/{region}/bean/transactions/{id}",
+      path: {
+        id: data.id,
+        region: data.region
+      },
+      errors: {
+        401: "Authentication required",
+        404: "Transaction not found"
+      }
+    });
+  }
+  /**
+   * Update transaction metadata
+   * Updates transaction metadata (flag, payee, narration, tags, links, meta). Postings cannot be modified.
+   * @param data The data for the request.
+   * @param data.id Transaction ID
+   * @param data.region Region code for tenant context
+   * @param data.requestBody Fields to update (all optional)
+   * @returns TransactionDetailDto Transaction updated successfully
+   * @throws ApiError
+   */
+  static transactionControllerUpdate(data) {
+    return request(OpenAPI, {
+      method: "PATCH",
+      url: "/api/v1/{region}/bean/transactions/{id}",
+      path: {
+        id: data.id,
+        region: data.region
+      },
+      body: data.requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: "Cannot update voided transaction",
+        401: "Authentication required",
+        404: "Transaction not found"
+      }
+    });
+  }
+  /**
+   * @param data The data for the request.
+   * @param data.region Region code for tenant context
+   * @returns void
+   * @throws ApiError
+   */
+  static transactionController1(data) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/api/v1/{region}/bean/transactions/{id}",
+      path: {
+        region: data.region
+      }
+    });
+  }
+};
+var BeanBalancesService = class {
+  /**
+   * Query account balance
+   * Calculate account balance at a specific date for a single currency
+   * @param data The data for the request.
+   * @param data.account Account name (e.g., "Assets:Bank:Checking")
+   * @param data.region Region code (cn, us, eu-core, de)
+   * @param data.date Date to calculate balance at (ISO 8601 format)
+   * @param data.currency Currency to query (e.g., "USD", "CNY")
+   * @returns BalanceResponseDto Balance calculated successfully
+   * @throws ApiError
+   */
+  static balanceControllerGetBalance(data) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/{region}/bean/balances",
+      path: {
+        region: data.region
+      },
+      query: {
+        account: data.account,
+        date: data.date,
+        currency: data.currency
+      },
+      errors: {
+        400: "Invalid query parameters",
+        401: "User not authenticated"
+      }
+    });
+  }
+  /**
+   * Query multi-currency account balance
+   * Calculate account balances for all currencies at a specific date
+   * @param data The data for the request.
+   * @param data.region Region code (cn, us, eu-core, de)
+   * @returns MultiCurrencyBalanceResponseDto Balances calculated successfully
+   * @throws ApiError
+   */
+  static balanceControllerGetMultiCurrencyBalance(data) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/{region}/bean/balances/multi-currency",
+      path: {
+        region: data.region
+      },
+      errors: {
+        400: "Invalid query parameters",
+        401: "User not authenticated"
+      }
+    });
+  }
+};
+var BeanCommoditiesService = class {
+  /**
+   * @param data The data for the request.
+   * @param data.region Region code (cn, us, eu-core, de)
+   * @returns unknown
+   * @throws ApiError
+   */
+  static commodityController(data) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/{region}/bean/commodities",
+      path: {
+        region: data.region
+      }
+    });
+  }
+  /**
+   * List user commodities
+   * Returns all commodity definitions for the authenticated user with optional filtering
+   * @param data The data for the request.
+   * @param data.region Region code (cn, us, eu-core, de)
+   * @param data.search Search term for symbol or metadata fields (partial match). Searches symbol and metadata.name.
+   * @param data.symbol Filter by exact symbol match
+   * @returns CommodityListResponseDto Commodities retrieved successfully
+   * @throws ApiError
+   */
+  static commodityControllerFindAll(data) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/{region}/bean/commodities",
+      path: {
+        region: data.region
+      },
+      query: {
+        search: data.search,
+        symbol: data.symbol
+      }
+    });
+  }
+  /**
+   * Get commodity by symbol
+   * Returns a specific commodity definition by its symbol
+   * @param data The data for the request.
+   * @param data.symbol Commodity symbol
+   * @param data.region Region code (cn, us, eu-core, de)
+   * @returns CommodityResponseDto Commodity retrieved successfully
+   * @throws ApiError
+   */
+  static commodityControllerFindOne(data) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/{region}/bean/commodities/{symbol}",
+      path: {
+        symbol: data.symbol,
+        region: data.region
+      },
+      errors: {
+        404: "Commodity not found"
+      }
+    });
+  }
+  /**
+   * @param data The data for the request.
+   * @param data.region Region code (cn, us, eu-core, de)
+   * @returns unknown
+   * @throws ApiError
+   */
+  static commodityController1(data) {
+    return request(OpenAPI, {
+      method: "PUT",
+      url: "/api/v1/{region}/bean/commodities/{symbol}",
+      path: {
+        region: data.region
+      }
+    });
+  }
+  /**
+   * @param data The data for the request.
+   * @param data.region Region code (cn, us, eu-core, de)
+   * @returns void
+   * @throws ApiError
+   */
+  static commodityController2(data) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/api/v1/{region}/bean/commodities/{symbol}",
+      path: {
+        region: data.region
+      }
+    });
+  }
+  /**
+   * @param data The data for the request.
+   * @param data.region Region code (cn, us, eu-core, de)
+   * @returns unknown
+   * @throws ApiError
+   */
+  static commodityController3(data) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/{region}/bean/commodities/{symbol}/ensure",
+      path: {
+        region: data.region
+      }
+    });
+  }
+  /**
+   * @param data The data for the request.
+   * @param data.region Region code (cn, us, eu-core, de)
+   * @returns unknown
+   * @throws ApiError
+   */
+  static commodityController4(data) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/{region}/bean/commodities/bulk",
+      path: {
+        region: data.region
+      }
+    });
+  }
+};
+var ProviderSyncService = class {
+  /**
+   * Sync transactions from financial data provider
+   *
+   * Accepts raw transactions from external financial data providers, transforms them to Beancount format, and processes them through the ingestion pipeline.
+   *
+   * **Supported Providers:**
+   * - **plaid**: Plaid API (US, Canada, Europe)
+   * - **teller**: Teller API (US)
+   * - **truelayer**: TrueLayer Open Banking (UK, Europe)
+   * - **gocardless**: GoCardless Bank Account Data (Europe)
+   * - **simplefin**: SimpleFIN (Self-hosted)
+   * - **yodlee**: Yodlee (Global)
+   * - **beancount-direct**: Beancount format transactions
+   *
+   * **Processing Flow:**
+   * 1. Transform raw data via provider adapter
+   * 2. Validate transaction format
+   * 3. Deduplicate using originalId
+   * 4. Classify using rule engine
+   * 5. Route low-confidence to Review Center
+   * 6. Persist validated transactions
+   *
+   * @param data The data for the request.
+   * @param data.providerName Provider name
+   * @param data.region Region code
+   * @param data.requestBody
+   * @returns ProviderSyncResponseDto Sync completed successfully
+   * @throws ApiError
+   */
+  static providerSyncControllerSync(data) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/{region}/bean/import/provider/{providerName}/sync",
+      path: {
+        providerName: data.providerName,
+        region: data.region
+      },
+      body: data.requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: "Invalid request data",
+        401: "Missing or invalid authentication",
+        404: "Provider not supported"
+      }
+    });
+  }
+  /**
+   * Get supported providers
+   * Returns a list of all providers supported by the sync endpoint.
+   * @param data The data for the request.
+   * @param data.region Region code (cn, us, eu-core, de)
+   * @returns SupportedProvidersResponseDto List of supported providers
+   * @throws ApiError
+   */
+  static providerSyncControllerGetSupportedProviders(data) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/{region}/bean/import/provider/supported",
+      path: {
+        region: data.region
+      },
+      errors: {
+        401: "Missing or invalid authentication"
+      }
+    });
+  }
+  /**
+   * Check if provider is supported
+   * Returns whether a specific provider is supported.
+   * @param data The data for the request.
+   * @param data.providerName Provider name to check
+   * @param data.region Region code (cn, us, eu-core, de)
+   * @returns unknown Provider support status
+   * @throws ApiError
+   */
+  static providerSyncControllerIsProviderSupported(data) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/{region}/bean/import/provider/{providerName}/supported",
+      path: {
+        providerName: data.providerName,
+        region: data.region
+      },
+      errors: {
+        401: "Missing or invalid authentication"
+      }
+    });
+  }
+};
+var HealthService = class {
+  /**
+   * Basic health check for K8s/load balancer probes
+   * @param data The data for the request.
+   * @param data.region Region code (cn, us, eu-core, de)
+   * @returns unknown Service is healthy
+   * @throws ApiError
+   */
+  static healthControllerGetHealth(data) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/health",
+      path: {
+        region: data.region
+      },
+      errors: {
+        503: "Service unavailable"
+      }
+    });
+  }
+  /**
+   * Check database connection health
+   * @param data The data for the request.
+   * @param data.region Region code (cn, us, eu-core, de)
+   * @returns unknown Database is healthy
+   * @throws ApiError
+   */
+  static healthControllerCheckDatabase(data) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/health/database",
+      path: {
+        region: data.region
+      },
+      errors: {
+        503: "Database unavailable"
+      }
+    });
+  }
+  /**
+   * Check Redis connection health
+   * @param data The data for the request.
+   * @param data.region Region code (cn, us, eu-core, de)
+   * @returns unknown Redis is healthy
+   * @throws ApiError
+   */
+  static healthControllerCheckRedis(data) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/health/redis",
+      path: {
+        region: data.region
+      },
+      errors: {
+        503: "Redis unavailable"
+      }
+    });
+  }
+  /**
+   * Get status of all circuit breakers
+   * @param data The data for the request.
+   * @param data.region Region code (cn, us, eu-core, de)
+   * @returns unknown Circuit breaker status
+   * @throws ApiError
+   */
+  static healthControllerGetCircuitBreakersHealth(data) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/health/circuit-breakers",
+      path: {
+        region: data.region
+      },
+      errors: {
+        401: "Unauthorized",
+        500: "Internal error"
+      }
+    });
+  }
+  /**
+   * Reset a circuit breaker to CLOSED state
+   * @param data The data for the request.
+   * @param data.name Circuit breaker name to reset
+   * @param data.region Region code (cn, us, eu-core, de)
+   * @returns unknown Circuit breaker reset successfully
+   * @throws ApiError
+   */
+  static healthControllerResetCircuitBreaker(data) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/health/circuit-breakers/{name}/reset",
+      path: {
+        name: data.name,
+        region: data.region
+      },
+      errors: {
+        401: "Unauthorized",
+        404: "Circuit breaker not found"
+      }
+    });
+  }
+  /**
+   * Get health check metrics and statistics
+   * @param data The data for the request.
+   * @param data.region Region code (cn, us, eu-core, de)
+   * @returns unknown Health metrics
+   * @throws ApiError
+   */
+  static healthControllerGetMetrics(data) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/health/metrics",
+      path: {
+        region: data.region
+      },
+      errors: {
+        401: "Unauthorized"
+      }
+    });
+  }
+  /**
+   * Check health of a specific data enhancer
+   * @param data The data for the request.
+   * @param data.name Data enhancer name
+   * @param data.region Region code (cn, us, eu-core, de)
+   * @returns unknown Data enhancer is healthy
+   * @throws ApiError
+   */
+  static healthControllerGetHealthOfDataEnhancer(data) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/health/data-enhancer/{name}",
+      path: {
+        name: data.name,
+        region: data.region
+      },
+      errors: {
+        401: "Unauthorized",
+        503: "Data enhancer unavailable"
+      }
+    });
+  }
+  /**
+   * Check health of all data providers
+   * @param data The data for the request.
+   * @param data.region Region code (cn, us, eu-core, de)
+   * @returns unknown Data providers health status
+   * @throws ApiError
+   */
+  static healthControllerCheckDataProviders(data) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/health/data-providers",
+      path: {
+        region: data.region
+      },
+      errors: {
+        401: "Unauthorized",
+        503: "Data providers check failed"
+      }
+    });
+  }
+  /**
+   * Check health of a specific data provider
+   * @param data The data for the request.
+   * @param data.dataSource Data source identifier
+   * @param data.region Region code (cn, us, eu-core, de)
+   * @returns unknown Data provider is healthy
+   * @throws ApiError
+   */
+  static healthControllerGetHealthOfDataProvider(data) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/health/data-provider/{dataSource}",
+      path: {
+        dataSource: data.dataSource,
+        region: data.region
+      },
+      errors: {
+        400: "Invalid data source",
+        401: "Unauthorized",
+        503: "Data provider unavailable"
+      }
+    });
+  }
+};
+export {
+  BeanAccountsService,
+  BeanBalancesService,
+  BeanCommoditiesService,
+  BeanTransactionsService,
+  HealthService,
+  OpenAPI,
+  ProviderSyncService
+};