@abyss-project/banking 1.0.0 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abyss-project/banking",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Core package to interact with Abyss-Banking",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/api/abyss.admin.api.ts

@@ -1,16 +0,0 @@
-import {
-  AbyssBankingCore,
-  IActivateUserServiceAbyssAdminBody,
-  IActivateUserServiceAbyssAdminResponse,
-} from '..';
-
-export const activateUserServiceAbyssAdmin = async (
-  body: IActivateUserServiceAbyssAdminBody,
-): Promise<IActivateUserServiceAbyssAdminResponse> => {
-  return (
-    await AbyssBankingCore.axios.post<IActivateUserServiceAbyssAdminResponse>(
-      `abyss/admin/user/activate-service`,
-      body,
-    )
-  ).data;
-};

package/src/api/banking.admin.api.ts

@@ -1,141 +0,0 @@
-import {
-  AbyssBankingCore,
-  IConfirmRequisitionBankingAdminParams,
-  IConfirmRequisitionBankingAdminResponse,
-  IListInstitutionBankingAdminResponse,
-  IListInstitutionBankingAdminQuery,
-  IListBankConnectionBankingAdminResponse,
-  IListBankBankingAdminResponse,
-  IGetBankConnectionBankingAdminResponse,
-  IGetBankConnectionBankingAdminParams,
-  IPaginateAccountTransactionBankingAdminQuery,
-  IPaginateAccountTransactionBankingAdminResponse,
-  IGetAccountTransactionBankingAdminParams,
-  IGetAccountTransactionBankingAdminResponse,
-  IUpdateBankAccountBankingAdminParams,
-  IUpdateBankAccountBankingAdminBody,
-  IUpdateBankAccountBankingAdminResponse,
-  ILoadDemoDataBankingAdminResponse,
-  IDeleteDemoDataBankingAdminResponse,
-  IListBankConnectionBankingAdminParams,
-  ILoadDemoDataBankingAdminParams,
-  IDeleteDemoDataBankingAdminParams,
-  IUpdateAccountTransactionBankingAdminParams,
-  IUpdateAccountTransactionBankingAdminBody,
-} from '..';
-
-export const listBankConnectionBankingAdmin = async (
-  params: IListBankConnectionBankingAdminParams,
-): Promise<IListBankConnectionBankingAdminResponse> => {
-  return (
-    await AbyssBankingCore.axios.get<IListBankConnectionBankingAdminResponse>(
-      `banking/admin/connection/${params.userId}/list`,
-    )
-  ).data;
-};
-
-export const getBankConnectionBankingAdmin = async (
-  params: IGetBankConnectionBankingAdminParams,
-): Promise<IGetBankConnectionBankingAdminResponse> => {
-  return (
-    await AbyssBankingCore.axios.get<IGetBankConnectionBankingAdminResponse>(
-      `banking/admin/connection/${params.bankConnectionId}`,
-    )
-  ).data;
-};
-
-export const listBankBankingAdmin = async (): Promise<IListBankBankingAdminResponse> => {
-  return (
-    await AbyssBankingCore.axios.get<IListBankBankingAdminResponse>(`banking/admin/bank/list`)
-  ).data;
-};
-
-export const listInstitutionBankingAdmin = async (
-  query: IListInstitutionBankingAdminQuery,
-): Promise<IListInstitutionBankingAdminResponse> => {
-  return (
-    await AbyssBankingCore.axios.get<IListInstitutionBankingAdminResponse>(
-      `banking/admin/institution/list`,
-      { params: query },
-    )
-  ).data;
-};
-
-export const confirmRequisitionBankingAdmin = async (
-  params: IConfirmRequisitionBankingAdminParams,
-): Promise<IConfirmRequisitionBankingAdminResponse> => {
-  return (
-    await AbyssBankingCore.axios.post<IConfirmRequisitionBankingAdminResponse>(
-      `banking/admin/requisition/confirm/${params.userId}/${params.reference}`,
-    )
-  ).data;
-};
-
-export const paginateAccountTransactionBankingAdmin = async (
-  query: IPaginateAccountTransactionBankingAdminQuery,
-): Promise<IPaginateAccountTransactionBankingAdminResponse> => {
-  return (
-    await AbyssBankingCore.axios.get<IPaginateAccountTransactionBankingAdminResponse>(
-      `banking/admin/transaction/paginate`,
-      { params: query },
-    )
-  ).data;
-};
-
-export const getAccountTransactionBankingAdmin = async (
-  params: IGetAccountTransactionBankingAdminParams,
-): Promise<IGetAccountTransactionBankingAdminResponse> => {
-  return (
-    await AbyssBankingCore.axios.get<IGetAccountTransactionBankingAdminResponse>(
-      `banking/admin/transaction/${params.accountTransactionId}`,
-    )
-  ).data;
-};
-
-export const updateAccountTransactionBankingAdmin = async (
-  params: IUpdateAccountTransactionBankingAdminParams,
-  body: IUpdateAccountTransactionBankingAdminBody,
-): Promise<IGetAccountTransactionBankingAdminResponse> => {
-  return (
-    await AbyssBankingCore.axios.put<IGetAccountTransactionBankingAdminResponse>(
-      `banking/admin/transaction/${params.accountTransactionId}`,
-      body,
-    )
-  ).data;
-};
-
-export const updateBankAccountBankingAdmin = async (
-  params: IUpdateBankAccountBankingAdminParams,
-  body: IUpdateBankAccountBankingAdminBody,
-): Promise<IUpdateBankAccountBankingAdminResponse> => {
-  return (
-    await AbyssBankingCore.axios.put<IUpdateBankAccountBankingAdminResponse>(
-      `banking/admin/account/${params.bankAccountId}`,
-      body,
-    )
-  ).data;
-};
-
-export const loadDemoDataBankingAdmin = async (
-  params: ILoadDemoDataBankingAdminParams,
-): Promise<ILoadDemoDataBankingAdminResponse> => {
-  return (
-    await AbyssBankingCore.axios.post<ILoadDemoDataBankingAdminResponse>(
-      `banking/admin/demo-data/${params.userId}`,
-    )
-  ).data;
-};
-
-export const deleteDemoDataBankingAdmin = async (
-  params: IDeleteDemoDataBankingAdminParams,
-): Promise<IDeleteDemoDataBankingAdminResponse> => {
-  return (
-    await AbyssBankingCore.axios.delete<IDeleteDemoDataBankingAdminResponse>(
-      `banking/admin/demo-data/${params.userId}`,
-    )
-  ).data;
-};
-
-export const fetchBankingDataBankingAdmin = async (): Promise<string> => {
-  return (await AbyssBankingCore.axios.post<string>(`banking/admin/fetch-banking-data`)).data;
-};

