Method Detail

• setApis

   void setApis(Map<Service, out Object> clients)

• getMerchant

   Result<MenigaMerchant> getMerchant(GetMerchant req)

• getMerchants

   Result<List<MenigaMerchant>> getMerchants(GetMerchants req)

• getTopMerchants

   Result<List<MenigaTopMerchant>> getTopMerchants(GetTopMerchants req)

• getAccounts

   Result<List<Account>> getAccounts(GetAccounts req)

• getAccount

   Result<Account> getAccount(GetAccount req)

• getAccountTypes

   Result<List<AccountType>> getAccountTypes(GetAccountTypes req)

• getAccountAuthorizationTypes

   Result<List<AccountAuthorizationType>> getAccountAuthorizationTypes(GetAuthorizationTypes req)

• getAccountCategories

   Result<List<AccountTypeCategory>> getAccountCategories()

• getAccountMetadata

   Result<List<AccountMetaData>> getAccountMetadata(GetAccountMetadata req)

• updateAccountMetadata

   Result<AccountMetaData> updateAccountMetadata(long accountId, UpdateAccountMetadata req)

• getAccountMetadataKeyVal

   Result<AccountMetaData> getAccountMetadataKeyVal(GetAccountMetadataKeyVal req)

• getAccountBalanceHistory

   Result<List<AccountBalanceHistory>> getAccountBalanceHistory(GetAccountBalanceHistory req)

• updateAccount

   Result<Void> updateAccount(UpdateAccount req)

• deleteAccount

   Result<Void> deleteAccount(DeleteAccount req)

• getTags

   Result<List<MenigaTag>> getTags()

• getTag

   Result<MenigaTag> getTag(GetTag req)

• getTransactions

   Result<MenigaTransactionPage> getTransactions(GetTransactions req)

• createTransaction

   Result<MenigaTransaction> createTransaction(CreateTransaction req)

• getTransaction

   Result<MenigaTransaction> getTransaction(GetTransaction req)

• updateTransaction

   Result<MenigaTransactionUpdate> updateTransaction(UpdateTransaction req)

• updateTransactions

   Result<MenigaTransactionUpdate> updateTransactions(UpdateTransactions req)

• startSync

   Result<MenigaSync> startSync(StartSync req)

• startRealmSync

   Result<MenigaSync> startRealmSync(StartRealmSync req)

• getSyncStatus

   Result<MenigaSyncStatus> getSyncStatus()

• performBankAuthenticationStep

   Result<MenigaRealmAuthResponse> performBankAuthenticationStep(GetRealmAuthMethod req)

• getRealmAccounts

   Result<List<MenigaRealmAccount>> getRealmAccounts(GetRealmAccounts req)

• addRealmAccountsToMeniga

   Result<List<MenigaRealmAccount>> addRealmAccountsToMeniga(AddRealmAccountsToMeniga req)

• getUserEvents

   Result<List<MenigaUserEvent>> getUserEvents()

• setSubscription

   Result<Void> setSubscription(SetSubscription req)

• updateSettings

   Result<Void> updateSettings(SetSubscriptionSettings req)

• getSync

   Result<MenigaSync> getSync(GetSync req)

• fetchSplitTransactions

   Result<List<MenigaTransaction>> fetchSplitTransactions(GetSplitTransactions req)

• splitTransaction

   Result<List<MenigaTransaction>> splitTransaction(SplitTransaction req)

• updateSplits

   Result<List<MenigaTransaction>> updateSplits(long id, List<UpdateSplits> req)

• deleteTransaction

   Result<Void> deleteTransaction(DeleteTransaction req)

• deleteTransactions

   Result<Void> deleteTransactions(DeleteTransactions req)

• getTransactionSeries

   Result<List<MenigaTransactionSeries>> getTransactionSeries(GetTransactionSeries req)

• createComment

   Result<MenigaComment> createComment(CreateComment req)

• updateComment

   Result<Void> updateComment(UpdateComment req)

• deleteComment

   Result<Void> deleteComment(DeleteComment req)

• addComments

   Result<List<MenigaComment>> addComments(AddComments req)

• recategorizeTransactions

   Result<Void> recategorizeTransactions(RecategorizeTransactions req)

• getTransactionRules

   Result<List<MenigaTransactionRule>> getTransactionRules(GetTransactionRules req)

• createTransactionRule

   Result<MenigaTransactionRule> createTransactionRule(CreateTransactionRule req)

• deleteTransactionRule

   Result<Void> deleteTransactionRule(DeleteTransactionRule req)

