Antaca SDK

fun init(configuration: Configuration) {
    AntacaStdApi.init(configuration)
}

fun init(configuration: Configuration) {
    AntacaCoroutineApi.init(configuration)
}

fun register(registerData: RegisterData) {
    AntacaStdApi
        .antacaStdService
        .register(registerData, object: ApiCallback<RegisterResult> {
            override fun onSuccess(result: RegisterResult) {
                 /*TODO: do something with success event*/
            }
            override fun onFailure(error: Throwable) {
                /*TODO: something went wrong*/
            }
        })
    )
}

suspend fun register(registerData: RegisterData): RegisterResult =
    AntacaCoroutineApi
        .antacaCoroutineService
        .register(registerData)

fun getBalances() {
    AntacaStdApi
        .antacaStdService
        .getBalances( object: ApiCallback<GetBalancesResult> {
            override fun onSuccess(result: GetBalancesResult) {
                 /*TODO: do something with success event*/
            }
            override fun onFailure(error: Throwable) {
                /*TODO: something went wrong*/
            }
        })
    )
}

suspend fun getBalances(): GetBalancesResult =
    AntacaCoroutineApi
        .antacaCoroutineService
        .getBalances()

fun getBalance(getBalanceData: GetBalanceData) {
    AntacaStdApi
        .antacaStdService
        .getBalance(getBalanceData, object: ApiCallback<GetBalanceResult> {
            override fun onSuccess(result: GetBalanceResult) {
                 /*TODO: do something with success event*/
            }
            override fun onFailure(error: Throwable) {
                /*TODO: something went wrong*/
            }
        })
    )
}

suspend fun getBalance(getBalanceData: GetBalanceData): GetBalanceResult =
    AntacaCoroutineApi
        .antacaCoroutineService
        .getBalance(getBalanceData)

fun createVirtualCard(createVirtualCardData: CreateVirtualCardData) {
    AntacaStdApi
        .antacaStdService
        .createVirtualCard(createVirtualCardData, object: ApiCallback<CreateVirtualCardResult> {
            override fun onSuccess(result: CreateVirtualCardResult) {
                 /*TODO: do something with success event*/
            }
            override fun onFailure(error: Throwable) {
                /*TODO: something went wrong*/
            }
        })
    )
}

suspend fun createVirtualCard(createVirtualCardData: CreateVirtualCardData): CreateVirtualCardResult =
    AntacaCoroutineApi
        .antacaCoroutineService
        .createVirtualCard(createVirtualCardData)

fun getCardDetails(getCardDetailsData: GetCardDetailsData) {
    AntacaStdApi
        .antacaStdService
        .getCardDetails(getCardDetailsData, object: ApiCallback<GetCardDetailsResult> {
            override fun onSuccess(result: GetCardDetailsResult) {
                 /*TODO: do something with success event*/
            }
            override fun onFailure(error: Throwable) {
                /*TODO: something went wrong*/
            }
        })
    )
}

suspend fun getCardDetails(getCardDetailsData: GetCardDetailsData): GetCardDetailsResult =
    AntacaCoroutineApi
        .antacaCoroutineService
        .getCardDetails(getCardDetailsData)

fun lockCard(lockCardData: LockCardData) {
    AntacaStdApi
        .antacaStdService
        .lockCard(lockCardData, object: ApiCallback<LockCardResult> {
            override fun onSuccess(result: LockCardResult) {
                 /*TODO: do something with success event*/
            }
            override fun onFailure(error: Throwable) {
                /*TODO: something went wrong*/
            }
        })
    )
}

suspend fun lockCard(lockCardData: LockCardData): LockCardResult =
    AntacaCoroutineApi
        .antacaCoroutineService
        .lockCard(lockCardData)

fun unlockCard(unlockCardData: UnlockCardData) {
    AntacaStdApi
        .antacaStdService
        .unlockCard(unlockCardData, object: ApiCallback<UnlockCardResult> {
            override fun onSuccess(result: UnlockCardResult) {
                 /*TODO: do something with success event*/
            }
            override fun onFailure(error: Throwable) {
                /*TODO: something went wrong*/
            }
        })
    )
}