package/src/api/banking.api.ts

@@ -1,197 +0,0 @@
-import {
-  AbyssBankingCore,
-  IConfirmRequisitionBankingParams,
-  IConfirmRequisitionBankingResponse,
-  ICreateRequisitionBankingBody,
-  ICreateRequisitionBankingResponse,
-  IListInstitutionBankingResponse,
-  IListInstitutionBankingQuery,
-  IListConnectionBankingResponse,
-  IListBankBankingResponse,
-  IGetBankConnectionBankingResponse,
-  IGetBankConnectionBankingParams,
-  IRenewRequisitionBankingParams,
-  IRenewRequisitionBankingResponse,
-  IRenewRequisitionBankingBody,
-  IPaginateAccountTransactionBankingQuery,
-  IPaginateAccountTransactionBankingResponse,
-  IGetAccountTransactionBankingParams,
-  IGetAccountTransactionBankingResponse,
-  IUpdateBankAccountBankingParams,
-  IUpdateBankAccountBankingBody,
-  IUpdateBankAccountBankingResponse,
-  ILoadDemoDataBankingResponse,
-  IDeleteDemoDataBankingResponse,
-  IGetTransactionPerCategoryBankingQuery,
-  IGetTransactionPerCategoryBankingResponse,
-  IGetSumTransactionPerBankAccountPerCategoryQuery,
-  IGetSumTransactionPerBankAccountPerCategoryBankingResponse,
-  IPaginateBankAccountHistoryBankingQuery,
-  IPaginateBankAccountHistoryBankingResponse,
-  IListBankAccountHistoryBankingQuery,
-  IListBankAccountHistoryBankingResponse,
-  IUpdateAccountTransactionBankingParams,
-  IUpdateAccountTransactionBankingBody,
-} from '..';
-
-export const listConnectionBanking = async (): Promise<IListConnectionBankingResponse> => {
-  return (
-    await AbyssBankingCore.axios.get<IListConnectionBankingResponse>(`banking/connection/list`)
-  ).data;
-};
-
-export const getBankConnectionBanking = async (
-  params: IGetBankConnectionBankingParams,
-): Promise<IGetBankConnectionBankingResponse> => {
-  return (
-    await AbyssBankingCore.axios.get<IGetBankConnectionBankingResponse>(
-      `banking/connection/${params.bankConnectionId}`,
-    )
-  ).data;
-};
-
-export const listBankBanking = async (): Promise<IListBankBankingResponse> => {
-  return (await AbyssBankingCore.axios.get<IListBankBankingResponse>(`banking/bank/list`)).data;
-};
-
-export const listInstitutionBanking = async (
-  query: IListInstitutionBankingQuery,
-): Promise<IListInstitutionBankingResponse> => {
-  return (
-    await AbyssBankingCore.axios.get<IListInstitutionBankingResponse>(`banking/institution/list`, {
-      params: query,
-    })
-  ).data;
-};
-
-export const createRequisitionBanking = async (
-  body: ICreateRequisitionBankingBody,
-): Promise<ICreateRequisitionBankingResponse> => {
-  return (
-    await AbyssBankingCore.axios.post<ICreateRequisitionBankingResponse>(
-      `banking/requisition/create`,
-      body,
-    )
-  ).data;
-};
-
-export const confirmRequisitionBanking = async (
-  params: IConfirmRequisitionBankingParams,
-): Promise<IConfirmRequisitionBankingResponse> => {
-  return (
-    await AbyssBankingCore.axios.post<IConfirmRequisitionBankingResponse>(
-      `banking/requisition/confirm/${params.reference}`,
-    )
-  ).data;
-};
-
-export const renewRequisitionBanking = async (
-  params: IRenewRequisitionBankingParams,
-  body: IRenewRequisitionBankingBody,
-): Promise<IRenewRequisitionBankingResponse> => {
-  return (
-    await AbyssBankingCore.axios.post<IRenewRequisitionBankingResponse>(
-      `banking/requisition/${params.bankConnectionId}/renew`,
-      body,
-    )
-  ).data;
-};
-
-export const paginateAccountTransactionBanking = async (
-  query: IPaginateAccountTransactionBankingQuery,
-): Promise<IPaginateAccountTransactionBankingResponse> => {
-  return (
-    await AbyssBankingCore.axios.get<IPaginateAccountTransactionBankingResponse>(
-      `banking/transaction/paginate`,
-      { params: query },
-    )
-  ).data;
-};
-
-export const getAccountTransactionBanking = async (
-  params: IGetAccountTransactionBankingParams,
-): Promise<IGetAccountTransactionBankingResponse> => {
-  return (
-    await AbyssBankingCore.axios.get<IGetAccountTransactionBankingResponse>(
-      `banking/transaction/${params.accountTransactionId}`,
-    )
-  ).data;
-};
-
-export const updateAccountTransactionBanking = async (
-  params: IUpdateAccountTransactionBankingParams,
-  body: IUpdateAccountTransactionBankingBody,
-): Promise<IGetAccountTransactionBankingResponse> => {
-  return (
-    await AbyssBankingCore.axios.put<IGetAccountTransactionBankingResponse>(
-      `banking/transaction/${params.accountTransactionId}`,
-      body,
-    )
-  ).data;
-};
-
-export const updateBankAccountBanking = async (
-  params: IUpdateBankAccountBankingParams,
-  body: IUpdateBankAccountBankingBody,
-): Promise<IUpdateBankAccountBankingResponse> => {
-  return (
-    await AbyssBankingCore.axios.put<IUpdateBankAccountBankingResponse>(
-      `banking/account/${params.bankAccountId}`,
-      body,
-    )
-  ).data;
-};
-
-export const loadDemoDataBanking = async (): Promise<ILoadDemoDataBankingResponse> => {
-  return (await AbyssBankingCore.axios.post<ILoadDemoDataBankingResponse>(`banking/demo-data`))
-    .data;
-};
-
-export const deleteDemoDataBanking = async (): Promise<IDeleteDemoDataBankingResponse> => {
-  return (await AbyssBankingCore.axios.delete<IDeleteDemoDataBankingResponse>(`banking/demo-data`))
-    .data;
-};
-
-export const getTransactionPerCategoryBanking = async (
-  query: IGetTransactionPerCategoryBankingQuery,
-): Promise<IGetTransactionPerCategoryBankingResponse> => {
-  return (
-    await AbyssBankingCore.axios.get<IGetTransactionPerCategoryBankingResponse>(
-      `banking/transaction-per-category`,
-      { params: query },
-    )
-  ).data;
-};
-
-export const getSumTransactionPerBankAccountPerCategoryBanking = async (
-  query: IGetSumTransactionPerBankAccountPerCategoryQuery,
-): Promise<IGetSumTransactionPerBankAccountPerCategoryBankingResponse> => {
-  return (
-    await AbyssBankingCore.axios.get<IGetSumTransactionPerBankAccountPerCategoryBankingResponse>(
-      `banking/sum-transaction-per-bank-account-category`,
-      { params: query },
-    )
-  ).data;
-};
-
-export const paginateBankAccountHistoryBanking = async (
-  query: IPaginateBankAccountHistoryBankingQuery,
-): Promise<IPaginateBankAccountHistoryBankingResponse> => {
-  return (
-    await AbyssBankingCore.axios.get<IPaginateBankAccountHistoryBankingResponse>(
-      `banking/bank-account-history/paginate`,
-      { params: query },
-    )
-  ).data;
-};
-
-export const listBankAccountHistoryBanking = async (
-  query: IListBankAccountHistoryBankingQuery,
-): Promise<IListBankAccountHistoryBankingResponse> => {
-  return (
-    await AbyssBankingCore.axios.get<IListBankAccountHistoryBankingResponse>(
-      `banking/bank-account-history/list`,
-      { params: query },
-    )
-  ).data;
-};