• getTransactionRule

   Result<MenigaTransactionRule> getTransactionRule(GetTransactionRule req)

• updateTransactionRule

   Result<Void> updateTransactionRule(UpdateTransactionRule req)

• getFeed

   Result<MenigaFeed> getFeed(GetFeed req)

• getScheduledEvent

   Result<MenigaScheduledEvent> getScheduledEvent(GetScheduledEvent req)

• getEvent

   Result<MenigaFeedItem> getEvent(GetEvent req)

• getCategories

   Result<List<MenigaCategory>> getCategories(GetCategories req)

• getCategoryById

   Result<MenigaCategory> getCategoryById(GetCategoryById req)

• createUserCategory

   Result<MenigaUserCategory> createUserCategory(CreateUserCategory req)

• deleteCategory

   Result<Void> deleteCategory(DeleteUserCategory req)

• updateUserCategory

   Result<Void> updateUserCategory(UpdateUserCategory req)

• getUserProfile

   Result<MenigaUserProfile> getUserProfile()

• getUsers

   Result<List<MenigaUser>> getUsers(GetUsers req)

• setCulture

   Result<Void> setCulture(SetCulture req)

• registerUser

   Result<MenigaUser> registerUser(RegisterUser req)

• forgotPassword

   Result<Void> forgotPassword(ForgotPassword req)

• getUserMetaData

   Result<List<MenigaUserMetaData>> getUserMetaData(GetUserMetaData req)

• saveUserMetaData

   Result<MenigaUserMetaData> saveUserMetaData(SaveMetaData req)

• resetPassword

   Result<Void> resetPassword(ResetPasswordWithToken req)

• updateEmail

   Result<Void> updateEmail(UpdateEmail req)

• changePassword

   Result<Void> changePassword(ChangePassword req)

• deleteUser

   Result<Void> deleteUser()

• getOffers

   Result<MenigaOfferPage> getOffers(GetOffers req)

• getOfferByToken

   Result<MenigaOffer> getOfferByToken(GetOfferByToken req)

• getOfferById

   Result<MenigaOffer> getOfferById(GetOfferById req)

• getRedemptions

   Result<MenigaRedemptions> getRedemptions(GetRedemptions req)

• activateOfferById

   Result<Void> activateOfferById(ActivateOfferById req)

• activateOfferByToken

   Result<Void> activateOfferByToken(ActivateOfferByToken req)

• declineOffer

   Result<Void> declineOffer(DeclineOffer req)

• acceptTermsAndConditions

   Result<Void> acceptTermsAndConditions(AcceptOffersTermsAndConditions req)

• enableOffers

   Result<Void> enableOffers(EnableOffers req)

• disableOffers

   Result<Void> disableOffers(DisableOffers req)

• markOfferAsSeen

   Result<Void> markOfferAsSeen(MarkOfferAsSeen req)

• getSimilarBrandSpendingDetails

   Result<MenigaSimilarBrandSpendingDetails> getSimilarBrandSpendingDetails(GetSimilarBrandSpendingDetails req)

• getRedemptionsByOfferId

   Result<MenigaRedemptions> getRedemptionsByOfferId(GetRedemptionsByOfferId req)

• getMerchantLocationsByOfferId

   Result<MenigaOfferMerchantLocationPage> getMerchantLocationsByOfferId(GetMerchantLocationsByOfferId req)

• addReimbursementAccount

   Result<MenigaReimbursementAccount> addReimbursementAccount(CreateReimbursementAccount req)

• getReimbursementAccounts

   Result<MenigaReimbursementAccountPage> getReimbursementAccounts(GetReimbursementAccounts req)

• getReimbursementAccountTypes

   Result<MenigaReimbursementAccountTypePage> getReimbursementAccountTypes(GetReimbursementAccountTypes req)

• getReimbursementAccountById

   Result<MenigaReimbursementAccount> getReimbursementAccountById(GetReimbursementAccountById req)

• getNetWorth

   Result<List<MenigaNetWorth>> getNetWorth(GetNetWorths req)

• getNetWorth

   Result<MenigaNetWorth> getNetWorth(GetNetWorth req)

• updateBalance

   Result<Void> updateBalance(UpdateHistoryBalance req)

• deleteBalance

   Result<Void> deleteBalance(DeleteNetWorthBalance req)

• getNetWorthFirstBalanceEntry

   Result<MenigaNetWorthBalance> getNetWorthFirstBalanceEntry(GetNetWorthFirstBalanceEntry req)

• createNetWorthAccount

   Result<MenigaNetWorth> createNetWorthAccount(CreateNetWorthAccount req)

