@smartbills/react-hooks-sdk 0.0.2-alpha.16 → 0.0.2-alpha.17

package/dist/umd/index.js

@@ -19,21 +19,240 @@
       return context;
     };
 
-    const LOGS_KEY = "LOGS";
+    var SBApiKeys;
+    (function (SBApiKeys) {
+      SBApiKeys["BankAccounts"] = "BANK_ACCOUNT";
+      SBApiKeys["BankAccountTransactions"] = "BANK_ACCOUNT_TRANSACTIONS";
+      SBApiKeys["BankTransactions"] = "BANK_TRANSACTIONS";
+      SBApiKeys["BankInstitutions"] = "BANK_INSTITUTIONS";
+      SBApiKeys["Cards"] = "CARDS";
+      SBApiKeys["CardSetupIntents"] = "CARDS_SETUP_INTENTS";
+      SBApiKeys["Documents"] = "DOCUMENTS";
+      SBApiKeys["Organizations"] = "ORGANIZATIONS";
+      SBApiKeys["Logs"] = "LOGS";
+      SBApiKeys["Locations"] = "LOCATIONS";
+      SBApiKeys["Merchants"] = "MERCHANTS";
+      SBApiKeys["PromoCodes"] = "PROMO_CODES";
+      SBApiKeys["Domains"] = "DOMAINS";
+      SBApiKeys["User"] = "USER";
+      SBApiKeys["Users"] = "USERS";
+      SBApiKeys["PaymentMethods"] = "PAYMENT_METHODS";
+      SBApiKeys["Taxes"] = "TAXES";
+      SBApiKeys["Friends"] = "FRIENDS";
+    })(SBApiKeys || (SBApiKeys = {}));
+
     const useGetLogById = (id, options, config) => {
       const client = useApiClient();
       return reactQuery.useQuery({
-        queryKey: [LOGS_KEY, id],
+        queryKey: [SBApiKeys.Logs, id],
         queryFn: async () => await client.logs.getById(id, options, config)
       });
     };
     const useListLogs = (request, options, config) => {
       const client = useApiClient();
       return reactQuery.useQuery({
-        queryKey: [LOGS_KEY, request],
-        queryFn: async () => await client.logs.get(request, options, config)
+        queryKey: [SBApiKeys.Logs, request],
+        queryFn: async () => await client.logs.list(request, options, config)
+      });
+    };
+
+    const useGetBankAccountById = (id, options, config) => {
+      const client = useApiClient();
+      return reactQuery.useQuery({
+        queryKey: [SBApiKeys.BankAccounts, id],
+        queryFn: async () => {
+          return client.bankAccounts.getById(id, options, config);
+        }
+      });
+    };
+    const useGetBankAccounts = request => {
+      const client = useApiClient();
+      return reactQuery.useQuery({
+        queryKey: [SBApiKeys.BankAccounts, request],
+        queryFn: async request => {
+          return client.bankAccounts.get(request);
+        }
+      });
+    };
+    const useListBankAccountTransanctions = (id, request, options, config) => {
+      const client = useApiClient();
+      return reactQuery.useInfiniteQuery({
+        initialPageParam: request.page,
+        queryKey: [SBApiKeys.BankAccounts, id, request],
+        queryFn: async ({
+          pageParam = 1
+        }) => {
+          request.page = pageParam;
+          return client.bankAccounts.listTransactions(id, request, options, config);
+        },
+        getPreviousPageParam: firstPage => {
+          if (firstPage.metadata.currentPage === 1) {
+            return 1;
+          }
+          return firstPage.metadata.currentPage - 1;
+        },
+        getNextPageParam: lastPage => {
+          if (lastPage.metadata.currentPage === lastPage.metadata.pageCount) {
+            return undefined;
+          }
+          return lastPage.metadata.currentPage + 1;
+        }
+      });
+    };
+
+    const useGetBankTransactions = request => {
+      const client = useApiClient();
+      return reactQuery.useInfiniteQuery({
+        initialPageParam: request.page,
+        queryKey: ["bankTransactions", request],
+        queryFn: async ({
+          pageParam = 1
+        }) => {
+          return client.bankTransactions.list({
+            ...request,
+            page: pageParam
+          });
+        },
+        getNextPageParam: lastPage => {
+          if (lastPage.metadata.currentPage === lastPage.metadata.pageCount) {
+            return undefined;
+          }
+          return lastPage.metadata.currentPage + 1;
+        }
+      });
+    };
+    const useGetBankTransaction = id => {
+      const client = useApiClient();
+      return reactQuery.useQuery({
+        queryKey: ["bankTransaction", id],
+        queryFn: async () => await client.bankTransactions.getById(id)
       });
     };