package/src/api/categorization-rule.admin.api.ts

@@ -1,80 +0,0 @@
-import {
-  AbyssBankingCore,
-  IApplyCategorizationRuleAdminParams,
-  IApplyCategorizationRuleAdminResponse,
-  ICreateCategorizationRuleAdminBody,
-  ICreateCategorizationRuleAdminResponse,
-  IDeleteCategorizationRuleAdminParams,
-  IDeleteCategorizationRuleAdminResponse,
-  IGetCategorizationRuleAdminParams,
-  IGetCategorizationRuleAdminResponse,
-  IPaginateCategorizationRuleAdminQuery,
-  IPaginateCategorizationRuleAdminResponse,
-  IUpdateCategorizationRuleAdminBody,
-  IUpdateCategorizationRuleAdminParams,
-  IUpdateCategorizationRuleAdminResponse,
-} from '..';
-
-export const getCategorizationRuleAdmin = async (
-  params: IGetCategorizationRuleAdminParams,
-): Promise<IGetCategorizationRuleAdminResponse> => {
-  return (
-    await AbyssBankingCore.axios.get<IGetCategorizationRuleAdminResponse>(
-      `categorization-rule/admin/${params.categorizationRuleId}`,
-    )
-  ).data;
-};
-
-export const applyCategorizationRuleAdmin = async (
-  params: IApplyCategorizationRuleAdminParams,
-): Promise<IApplyCategorizationRuleAdminResponse> => {
-  return (
-    await AbyssBankingCore.axios.post<IApplyCategorizationRuleAdminResponse>(
-      `categorization-rule/admin/${params.categorizationRuleId}/apply`,
-    )
-  ).data;
-};
-
-export const paginateCategorizationRuleAdmin = async (
-  query: IPaginateCategorizationRuleAdminQuery,
-): Promise<IPaginateCategorizationRuleAdminResponse> => {
-  return (
-    await AbyssBankingCore.axios.get<IPaginateCategorizationRuleAdminResponse>(
-      `categorization-rule/admin/paginate`,
-      { params: query },
-    )
-  ).data;
-};
-
-export const deleteCategorizationRuleAdmin = async (
-  params: IDeleteCategorizationRuleAdminParams,
-): Promise<IDeleteCategorizationRuleAdminResponse> => {
-  return (
-    await AbyssBankingCore.axios.delete<IDeleteCategorizationRuleAdminResponse>(
-      `categorization-rule/admin/${params.categorizationRuleId}`,
-    )
-  ).data;
-};
-
-export const createCategorizationRuleAdmin = async (
-  body: ICreateCategorizationRuleAdminBody,
-): Promise<ICreateCategorizationRuleAdminResponse> => {
-  return (
-    await AbyssBankingCore.axios.post<ICreateCategorizationRuleAdminResponse>(
-      `categorization-rule/admin`,
-      body,
-    )
-  ).data;
-};
-
-export const updateCategorizationRuleAdmin = async (
-  params: IUpdateCategorizationRuleAdminParams,
-  body: IUpdateCategorizationRuleAdminBody,
-): Promise<IUpdateCategorizationRuleAdminResponse> => {
-  return (
-    await AbyssBankingCore.axios.put<IUpdateCategorizationRuleAdminResponse>(
-      `categorization-rule/admin/${params.categorizationRuleId}`,
-      body,
-    )
-  ).data;
-};