suspend fun unlockCard(unlockCardData: UnlockCardData): UnlockCardResult =
    AntacaCoroutineApi
        .antacaCoroutineService
        .unlockCard(unlockCardData)

fun getLimits(getLimitsData: GetLimitsData) {
    AntacaStdApi
        .antacaStdService
        .getLimits(getLimitsData, object: ApiCallback<GetLimitsResult> {
            override fun onSuccess(result: GetLimitsResult) {
                 /*TODO: do something with success event*/
            }
            override fun onFailure(error: Throwable) {
                /*TODO: something went wrong*/
            }
        })
    )
}

suspend fun getLimits(getLimitsData: GetLimitsData): GetLimitsResult =
    AntacaCoroutineApi
        .antacaCoroutineService
        .getLimits(getLimitsData)

fun getLimit(getLimitData: GetLimitData) {
    AntacaStdApi
        .antacaStdService
        .getLimit(getLimitsData, object: ApiCallback<GetLimitResult> {
            override fun onSuccess(result: GetLimitResult) {
                 /*TODO: do something with success event*/
            }
            override fun onFailure(error: Throwable) {
                /*TODO: something went wrong*/
            }
        })
    )
}

suspend fun getLimit(getLimitData: GetLimitData): GetLimitResult =
    AntacaCoroutineApi
        .antacaCoroutineService
        .getLimit(getLimitData)

fun addLimit(addLimitData: AddLimitData) {
    AntacaStdApi
        .antacaStdService
        .addLimit(addLimitData, object: ApiCallback<AddLimitResult> {
            override fun onSuccess(result: AddLimitResult) {
                 /*TODO: do something with success event*/
            }
            override fun onFailure(error: Throwable) {
                /*TODO: something went wrong*/
            }
        })
    )
}

suspend fun addLimit(addLimitData: AddLimitData): AddLimitResult =
    AntacaCoroutineApi
        .antacaCoroutineService
        .addLimit(addLimitData)

fun updateLimit(updateLimitData: UpdateLimitData) {
    AntacaStdApi
        .antacaStdService
        .updateLimit(updateLimitData, object: ApiCallback<UpdateLimitResult> {
            override fun onSuccess(result: UpdateLimitResult) {
                 /*TODO: do something with success event*/
            }
            override fun onFailure(error: Throwable) {
                /*TODO: something went wrong*/
            }
        })
    )
}

suspend fun updateLimit(updateLimitData: UpdateLimitData): UpdateLimitResult =
    AntacaCoroutineApi
        .antacaCoroutineService
        .updateLimit(updateLimitData)

fun deleteLimit(deleteLimitData: DeleteLimitData) {
    AntacaStdApi
        .antacaStdService
        .deleteLimit(deleteLimitData, object: ApiCallback<DeleteLimitResult> {
            override fun onSuccess(result: DeleteLimitResult) {
                 /*TODO: do something with success event*/
            }
            override fun onFailure(error: Throwable) {
                /*TODO: something went wrong*/
            }
        })
    )
}

suspend fun deleteLimit(deleteLimitData: DeleteLimitData): DeleteLimitResult =
    AntacaCoroutineApi
        .antacaCoroutineService
        .deleteLimit(deleteLimitData)

fun changeLimits(changeLimitsData: ChangeLimitsData) {
    AntacaStdApi
        .antacaStdService
        .changeLimits(changeLimitsData, object: ApiCallback<ChangeLimitsResult> {
            override fun onSuccess(result: ChangeLimitsResult) {
                 /*TODO: do something with success event*/
            }
            override fun onFailure(error: Throwable) {
                /*TODO: something went wrong*/
            }
        })
    )
}

suspend fun changeLimits(changeLimitsData: ChangeLimitsData): ChangeLimitsResult =
    AntacaCoroutineApi
        .antacaCoroutineService
        .changeLimits(changeLimitsData)