+    // export const useAssociateReceipt = () => {
+    // 	const client = useApiClient();
+    // 	return useMutation<
+    // 		SBReceipt,
+    // 		SBApiException,
+    // 		{ id: number; receiptId: number }
+    // 	>({
+    // 		mutationFn: ({ id, receiptId }) => await,
+    // 		onSuccess: (_, { id, receiptId }) => {
+    // 			queryClient.invalidateQueries({
+    // 				queryKey: ["bankTransaction", id],
+    // 			});
+    // 			queryClient.invalidateQueries({ queryKey: ["receipt", receiptId] });
+    // 		},
+    // 	});
+    // };
+    // export const useLinkDocuments = () => {
+    // 	const client = useApiClient();
+    // 	return useMutation<
+    // 		SBDocument[],
+    // 		SBApiException,
+    // 		{ id: number; documents: number[] }
+    // 	>({
+    // 		mutationFn: async({ id, documents }) => await client.bankAccounts,
+    // 		onSuccess: (_, { id }) => {
+    // 			queryClient.invalidateQueries({
+    // 				queryKey: ["bankTransaction", id],
+    // 			});
+    // 			queryClient.invalidateQueries({ queryKey: ["pendingDocuments"] });
+    // 		},
+    // 	});
+    // };
+    // export const useUnlinkDocument = () => {
+    // 	const client = useApiClient();
+    // 	return useMutation<SBDocument, SBApiException, { id: number; documentId: number }>({
+    // 		mutationFn: ({ id, documentId }) => {
+    // 		},
+    // 		onMutate: async ({ id, documentId }) => {
+    // 			await queryClient.cancelQueries({
+    // 				queryKey: ["bankTransaction", id],
+    // 			});
+    // 			const previousTransaction =
+    // 				queryClient.getQueryData<SBBankTransaction>([
+    // 					"bankTransaction",
+    // 					id,
+    // 				]);
+    // 			queryClient.setQueryData<SBBankTransaction>(
+    // 				["bankTransaction", id],
+    // 				(old) => {
+    // 					if (old) {
+    // 						return {
+    // 							...old,
+    // 							documents: old.documents.filter(
+    // 								(doc) => doc.id !== documentId,
+    // 							),
+    // 						};
+    // 					}
+    // 					return old;
+    // 				},
+    // 			);
+    // 			return { previousTransaction };
+    // 		},
+    // 		onError: (_, __, context) => {
+    // 			if (context?.previousTransaction) {
+    // 				queryClient.setQueryData(
+    // 					["bankTransaction", context.previousTransaction.id],
+    // 					context.previousTransaction,
+    // 				);
+    // 			}
+    // 		},
+    // 		onSettled: (data, error, { id }) => {
+    // 			queryClient.invalidateQueries({
+    // 				queryKey: ["bankTransaction", id],
+    // 			});
+    // 			queryClient.invalidateQueries({ queryKey: ["pendingDocuments"] });
+    // 		},
+    // 	});
+    // };
+    // export const useRenameDocument = () => {
+    // 	const client = useApiClient();
+    // 	return useMutation<SBDocument, SBApiException>({
+    // 		mutationFn: (id: number, documentId, request) =>
+    // 			client.bankTransactions.renameDocument(id, documentId, request),
+    // 		onMutate: async ({ id, documentId, request }) => {
+    // 			await queryClient.cancelQueries({
+    // 				queryKey: ["bankTransaction", id],
+    // 			});
+    // 			const previousTransaction =
+    // 				queryClient.getQueryData<SBBankTransaction>([
+    // 					"bankTransaction",
+    // 					id,
+    // 				]);
+    // 			queryClient.setQueryData<SBBankTransaction>(
+    // 				["bankTransaction", id],
+    // 				(old) => {
+    // 					if (old) {
+    // 						const index = old.documents.findIndex(
+    // 							(doc) => doc.id === documentId,
+    // 						);
+    // 						if (index !== -1) {
+    // 							old.documents[index].name = request.name;
+    // 						}
+    // 						return old;
+    // 					}
+    // 					return old;
+    // 				},
+    // 			);
+    // 			return { previousTransaction };
+    // 		},
+    // 		onError: (_, __, context) => {
+    // 			if (context?.previousTransaction) {
+    // 				queryClient.setQueryData(
+    // 					["bankTransaction", context.previousTransaction.id],
+    // 					context.previousTransaction,
+    // 				);
+    // 			}
+    // 		},
+    // 		onSettled: (data, error, { id }) => {
+    // 			queryClient.invalidateQueries({
+    // 				queryKey: ["bankTransaction", id],
+    // 			});
+    // 			queryClient.invalidateQueries({ queryKey: ["pendingDocuments"] });
+    // 		},
+    // 	});
+    // };
 
     const queryClient = new reactQuery.QueryClient();
     function SmartbillsSDKProvider({
@@ -52,30 +271,678 @@
     const BANK_TRANSACTIONS_KEY = "bankTransactions";
     const useGetBankById = id => {
       const client = useApiClient();
-      return reactQuery.useQuery({
-        queryKey: [BANKS_KEY, id],
-        queryFn: async () => await client.banks.getById(id)
+      return reactQuery.useQuery({
+        queryKey: [BANKS_KEY, id],
+        queryFn: async () => await client.banks.getById(id)
+      });
+    };
+    const useGetBankAccountForBank = (id, accountId) => {
+      const client = useApiClient();
+      return reactQuery.useQuery({
+        queryKey: [BANK_ACCOUNTS_KEY, id, accountId],
+        queryFn: async () => await client.banks.getBankAccount(id, accountId)
+      });
+    };
+    const useGetBankAccountTransactions = (id, accountId, request) => {
+      const client = useApiClient();
+      return reactQuery.useInfiniteQuery({
+        initialPageParam: request.page,
+        queryKey: [BANK_TRANSACTIONS_KEY, id, accountId],
+        queryFn: async ({
+          pageParam = 1
+        }) => {
+          return await client.banks.listBankAccountTransactions(id, accountId, {
+            ...request,
+            page: pageParam
+          });
+        },
+        getNextPageParam: lastPage => {
+          if (lastPage.metadata.currentPage === lastPage.metadata.pageCount) {
+            return undefined;
+          }
+          return lastPage.metadata.currentPage + 1;
+        }
+      });
+    };
+    const useGetBankLinkToken = () => {
+      const client = useApiClient();
+      return reactQuery.useQuery({
+        queryKey: ["bankLinkToken"],
+        queryFn: async () => await client.banks.getBankLinkToken()
+      });
+    };
+    const useGetBankLink = () => {
+      const client = useApiClient();
+      return reactQuery.useQuery({
+        queryKey: ["bankLink"],
+        queryFn: async () => await client.banks.getBankLink()
+      });
+    };
+    const useGetBanks = request => {
+      const client = useApiClient();
+      return reactQuery.useQuery({
+        queryKey: [BANKS_KEY, request],
+        queryFn: async () => await client.banks.get(request)
+      });
+    };
+    const useCreateBank = () => {
+      const client = useApiClient();
+      return reactQuery.useMutation({
+        mutationFn: async request => await client.banks.create(request),
+        onSuccess: () => {
+          queryClient.invalidateQueries({
+            queryKey: [BANKS_KEY]
+          });
+        }
+      });
+    };
+    const useDeleteBank = id => {
+      const client = useApiClient();
+      return reactQuery.useMutation({
+        mutationFn: async () => await client.banks.delete(id),
+        onMutate: async () => {
+          await queryClient.cancelQueries({
+            queryKey: [BANKS_KEY]
+          });
+          const previousBanks = queryClient.getQueryData([BANKS_KEY]);
+          queryClient.setQueryData([BANKS_KEY], old => ({
+            ...old,
+            data: old.data.filter(bank => bank.id !== id)
+          }));
+          return {
+            previousBanks
+          };
+        },
+        onError: (err, _, context) => {
+          queryClient.setQueryData([BANKS_KEY], context?.previousBanks);
+        },
+        onSettled: () => {
+          queryClient.invalidateQueries({
+            queryKey: [BANKS_KEY]
+          });
+        }
+      });
+    };
+
+    const useCreateCard = () => {
+      const client = useApiClient();
+      return reactQuery.useMutation({
+        mutationFn: async (request, options, config) => {
+          return await client.cards.create(request, options, config);
+        },
+        onSuccess: () => {
+          queryClient.invalidateQueries({
+            queryKey: [SBApiKeys.Cards]
+          });
+        }
+      });
+    };
+    const useAttachCard = () => {
+      const client = useApiClient();
+      return reactQuery.useMutation({
+        mutationFn: async (request, options, config) => {
+          return await client.cards.attach(request, options, config);
+        },
+        onSuccess: (data, id) => {
+          queryClient.invalidateQueries({
+            queryKey: [SBApiKeys.Cards, id]
+          });
+        }
+      });
+    };
+    const useDetachCard = () => {
+      const client = useApiClient();
+      return reactQuery.useMutation({
+        mutationFn: async (id, options, config) => {
+          return await client.cards.detach(id, options, config);
+        },
+        onSuccess: (data, id) => {
+          queryClient.invalidateQueries({
+            queryKey: [SBApiKeys.Cards, id]
+          });
+        }
+      });
+    };
+    const useGetCards = (request, options, config) => {
+      const client = useApiClient();
+      return reactQuery.useQuery({
+        queryKey: [SBApiKeys.Cards],
+        queryFn: async () => {
+          return await client.cards.get(request, options, config);
+        }
+      });
+    };
+    const useGetCardById = (id, options, config) => {
+      const client = useApiClient();
+      return reactQuery.useQuery({
+        queryKey: [SBApiKeys.Cards, id],
+        queryFn: async () => {
+          return await client.cards.getById(id, options, config);
+        }
+      });
+    };
+
+    const useCreateCardSetupIntent = () => {
+      const client = useApiClient();
+      return reactQuery.useMutation({
+        mutationKey: [SBApiKeys.CardSetupIntents],
+        mutationFn: async ({
+          options,
+          config
+        }) => {
+          return await client.cards.createSetupIntent(options, config);
+        },
+        onSuccess: data => {
+          queryClient.invalidateQueries({
+            queryKey: [SBApiKeys.CardSetupIntents, data.id]
+          });
+        }
+      });
+    };
+    const useConfirmCardSetupIntent = () => {
+      const client = useApiClient();
+      return reactQuery.useMutation({
+        mutationKey: [SBApiKeys.CardSetupIntents],
+        mutationFn: async (id, options, config) => {
+          return await client.cards.confirmSetupIntent(id, options, config);
+        },
+        onSuccess: (data, id) => {
+          queryClient.invalidateQueries({
+            queryKey: [SBApiKeys.CardSetupIntents, id]
+          });
+        }
+      });
+    };
+    const useCancelCardSetupIntent = () => {
+      const client = useApiClient();
+      return reactQuery.useMutation({
+        mutationKey: [SBApiKeys.CardSetupIntents],
+        mutationFn: async (id, options, config) => {
+          return await client.cards.cancelSetupIntent(id, options, config);
+        },
+        onSuccess: (data, id) => {
+          queryClient.invalidateQueries({
+            queryKey: [SBApiKeys.CardSetupIntents, id]
+          });
+        }
+      });
+    };
+    const useGetCardSetupIntentById = id => {
+      const client = useApiClient();
+      return reactQuery.useQuery({
+        queryKey: [SBApiKeys.CardSetupIntents, id],
+        queryFn: async () => {
+          return await client.cards.getSetupIntent(id);
+        }
+      });
+    };
+
+    const useGetDocuments = (request, options, config) => {
+      const client = useApiClient();
+      return reactQuery.useQuery({
+        queryKey: [SBApiKeys.Documents, request],
+        queryFn: async () => {
+          return await client.documents.list(request, options, config);
+        }
+      });
+    };
+    const useGetDocument = (id, options, config) => {
+      const client = useApiClient();
+      return reactQuery.useQuery({
+        queryKey: [SBApiKeys.Documents, id],
+        queryFn: async () => {
+          return await client.documents.getById(id, options, config);
+        }
+      });
+    };
+    const useUploadDocument = () => {
+      const client = useApiClient();
+      return reactQuery.useMutation({
+        mutationFn: async ({
+          request,
+          options,
+          config
+        }) => {
+          return await client.documents.upload(request, options, config);
+        },
+        onSuccess: data => {
+          queryClient.invalidateQueries({
+            queryKey: [SBApiKeys.Documents, data.id]
+          });
+        }
+      });
+    };
+    const useDeleteDocument = () => {
+      const client = useApiClient();
+      return reactQuery.useMutation({
+        mutationFn: async id => {
+          return await client.documents.delete(id);
+        },
+        onSuccess: (data, id) => {
+          queryClient.invalidateQueries({
+            queryKey: [SBApiKeys.Documents, id]
+          });
+        }
+      });
+    };
+
+    const useGetFriends = (request, options) => {
+      const client = useApiClient();
+      return reactQuery.useQuery({
+        queryKey: [SBApiKeys.Friends, request],
+        queryFn: async () => {
+          return await client.friends.list(request, options);
+        }
+      });
+    };
+    const useListRecommandedFriends = (request, options, config) => {
+      const client = useApiClient();
+      return reactQuery.useQuery({
+        queryKey: [SBApiKeys.Friends, request],
+        queryFn: async () => {
+          return await client.friends.listRecommanded(request, options, config);
+        }
+      });
+    };
+    const useDeleteFriend = () => {
+      const client = useApiClient();
+      return reactQuery.useMutation({
+        mutationFn: async ({
+          id,
+          options,
+          config
+        }) => {
+          return await client.friends.delete(id, options, config);
+        },
+        onSuccess: (data, id) => {
+          queryClient.invalidateQueries({
+            queryKey: [SBApiKeys.Friends, id]
+          });
+        }
+      });
+    };
+
+    const useListMerchants = (request, options, config) => {
+      const client = useApiClient();
+      return reactQuery.useInfiniteQuery({
+        initialPageParam: 1,
+        queryKey: [SBApiKeys.Merchants, request],
+        queryFn: async ({
+          pageParam = 1
+        }) => {
+          return await client.merchants.list({
+            ...request,
+            page: pageParam
+          }, options, config);
+        },
+        getNextPageParam: lastPage => {
+          if (lastPage.metadata.currentPage === lastPage.metadata.pageCount) {
+            return undefined;
+          }
+          return lastPage.metadata.currentPage + 1;
+        }
+      });
+    };
+    const useGetMerchantById = (id, options, config) => {
+      const client = useApiClient();
+      return reactQuery.useQuery({
+        queryKey: [SBApiKeys.Merchants, id],
+        queryFn: async () => await client.merchants.getById(id, options, config)
+      });
+    };
+    const useCreateMerchant = () => {
+      const client = useApiClient();
+      return reactQuery.useMutation({
+        mutationFn: async (request, options, config) => {
+          return await client.merchants.create(request, options, config);
+        },
+        onSuccess: () => {
+          queryClient.invalidateQueries({
+            queryKey: [SBApiKeys.Merchants]
+          });
+        }
+      });
+    };
+    const useDeleteMerchant = () => {
+      const client = useApiClient();
+      return reactQuery.useMutation({
+        mutationKey: [SBApiKeys.Merchants],
+        mutationFn: async (id, options, config) => {
+          return await client.merchants.delete(id, options, config);
+        },
+        onSuccess: (_, id) => {
+          queryClient.invalidateQueries({
+            queryKey: [SBApiKeys.Merchants]
+          });
+          queryClient.invalidateQueries({
+            queryKey: [SBApiKeys.Merchants, id]
+          });
+        }
+      });
+    };
+    const useUpdateMerchant = () => {
+      const client = useApiClient();
+      return reactQuery.useMutation({
+        mutationKey: [SBApiKeys.Merchants],
+        mutationFn: async ({
+          id,
+          request,
+          options,
+          config
+        }) => {
+          return await client.merchants.update(id, request, options, config);
+        },
+        onSuccess: (_, id) => {
+          queryClient.invalidateQueries({
+            queryKey: [SBApiKeys.Merchants]
+          });
+          queryClient.invalidateQueries({
+            queryKey: [SBApiKeys.Merchants, id]
+          });
+        }
+      });
+    };
+
+    const CUSTOMER_KEY = "customers";
+    const useGetCustomerById = (id, options) => {
+      const client = useApiClient();
+      return reactQuery.useQuery({
+        queryKey: [CUSTOMER_KEY, id],
+        queryFn: async () => {
+          try {
+            return await client.customers.getById(id, options);
+          } catch (exception) {
+            throw exception;
+          }
+        }
+      });
+    };
+    const useListCustomers = (request, options) => {
+      const client = useApiClient();
+      return reactQuery.useInfiniteQuery({
+        queryKey: [CUSTOMER_KEY],
+        queryFn: async () => {
+          try {
+            return await client.customers.list(request, options);
+          } catch (exception) {
+            throw exception;
+          }
+        },
+        initialPageParam: 1,
+        getNextPageParam: (lastPage, allPages, lastPageParam) => {
+          if (lastPage.metadata.currentPage === lastPage.metadata.pageCount) {
+            return undefined;
+          }
+          return lastPageParam + 1;
+        },
+        getPreviousPageParam: (firstPage, allPages, firstPageParam) => {
+          if (firstPage.metadata.currentPage <= 1) {
+            return undefined;
+          }
+          return firstPageParam - 1;
+        }
+      });
+    };
+    const useCreateCustomer = (request, options) => {
+      const client = useApiClient();
+      return reactQuery.useMutation({
+        mutationKey: [CUSTOMER_KEY],
+        mutationFn: async () => {
+          try {
+            return await client.customers.create(request, options);
+          } catch (exception) {
+            throw exception;
+          }
+        },
+        onMutate: async Customer => {
+          await queryClient.cancelQueries({
+            queryKey: [CUSTOMER_KEY]
+          });
+          const previousTodos = queryClient.getQueryData([CUSTOMER_KEY]);
+          // queryClient.setQueryData([CUSTOMER_KEY], (old) => [...old, newTodo])
+          // Return a context object with the snapshotted value
+          return {
+            previousTodos
+          };
+        },
+        onError: (err, newTodo, context) => {
+          queryClient.setQueryData([CUSTOMER_KEY], context.previousTodos);
+        },
+        onSettled: () => {
+          queryClient.invalidateQueries({
+            queryKey: [CUSTOMER_KEY]
+          });
+        }
+      });
+    };
+    const useDeleteCustomer = (id, options) => {
+      const client = useApiClient();
+      return reactQuery.useMutation({
+        mutationKey: [CUSTOMER_KEY, id],
+        mutationFn: async () => {
+          try {
+            return await client.customers.delete(id, options);
+          } catch (exception) {
+            throw exception;
+          }
+        },
+        onMutate: async Customer => {
+          await queryClient.cancelQueries({
+            queryKey: [CUSTOMER_KEY]
+          });
+          const previousTodos = queryClient.getQueryData([CUSTOMER_KEY]);
+          // queryClient.setQueryData([CUSTOMER_KEY], (old) => [...old, newTodo])
+          // Return a context object with the snapshotted value
+          return {
+            previousTodos
+          };
+        },
+        onError: (err, newTodo, context) => {
+          queryClient.setQueryData([CUSTOMER_KEY], context.previousTodos);
+        },
+        onSettled: () => {
+          queryClient.invalidateQueries({
+            queryKey: [CUSTOMER_KEY]
+          });
+        }
+      });
+    };
+
+    const useGetDomains = (request, options, config) => {
+      const client = useApiClient();
+      return reactQuery.useInfiniteQuery({
+        initialPageParam: 1,
+        queryKey: [SBApiKeys.Domains, request],
+        queryFn: async ({
+          pageParam = 1
+        }) => {
+          return await client.domains.list({
+            ...request,
+            page: pageParam
+          }, options, config);
+        },
+        getNextPageParam: lastPage => {
+          if (lastPage.metadata.currentPage === lastPage.metadata.pageCount) {
+            return undefined;
+          }
+          return lastPage.metadata.currentPage + 1;
+        }
+      });
+    };
+    const useGetDomainById = (id, options, config) => {
+      const client = useApiClient();
+      return reactQuery.useQuery({
+        queryKey: [SBApiKeys.Domains, id],
+        queryFn: async () => await client.domains.getById(id, options, config)
+      });
+    };
+    const useCreateDomain = () => {
+      const client = useApiClient();
+      return reactQuery.useMutation({
+        mutationFn: async (request, options, config) => {
+          return await client.domains.create(request, options, config);
+        },
+        onSuccess: () => {
+          queryClient.invalidateQueries({
+            queryKey: [SBApiKeys.Domains]
+          });
+        }
+      });
+    };
+    const useDeleteDomain = () => {
+      const client = useApiClient();
+      return reactQuery.useMutation({
+        mutationKey: [SBApiKeys.Domains],
+        mutationFn: async (id, options, config) => {
+          return await client.domains.delete(id, options, config);
+        },
+        onSuccess: (_, id) => {
+          queryClient.invalidateQueries({
+            queryKey: [SBApiKeys.Domains]
+          });
+          queryClient.invalidateQueries({
+            queryKey: [SBApiKeys.Domains, id]
+          });
+        }
+      });
+    };
+
+    const useGetLocations = (request, options, config) => {
+      const client = useApiClient();
+      return reactQuery.useInfiniteQuery({
+        initialPageParam: 1,
+        queryKey: [SBApiKeys.Locations, request],
+        queryFn: async ({
+          pageParam = 1
+        }) => {
+          return await client.locations.list({
+            ...request,
+            page: pageParam
+          }, options, config);
+        },
+        getNextPageParam: lastPage => {
+          if (lastPage.metadata.currentPage === lastPage.metadata.pageCount) {
+            return undefined;
+          }
+          return lastPage.metadata.currentPage + 1;
+        }
+      });
+    };
+    const useGetLocationById = (id, options, config) => {
+      const client = useApiClient();
+      return reactQuery.useQuery({
+        queryKey: [SBApiKeys.Locations, id],
+        queryFn: async () => await client.locations.getById(id, options, config)
+      });
+    };
+    const useCreateLocation = () => {
+      const client = useApiClient();
+      return reactQuery.useMutation({
+        mutationFn: async (request, options, config) => {
+          return await client.locations.create(request, options, config);
+        },
+        onSuccess: () => {
+          queryClient.invalidateQueries({
+            queryKey: [SBApiKeys.Locations]
+          });
+        }
+      });
+    };
+    const useDeleteLocation = () => {
+      const client = useApiClient();
+      return reactQuery.useMutation({
+        mutationKey: [SBApiKeys.Locations],
+        mutationFn: async (id, options, config) => {
+          return await client.locations.delete(id, options, config);
+        },
+        onSuccess: (_, id) => {
+          queryClient.invalidateQueries({
+            queryKey: [SBApiKeys.Locations]
+          });
+          queryClient.invalidateQueries({
+            queryKey: [SBApiKeys.Locations, id]
+          });
+        }
+      });
+    };
+    const useUpdateLocation = () => {
+      const client = useApiClient();
+      return reactQuery.useMutation({
+        mutationKey: [SBApiKeys.Locations],
+        mutationFn: async ({
+          id,
+          request,
+          options,
+          config
+        }) => {
+          return await client.locations.update(id, request, options, config);
+        },
+        onSuccess: (_, id) => {
+          queryClient.invalidateQueries({
+            queryKey: [SBApiKeys.Locations]
+          });
+          queryClient.invalidateQueries({
+            queryKey: [SBApiKeys.Locations, id]
+          });
+        }
+      });
+    };
+
+    const useGetToken = () => {
+      const client = useApiClient();
+      return reactQuery.useMutation({
+        mutationFn: async request => {
+          try {
+            return await client.oauth.getToken(request);
+          } catch (error) {
+            throw error;
+          }
+        }
+      });
+    };
+    const useGetAuthorizationCode = () => {
+      const client = useApiClient();
+      return reactQuery.useMutation({
+        mutationFn: async request => {
+          try {
+            return await client.oauth.getAuthorizationCode(request);
+          } catch (error) {
+            throw error;
+          }
+        }
       });
     };
-    const useGetBankAccountForBank = (id, accountId) => {
+    const useRefreshToken = () => {
       const client = useApiClient();
-      return reactQuery.useQuery({
-        queryKey: [BANK_ACCOUNTS_KEY, id, accountId],
-        queryFn: async () => await client.banks.getBankAccount(id, accountId)
+      return reactQuery.useMutation({
+        mutationFn: async request => {
+          try {
+            return await client.oauth.refreshToken(request);
+          } catch (error) {
+            throw error;
+          }
+        }
       });
     };
-    const useGetBankAccountTransactions = (id, accountId, request) => {
+
+    const useListOrganizations = (request, options, config) => {
       const client = useApiClient();
       return reactQuery.useInfiniteQuery({
-        initialPageParam: request.page,
-        queryKey: [BANK_TRANSACTIONS_KEY, id, accountId],
+        initialPageParam: 1,
+        queryKey: [SBApiKeys.Organizations, request],
         queryFn: async ({
           pageParam = 1
         }) => {
-          return await client.banks.getBankAccountTransactions(id, accountId, {
+          return client.organizations.list({
             ...request,
             page: pageParam
-          });
+          }, options, config);
+        },
+        getPreviousPageParam: firstPage => {
+          if (firstPage.metadata.currentPage === 1) {
+            return undefined;
+          }
+          return firstPage.metadata.currentPage - 1;
         },
         getNextPageParam: lastPage => {
           if (lastPage.metadata.currentPage === lastPage.metadata.pageCount) {
@@ -85,99 +952,232 @@
         }
       });
     };
-    const useGetBankLinkToken = () => {
+    const useGetOrganizationById = id => {
       const client = useApiClient();
       return reactQuery.useQuery({
-        queryKey: ["bankLinkToken"],
-        queryFn: async () => await client.banks.getBankLinkToken()
+        queryKey: ["organization", id],
+        queryFn: async () => await client.organizations.getById(id)
       });
     };
-    const useGetBankLink = () => {
+    const useCreateOrganization = () => {
+      const client = useApiClient();
+      return reactQuery.useMutation({
+        mutationFn: async request => {
+          return client.organizations.create(request);
+        },
+        onSuccess: () => {
+          queryClient.invalidateQueries({
+            queryKey: [SBApiKeys.Organizations]
+          });
+        }
+      });
+    };
+    const useUpdateOrganization = () => {
+      const client = useApiClient();
+      return reactQuery.useMutation({
+        mutationFn: async ({
+          id,
+          request
+        }) => {
+          return client.organizations.update(id, request);
+        },
+        onSuccess: (_, {
+          id
+        }) => {
+          queryClient.invalidateQueries({
+            queryKey: ["organization", id]
+          });
+          queryClient.invalidateQueries({
+            queryKey: [SBApiKeys.Organizations]
+          });
+        }
+      });
+    };
+    const useDeleteOrganization = () => {
+      const client = useApiClient();
+      return reactQuery.useMutation({
+        mutationFn: async id => {
+          return client.organizations.delete(id);
+        },
+        onSuccess: (_, id) => {
+          queryClient.invalidateQueries({
+            queryKey: [SBApiKeys.Organizations]
+          });
+          queryClient.invalidateQueries({
+            queryKey: ["organization", id]
+          });
+        }
+      });
+    };
+    const useListOrganizationMembers = (organizationId, request) => {
       const client = useApiClient();
       return reactQuery.useQuery({
-        queryKey: ["bankLink"],
-        queryFn: async () => await client.banks.getBankLink()
+        queryKey: ["organizationMembers", organizationId, request],
+        queryFn: async () => {
+          return client.organizations.listMembers(organizationId, request);
+        }
       });
     };
-    const useListBanks = request => {
+    const useGetOrganizationMemberById = (organizationId, id) => {
       const client = useApiClient();
       return reactQuery.useQuery({
-        queryKey: [BANKS_KEY, request],
-        queryFn: async () => await client.banks.list(request)
+        queryKey: ["organizationMember", organizationId, id],
+        queryFn: async () => await client.organizations.getMemberById(organizationId, id)
       });
     };
-    const useCreateBank = () => {
+    const useDeleteOrganizationMember = () => {
       const client = useApiClient();
       return reactQuery.useMutation({
-        mutationFn: async request => await client.banks.create(request),
-        onSuccess: () => {
+        mutationFn: async ({
+          organizationId,
+          id
+        }) => {
+          return client.organizations.deleteMember(organizationId, id);
+        },
+        onSuccess: (_, {
+          organizationId,
+          id
+        }) => {
           queryClient.invalidateQueries({
-            queryKey: [BANKS_KEY]
+            queryKey: ["organizationMembers", organizationId]
+          });
+          queryClient.invalidateQueries({
+            queryKey: ["organizationMember", organizationId, id]
           });
         }
       });
     };
-    const useDeleteBank = id => {
+
+    const useCreatePaymentMethod = () => {
       const client = useApiClient();
       return reactQuery.useMutation({
-        mutationFn: async () => await client.banks.delete(id),
-        onMutate: async () => {
-          await queryClient.cancelQueries({
-            queryKey: [BANKS_KEY]
-          });
-          const previousBanks = queryClient.getQueryData([BANKS_KEY]);
-          queryClient.setQueryData([BANKS_KEY], old => ({
-            ...old,
-            data: old.data.filter(bank => bank.id !== id)
-          }));
-          return {
-            previousBanks
-          };
+        mutationFn: async (request, options, config) => {
+          return await client.paymentMethods.create(request, options, config);
         },
-        onError: (err, _, context) => {
-          queryClient.setQueryData([BANKS_KEY], context?.previousBanks);
+        onSuccess: () => {
+          queryClient.invalidateQueries({
+            queryKey: [SBApiKeys.PaymentMethods]
+          });
+        }
+      });
+    };
+    const useGetPaymentMethods = (request, options, config) => {
+      const client = useApiClient();
+      return reactQuery.useQuery({
+        queryKey: [SBApiKeys.PaymentMethods],
+        queryFn: async () => {
+          return await client.paymentMethods.get(request, options, config);
+        }
+      });
+    };
+    const useGetPaymentMethodById = (id, options, config) => {
+      const client = useApiClient();
+      return reactQuery.useQuery({
+        queryKey: [SBApiKeys.PaymentMethods, id],
+        queryFn: async () => {
+          return await client.paymentMethods.getById(id, options, config);
+        }
+      });
+    };
+    const useDeletePaymentMethod = () => {
+      const client = useApiClient();
+      return reactQuery.useMutation({
+        mutationFn: async (id, options, config) => {
+          return await client.paymentMethods.delete(id, options, config);
         },
-        onSettled: () => {
+        onSuccess: (data, id) => {
           queryClient.invalidateQueries({
-            queryKey: [BANKS_KEY]
+            queryKey: [SBApiKeys.PaymentMethods, id]
           });
         }
       });
     };
-
-    const useGetToken = () => {
+    const useSetupPaymentMethod = () => {
       const client = useApiClient();
       return reactQuery.useMutation({
-        mutationFn: async request => {
-          try {
-            return await client.oauth.getToken(request);
-          } catch (error) {
-            throw error;
+        mutationFn: async (_, options, config) => {
+          return await client.paymentMethods.setup(options, config);
+        }
+      });
+    };
+
+    const useGetPromoCodes = (request, options, config) => {
+      const client = useApiClient();
+      return reactQuery.useInfiniteQuery({
+        initialPageParam: 1,
+        queryKey: [SBApiKeys.PromoCodes, request],
+        queryFn: async ({
+          pageParam = 1
+        }) => {
+          return await client.promoCodes.list({
+            ...request,
+            page: pageParam
+          }, options, config);
+        },
+        getNextPageParam: lastPage => {
+          if (lastPage.metadata.currentPage === lastPage.metadata.pageCount) {
+            return undefined;
           }
+          return lastPage.metadata.currentPage + 1;
         }
       });
     };
-    const useGetAuthorizationCode = () => {
+    const useGetPromoCodeById = (id, options, config) => {
+      const client = useApiClient();
+      return reactQuery.useQuery({
+        queryKey: [SBApiKeys.PromoCodes, id],
+        queryFn: async () => await client.promoCodes.getById(id, options, config)
+      });
+    };
+    const useCreatePromoCode = () => {
       const client = useApiClient();
       return reactQuery.useMutation({
-        mutationFn: async request => {
-          try {
-            return await client.oauth.getAuthorizationCode(request);
-          } catch (error) {
-            throw error;
-          }
+        mutationFn: async (request, options, config) => {
+          return await client.promoCodes.create(request, options, config);
+        },
+        onSuccess: () => {
+          queryClient.invalidateQueries({
+            queryKey: [SBApiKeys.PromoCodes]
+          });
         }
       });
     };
-    const useRefreshToken = () => {
+    const useDeletePromoCode = () => {
       const client = useApiClient();
       return reactQuery.useMutation({
-        mutationFn: async request => {
-          try {
-            return await client.oauth.refreshToken(request);
-          } catch (error) {
-            throw error;
-          }
+        mutationKey: [SBApiKeys.PromoCodes],
+        mutationFn: async (id, options, config) => {
+          return await client.promoCodes.delete(id, options, config);
+        },
+        onSuccess: (_, id) => {
+          queryClient.invalidateQueries({
+            queryKey: [SBApiKeys.PromoCodes]
+          });
+          queryClient.invalidateQueries({
+            queryKey: [SBApiKeys.PromoCodes, id]
+          });
+        }
+      });
+    };
+    const useUpdatePromoCode = () => {
+      const client = useApiClient();
+      return reactQuery.useMutation({
+        mutationKey: [SBApiKeys.PromoCodes],
+        mutationFn: async ({
+          id,
+          request,
+          options,
+          config
+        }) => {
+          return await client.promoCodes.update(id, request, options, config);
+        },
+        onSuccess: (_, id) => {
+          queryClient.invalidateQueries({
+            queryKey: [SBApiKeys.PromoCodes]
+          });
+          queryClient.invalidateQueries({
+            queryKey: [SBApiKeys.PromoCodes, id]
+          });
         }
       });
     };
@@ -196,13 +1196,13 @@
         }
       });
     };
-    const useGetReceipts = (request, options) => {
+    const useListReceipts = (request, options) => {
       const client = useApiClient();
       return reactQuery.useInfiniteQuery({
         queryKey: [RECEIPTS_KEY],
         queryFn: async () => {
           try {
-            return await client.receipts.get(request, options);
+            return await client.receipts.list(request, options);
           } catch (exception) {
             throw exception;
           }
@@ -215,7 +1215,7 @@
           return lastPageParam + 1;
         },
         getPreviousPageParam: (firstPage, allPages, firstPageParam) => {
-          if (firstPage.metadata.currentPage <= 1) {
+          if (firstPage.metadata.currentPage == 1) {
             return undefined;
           }
           return firstPageParam - 1;
@@ -265,7 +1265,7 @@
           pageParam = 1
         }) => {
           try {
-            return await client.reviews.get({
+            return await client.reviews.list({
               ...request,
               page: pageParam
             });
@@ -361,37 +1361,204 @@
       });
     };
 
+    const useListTaxes = (request, options, config) => {
+      const client = useApiClient();
+      return reactQuery.useQuery({
+        queryKey: [SBApiKeys.Taxes],
+        queryFn: async () => {
+          return await client.taxes.list(request, options, config);
+        }
+      });
+    };
+    const useGetTaxById = (id, options, config) => {
+      const client = useApiClient();
+      return reactQuery.useQuery({
+        queryKey: [SBApiKeys.Taxes, id],
+        queryFn: async () => {
+          return await client.taxes.getById(id, options, config);
+        }
+      });
+    };
+    const useCreateTax = () => {
+      const client = useApiClient();
+      return reactQuery.useMutation({
+        mutationFn: async ({
+          request,
+          options,
+          config
+        }) => {
+          return await client.taxes.create(request, options, config);
+        },
+        onSuccess: data => {
+          queryClient.invalidateQueries({
+            queryKey: [SBApiKeys.Taxes, data.id]
+          });
+        }
+      });
+    };
+    const useDeleteTaxes = () => {
+      const client = useApiClient();
+      return reactQuery.useMutation({
+        mutationFn: async ({
+          id,
+          options,
+          config
+        }) => {
+          return await client.taxes.delete(id, options, config);
+        },
+        onSuccess: (_, request) => {
+          queryClient.invalidateQueries({
+            queryKey: [(SBApiKeys.Taxes, request.id)]
+          });
+        }
+      });
+    };
+    const useUpdateTaxes = () => {
+      const client = useApiClient();
+      return reactQuery.useMutation({
+        mutationFn: async ({
+          id,
+          request,
+          options,
+          config
+        }) => {
+          return await client.taxes.update(id, request, options, config);
+        },
+        onSuccess: (_, {
+          id
+        }) => {
+          queryClient.invalidateQueries({
+            queryKey: [SBApiKeys.Taxes, id]
+          });
+        }
+      });
+    };
+
+    const useGetCurrentUser = (options, config) => {
+      const smartbillsClient = useApiClient();
+      return reactQuery.useQuery({
+        queryKey: [SBApiKeys.User],
+        queryFn: async () => await smartbillsClient.user.get(options, config)
+      });
+    };
+
+    const useSearchUsers = (request, options, config) => {
+      const client = useApiClient();
+      return reactQuery.useInfiniteQuery({
+        initialPageParam: 1,
+        queryKey: [SBApiKeys.Users, request],
+        queryFn: async ({
+          pageParam = 1
+        }) => {
+          return await client.users.list({
+            ...request,
+            page: pageParam
+          }, options, config);
+        },
+        getNextPageParam: lastPage => {
+          if (lastPage.metadata.currentPage === lastPage.metadata.pageCount) {
+            return undefined;
+          }
+          return lastPage.metadata.currentPage + 1;
+        }
+      });
+    };
+
     exports.ApiClientProvider = ApiClientProvider;
     exports.BANKS_KEY = BANKS_KEY;
     exports.BANK_ACCOUNTS_KEY = BANK_ACCOUNTS_KEY;
     exports.BANK_TRANSACTIONS_KEY = BANK_TRANSACTIONS_KEY;
-    exports.LOGS_KEY = LOGS_KEY;
+    exports.CUSTOMER_KEY = CUSTOMER_KEY;
     exports.RECEIPTS_KEY = RECEIPTS_KEY;
     exports.REVIEWS_KEY = REVIEWS_KEY;
     exports.SmartbillsSDKProvider = SmartbillsSDKProvider;
     exports.queryClient = queryClient;
     exports.useApiClient = useApiClient;
+    exports.useAttachCard = useAttachCard;
+    exports.useCancelCardSetupIntent = useCancelCardSetupIntent;
+    exports.useConfirmCardSetupIntent = useConfirmCardSetupIntent;
     exports.useCreateBank = useCreateBank;
+    exports.useCreateCard = useCreateCard;
+    exports.useCreateCardSetupIntent = useCreateCardSetupIntent;
+    exports.useCreateCustomer = useCreateCustomer;
+    exports.useCreateDomain = useCreateDomain;
+    exports.useCreateLocation = useCreateLocation;
+    exports.useCreateMerchant = useCreateMerchant;
+    exports.useCreateOrganization = useCreateOrganization;
+    exports.useCreatePaymentMethod = useCreatePaymentMethod;
+    exports.useCreatePromoCode = useCreatePromoCode;
     exports.useCreateReview = useCreateReview;
+    exports.useCreateTax = useCreateTax;
     exports.useDeleteBank = useDeleteBank;
+    exports.useDeleteCustomer = useDeleteCustomer;
+    exports.useDeleteDocument = useDeleteDocument;
+    exports.useDeleteDomain = useDeleteDomain;
+    exports.useDeleteFriend = useDeleteFriend;
+    exports.useDeleteLocation = useDeleteLocation;
+    exports.useDeleteMerchant = useDeleteMerchant;
+    exports.useDeleteOrganization = useDeleteOrganization;
+    exports.useDeleteOrganizationMember = useDeleteOrganizationMember;
+    exports.useDeletePaymentMethod = useDeletePaymentMethod;
+    exports.useDeletePromoCode = useDeletePromoCode;
     exports.useDeleteReceipt = useDeleteReceipt;
     exports.useDeleteReview = useDeleteReview;
+    exports.useDeleteTaxes = useDeleteTaxes;
+    exports.useDetachCard = useDetachCard;
     exports.useGetAuthorizationCode = useGetAuthorizationCode;
+    exports.useGetBankAccountById = useGetBankAccountById;
     exports.useGetBankAccountForBank = useGetBankAccountForBank;
     exports.useGetBankAccountTransactions = useGetBankAccountTransactions;
+    exports.useGetBankAccounts = useGetBankAccounts;
     exports.useGetBankById = useGetBankById;
     exports.useGetBankLink = useGetBankLink;
     exports.useGetBankLinkToken = useGetBankLinkToken;
+    exports.useGetBankTransaction = useGetBankTransaction;
+    exports.useGetBankTransactions = useGetBankTransactions;
+    exports.useGetBanks = useGetBanks;
+    exports.useGetCardById = useGetCardById;
+    exports.useGetCardSetupIntentById = useGetCardSetupIntentById;
+    exports.useGetCards = useGetCards;
+    exports.useGetCurrentUser = useGetCurrentUser;
+    exports.useGetCustomerById = useGetCustomerById;
+    exports.useGetDocument = useGetDocument;
+    exports.useGetDocuments = useGetDocuments;
+    exports.useGetDomainById = useGetDomainById;
+    exports.useGetDomains = useGetDomains;
+    exports.useGetFriends = useGetFriends;
+    exports.useGetLocationById = useGetLocationById;
+    exports.useGetLocations = useGetLocations;
     exports.useGetLogById = useGetLogById;
+    exports.useGetMerchantById = useGetMerchantById;
+    exports.useGetOrganizationById = useGetOrganizationById;
+    exports.useGetOrganizationMemberById = useGetOrganizationMemberById;
+    exports.useGetPaymentMethodById = useGetPaymentMethodById;
+    exports.useGetPaymentMethods = useGetPaymentMethods;
+    exports.useGetPromoCodeById = useGetPromoCodeById;
+    exports.useGetPromoCodes = useGetPromoCodes;
     exports.useGetReceiptById = useGetReceiptById;
-    exports.useGetReceipts = useGetReceipts;
     exports.useGetReviewById = useGetReviewById;
     exports.useGetReviews = useGetReviews;
+    exports.useGetTaxById = useGetTaxById;
     exports.useGetToken = useGetToken;
-    exports.useListBanks = useListBanks;
+    exports.useListBankAccountTransanctions = useListBankAccountTransanctions;
+    exports.useListCustomers = useListCustomers;
     exports.useListLogs = useListLogs;
+    exports.useListMerchants = useListMerchants;
+    exports.useListOrganizationMembers = useListOrganizationMembers;
+    exports.useListOrganizations = useListOrganizations;
+    exports.useListReceipts = useListReceipts;
+    exports.useListRecommandedFriends = useListRecommandedFriends;
+    exports.useListTaxes = useListTaxes;
     exports.useRefreshToken = useRefreshToken;
+    exports.useSearchUsers = useSearchUsers;
+    exports.useSetupPaymentMethod = useSetupPaymentMethod;
+    exports.useUpdateLocation = useUpdateLocation;
+    exports.useUpdateMerchant = useUpdateMerchant;
+    exports.useUpdateOrganization = useUpdateOrganization;
+    exports.useUpdatePromoCode = useUpdatePromoCode;
     exports.useUpdateReview = useUpdateReview;
+    exports.useUpdateTaxes = useUpdateTaxes;
+    exports.useUploadDocument = useUploadDocument;
 
 }));
 //# sourceMappingURL=index.js.map