@abyss-project/banking 1.0.0

package/src/api/banking.api.ts

@@ -0,0 +1,197 @@
+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

@@ -0,0 +1,80 @@
+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

@@ -0,0 +1,80 @@
+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

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,74 @@
+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

@@ -0,0 +1,12 @@
+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

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

package/src/api/panel.admin.api.ts

@@ -0,0 +1,57 @@
+import {
+  AbyssBankingCore,
+  ICreatePanelAdminBody,
+  ICreatePanelAdminResponse,
+  IDeletePanelAdminParams,
+  IDeletePanelAdminResponse,
+  IGetPanelAdminParams,
+  IGetPanelAdminResponse,
+  IPaginatePanelAdminQuery,
+  IPaginatePanelAdminResponse,
+  IUpdatePanelAdminBody,
+  IUpdatePanelAdminParams,
+  IUpdatePanelAdminResponse,
+} from '..';
+
+export const getPanelAdmin = async (
+  params: IGetPanelAdminParams,
+): Promise<IGetPanelAdminResponse> => {
+  return (await AbyssBankingCore.axios.get<IGetPanelAdminResponse>(`panel/admin/${params.panelId}`))
+    .data;
+};
+
+export const paginatePanelAdmin = async (
+  query: IPaginatePanelAdminQuery,
+): Promise<IPaginatePanelAdminResponse> => {
+  return (
+    await AbyssBankingCore.axios.get<IPaginatePanelAdminResponse>(`panel/admin/paginate`, {
+      params: query,
+    })
+  ).data;
+};
+
+export const deletePanelAdmin = async (
+  params: IDeletePanelAdminParams,
+): Promise<IDeletePanelAdminResponse> => {
+  return (
+    await AbyssBankingCore.axios.delete<IDeletePanelAdminResponse>(`panel/admin/${params.panelId}`)
+  ).data;
+};
+
+export const createPanelAdmin = async (
+  body: ICreatePanelAdminBody,
+): Promise<ICreatePanelAdminResponse> => {
+  return (await AbyssBankingCore.axios.post<ICreatePanelAdminResponse>(`panel/admin`, body)).data;
+};
+
+export const updatePanelAdmin = async (
+  params: IUpdatePanelAdminParams,
+  body: IUpdatePanelAdminBody,
+): Promise<IUpdatePanelAdminResponse> => {
+  return (
+    await AbyssBankingCore.axios.put<IUpdatePanelAdminResponse>(
+      `panel/admin/${params.panelId}`,
+      body,
+    )
+  ).data;
+};

package/src/api/panel.api.ts

@@ -0,0 +1,45 @@
+import {
+  AbyssBankingCore,
+  ICreatePanelBody,
+  ICreatePanelResponse,
+  IDeletePanelParams,
+  IDeletePanelResponse,
+  IGetPanelParams,
+  IGetPanelResponse,
+  IPaginatePanelQuery,
+  IPaginatePanelResponse,
+  IUpdatePanelBody,
+  IUpdatePanelParams,
+  IUpdatePanelResponse,
+} from '..';
+
+export const getPanel = async (params: IGetPanelParams): Promise<IGetPanelResponse> => {
+  return (await AbyssBankingCore.axios.get<IGetPanelResponse>(`panel/${params.panelId}`)).data;
+};
+
+export const paginatePanel = async (
+  query: IPaginatePanelQuery,
+): Promise<IPaginatePanelResponse> => {
+  return (
+    await AbyssBankingCore.axios.get<IPaginatePanelResponse>(`panel/paginate`, {
+      params: query,
+    })
+  ).data;
+};
+
+export const deletePanel = async (params: IDeletePanelParams): Promise<IDeletePanelResponse> => {
+  return (await AbyssBankingCore.axios.delete<IDeletePanelResponse>(`panel/${params.panelId}`))
+    .data;
+};
+
+export const createPanel = async (body: ICreatePanelBody): Promise<ICreatePanelResponse> => {
+  return (await AbyssBankingCore.axios.post<ICreatePanelResponse>(`panel`, body)).data;
+};
+
+export const updatePanel = async (
+  params: IUpdatePanelParams,
+  body: IUpdatePanelBody,
+): Promise<IUpdatePanelResponse> => {
+  return (await AbyssBankingCore.axios.put<IUpdatePanelResponse>(`panel/${params.panelId}`, body))
+    .data;
+};

package/src/api/user.admin.api.ts

@@ -0,0 +1,44 @@
+import {
+  IGetUserAdminParams,
+  IGetUserAdminResponse,
+  IUpdateUserAdminParams,
+  IUpdateUserAdminResponse,
+  IUpdateUserAdminBody,
+  IPaginateUserAdminResponse,
+  IPaginateUserAdminQuery,
+  IResetApiKeyUserAdminResponse,
+  IResetApiKeyUserAdminParams,
+  AbyssBankingCore,
+} from '..';
+
+export const getUserAdmin = async (params: IGetUserAdminParams): Promise<IGetUserAdminResponse> => {
+  return (await AbyssBankingCore.axios.get<IGetUserAdminResponse>(`user/admin/${params.userId}`))
+    .data;
+};
+
+export const resetApiKeyUserAdmin = async (
+  params: IResetApiKeyUserAdminParams,
+): Promise<IResetApiKeyUserAdminResponse> => {
+  return (
+    await AbyssBankingCore.axios.post<IResetApiKeyUserAdminResponse>(`user/admin/${params.userId}`)
+  ).data;
+};
+
+export const paginateUserAdmin = async (
+  query: IPaginateUserAdminQuery,
+): Promise<IPaginateUserAdminResponse> => {
+  return (
+    await AbyssBankingCore.axios.get<IPaginateUserAdminResponse>(`user/admin/paginate`, {
+      params: query,
+    })
+  ).data;
+};
+
+export const updateUserAdmin = async (
+  params: IUpdateUserAdminParams,
+  body: IUpdateUserAdminBody,
+): Promise<IUpdateUserAdminResponse> => {
+  return (
+    await AbyssBankingCore.axios.put<IUpdateUserAdminResponse>(`user/admin/${params.userId}`, body)
+  ).data;
+};

package/src/api/user.api.ts

@@ -0,0 +1,20 @@
+import {
+  IMeUserResponse,
+  IUpdateUserBody,
+  IUpdateUserResponse,
+  IResetApiKeyUserResponse,
+  AbyssBankingCore,
+} from '..';
+
+export const meUser = async (): Promise<IMeUserResponse> => {
+  return (await AbyssBankingCore.axios.get<IMeUserResponse>(`user/me`)).data;
+};
+
+export const updateUser = async (body: IUpdateUserBody): Promise<IUpdateUserResponse> => {
+  return (await AbyssBankingCore.axios.put<IUpdateUserResponse>(`user/me`, body)).data;
+};
+
+export const resetApiKeyUser = async (): Promise<IResetApiKeyUserResponse> => {
+  return (await AbyssBankingCore.axios.post<IResetApiKeyUserResponse>(`user/me/reset-api-key`))
+    .data;
+};