fun addBalance(addBalanceData: AddBalanceData) {
    AntacaStdApi
        .antacaStdService
        .addBalance(addBalanceData, object: ApiCallback<AddBalanceResult> {
            override fun onSuccess(result: AddBalanceResult) {
                 /*TODO: do something with success event*/
            }
            override fun onFailure(error: Throwable) {
                /*TODO: something went wrong*/
            }
        })
    )
}

suspend fun addBalance(addBalanceData: AddBalanceData): AddBalanceResult =
    AntacaCoroutineApi
        .antacaCoroutineService
        .addBalance(addBalanceData)

fun getCardsConfig() {
    AntacaStdApi
        .antacaStdService
        .getCardsConfig(object: ApiCallback<GetCardsConfigResult> {
            override fun onSuccess(result: GetCardsConfigResult) {
                 /*TODO: do something with success event*/
            }
            override fun onFailure(error: Throwable) {
                /*TODO: something went wrong*/
            }
        })
    )
}

suspend fun getCardsConfig(): GetCardsConfigResult =
    AntacaCoroutineApi
        .antacaCoroutineService
        .getCardsConfig()

fun getCustomerDetails() {
    AntacaStdApi
        .antacaStdService
        .getCustomerDetails(object: ApiCallback<GetCustomerDetailsResult> {
            override fun onSuccess(result: GetCustomerDetailsResult) {
                 /*TODO: do something with success event*/
            }
            override fun onFailure(error: Throwable) {
                /*TODO: something went wrong*/
            }
        })
    )
}

suspend fun getCustomerDetails(): GetCustomerDetailsResult =
    AntacaCoroutineApi
        .antacaCoroutineService
        .getCustomerDetails()

fun changePin(changePinData: ChangePinData) {
    AntacaStdApi
        .antacaStdService
        .changePin(changePinData, object: ApiCallback<ChangePinResult> {
            override fun onSuccess(result: ChangePinResult) {
                /*TODO: do something with success event*/
            }
            override fun onFailure(error: Throwable) {
                /*TODO: something went wrong*/
            }
        })
}

suspend fun changePin(changePinData: ChangePinData): ChangePinResult =
    AntacaCoroutineApi
        .antacaCoroutineService
        .changePin(changePinData)

fun getBalances() {
    AntacaStdApi
        .antacaAccountStdService
        .getBalances( object: ApiCallback<GetBalancesResult> {
            override fun onSuccess(result: GetBalancesResult) {
                 /*TODO: do something with success event*/
            }
            override fun onFailure(error: Throwable) {
                /*TODO: something went wrong*/
            }
        })
    )
}

suspend fun getBalances(): GetBalancesResult =
    AntacaCoroutineApi
        .antacaAccountCoroutineService
        .getBalances()

fun getBalance(getBalanceData: GetBalanceData) {
    AntacaStdApi
        .antacaAccountStdService
        .getBalance(getBalanceData, object: ApiCallback<GetBalanceResult> {
            override fun onSuccess(result: GetBalanceResult) {
                 /*TODO: do something with success event*/
            }
            override fun onFailure(error: Throwable) {
                /*TODO: something went wrong*/
            }
        })
    )
}

suspend fun getBalance(getBalanceData: GetBalanceData): GetBalanceResult =
    AntacaCoroutineApi
        .antacaAccountCoroutineService
        .getBalance(getBalanceData)

fun addBalance(addBalanceData: AddBalanceData) {
    AntacaStdApi
        .antacaAccountStdService
        .addBalance(addBalanceData, object: ApiCallback<AddBalanceResult> {
            override fun onSuccess(result: AddBalanceResult) {
                 /*TODO: do something with success event*/
            }
            override fun onFailure(error: Throwable) {
                /*TODO: something went wrong*/
            }
        })
    )
}

suspend fun addBalance(addBalanceData: AddBalanceData): AddBalanceResult =
    AntacaCoroutineApi
        .antacaAccountCoroutineService
        .addBalance(addBalanceData)