package/src/api/categorization-rule.api.ts

@@ -1,80 +0,0 @@
-import {
-  AbyssBankingCore,
-  IApplyCategorizationRuleParams,
-  IApplyCategorizationRuleResponse,
-  ICreateCategorizationRuleBody,
-  ICreateCategorizationRuleResponse,
-  IDeleteCategorizationRuleParams,
-  IDeleteCategorizationRuleResponse,
-  IGetCategorizationRuleParams,
-  IGetCategorizationRuleResponse,
-  IPaginateCategorizationRuleQuery,
-  IPaginateCategorizationRuleResponse,
-  IUpdateCategorizationRuleBody,
-  IUpdateCategorizationRuleParams,
-  IUpdateCategorizationRuleResponse,
-} from '..';
-
-export const getCategorizationRule = async (
-  params: IGetCategorizationRuleParams,
-): Promise<IGetCategorizationRuleResponse> => {
-  return (
-    await AbyssBankingCore.axios.get<IGetCategorizationRuleResponse>(
-      `categorization-rule/${params.categorizationRuleId}`,
-    )
-  ).data;
-};
-
-export const applyCategorizationRule = async (
-  params: IApplyCategorizationRuleParams,
-): Promise<IApplyCategorizationRuleResponse> => {
-  return (
-    await AbyssBankingCore.axios.post<IApplyCategorizationRuleResponse>(
-      `categorization-rule/${params.categorizationRuleId}/apply`,
-    )
-  ).data;
-};
-
-export const paginateCategorizationRule = async (
-  query: IPaginateCategorizationRuleQuery,
-): Promise<IPaginateCategorizationRuleResponse> => {
-  return (
-    await AbyssBankingCore.axios.get<IPaginateCategorizationRuleResponse>(
-      `categorization-rule/paginate`,
-      { params: query },
-    )
-  ).data;
-};
-
-export const deleteCategorizationRule = async (
-  params: IDeleteCategorizationRuleParams,
-): Promise<IDeleteCategorizationRuleResponse> => {
-  return (
-    await AbyssBankingCore.axios.delete<IDeleteCategorizationRuleResponse>(
-      `categorization-rule/${params.categorizationRuleId}`,
-    )
-  ).data;
-};
-
-export const createCategorizationRule = async (
-  body: ICreateCategorizationRuleBody,
-): Promise<ICreateCategorizationRuleResponse> => {
-  return (
-    await AbyssBankingCore.axios.post<ICreateCategorizationRuleResponse>(
-      `categorization-rule`,
-      body,
-    )
-  ).data;
-};
-
-export const updateCategorizationRule = async (
-  params: IUpdateCategorizationRuleParams,
-  body: IUpdateCategorizationRuleBody,
-): Promise<IUpdateCategorizationRuleResponse> => {
-  return (
-    await AbyssBankingCore.axios.put<IUpdateCategorizationRuleResponse>(
-      `categorization-rule/${params.categorizationRuleId}`,
-      body,
-    )
-  ).data;
-};