• deleteNetWorthAccount

   Result<Void> deleteNetWorthAccount(DeleteNetWorthAccount req)

• updateNetWorthAccount

   Result<Void> updateNetWorthAccount(UpdatedNetWorthAccount req)

• createNetWorthBalanceHistory

   Result<MenigaNetWorthBalance> createNetWorthBalanceHistory(CreateNetWorthBalanceHistory req)

• getNetWorthTypes

   Result<List<KeyVal<Long, String>>> getNetWorthTypes(GetNetWorthTypes req)

• getUpcoming

   Result<List<MenigaUpcoming>> getUpcoming(GetUpcoming req)

• getUpcoming

   Result<MenigaUpcoming> getUpcoming(GetUpcomingById req)

• createUpcoming

   Result<List<MenigaUpcoming>> createUpcoming(CreateUpcoming req)

• updateUpcoming

   Result<Void> updateUpcoming(UpdateUpcoming req)

• deleteUpcoming

   Result<Void> deleteUpcoming(DeleteUpcoming req)

• deleteUpcomingSeries

   Result<Void> deleteUpcomingSeries(DeleteUpcomingSeries req)

• reconcileUpcoming

   Result<Void> reconcileUpcoming(ReconcileUpcoming req)

• getChallenges

   Result<List<MenigaChallenge>> getChallenges(GetChallenges req)

• getChallenge

   Result<MenigaChallenge> getChallenge(GetChallenge req)

• acceptChallenge

   Result<MenigaChallenge> acceptChallenge(AcceptChallenge req)

• disableChallenge

   Result<Void> disableChallenge(UUID id)

• enableChallenge

   Result<Void> enableChallenge(UUID id)

• deleteChallenge

   Result<Void> deleteChallenge(DeleteChallenge req)

• createChallenge

   Result<MenigaChallenge> createChallenge(CreateChallenge req)

• updateChallenge

   Result<Void> updateChallenge(UpdateChallenge req)

• getChallengeHistory

   Result<List<MenigaChallenge>> getChallengeHistory(GetChallengeHistory req)

• getBudgets

   Result<List<MenigaBudget>> getBudgets(GetBudgets req)

• getBudget

   Result<MenigaBudget> getBudget(GetBudget parameters)

• getBudgetEntries

   Result<List<MenigaBudgetEntry>> getBudgetEntries(GetBudgetEntries req)

• createBudgetEntries

   Result<List<MenigaBudgetEntry>> createBudgetEntries(long budgetId, CreateBudgetEntries parameters)

• deleteBudgetEntry

   Result<Void> deleteBudgetEntry(long budgetId, long entryId)

• getBudgetEntry

   Result<MenigaBudgetEntry> getBudgetEntry(GetBudgetEntryById request)

• updateBudgetEntry

   Result<MenigaBudgetEntry> updateBudgetEntry(long budgetId, long entryId, UpdateBudgetEntry updateBudgetEntry)

• createBudget

   Result<MenigaBudget> createBudget(CreateBudget req)

• updateBudget

   Result<MenigaBudget> updateBudget(long budgetId, UpdateBudget parameters)

• getBudgetRules

   Result<List<MenigaBudgetRule>> getBudgetRules(GetBudgetRules filter)

• createBudgetRules

   Result<List<MenigaBudgetRule>> createBudgetRules(long budgetId, CreateBudgetRules req)

• deleteBudgetRule

   Result<Void> deleteBudgetRule(long budgetId, long ruleId)

• deleteBudget

   Result<Void> deleteBudget(long budgetId)

• resetBudget

   Result<Void> resetBudget(long budgetId)

• getOrganizations

   Result<List<MenigaOrganization>> getOrganizations()

• getTerms

   Result<List<MenigaTerms>> getTerms(GetTerms req)

• getTerm

   Result<MenigaTerms> getTerm(GetTerm req)

• getTermTypes

   Result<List<MenigaTermType>> getTermTypes(GetTermTypes req)

• acceptTerms

   Result<Void> acceptTerms(AcceptTerms req)

• declineTerms

   Result<Void> declineTerms(DeclineTerms req)

• trackEvent

   Result<Void> trackEvent(TrackEvent req)

• genericRequest

   Result<Object> genericRequest(HttpMethod method, String path, Map<String, String> headers, Object body, Map<String, String> query)

• getPublicSettings

   Result<MenigaPublicSettings> getPublicSettings(GetPublicSettings req)

• getApis

   Map<Service, out Object> getApis()

• setProvider

   void setProvider(PersistenceProvider provider)