fun createVirtualCard(createVirtualCardData: CreateVirtualCardData) {
    AntacaStdApi
        .antacaCardStdService
        .createVirtualCard(createVirtualCardData, object: ApiCallback<CreateVirtualCardResult> {
            override fun onSuccess(result: CreateVirtualCardResult) {
                 /*TODO: do something with success event*/
            }
            override fun onFailure(error: Throwable) {
                /*TODO: something went wrong*/
            }
        })
    )
}

suspend fun createVirtualCard(createVirtualCardData: CreateVirtualCardData): CreateVirtualCardResult =
    AntacaCoroutineApi
        .antacaCardCoroutineService
        .createVirtualCard(createVirtualCardData)

fun getCardDetails(getCardDetailsData: GetCardDetailsData) {
    AntacaStdApi
        .antacaCardStdService
        .getCardDetails(getCardDetailsData, object: ApiCallback<GetCardDetailsResult> {
            override fun onSuccess(result: GetCardDetailsResult) {
                 /*TODO: do something with success event*/
            }
            override fun onFailure(error: Throwable) {
                /*TODO: something went wrong*/
            }
        })
    )
}

suspend fun getCardDetails(getCardDetailsData: GetCardDetailsData): GetCardDetailsResult =
    AntacaCoroutineApi
        .antacaCardCoroutineService
        .getCardDetails(getCardDetailsData)

fun lockCard(lockCardData: LockCardData) {
    AntacaStdApi
        .antacaCardStdService
        .lockCard(lockCardData, object: ApiCallback<LockCardResult> {
            override fun onSuccess(result: LockCardResult) {
                 /*TODO: do something with success event*/
            }
            override fun onFailure(error: Throwable) {
                /*TODO: something went wrong*/
            }
        })
    )
}

suspend fun lockCard(lockCardData: LockCardData): LockCardResult =
    AntacaCoroutineApi
        .antacaCardCoroutineService
        .lockCard(lockCardData)

fun unlockCard(unlockCardData: UnlockCardData) {
    AntacaStdApi
        .antacaCardStdService
        .unlockCard(unlockCardData, object: ApiCallback<UnlockCardResult> {
            override fun onSuccess(result: UnlockCardResult) {
                 /*TODO: do something with success event*/
            }
            override fun onFailure(error: Throwable) {
                /*TODO: something went wrong*/
            }
        })
    )
}

suspend fun unlockCard(unlockCardData: UnlockCardData): UnlockCardResult =
    AntacaCoroutineApi
        .antacaCardCoroutineService
        .unlockCard(unlockCardData)

fun getCardsConfig() {
    AntacaStdApi
        .antacaCardStdService
        .getCardsConfig(object: ApiCallback<GetCardsConfigResult> {
            override fun onSuccess(result: GetCardsConfigResult) {
                 /*TODO: do something with success event*/
            }
            override fun onFailure(error: Throwable) {
                /*TODO: something went wrong*/
            }
        })
    )
}

suspend fun getCardsConfig(): GetCardsConfigResult =
    AntacaCoroutineApi
        .antacaCardCoroutineService
        .getCardsConfig()

fun changePin(changePinData: ChangePinData) {
    AntacaStdApi
        .antacaCardStdService
        .changePin(changePinData, object: ApiCallback<ChangePinResult> {
            override fun onSuccess(result: ChangePinResult) {
                /*TODO: do something with success event*/
            }
            override fun onFailure(error: Throwable) {
                /*TODO: something went wrong*/
            }
        })
}

suspend fun changePin(changePinData: ChangePinData): ChangePinResult =
    AntacaCoroutineApi
        .antacaCardCoroutineService
        .changePin(changePinData)

fun orderPhysicalCard(orderPhysicalCardData: OrderPhysicalCardData) {
    AntacaStdApi
        .antacaStdService
        .orderPhysicalCard(orderPhysicalCardData, object: ApiCallback<OrderPhysicalCardResult> {
            override fun onSuccess(result: OrderPhysicalCardResult) {
                /*TODO: do something with success event*/
            }
            override fun onFailure(error: Throwable) {
                /*TODO: something went wrong*/
            }
        })
}