package/src/api/category.admin.api.ts

@@ -1,63 +0,0 @@
-import { AbyssBankingCore } from '..';
-import {
-  IGetCategoryAdminParams,
-  IGetCategoryAdminResponse,
-  IPaginateCategoryAdminQuery,
-  IPaginateCategoryAdminResponse,
-  IDeleteCategoryAdminResponse,
-  IDeleteCategoryAdminParams,
-  ICreateCategoryAdminBody,
-  ICreateCategoryAdminResponse,
-  IUpdateCategoryAdminBody,
-  IUpdateCategoryAdminParams,
-  IUpdateCategoryAdminResponse,
-} from '../types';
-
-export const getCategoryAdmin = async (
-  params: IGetCategoryAdminParams,
-): Promise<IGetCategoryAdminResponse> => {
-  return (
-    await AbyssBankingCore.axios.get<IGetCategoryAdminResponse>(
-      `category/admin/${params.categoryId}`,
-    )
-  ).data;
-};
-
-export const paginateCategoryAdmin = async (
-  query: IPaginateCategoryAdminQuery,
-): Promise<IPaginateCategoryAdminResponse> => {
-  return (
-    await AbyssBankingCore.axios.get<IPaginateCategoryAdminResponse>(`category/admin/paginate`, {
-      params: query,
-    })
-  ).data;
-};
-
-export const deleteCategoryAdmin = async (
-  params: IDeleteCategoryAdminParams,
-): Promise<IDeleteCategoryAdminResponse> => {
-  return (
-    await AbyssBankingCore.axios.delete<IDeleteCategoryAdminResponse>(
-      `category/admin/${params.categoryId}`,
-    )
-  ).data;
-};
-
-export const createCategoryAdmin = async (
-  body: ICreateCategoryAdminBody,
-): Promise<ICreateCategoryAdminResponse> => {
-  return (await AbyssBankingCore.axios.post<ICreateCategoryAdminResponse>(`category/admin`, body))
-    .data;
-};
-
-export const updateCategoryAdmin = async (
-  params: IUpdateCategoryAdminParams,
-  body: IUpdateCategoryAdminBody,
-): Promise<IUpdateCategoryAdminResponse> => {
-  return (
-    await AbyssBankingCore.axios.put<IUpdateCategoryAdminResponse>(
-      `category/admin/${params.categoryId}`,
-      body,
-    )
-  ).data;
-};

