react-native-candle 0.1.51 → 19.0.6-beta

package/ios/Sources/Types.swift

@@ -25,21 +25,6 @@ extension Models.TradeQuote {
     }
 }
 
-extension Models.MarketTradeAsset.AssetKindPayload {
-    init(reactModel: MarketAssetKind) {
-        switch reactModel {
-        case .crypto: self = .crypto
-        case .stock: self = .stock
-        }
-    }
-    var reactModel: MarketAssetKind {
-        switch self {
-        case .crypto: return .crypto
-        case .stock: return .stock
-        }
-    }
-}
-
 extension Models.Address {
     init(reactModel: Address) { self.init(value: reactModel.value) }
     var reactModel: Address { .init(value: value) }
@@ -226,7 +211,7 @@ extension Models.Service {
 extension Models.Counterparty {
     init(reactModel: Counterparty) throws {
         if let merchantCounterparty = reactModel.merchantCounterparty {
-            self = .MerchantCounterparty(
+            self = .merchant(
                 .init(
                     kind: .merchant,
                     name: merchantCounterparty.name,
@@ -241,7 +226,7 @@ extension Models.Counterparty {
                 )
             )
         } else if let userCounterparty = reactModel.userCounterparty {
-            self = .UserCounterparty(
+            self = .user(
                 .init(
                     kind: .user,
                     legalName: userCounterparty.legalName,
@@ -250,7 +235,7 @@ extension Models.Counterparty {
                 )
             )
         } else if let serviceCounterparty = reactModel.serviceCounterparty {
-            self = .ServiceCounterparty(
+            self = .service(
                 .init(kind: .service, service: .init(reactModel: serviceCounterparty.service))
             )
         } else {
@@ -259,18 +244,18 @@ extension Models.Counterparty {
     }
     var reactModel: Counterparty {
         switch self {
-        case .MerchantCounterparty(let merchantCounterparty):
+        case .merchant(let merchantCounterparty):
             return .init(
                 merchantCounterparty: .init(
                     kind: merchantCounterparty.kind.rawValue,
                     name: merchantCounterparty.name,
                     logoURL: merchantCounterparty.logoURL,
-                    location: merchantCounterparty.location.map(\.reactModel)
+                    location: merchantCounterparty.location.map { $0.reactModel }
                 ),
                 userCounterparty: nil,
                 serviceCounterparty: nil
             )
-        case .UserCounterparty(let userCounterparty):
+        case .user(let userCounterparty):
             return .init(
                 merchantCounterparty: nil,
                 userCounterparty: .init(
@@ -281,7 +266,7 @@ extension Models.Counterparty {
                 ),
                 serviceCounterparty: nil
             )
-        case .ServiceCounterparty(let serviceCounterparty):
+        case .service(let serviceCounterparty):
             return .init(
                 merchantCounterparty: nil,
                 userCounterparty: nil,
@@ -297,7 +282,7 @@ extension Models.Counterparty {
 extension Models.TradeAsset {
     init(reactModel: TradeAsset) throws {
         if let fiatAsset = reactModel.fiatAsset {
-            self = .FiatAsset(
+            self = .fiat(
                 .init(
                     assetKind: .fiat,
                     serviceTradeID: fiatAsset.serviceTradeID,
@@ -308,24 +293,40 @@ extension Models.TradeAsset {
                     service: .init(reactModel: fiatAsset.service)
                 )
             )
-        } else if let marketAsset = reactModel.marketTradeAsset {
-            self = .MarketTradeAsset(
+        } else if let cryptoAsset = reactModel.cryptoAsset {
+            self = .crypto(
                 .init(
-                    assetKind: .init(reactModel: marketAsset.assetKind),
-                    serviceAccountID: marketAsset.serviceAccountID,
-                    serviceAssetID: marketAsset.serviceAssetID,
-                    symbol: marketAsset.symbol,
-                    amount: marketAsset.amount,
-                    serviceTradeID: marketAsset.serviceTradeID,
-                    linkedAccountID: marketAsset.linkedAccountID,
-                    service: .init(reactModel: marketAsset.service),
-                    name: marketAsset.name,
-                    color: marketAsset.color,
-                    logoURL: marketAsset.logoURL
+                    assetKind: .crypto,
+                    serviceTradeID: cryptoAsset.serviceTradeID,
+                    serviceAccountID: cryptoAsset.serviceAccountID,
+                    serviceAssetID: cryptoAsset.serviceAssetID,
+                    symbol: cryptoAsset.symbol,
+                    amount: cryptoAsset.amount,
+                    linkedAccountID: cryptoAsset.linkedAccountID,
+                    service: .init(reactModel: cryptoAsset.service),
+                    name: cryptoAsset.name,
+                    color: cryptoAsset.color,
+                    logoURL: cryptoAsset.logoURL
+                )
+            )
+        } else if let stockAsset = reactModel.stockAsset {
+            self = .stock(
+                .init(
+                    assetKind: .stock,
+                    serviceTradeID: stockAsset.serviceTradeID,
+                    serviceAccountID: stockAsset.serviceAccountID,
+                    serviceAssetID: stockAsset.serviceAssetID,
+                    symbol: stockAsset.symbol,
+                    amount: stockAsset.amount,
+                    linkedAccountID: stockAsset.linkedAccountID,
+                    service: .init(reactModel: stockAsset.service),
+                    name: stockAsset.name,
+                    color: stockAsset.color,
+                    logoURL: stockAsset.logoURL
                 )
             )
         } else if let transportAsset = reactModel.transportAsset {
-            self = .TransportAsset(
+            self = .transport(
                 .init(
                     assetKind: .transport,
                     serviceTradeID: transportAsset.serviceTradeID,
@@ -347,17 +348,34 @@ extension Models.TradeAsset {
                     service: .init(reactModel: transportAsset.service)
                 )
             )
+        } else if let eventAsset = reactModel.eventAsset {
+            self = .event(
+                .init(
+                    assetKind: .event,
+                    serviceTradeID: eventAsset.serviceTradeID,
+                    serviceAssetID: eventAsset.serviceAssetID,
+                    name: eventAsset.name,
+                    description: eventAsset.description,
+                    imageURL: eventAsset.imageURL,
+                    locationCoordinates: .init(reactModel: eventAsset.locationCoordinates),
+                    locationAddress: .init(reactModel: eventAsset.locationAddress),
+                    partySize: eventAsset.partySize,
+                    dateTime: eventAsset.dateTime,
+                    linkedAccountID: eventAsset.linkedAccountID,
+                    service: .init(reactModel: eventAsset.service)
+                )
+            )
         } else if reactModel.otherAsset != nil {
-            self = .OtherAsset(.init(assetKind: .other))
+            self = .other(.init(assetKind: .other))
         } else if reactModel.nothingAsset != nil {
-            self = .NothingAsset(.init(assetKind: .nothing))
+            self = .nothing(.init(assetKind: .nothing))
         } else {
             throw CandleError.unexpected(message: "Internal Candle Error: corrupted trade asset.")
         }
     }
     var reactModel: TradeAsset {
         switch self {
-        case .FiatAsset(let fiatAsset):
+        case .fiat(let fiatAsset):
             return .init(
                 fiatAsset: .init(
                     assetKind: fiatAsset.assetKind.rawValue,
@@ -368,35 +386,62 @@ extension Models.TradeAsset {
                     linkedAccountID: fiatAsset.linkedAccountID,
                     service: fiatAsset.service.reactModel
                 ),
-                marketTradeAsset: nil,
+                cryptoAsset: nil,
+                stockAsset: nil,
+                transportAsset: nil,
+                eventAsset: nil,
+                otherAsset: nil,
+                nothingAsset: nil
+            )
+        case .crypto(let cryptoAsset):
+            return .init(
+                fiatAsset: nil,
+                cryptoAsset: .init(
+                    assetKind: cryptoAsset.assetKind.rawValue,
+                    serviceAccountID: cryptoAsset.serviceAccountID,
+                    serviceAssetID: cryptoAsset.serviceAssetID,
+                    symbol: cryptoAsset.symbol,
+                    amount: cryptoAsset.amount,
+                    serviceTradeID: cryptoAsset.serviceTradeID,
+                    linkedAccountID: cryptoAsset.linkedAccountID,
+                    name: cryptoAsset.name,
+                    color: cryptoAsset.color,
+                    logoURL: cryptoAsset.logoURL,
+                    service: cryptoAsset.service.reactModel
+                ),
+                stockAsset: nil,
                 transportAsset: nil,
+                eventAsset: nil,
                 otherAsset: nil,
                 nothingAsset: nil
             )
-        case .MarketTradeAsset(let marketAsset):
+        case .stock(let stockAsset):
             return .init(
                 fiatAsset: nil,
-                marketTradeAsset: .init(
-                    assetKind: marketAsset.assetKind.reactModel,
-                    serviceAccountID: marketAsset.serviceAccountID,
-                    serviceAssetID: marketAsset.serviceAssetID,
-                    symbol: marketAsset.symbol,
-                    amount: marketAsset.amount,
-                    serviceTradeID: marketAsset.serviceTradeID,
-                    linkedAccountID: marketAsset.linkedAccountID,
-                    name: marketAsset.name,
-                    color: marketAsset.color,
-                    logoURL: marketAsset.logoURL,
-                    service: marketAsset.service.reactModel
+                cryptoAsset: nil,
+                stockAsset: .init(
+                    assetKind: stockAsset.assetKind.rawValue,
+                    serviceAccountID: stockAsset.serviceAccountID,
+                    serviceAssetID: stockAsset.serviceAssetID,
+                    symbol: stockAsset.symbol,
+                    amount: stockAsset.amount,
+                    serviceTradeID: stockAsset.serviceTradeID,
+                    linkedAccountID: stockAsset.linkedAccountID,
+                    name: stockAsset.name,
+                    color: stockAsset.color,
+                    logoURL: stockAsset.logoURL,
+                    service: stockAsset.service.reactModel
                 ),
                 transportAsset: nil,
+                eventAsset: nil,
                 otherAsset: nil,
                 nothingAsset: nil
             )
-        case .TransportAsset(let transportAsset):
+        case .transport(let transportAsset):
             return .init(
                 fiatAsset: nil,
-                marketTradeAsset: nil,
+                cryptoAsset: nil,
+                stockAsset: nil,
                 transportAsset: .init(
                     assetKind: transportAsset.assetKind.rawValue,
                     serviceTradeID: transportAsset.serviceTradeID,
@@ -415,22 +460,50 @@ extension Models.TradeAsset {
                     linkedAccountID: transportAsset.linkedAccountID,
                     service: transportAsset.service.reactModel
                 ),
+                eventAsset: nil,
+                otherAsset: nil,
+                nothingAsset: nil
+            )
+        case .event(let eventAsset):
+            return .init(
+                fiatAsset: nil,
+                cryptoAsset: nil,
+                stockAsset: nil,
+                transportAsset: nil,
+                eventAsset: .init(
+                    assetKind: eventAsset.assetKind.rawValue,
+                    serviceTradeID: eventAsset.serviceTradeID,
+                    serviceAssetID: eventAsset.serviceAssetID,
+                    name: eventAsset.name,
+                    description: eventAsset.description,
+                    imageURL: eventAsset.imageURL,
+                    locationCoordinates: eventAsset.locationCoordinates.reactModel,
+                    locationAddress: eventAsset.locationAddress.reactModel,
+                    partySize: eventAsset.partySize,
+                    dateTime: eventAsset.dateTime,
+                    linkedAccountID: eventAsset.linkedAccountID,
+                    service: eventAsset.service.reactModel
+                ),
                 otherAsset: nil,
                 nothingAsset: nil
             )
-        case .OtherAsset(let otherAsset):
+        case .other(let otherAsset):
             return .init(
                 fiatAsset: nil,
-                marketTradeAsset: nil,
+                cryptoAsset: nil,
+                stockAsset: nil,
                 transportAsset: nil,
+                eventAsset: nil,
                 otherAsset: .init(assetKind: otherAsset.assetKind.rawValue),
                 nothingAsset: nil
             )
-        case .NothingAsset(let nothingAsset):
+        case .nothing(let nothingAsset):
             return .init(
                 fiatAsset: nil,
-                marketTradeAsset: nil,
+                cryptoAsset: nil,
+                stockAsset: nil,
                 transportAsset: nil,
+                eventAsset: nil,
                 otherAsset: nil,
                 nothingAsset: .init(assetKind: nothingAsset.assetKind.rawValue)
             )
@@ -454,7 +527,7 @@ extension Candle.Models.LinkedAccount {
 extension Candle.Models.LinkedAccountDetails {
     var reactModel: LinkedAccountDetails {
         switch self {
-        case .ActiveLinkedAccountDetails(let activeDetails):
+        case .active(let activeDetails):
             return .init(
                 activeLinkedAccountDetails: .init(
                     state: activeDetails.state.rawValue,
@@ -466,21 +539,18 @@ extension Candle.Models.LinkedAccountDetails {
                 inactiveLinkedAccountDetails: nil,
                 unavailableLinkedAccountDetails: nil,
             )
-        case .InactiveLinkedAccountDetails(let inactiveDetails):
-            switch inactiveDetails.state {
-            case .inactive:
-                return .init(
-                    activeLinkedAccountDetails: nil,
-                    inactiveLinkedAccountDetails: .init(state: inactiveDetails.state.rawValue),
-                    unavailableLinkedAccountDetails: nil,
-                )
-            case .unavailable:
-                return .init(
-                    activeLinkedAccountDetails: nil,
-                    inactiveLinkedAccountDetails: nil,
-                    unavailableLinkedAccountDetails: .init(state: inactiveDetails.state.rawValue)
-                )
-            }
+        case .inactive(let inactiveDetails):
+            return .init(
+                activeLinkedAccountDetails: nil,
+                inactiveLinkedAccountDetails: .init(state: inactiveDetails.state.rawValue),
+                unavailableLinkedAccountDetails: nil,
+            )
+        case .unavailable(let unavailableDetails):
+            return .init(
+                activeLinkedAccountDetails: nil,
+                inactiveLinkedAccountDetails: nil,
+                unavailableLinkedAccountDetails: .init(state: unavailableDetails.state.rawValue)
+            )
         }
     }
 }
@@ -495,33 +565,6 @@ extension Models.MerchantLocation {
     }
 }
 
-extension Models.MarketAssetQuoteRequest.AssetKindPayload {
-    init(reactModel: MarketAssetKind) {
-        switch reactModel {
-        case .crypto: self = .crypto
-        case .stock: self = .stock
-        }
-    }
-}
-
-extension Models.MarketAssetRef.AssetKindPayload {
-    init(reactModel: MarketAssetKind) {
-        switch reactModel {
-        case .crypto: self = .crypto
-        case .stock: self = .stock
-        }
-    }
-}
-
-extension Models.MarketAccount.AssetKindPayload {
-    var reactModel: MarketAssetKind {
-        switch self {
-        case .crypto: return .crypto
-        case .stock: return .stock
-        }
-    }
-}
-
 extension Models.Trade {
     var reactModel: Trade {
         .init(
@@ -534,37 +577,6 @@ extension Models.Trade {
     }
 }
 
-extension Models.FiatMarketAccountKind {
-    var reactModel: FiatMarketAccountKind {
-        switch self {
-        case .individual: return .individual
-        case .joint: return .joint
-        case .rothIra: return .rothira
-        case .traditionalIra: return .traditionalira
-        case .business: return .business
-        }
-    }
-}
-
-extension Models.TransportAccountKind {
-    var reactModel: TransportAccountKind {
-        switch self {
-        case .individual: return .individual
-        case .joint: return .joint
-        case .business: return .business
-        }
-    }
-}
-
-extension Models.ACHAccountKind {
-    var reactModel: ACHAccountKind {
-        switch self {
-        case .checking: return .checking
-        case .savings: return .savings
-        }
-    }
-}
-
 extension Models.Trade.StatePayload {
     var reactModel: TradeState {
         switch self {
@@ -596,9 +608,40 @@ extension Models.LinkedAccountStatusRef {
     }
 }
 
+extension Models.ACHAccountKind {
+    var reactModel: ACHAccountKind {
+        switch self {
+        case .checking: return .checking
+        case .savings: return .savings
+        }
+    }
+}
+
+extension Models.FinancialAccountKind {
+    var reactModel: FinancialAccountKind {
+        switch self {
+        case .individual: return .individual
+        case .joint: return .joint
+        case .traditionalIra: return .traditionalira
+        case .rothIra: return .rothira
+        case .business: return .business
+        }
+    }
+}
+
+extension Models.TransportAccountKind {
+    var reactModel: TransportAccountKind {
+        switch self {
+        case .individual: return .individual
+        case .joint: return .joint
+        case .business: return .business
+        }
+    }
+}
+
 extension Models.ACHDetails {
     var reactModel: ACHDetails {
-        .init(
+        return .init(
             accountNumber: accountNumber,
             routingNumber: routingNumber,
             accountKind: accountKind.reactModel
@@ -615,7 +658,7 @@ extension Models.WireDetails {
 extension Models.AssetAccount {
     var reactModel: AssetAccount {
         switch self {
-        case .FiatAccount(let fiatDetails):
+        case .fiat(let fiatDetails):
             return AssetAccount(
                 fiatAccount: .init(
                     assetKind: fiatDetails.assetKind.rawValue,
@@ -624,31 +667,48 @@ extension Models.AssetAccount {
                     nickname: fiatDetails.nickname,
                     currencyCode: fiatDetails.currencyCode,
                     balance: fiatDetails.balance,
-                    ach: fiatDetails.ach.map(\.reactModel),
-                    wire: fiatDetails.wire.map(\.reactModel),
+                    ach: fiatDetails.ach.map { $0.reactModel },
+                    wire: fiatDetails.wire.map { $0.reactModel },
                     linkedAccountID: fiatDetails.linkedAccountID,
                     service: fiatDetails.service.reactModel
                 ),
-                marketAccount: nil,
+                cryptoAccount: nil,
+                stockAccount: nil,
+                transportAccount: nil
+            )
+        case .crypto(let cryptoDetails):
+            return AssetAccount(
+                fiatAccount: nil,
+                cryptoAccount: .init(
+                    assetKind: cryptoDetails.assetKind.rawValue,
+                    serviceAccountID: cryptoDetails.serviceAccountID,
+                    accountKind: cryptoDetails.accountKind.reactModel,
+                    nickname: cryptoDetails.nickname,
+                    linkedAccountID: cryptoDetails.linkedAccountID,
+                    service: cryptoDetails.service.reactModel
+                ),
+                stockAccount: nil,
                 transportAccount: nil
             )
-        case .MarketAccount(let marketDetails):
+        case .stock(let stockDetails):
             return AssetAccount(
                 fiatAccount: nil,
-                marketAccount: .init(
-                    assetKind: marketDetails.assetKind.reactModel,
-                    serviceAccountID: marketDetails.serviceAccountID,
-                    accountKind: marketDetails.accountKind.reactModel,
-                    nickname: marketDetails.nickname,
-                    linkedAccountID: marketDetails.linkedAccountID,
-                    service: marketDetails.service.reactModel
+                cryptoAccount: nil,
+                stockAccount: .init(
+                    assetKind: stockDetails.assetKind.rawValue,
+                    serviceAccountID: stockDetails.serviceAccountID,
+                    accountKind: stockDetails.accountKind.reactModel,
+                    nickname: stockDetails.nickname,
+                    linkedAccountID: stockDetails.linkedAccountID,
+                    service: stockDetails.service.reactModel
                 ),
                 transportAccount: nil
             )
-        case .TransportAccount(let transportDetails):
+        case .transport(let transportDetails):
             return AssetAccount(
                 fiatAccount: nil,
-                marketAccount: nil,
+                cryptoAccount: nil,
+                stockAccount: nil,
                 transportAccount: .init(
                     assetKind: transportDetails.assetKind.rawValue,
                     serviceAccountID: transportDetails.serviceAccountID,
@@ -732,7 +792,7 @@ extension Models.TradeQuotesRequest {
 extension Models.TradeAssetQuoteRequest {
     init(reactModel: TradeAssetQuoteRequest) throws {
         if let fiatAssetQuoteRequest = reactModel.fiatAssetQuoteRequest {
-            self = .FiatAssetQuoteRequest(
+            self = .fiat(
                 .init(
                     assetKind: .fiat,
                     serviceAccountID: fiatAssetQuoteRequest.serviceAccountID,
@@ -740,18 +800,28 @@ extension Models.TradeAssetQuoteRequest {
                     amount: fiatAssetQuoteRequest.amount
                 )
             )
-        } else if let marketAssetQuoteRequest = reactModel.marketAssetQuoteRequest {
-            self = .MarketAssetQuoteRequest(
+        } else if let cryptoAssetQuoteRequest = reactModel.cryptoAssetQuoteRequest {
+            self = .crypto(
                 .init(
-                    assetKind: .init(reactModel: marketAssetQuoteRequest.assetKind),
-                    serviceAccountID: marketAssetQuoteRequest.serviceAccountID,
-                    serviceAssetID: marketAssetQuoteRequest.serviceAssetID,
-                    symbol: marketAssetQuoteRequest.symbol,
-                    amount: marketAssetQuoteRequest.amount
+                    assetKind: .crypto,
+                    serviceAccountID: cryptoAssetQuoteRequest.serviceAccountID,
+                    serviceAssetID: cryptoAssetQuoteRequest.serviceAssetID,
+                    symbol: cryptoAssetQuoteRequest.symbol,
+                    amount: cryptoAssetQuoteRequest.amount
+                )
+            )
+        } else if let stockAssetQuoteRequest = reactModel.stockAssetQuoteRequest {
+            self = .stock(
+                .init(
+                    assetKind: .stock,
+                    serviceAccountID: stockAssetQuoteRequest.serviceAccountID,
+                    serviceAssetID: stockAssetQuoteRequest.serviceAssetID,
+                    symbol: stockAssetQuoteRequest.symbol,
+                    amount: stockAssetQuoteRequest.amount
                 )
             )
         } else if let transportAssetQuoteRequest = reactModel.transportAssetQuoteRequest {
-            self = .TransportAssetQuoteRequest(
+            self = .transport(
                 .init(
                     assetKind: .transport,
                     serviceAssetID: transportAssetQuoteRequest.serviceAssetID,
@@ -771,10 +841,19 @@ extension Models.TradeAssetQuoteRequest {
                     serviceAccountID: transportAssetQuoteRequest.serviceAccountID
                 )
             )
+        } else if let eventAssetQuoteRequest = reactModel.eventAssetQuoteRequest {
+            self = .event(
+                .init(
+                    assetKind: .event,
+                    serviceAssetID: eventAssetQuoteRequest.serviceAssetID,
+                    partySize: eventAssetQuoteRequest.partySize,
+                    dateTime: eventAssetQuoteRequest.dateTime
+                )
+            )
         } else if reactModel.nothingAssetQuoteRequest != nil {
-            self = .NothingAssetQuoteRequest(.init(assetKind: .nothing))
+            self = .nothing(.init(assetKind: .nothing))
         } else if reactModel.otherAssetQuoteRequest != nil {
-            self = .OtherAssetQuoteRequest(.init(assetKind: .other))
+            self = .other(.init(assetKind: .other))
         } else {
             throw CandleError.unexpected(
                 message: "Internal Candle Error: corrupted trade asset quote request."
@@ -786,11 +865,21 @@ extension Models.TradeAssetQuoteRequest {
 extension Models.CounterpartyQuoteRequest {
     init(reactModel: CounterpartyQuoteRequest) throws {
         if let merchantCounterpartyQuoteRequest = reactModel.merchantCounterpartyQuoteRequest {
-            self = .MerchantCounterpartyQuoteRequest(
-                .init(kind: .merchant, name: merchantCounterpartyQuoteRequest.name)
+            self = .merchant(
+                .init(
+                    kind: .merchant,
+                    name: merchantCounterpartyQuoteRequest.name,
+                    location: merchantCounterpartyQuoteRequest.location.map {
+                        .init(
+                            countryCode: $0.countryCode,
+                            countrySubdivisionCode: $0.countrySubdivisionCode,
+                            localityName: $0.localityName
+                        )
+                    }
+                )
             )
         } else if let userCounterpartyQuoteRequest = reactModel.userCounterpartyQuoteRequest {
-            self = .UserCounterpartyQuoteRequest(
+            self = .user(
                 .init(
                     kind: .user,
                     legalName: userCounterpartyQuoteRequest.legalName,
@@ -798,7 +887,7 @@ extension Models.CounterpartyQuoteRequest {
                 )
             )
         } else if reactModel.serviceCounterpartyQuoteRequest != nil {
-            self = .ServiceCounterpartyQuoteRequest(.init(kind: .service))
+            self = .service(.init(kind: .service))
         } else {
             throw CandleError.unexpected(
                 message: "Internal Candle Error: corrupted counterparty quote request."
@@ -836,6 +925,7 @@ extension Models.GetTrades.Input.Query.GainedAssetKindPayload {
         case .stock: self = .stock
         case .crypto: self = .crypto
         case .transport: self = .transport
+        case .event: self = .event
         case .other: self = .other
         case .nothing: self = .nothing
         }
@@ -849,6 +939,7 @@ extension Models.GetTrades.Input.Query.LostAssetKindPayload {
         case .stock: self = .stock
         case .crypto: self = .crypto
         case .transport: self = .transport
+        case .event: self = .event
         case .other: self = .other
         case .nothing: self = .nothing
         }
@@ -868,35 +959,49 @@ extension Models.GetTrades.Input.Query.CounterpartyKindPayload {
 extension Models.TradeAssetRef {
     init(reactModel: TradeAssetRef) throws {
         if let fiatAssetRef = reactModel.fiatAssetRef {
-            self = .FiatAssetRef(
+            self = .fiat(
                 .init(
                     assetKind: .fiat,
                     serviceTradeID: fiatAssetRef.serviceTradeID,
                     linkedAccountID: fiatAssetRef.linkedAccountID
                 )
             )
-        } else if let marketTradeAssetRef = reactModel.marketTradeAssetRef {
-            self = .MarketAssetRef(
+        } else if let cryptoAssetRef = reactModel.cryptoAssetRef {
+            self = .crypto(
                 .init(
-                    assetKind: Models.MarketAssetRef.AssetKindPayload.init(
-                        reactModel: marketTradeAssetRef.assetKind
-                    ),
-                    serviceTradeID: marketTradeAssetRef.serviceTradeID,
-                    linkedAccountID: marketTradeAssetRef.linkedAccountID
+                    assetKind: .crypto,
+                    serviceTradeID: cryptoAssetRef.serviceTradeID,
+                    linkedAccountID: cryptoAssetRef.linkedAccountID
+                )
+            )
+        } else if let stockAssetRef = reactModel.stockAssetRef {
+            self = .stock(
+                .init(
+                    assetKind: .stock,
+                    serviceTradeID: stockAssetRef.serviceTradeID,
+                    linkedAccountID: stockAssetRef.linkedAccountID
                 )
             )
         } else if let transportAssetRef = reactModel.transportAssetRef {
-            self = .TransportAssetRef(
+            self = .transport(
                 .init(
                     assetKind: .transport,
                     serviceTradeID: transportAssetRef.serviceTradeID,
                     linkedAccountID: transportAssetRef.linkedAccountID
                 )
             )
+        } else if let eventAssetRef = reactModel.eventAssetRef {
+            self = .event(
+                .init(
+                    assetKind: .event,
+                    serviceTradeID: eventAssetRef.serviceTradeID,
+                    linkedAccountID: eventAssetRef.linkedAccountID
+                )
+            )
         } else if reactModel.otherAssetRef != nil {
-            self = .OtherAsset(.init(assetKind: .other))
+            self = .other(.init(assetKind: .other))
         } else if reactModel.nothingAssetRef != nil {
-            self = .NothingAsset(.init(assetKind: .nothing))
+            self = .nothing(.init(assetKind: .nothing))
         } else {
             throw CandleError.unexpected(
                 message: "Internal Candle Error: corrupted trade asset ref."