suspend fun orderPhysicalCard(orderPhysicalCardData: OrderPhysicalCardData): OrderPhysicalCardResult =
    AntacaCoroutineApi
        .antacaCoroutineService
        .orderPhysicalCard(orderPhysicalCardData)

fun activateCard(activateCardData: ActivateCardData) {
    AntacaStdApi
        .antacaStdService
        .activateCard(activateCardData, object: ApiCallback<ActivateCardResult> {
            override fun onSuccess(result: ActivateCardResult) {
                /*TODO: do something with success event*/
            }
            override fun onFailure(error: Throwable) {
                /*TODO: something went wrong*/
            }
        })
}

suspend fun activateCard(activateCardData: ActivateCardData): ActivateCardResult =
    AntacaCoroutineApi
        .antacaCoroutineService
        .activateCard(activateCardData)

fun register(registerData: RegisterData) {
    AntacaStdApi
        .antacaCustomerStdService
        .register(registerData, object: ApiCallback<RegisterResult> {
            override fun onSuccess(result: RegisterResult) {
                 /*TODO: do something with success event*/
            }
            override fun onFailure(error: Throwable) {
                /*TODO: something went wrong*/
            }
        })
    )
}

suspend fun register(registerData: RegisterData): RegisterResult =
    AntacaCoroutineApi
        .antacaCustomerCoroutineService
        .register(registerData)

fun getCustomerDetails() {
    AntacaStdApi
        .antacaCustomerStdService
        .getCustomerDetails(object: ApiCallback<GetCustomerDetailsResult> {
            override fun onSuccess(result: GetCustomerDetailsResult) {
                 /*TODO: do something with success event*/
            }
            override fun onFailure(error: Throwable) {
                /*TODO: something went wrong*/
            }
        })
    )
}

suspend fun getCustomerDetails(): GetCustomerDetailsResult =
    AntacaCoroutineApi
        .antacaCustomerCoroutineService
        .getCustomerDetails()

fun getLimits(getLimitsData: GetLimitsData) {
    AntacaStdApi
        .antacaLimitStdService
        .getLimits(getLimitsData, object: ApiCallback<GetLimitsResult> {
            override fun onSuccess(result: GetLimitsResult) {
                 /*TODO: do something with success event*/
            }
            override fun onFailure(error: Throwable) {
                /*TODO: something went wrong*/
            }
        }
        )
}

suspend fun getLimits(getLimitsData: GetLimitsData): GetLimitsResult =
    AntacaCoroutineApi
        .antacaCoroutineService
        .getLimits(getLimitsData)

fun getLimit(getLimitData: GetLimitData) {
    AntacaStdApi
        .antacaLimitStdService
        .getLimit(getLimitsData, object: ApiCallback<GetLimitResult> {
            override fun onSuccess(result: GetLimitResult) {
                 /*TODO: do something with success event*/
            }
            override fun onFailure(error: Throwable) {
                /*TODO: something went wrong*/
            }
        })
    )
}

suspend fun getLimit(getLimitData: GetLimitData): GetLimitResult =
    AntacaCoroutineApi
        .antacaLimitCoroutineService
        .getLimit(getLimitData)

fun addLimit(addLimitData: AddLimitData) {
    AntacaStdApi
        .antacaLimitStdService
        .addLimit(addLimitData, object: ApiCallback<AddLimitResult> {
            override fun onSuccess(result: AddLimitResult) {
                 /*TODO: do something with success event*/
            }
            override fun onFailure(error: Throwable) {
                /*TODO: something went wrong*/
            }
        })
    )
}

suspend fun addLimit(addLimitData: AddLimitData): AddLimitResult =
    AntacaCoroutineApi
        .antacaLimitCoroutineService
        .addLimit(addLimitData)