package/src/api/category.api.ts

@@ -1,74 +0,0 @@
-import { AbyssBankingCore } from '..';
-import {
-  IListCategoryResponse,
-  IRemoveCategoryResponse,
-  IAddCategoryResponse,
-  IDeleteCategoryResponse,
-  ICreateCategoryResponse,
-  IUpdateCategoryResponse,
-  IListAnalyticsCategoryResponse,
-} from '../types';
-import {
-  IRemoveCategoryParams,
-  IAddCategoryParams,
-  IDeleteCategoryParams,
-  ICreateCategoryBody,
-  IUpdateCategoryParams,
-  IUpdateCategoryBody,
-  IListAnalyticsCategoryQuery,
-} from '../types/interface/api/requests/category.request';
-
-export const listCategory = async (): Promise<IListCategoryResponse> => {
-  return (await AbyssBankingCore.axios.get<IListCategoryResponse>(`category/list`)).data;
-};
-
-export const listAnalyticsCategory = async (
-  query: IListAnalyticsCategoryQuery,
-): Promise<IListAnalyticsCategoryResponse> => {
-  return (
-    await AbyssBankingCore.axios.get<IListAnalyticsCategoryResponse>(`category/list/analytics`, {
-      params: query,
-    })
-  ).data;
-};
-
-export const removeCategory = async (
-  params: IRemoveCategoryParams,
-): Promise<IRemoveCategoryResponse> => {
-  return (
-    await AbyssBankingCore.axios.delete<IRemoveCategoryResponse>(
-      `category/transaction/${params.transactionCategoryId}`,
-    )
-  ).data;
-};
-
-export const addCategory = async (params: IAddCategoryParams): Promise<IAddCategoryResponse> => {
-  return (
-    await AbyssBankingCore.axios.post<IAddCategoryResponse>(
-      `category/${params.categoryId}/transaction/${params.accountTransactionId}`,
-    )
-  ).data;
-};
-
-export const deleteCategory = async (
-  params: IDeleteCategoryParams,
-): Promise<IDeleteCategoryResponse> => {
-  return (
-    await AbyssBankingCore.axios.delete<IDeleteCategoryResponse>(`category/${params.categoryId}`)
-  ).data;
-};
-
-export const createCategory = async (
-  body: ICreateCategoryBody,
-): Promise<ICreateCategoryResponse> => {
-  return (await AbyssBankingCore.axios.post<ICreateCategoryResponse>(`category`, body)).data;
-};
-
-export const updateCategory = async (
-  params: IUpdateCategoryParams,
-  body: IUpdateCategoryBody,
-): Promise<IUpdateCategoryResponse> => {
-  return (
-    await AbyssBankingCore.axios.put<IUpdateCategoryResponse>(`category/${params.categoryId}`, body)
-  ).data;
-};

package/src/api/index.ts

@@ -1,12 +0,0 @@
-export * from './abyss.admin.api';
-export * from './user.admin.api';
-export * from './user.api';
-export * from './monitor.api';
-export * from './banking.admin.api';
-export * from './banking.api';
-export * from './category.admin.api';
-export * from './category.api';
-export * from './categorization-rule.admin.api';
-export * from './categorization-rule.api';
-export * from './panel.api';
-export * from './panel.admin.api';

package/src/api/monitor.api.ts

@@ -1,6 +0,0 @@
-import { AbyssBankingCore } from '..';
-import { IUpMonitorResponse } from '../types';
-
-export const upMonitor = async (): Promise<IUpMonitorResponse> => {
-  return (await AbyssBankingCore.axios.get<IUpMonitorResponse>(`monitor/up`)).data;
-};