react-native-candle 1.0.1 → 19.0.7-beta

package/android/src/main/java/com/margelo/nitro/rncandle/BridgeTypes.kt

@@ -0,0 +1,814 @@
+@file:OptIn(kotlinx.serialization.ExperimentalSerializationApi::class)
+
+package com.margelo.nitro.rncandle
+
+import fi.candle.client.Operations
+import fi.candle.generated.http.models.ACHAccountKind as CandleACHAccountKind
+import fi.candle.generated.http.models.ACHDetails as CandleACHDetails
+import fi.candle.generated.http.models.ActiveLinkedAccountDetails as CandleActiveLinkedAccountDetails
+import fi.candle.generated.http.models.Address as CandleAddress
+import fi.candle.generated.http.models.AssetAccount as CandleAssetAccount
+import fi.candle.generated.http.models.AssetAccountsResponse as CandleAssetAccountsResponse
+import fi.candle.generated.http.models.Coordinates as CandleCoordinates
+import fi.candle.generated.http.models.Counterparty as CandleCounterparty
+import fi.candle.generated.http.models.CounterpartyQuoteRequest as CandleCounterpartyQuoteRequest
+import fi.candle.generated.http.models.CryptoAccount as CandleCryptoAccount
+import fi.candle.generated.http.models.CryptoAsset as CandleCryptoAsset
+import fi.candle.generated.http.models.CryptoAssetQuoteRequest as CandleCryptoAssetQuoteRequest
+import fi.candle.generated.http.models.CryptoAssetRef as CandleCryptoAssetRef
+import fi.candle.generated.http.models.EventAsset as CandleEventAsset
+import fi.candle.generated.http.models.EventAssetQuoteRequest as CandleEventAssetQuoteRequest
+import fi.candle.generated.http.models.EventAssetRef as CandleEventAssetRef
+import fi.candle.generated.http.models.FiatAccount as CandleFiatAccount
+import fi.candle.generated.http.models.FiatAsset as CandleFiatAsset
+import fi.candle.generated.http.models.FiatAssetQuoteRequest as CandleFiatAssetQuoteRequest
+import fi.candle.generated.http.models.FiatAssetRef as CandleFiatAssetRef
+import fi.candle.generated.http.models.FinancialAccountKind as CandleFinancialAccountKind
+import fi.candle.generated.http.models.InactiveLinkedAccountDetails as CandleInactiveLinkedAccountDetails
+import fi.candle.generated.http.models.LinkedAccount as CandleLinkedAccount
+import fi.candle.generated.http.models.LinkedAccountDetails as CandleLinkedAccountDetails
+import fi.candle.generated.http.models.LinkedAccountStatusRef as CandleLinkedAccountStatusRef
+import fi.candle.generated.http.models.LinkedAccountStatusRefState as CandleLinkedAccountStatusRefState
+import fi.candle.generated.http.models.MerchantCounterparty as CandleMerchantCounterparty
+import fi.candle.generated.http.models.MerchantCounterpartyQuoteRequest as CandleMerchantCounterpartyQuoteRequest
+import fi.candle.generated.http.models.MerchantLocation as CandleMerchantLocation
+import fi.candle.generated.http.models.NothingAsset as CandleNothingAsset
+import fi.candle.generated.http.models.NothingAssetQuoteRequest as CandleNothingAssetQuoteRequest
+import fi.candle.generated.http.models.OtherAsset as CandleOtherAsset
+import fi.candle.generated.http.models.OtherAssetQuoteRequest as CandleOtherAssetQuoteRequest
+import fi.candle.generated.http.models.Service as CandleService
+import fi.candle.generated.http.models.ServiceCounterparty as CandleServiceCounterparty
+import fi.candle.generated.http.models.ServiceCounterpartyQuoteRequest as CandleServiceCounterpartyQuoteRequest
+import fi.candle.generated.http.models.StockAccount as CandleStockAccount
+import fi.candle.generated.http.models.StockAsset as CandleStockAsset
+import fi.candle.generated.http.models.StockAssetQuoteRequest as CandleStockAssetQuoteRequest
+import fi.candle.generated.http.models.StockAssetRef as CandleStockAssetRef
+import fi.candle.generated.http.models.Trade as CandleTrade
+import fi.candle.generated.http.models.TradeAsset as CandleTradeAsset
+import fi.candle.generated.http.models.TradeAssetQuoteRequest as CandleTradeAssetQuoteRequest
+import fi.candle.generated.http.models.TradeAssetRef as CandleTradeAssetRef
+import fi.candle.generated.http.models.TradeQuote as CandleTradeQuote
+import fi.candle.generated.http.models.TradeQuotesRequest as CandleTradeQuotesRequest
+import fi.candle.generated.http.models.TradeQuotesResponse as CandleTradeQuotesResponse
+import fi.candle.generated.http.models.TradeRef as CandleTradeRef
+import fi.candle.generated.http.models.TradeState as CandleTradeState
+import fi.candle.generated.http.models.TradesResponse as CandleTradesResponse
+import fi.candle.generated.http.models.TransportAccount as CandleTransportAccount
+import fi.candle.generated.http.models.TransportAccountKind as CandleTransportAccountKind
+import fi.candle.generated.http.models.TransportAsset as CandleTransportAsset
+import fi.candle.generated.http.models.TransportAssetQuoteRequest as CandleTransportAssetQuoteRequest
+import fi.candle.generated.http.models.TransportAssetRef as CandleTransportAssetRef
+import fi.candle.generated.http.models.UnavailableLinkedAccountDetails as CandleUnavailableLinkedAccountDetails
+import fi.candle.generated.http.models.UserCounterparty as CandleUserCounterparty
+import fi.candle.generated.http.models.UserCounterpartyQuoteRequest as CandleUserCounterpartyQuoteRequest
+import fi.candle.generated.http.models.WireDetails as CandleWireDetails
+import java.math.BigDecimal
+import java.util.UUID
+
+internal fun Service.toCandleModel(): CandleService = CandleService.valueOf(name)
+
+internal fun CandleService.toReactModel(): Service = Service.valueOf(name)
+
+internal fun LinkedAccountRef.toGetLinkedAccountRef(): Operations.GetLinkedAccount.Input.Path {
+    return Operations.GetLinkedAccount.Input.Path(
+        linkedAccountID = UUID.fromString(linkedAccountID)
+    )
+}
+
+internal fun LinkedAccountRef.toDeleteLinkedAccountRef():
+    Operations.DeleteLinkedAccount.Input.Path {
+    return Operations.DeleteLinkedAccount.Input.Path(
+        linkedAccountID = UUID.fromString(linkedAccountID)
+    )
+}
+
+internal fun AssetAccountRef.toCandleModel(): Operations.GetAssetAccount.Input.Path {
+    return Operations.GetAssetAccount.Input.Path(
+        linkedAccountID = UUID.fromString(linkedAccountID),
+        assetKind = assetKind.toCandleAssetAccountPathKind(),
+        serviceAccountID = serviceAccountID,
+    )
+}
+
+internal fun AssetAccountsQuery.toCandleModel(): Operations.GetAssetAccounts.Input.Query {
+    return Operations.GetAssetAccounts.Input.Query(
+        linkedAccountIDs = linkedAccountIDs,
+        assetKind = assetKind?.toCandleAssetAccountsQueryKind(),
+    )
+}
+
+internal fun TradesQuery.toCandleModel(): Operations.GetTrades.Input.Query {
+    return Operations.GetTrades.Input.Query(
+        linkedAccountIDs = linkedAccountIDs,
+        dateTimeSpan = dateTimeSpan,
+        gainedAssetKind = gainedAssetKind?.toCandleGainedAssetKind(),
+        lostAssetKind = lostAssetKind?.toCandleLostAssetKind(),
+        counterpartyKind = counterpartyKind?.toCandleCounterpartyKind(),
+    )
+}
+
+internal fun TradeRef.toCandleModel(): CandleTradeRef {
+    return CandleTradeRef(lost = lost.toCandleModel(), gained = gained.toCandleModel())
+}
+
+internal fun TradeQuotesRequest.toCandleModel(): CandleTradeQuotesRequest {
+    return CandleTradeQuotesRequest(
+        linkedAccountIDs = linkedAccountIDs,
+        gained = gained.toCandleModel(),
+        lost = lost.toCandleModel(),
+        counterparty = counterparty?.toCandleModel(),
+    )
+}
+
+internal fun TradeQuote.toCandleModel(): CandleTradeQuote {
+    return CandleTradeQuote(
+        lost = lost.toCandleModel(),
+        gained = gained.toCandleModel(),
+        counterparty = counterparty.toCandleModel(),
+        context = context,
+        expirationDateTime = expirationDateTime,
+    )
+}
+
+internal fun CandleLinkedAccount.toReactModel(): LinkedAccount {
+    return LinkedAccount(
+        linkedAccountID = linkedAccountID.toString(),
+        service = service.toReactModel(),
+        serviceUserID = serviceUserID,
+        details = details.toReactModel(),
+    )
+}
+
+internal fun CandleLinkedAccountDetails.toReactModel(): LinkedAccountDetails {
+    return when (this) {
+        is CandleActiveLinkedAccountDetails ->
+            LinkedAccountDetails(
+                activeLinkedAccountDetails =
+                    ActiveLinkedAccountDetails(
+                        state = "active",
+                        accountOpened = accountOpened,
+                        username = username,
+                        emailAddress = emailAddress,
+                        legalName = legalName,
+                    ),
+                inactiveLinkedAccountDetails = null,
+                unavailableLinkedAccountDetails = null,
+            )
+
+        is CandleInactiveLinkedAccountDetails ->
+            LinkedAccountDetails(
+                activeLinkedAccountDetails = null,
+                inactiveLinkedAccountDetails = InactiveLinkedAccountDetails(state = "inactive"),
+                unavailableLinkedAccountDetails = null,
+            )
+
+        is CandleUnavailableLinkedAccountDetails ->
+            LinkedAccountDetails(
+                activeLinkedAccountDetails = null,
+                inactiveLinkedAccountDetails = null,
+                unavailableLinkedAccountDetails =
+                    UnavailableLinkedAccountDetails(state = "unavailable"),
+            )
+    }
+}
+
+internal fun CandleLinkedAccountStatusRef.toReactModel(): LinkedAccountStatusRef {
+    return LinkedAccountStatusRef(
+        linkedAccountID = linkedAccountID.toString(),
+        service = service.toReactModel(),
+        serviceUserID = serviceUserID,
+        state = state.toReactModel(),
+    )
+}
+
+internal fun CandleAssetAccountsResponse.toReactModel(): AssetAccountsResponse {
+    return AssetAccountsResponse(
+        linkedAccounts = linkedAccounts.map { it.toReactModel() }.toTypedArray(),
+        assetAccounts = assetAccounts.map { it.toReactModel() }.toTypedArray(),
+    )
+}
+
+internal fun CandleAssetAccount.toReactModel(): AssetAccount {
+    return when (this) {
+        is CandleFiatAccount ->
+            AssetAccount(
+                fiatAccount =
+                    FiatAccount(
+                        assetKind = "fiat",
+                        serviceAccountID = serviceAccountID,
+                        accountKind = accountKind.toReactModel(),
+                        nickname = nickname,
+                        currencyCode = currencyCode,
+                        balance = balance?.toDouble(),
+                        ach = ach?.toReactModel(),
+                        wire = wire?.toReactModel(),
+                        linkedAccountID = linkedAccountID.toString(),
+                        service = service.toReactModel(),
+                    ),
+                cryptoAccount = null,
+                stockAccount = null,
+                transportAccount = null,
+            )
+
+        is CandleCryptoAccount ->
+            AssetAccount(
+                fiatAccount = null,
+                cryptoAccount =
+                    CryptoAccount(
+                        assetKind = "crypto",
+                        serviceAccountID = serviceAccountID,
+                        accountKind = accountKind.toReactModel(),
+                        nickname = nickname,
+                        linkedAccountID = linkedAccountID.toString(),
+                        service = service.toReactModel(),
+                    ),
+                stockAccount = null,
+                transportAccount = null,
+            )
+
+        is CandleStockAccount ->
+            AssetAccount(
+                fiatAccount = null,
+                cryptoAccount = null,
+                stockAccount =
+                    StockAccount(
+                        assetKind = "stock",
+                        serviceAccountID = serviceAccountID,
+                        accountKind = accountKind.toReactModel(),
+                        nickname = nickname,
+                        linkedAccountID = linkedAccountID.toString(),
+                        service = service.toReactModel(),
+                    ),
+                transportAccount = null,
+            )
+
+        is CandleTransportAccount ->
+            AssetAccount(
+                fiatAccount = null,
+                cryptoAccount = null,
+                stockAccount = null,
+                transportAccount =
+                    TransportAccount(
+                        assetKind = "transport",
+                        serviceAccountID = serviceAccountID,
+                        accountKind = accountKind.toReactModel(),
+                        nickname = nickname,
+                        linkedAccountID = linkedAccountID.toString(),
+                        service = service.toReactModel(),
+                    ),
+            )
+    }
+}
+
+internal fun CandleTradesResponse.toReactModel(): TradesResponse {
+    return TradesResponse(
+        linkedAccounts = linkedAccounts.map { it.toReactModel() }.toTypedArray(),
+        trades = trades.map { it.toReactModel() }.toTypedArray(),
+    )
+}
+
+internal fun CandleTrade.toReactModel(): Trade {
+    return Trade(
+        dateTime = dateTime,
+        state = state.toReactModel(),
+        counterparty = counterparty.toReactModel(),
+        lost = lost.toReactModel(),
+        gained = gained.toReactModel(),
+    )
+}
+
+internal fun CandleTradeQuotesResponse.toReactModel(): TradeQuotesResponse {
+    return TradeQuotesResponse(
+        linkedAccounts = linkedAccounts.map { it.toReactModel() }.toTypedArray(),
+        tradeQuotes = tradeQuotes.map { it.toReactModel() }.toTypedArray(),
+    )
+}
+
+internal fun CandleTradeQuote.toReactModel(): TradeQuote {
+    return TradeQuote(
+        lost = lost.toReactModel(),
+        gained = gained.toReactModel(),
+        counterparty = counterparty.toReactModel(),
+        context = context,
+        expirationDateTime = expirationDateTime,
+    )
+}
+
+internal fun CandleCounterparty.toReactModel(): Counterparty {
+    return when (this) {
+        is CandleMerchantCounterparty ->
+            Counterparty(
+                merchantCounterparty =
+                    MerchantCounterparty(
+                        kind = "merchant",
+                        name = name,
+                        logoURL = logoURL,
+                        location = location?.toReactModel(),
+                    ),
+                userCounterparty = null,
+                serviceCounterparty = null,
+            )
+
+        is CandleUserCounterparty ->
+            Counterparty(
+                merchantCounterparty = null,
+                userCounterparty =
+                    UserCounterparty(
+                        kind = "user",
+                        legalName = legalName,
+                        avatarURL = avatarURL,
+                        username = username,
+                    ),
+                serviceCounterparty = null,
+            )
+
+        is CandleServiceCounterparty ->
+            Counterparty(
+                merchantCounterparty = null,
+                userCounterparty = null,
+                serviceCounterparty =
+                    ServiceCounterparty(kind = "service", service = service.toReactModel()),
+            )
+    }
+}
+
+internal fun CandleTradeAsset.toReactModel(): TradeAsset {
+    return when (this) {
+        is CandleFiatAsset ->
+            TradeAsset(
+                fiatAsset =
+                    FiatAsset(
+                        assetKind = "fiat",
+                        serviceTradeID = serviceTradeID,
+                        serviceAccountID = serviceAccountID,
+                        currencyCode = currencyCode,
+                        amount = amount.toDouble(),
+                        linkedAccountID = linkedAccountID.toString(),
+                        service = service.toReactModel(),
+                    ),
+                cryptoAsset = null,
+                stockAsset = null,
+                transportAsset = null,
+                eventAsset = null,
+                otherAsset = null,
+                nothingAsset = null,
+            )
+
+        is CandleCryptoAsset ->
+            TradeAsset(
+                fiatAsset = null,
+                cryptoAsset =
+                    CryptoAsset(
+                        assetKind = "crypto",
+                        serviceAccountID = serviceAccountID,
+                        serviceAssetID = serviceAssetID,
+                        symbol = symbol,
+                        amount = amount.toDouble(),
+                        serviceTradeID = serviceTradeID,
+                        linkedAccountID = linkedAccountID.toString(),
+                        name = name,
+                        color = color,
+                        logoURL = logoURL,
+                        service = service.toReactModel(),
+                    ),
+                stockAsset = null,
+                transportAsset = null,
+                eventAsset = null,
+                otherAsset = null,
+                nothingAsset = null,
+            )
+
+        is CandleStockAsset ->
+            TradeAsset(
+                fiatAsset = null,
+                cryptoAsset = null,
+                stockAsset =
+                    StockAsset(
+                        assetKind = "stock",
+                        serviceAccountID = serviceAccountID,
+                        serviceAssetID = serviceAssetID,
+                        symbol = symbol,
+                        amount = amount.toDouble(),
+                        serviceTradeID = serviceTradeID,
+                        linkedAccountID = linkedAccountID.toString(),
+                        name = name,
+                        color = color,
+                        logoURL = logoURL,
+                        service = service.toReactModel(),
+                    ),
+                transportAsset = null,
+                eventAsset = null,
+                otherAsset = null,
+                nothingAsset = null,
+            )
+
+        is CandleTransportAsset ->
+            TradeAsset(
+                fiatAsset = null,
+                cryptoAsset = null,
+                stockAsset = null,
+                transportAsset =
+                    TransportAsset(
+                        assetKind = "transport",
+                        serviceTradeID = serviceTradeID,
+                        serviceAssetID = serviceAssetID,
+                        serviceAccountID = serviceAccountID,
+                        name = name,
+                        description = description,
+                        imageURL = imageURL,
+                        originCoordinates = originCoordinates.toReactModel(),
+                        originAddress = originAddress.toReactModel(),
+                        destinationCoordinates = destinationCoordinates.toReactModel(),
+                        destinationAddress = destinationAddress.toReactModel(),
+                        seats = seats.toDouble(),
+                        departureDateTime = departureDateTime,
+                        arrivalDateTime = arrivalDateTime,
+                        linkedAccountID = linkedAccountID.toString(),
+                        service = service.toReactModel(),
+                    ),
+                eventAsset = null,
+                otherAsset = null,
+                nothingAsset = null,
+            )
+
+        is CandleEventAsset ->
+            TradeAsset(
+                fiatAsset = null,
+                cryptoAsset = null,
+                stockAsset = null,
+                transportAsset = null,
+                eventAsset =
+                    EventAsset(
+                        assetKind = "event",
+                        serviceTradeID = serviceTradeID,
+                        serviceAssetID = serviceAssetID,
+                        name = name,
+                        description = description,
+                        imageURL = imageURL,
+                        locationCoordinates = locationCoordinates.toReactModel(),
+                        locationAddress = locationAddress.toReactModel(),
+                        partySize = partySize.toDouble(),
+                        dateTime = dateTime,
+                        linkedAccountID = linkedAccountID.toString(),
+                        service = service.toReactModel(),
+                    ),
+                otherAsset = null,
+                nothingAsset = null,
+            )
+
+        CandleOtherAsset ->
+            TradeAsset(
+                fiatAsset = null,
+                cryptoAsset = null,
+                stockAsset = null,
+                transportAsset = null,
+                eventAsset = null,
+                otherAsset = OtherAsset(assetKind = "other"),
+                nothingAsset = null,
+            )
+
+        CandleNothingAsset ->
+            TradeAsset(
+                fiatAsset = null,
+                cryptoAsset = null,
+                stockAsset = null,
+                transportAsset = null,
+                eventAsset = null,
+                otherAsset = null,
+                nothingAsset = NothingAsset(assetKind = "nothing"),
+            )
+    }
+}
+
+internal fun TradeAsset.toCandleModel(): CandleTradeAsset {
+    fiatAsset?.let {
+        return CandleFiatAsset(
+            serviceTradeID = it.serviceTradeID,
+            linkedAccountID = UUID.fromString(it.linkedAccountID),
+            serviceAccountID = it.serviceAccountID,
+            amount = it.amount.toBigDecimal(),
+            currencyCode = it.currencyCode,
+            service = it.service.toCandleModel(),
+        )
+    }
+    cryptoAsset?.let {
+        return CandleCryptoAsset(
+            serviceTradeID = it.serviceTradeID,
+            linkedAccountID = UUID.fromString(it.linkedAccountID),
+            serviceAccountID = it.serviceAccountID,
+            serviceAssetID = it.serviceAssetID,
+            amount = it.amount.toBigDecimal(),
+            symbol = it.symbol,
+            name = it.name,
+            service = it.service.toCandleModel(),
+            color = it.color,
+            logoURL = it.logoURL,
+        )
+    }
+    stockAsset?.let {
+        return CandleStockAsset(
+            serviceTradeID = it.serviceTradeID,
+            linkedAccountID = UUID.fromString(it.linkedAccountID),
+            serviceAccountID = it.serviceAccountID,
+            serviceAssetID = it.serviceAssetID,
+            amount = it.amount.toBigDecimal(),
+            symbol = it.symbol,
+            name = it.name,
+            service = it.service.toCandleModel(),
+            color = it.color,
+            logoURL = it.logoURL,
+        )
+    }
+    transportAsset?.let {
+        return CandleTransportAsset(
+            serviceTradeID = it.serviceTradeID,
+            serviceAssetID = it.serviceAssetID,
+            linkedAccountID = UUID.fromString(it.linkedAccountID),
+            serviceAccountID = it.serviceAccountID,
+            name = it.name,
+            description = it.description,
+            imageURL = it.imageURL,
+            originCoordinates = it.originCoordinates.toCandleModel(),
+            originAddress = it.originAddress.toCandleModel(),
+            destinationCoordinates = it.destinationCoordinates.toCandleModel(),
+            destinationAddress = it.destinationAddress.toCandleModel(),
+            seats = it.seats.toBigDecimal(),
+            departureDateTime = it.departureDateTime,
+            arrivalDateTime = it.arrivalDateTime,
+            service = it.service.toCandleModel(),
+        )
+    }
+    eventAsset?.let {
+        return CandleEventAsset(
+            serviceTradeID = it.serviceTradeID,
+            serviceAssetID = it.serviceAssetID,
+            linkedAccountID = UUID.fromString(it.linkedAccountID),
+            name = it.name,
+            description = it.description,
+            imageURL = it.imageURL,
+            locationCoordinates = it.locationCoordinates.toCandleModel(),
+            locationAddress = it.locationAddress.toCandleModel(),
+            partySize = it.partySize.toBigDecimal(),
+            dateTime = it.dateTime,
+            service = it.service.toCandleModel(),
+        )
+    }
+    if (otherAsset != null) return CandleOtherAsset
+    if (nothingAsset != null) return CandleNothingAsset
+    error("Internal Candle Error: corrupted trade asset.")
+}
+
+internal fun Counterparty.toCandleModel(): CandleCounterparty {
+    merchantCounterparty?.let {
+        return CandleMerchantCounterparty(
+            name = it.name,
+            logoURL = it.logoURL,
+            location = it.location?.toCandleModel(),
+        )
+    }
+    userCounterparty?.let {
+        return CandleUserCounterparty(
+            legalName = it.legalName,
+            avatarURL = it.avatarURL,
+            username = it.username,
+        )
+    }
+    serviceCounterparty?.let {
+        return CandleServiceCounterparty(service = it.service.toCandleModel())
+    }
+    error("Internal Candle Error: corrupted counterparty.")
+}
+
+internal fun CandleMerchantLocation.toReactModel(): MerchantLocation {
+    return MerchantLocation(
+        countryCode = countryCode,
+        countrySubdivisionCode = countrySubdivisionCode,
+        localityName = localityName,
+    )
+}
+
+internal fun MerchantLocation.toCandleModel(): CandleMerchantLocation {
+    return CandleMerchantLocation(
+        countryCode = countryCode,
+        countrySubdivisionCode = countrySubdivisionCode,
+        localityName = localityName,
+    )
+}
+
+internal fun CandleCoordinates.toReactModel(): Coordinates {
+    return Coordinates(latitude = latitude.toDouble(), longitude = longitude.toDouble())
+}
+
+internal fun Coordinates.toCandleModel(): CandleCoordinates {
+    return CandleCoordinates(
+        latitude = latitude.toBigDecimal(),
+        longitude = longitude.toBigDecimal(),
+    )
+}
+
+internal fun CandleAddress.toReactModel(): Address = Address(value = value)
+
+internal fun Address.toCandleModel(): CandleAddress = CandleAddress(value = value)
+
+internal fun CandleACHDetails.toReactModel(): ACHDetails {
+    return ACHDetails(
+        accountNumber = accountNumber,
+        routingNumber = routingNumber,
+        accountKind = accountKind.toReactModel(),
+    )
+}
+
+internal fun CandleWireDetails.toReactModel(): WireDetails {
+    return WireDetails(accountNumber = accountNumber, routingNumber = routingNumber)
+}
+
+internal fun TradeAssetQuoteRequest.toCandleModel(): CandleTradeAssetQuoteRequest {
+    fiatAssetQuoteRequest?.let {
+        return CandleFiatAssetQuoteRequest(
+            serviceAccountID = it.serviceAccountID,
+            currencyCode = it.currencyCode,
+            amount = it.amount?.toBigDecimal(),
+        )
+    }
+    cryptoAssetQuoteRequest?.let {
+        return CandleCryptoAssetQuoteRequest(
+            serviceAccountID = it.serviceAccountID,
+            serviceAssetID = it.serviceAssetID,
+            symbol = it.symbol,
+            amount = it.amount?.toBigDecimal(),
+        )
+    }
+    stockAssetQuoteRequest?.let {
+        return CandleStockAssetQuoteRequest(
+            serviceAccountID = it.serviceAccountID,
+            serviceAssetID = it.serviceAssetID,
+            symbol = it.symbol,
+            amount = it.amount?.toBigDecimal(),
+        )
+    }
+    transportAssetQuoteRequest?.let {
+        return CandleTransportAssetQuoteRequest(
+            serviceAssetID = it.serviceAssetID,
+            originCoordinates = it.originCoordinates?.toCandleModel(),
+            originAddress = it.originAddress?.toCandleModel(),
+            destinationCoordinates = it.destinationCoordinates?.toCandleModel(),
+            destinationAddress = it.destinationAddress?.toCandleModel(),
+            seats = it.seats?.toBigDecimal(),
+            serviceAccountID = it.serviceAccountID,
+        )
+    }
+    eventAssetQuoteRequest?.let {
+        return CandleEventAssetQuoteRequest(
+            serviceAssetID = it.serviceAssetID,
+            partySize = it.partySize?.toBigDecimal(),
+            dateTime = it.dateTime,
+        )
+    }
+    if (nothingAssetQuoteRequest != null) return CandleNothingAssetQuoteRequest
+    if (otherAssetQuoteRequest != null) return CandleOtherAssetQuoteRequest
+    error("Internal Candle Error: corrupted trade asset quote request.")
+}
+
+internal fun CounterpartyQuoteRequest.toCandleModel(): CandleCounterpartyQuoteRequest {
+    userCounterpartyQuoteRequest?.let {
+        return CandleUserCounterpartyQuoteRequest(legalName = it.legalName, username = it.username)
+    }
+    merchantCounterpartyQuoteRequest?.let {
+        return CandleMerchantCounterpartyQuoteRequest(
+            name = it.name,
+            location = it.location?.toCandleModel(),
+        )
+    }
+    serviceCounterpartyQuoteRequest?.let {
+        return CandleServiceCounterpartyQuoteRequest
+    }
+    error("Internal Candle Error: corrupted counterparty quote request.")
+}
+
+internal fun TradeAssetRef.toCandleModel(): CandleTradeAssetRef {
+    fiatAssetRef?.let {
+        return CandleFiatAssetRef(
+            linkedAccountID = UUID.fromString(it.linkedAccountID),
+            serviceTradeID = it.serviceTradeID,
+        )
+    }
+    cryptoAssetRef?.let {
+        return CandleCryptoAssetRef(
+            linkedAccountID = UUID.fromString(it.linkedAccountID),
+            serviceTradeID = it.serviceTradeID,
+        )
+    }
+    stockAssetRef?.let {
+        return CandleStockAssetRef(
+            linkedAccountID = UUID.fromString(it.linkedAccountID),
+            serviceTradeID = it.serviceTradeID,
+        )
+    }
+    transportAssetRef?.let {
+        return CandleTransportAssetRef(
+            linkedAccountID = UUID.fromString(it.linkedAccountID),
+            serviceTradeID = it.serviceTradeID,
+        )
+    }
+    eventAssetRef?.let {
+        return CandleEventAssetRef(
+            linkedAccountID = UUID.fromString(it.linkedAccountID),
+            serviceTradeID = it.serviceTradeID,
+        )
+    }
+    if (otherAssetRef != null) return CandleOtherAsset
+    if (nothingAssetRef != null) return CandleNothingAsset
+    error("Internal Candle Error: corrupted trade asset ref.")
+}
+
+internal fun CandleTradeState.toReactModel(): TradeState {
+    return when (this) {
+        CandleTradeState.SUCCESS -> TradeState.SUCCESS
+        CandleTradeState.IN_PROGRESS -> TradeState.INPROGRESS
+        CandleTradeState.FAILURE -> TradeState.FAILURE
+    }
+}
+
+internal fun CandleLinkedAccountStatusRefState.toReactModel(): LinkedAccountState {
+    return when (this) {
+        CandleLinkedAccountStatusRefState.ACTIVE -> LinkedAccountState.ACTIVE
+        CandleLinkedAccountStatusRefState.INACTIVE -> LinkedAccountState.INACTIVE
+        CandleLinkedAccountStatusRefState.UNAVAILABLE -> LinkedAccountState.UNAVAILABLE
+    }
+}
+
+internal fun CandleACHAccountKind.toReactModel(): ACHAccountKind = ACHAccountKind.valueOf(name)
+
+internal fun CandleFinancialAccountKind.toReactModel(): FinancialAccountKind {
+    return when (this) {
+        CandleFinancialAccountKind.INDIVIDUAL -> FinancialAccountKind.INDIVIDUAL
+        CandleFinancialAccountKind.JOINT -> FinancialAccountKind.JOINT
+        CandleFinancialAccountKind.TRADITIONAL_IRA -> FinancialAccountKind.TRADITIONALIRA
+        CandleFinancialAccountKind.ROTH_IRA -> FinancialAccountKind.ROTHIRA
+        CandleFinancialAccountKind.BUSINESS -> FinancialAccountKind.BUSINESS
+    }
+}
+
+internal fun CandleTransportAccountKind.toReactModel(): TransportAccountKind =
+    TransportAccountKind.valueOf(name)
+
+internal fun AssetAccountKind.toCandleAssetAccountPathKind():
+    Operations.GetAssetAccount.Input.Path.AssetKindPayload {
+    return when (this) {
+        AssetAccountKind.FIAT -> Operations.GetAssetAccount.Input.Path.AssetKindPayload.FIAT
+        AssetAccountKind.STOCK -> Operations.GetAssetAccount.Input.Path.AssetKindPayload.STOCK
+        AssetAccountKind.CRYPTO -> Operations.GetAssetAccount.Input.Path.AssetKindPayload.CRYPTO
+        AssetAccountKind.TRANSPORT ->
+            Operations.GetAssetAccount.Input.Path.AssetKindPayload.TRANSPORT
+    }
+}
+
+internal fun AssetAccountKind.toCandleAssetAccountsQueryKind():
+    Operations.GetAssetAccounts.Input.Query.AssetKindPayload {
+    return when (this) {
+        AssetAccountKind.FIAT -> Operations.GetAssetAccounts.Input.Query.AssetKindPayload.FIAT
+        AssetAccountKind.STOCK -> Operations.GetAssetAccounts.Input.Query.AssetKindPayload.STOCK
+        AssetAccountKind.CRYPTO -> Operations.GetAssetAccounts.Input.Query.AssetKindPayload.CRYPTO
+        AssetAccountKind.TRANSPORT ->
+            Operations.GetAssetAccounts.Input.Query.AssetKindPayload.TRANSPORT
+    }
+}
+
+internal fun TradeAssetKind.toCandleGainedAssetKind():
+    Operations.GetTrades.Input.Query.GainedAssetKindPayload {
+    return when (this) {
+        TradeAssetKind.FIAT -> Operations.GetTrades.Input.Query.GainedAssetKindPayload.FIAT
+        TradeAssetKind.STOCK -> Operations.GetTrades.Input.Query.GainedAssetKindPayload.STOCK
+        TradeAssetKind.CRYPTO -> Operations.GetTrades.Input.Query.GainedAssetKindPayload.CRYPTO
+        TradeAssetKind.TRANSPORT ->
+            Operations.GetTrades.Input.Query.GainedAssetKindPayload.TRANSPORT
+        TradeAssetKind.EVENT -> Operations.GetTrades.Input.Query.GainedAssetKindPayload.EVENT
+        TradeAssetKind.OTHER -> Operations.GetTrades.Input.Query.GainedAssetKindPayload.OTHER
+        TradeAssetKind.NOTHING -> Operations.GetTrades.Input.Query.GainedAssetKindPayload.NOTHING
+    }
+}
+
+internal fun TradeAssetKind.toCandleLostAssetKind():
+    Operations.GetTrades.Input.Query.LostAssetKindPayload {
+    return when (this) {
+        TradeAssetKind.FIAT -> Operations.GetTrades.Input.Query.LostAssetKindPayload.FIAT
+        TradeAssetKind.STOCK -> Operations.GetTrades.Input.Query.LostAssetKindPayload.STOCK
+        TradeAssetKind.CRYPTO -> Operations.GetTrades.Input.Query.LostAssetKindPayload.CRYPTO
+        TradeAssetKind.TRANSPORT -> Operations.GetTrades.Input.Query.LostAssetKindPayload.TRANSPORT
+        TradeAssetKind.EVENT -> Operations.GetTrades.Input.Query.LostAssetKindPayload.EVENT
+        TradeAssetKind.OTHER -> Operations.GetTrades.Input.Query.LostAssetKindPayload.OTHER
+        TradeAssetKind.NOTHING -> Operations.GetTrades.Input.Query.LostAssetKindPayload.NOTHING
+    }
+}
+
+internal fun CounterpartyKind.toCandleCounterpartyKind():
+    Operations.GetTrades.Input.Query.CounterpartyKindPayload {
+    return when (this) {
+        CounterpartyKind.MERCHANT ->
+            Operations.GetTrades.Input.Query.CounterpartyKindPayload.MERCHANT
+        CounterpartyKind.USER -> Operations.GetTrades.Input.Query.CounterpartyKindPayload.USER
+        CounterpartyKind.SERVICE -> Operations.GetTrades.Input.Query.CounterpartyKindPayload.SERVICE
+    }
+}
+
+private fun Double.toBigDecimal(): BigDecimal = BigDecimal.valueOf(this)