Additional classes

struct CRPTAddCardModel {
 	var billingAddress: CRPTBillingAddressModel
 	var cardExpirationMonth: Int
	var cardExpirationYear:	Int
	var cardHolder:	String
	var cardNumber:	Int64
}

class CRPTAddCardModel(
    val billingAddress: CRPTBillingAddressModel?,
    val cardExpirationMonth: Int?,
    val cardExpirationYear: Int?,
    val cardHolder: String?,
    val cardNumber: Long?
)

struct CRPTAmount {
  var value: Decimal
  var currency: CRPTCurrency
}

class CRPTAmount(
  var amount: BigDecimal,
  var sourceCurrency: String?    
)

enum CRPTBillingAddressModel: String {
  var countryCode: String
  var city: String
  var address: String
  var zip: String
}

class CRPTBillingAddressModel (
    val countryCode: String?,
    val city: String?,
    val address: String?,
    val zip: String?
)

struct CRPTCardModel {
  var cardId: Int64?
  var maskedPan: String?
  var billingAddressRequired: Bool?
  var validationStatus: CRPTCardDescriptorStatus? 
}

class CRPTCardModel(
    val cardId: Int?,
    val maskedPan: String?,
    val billingAddressRequired: Boolean?,
    val validationStatus: CRPTCardDescriptorStatus?
)

enum CRPTCardDescriptorStatus: String {
  case new = “NEW”
  case approved = “APPROVED”
  case unavailable = “UNAVAILABLE”
}

enum class CRPTCardDescriptorStatus {
    NEW, APPROVED, UNAVAILABLE
}

struct CRPTCountry {
  var name:	String
  var code: String
  var isoCode: String 
}

class CRPTCountry(
    var code: String,
    var name: String,
    var isoCode: String,
)

enum CRPTCurrency: String {
  case btc = “BTC”
  case bch = “BCH”
  case eth = “ETH”
  case xrp = “XRP”
  ...
}

enum class CRPTCurrency {
    BTC, BCH, ETH, XRP, LTC, CRPT, USDC, USDT, EUR, MKR, QASH, LINK, BAT, DAI, EURS,...
}

typealias CRPTCustomerOperations = [CrypteriumOperationView]

class CRPTCustomerOperations {
    var operations: List<CRPTCustomerOperation>? = null
}

struct CustomerProfile {
   var country: String?  
   var email: String?  
   var firstName: String?
   var lastName: String?  
   var phone: String?  
   var primaryCurrency: String? 
}

class CRPTCustomerProfile(
	 val country: String?,  
   val email: String?,  
   val firstName: String?,
   val lastName: String?,  
   val mobile: String?,  
   val primaryCurrency: String? 
)

struct CRPTError: Error {
  var code: Int?
  var type: CRPTErrorType?
  var message: String?
}

enum CRPTErrorType: String {
  case cancelled = “CANCELLED”
  case verified = “VERIFIED”
  case noData = “NO_DATA”
  case maintenance = “MAINTENANCE”
  case update = “UPDATE”
  case limits = “LIMITS”
  case kyc0 = “KYC0”
  case kyc1 = “KYC1"
  case kyc2 = “KYC2”
  case backend = “BACKEND”
  case internet = “INTERNET”
  case validation = “VALIDATION”
  case authorization = “AUTHORIZATION”
  case billingRequired = “BILLING_REQUIRED”
  case amount = “AMOUNT”
}

class CRPTError(
    val code: Int?
    val type: CRPTErrorType?
    val message: String?
) 
  
enum class CRPTErrorType(val value: String) {
    CANCEL("CANCEL"),
    NO_DATA("NO_DATA"),
    MAINTENANCE("MAINTENANCE"),
    UPDATE("UPDATE"),
    LIMITS("LIMITS"),
    KYC0("KYC0"),
    KYC1("KYC1"),
    KYC2("KYC2"),
    BACKEND("BACKEND"),
    INTERNET("INTERNET"),
    VALIDATION("VALIDATION"),
    VERIFIED("VERIFIED"),
    AUTHORIZATION("AUTHORIZATION")
}

struct CRPTKYCState {
	level:	CRPTKYCType
	status:	CRPTKYCStatus
}

class CRPTKYCState(
    val kycLevels: ArrayList<CRPTKYCLevel> = ArrayList()
)
  
class CRPTKYCLevel(
    val level: CRPTKYCType,
    val status: CRPTKYCStatus
)

enum CRPTKYCStatus: String {
  case _none = "NONE"
  case inProgress = "IN_PROGRESS"
  case rejected = "REJECTED"
  case approved = "APPROVED"
}

enum class CRPTKYCStatus(val type: String) {
    IN_PROGRESS("IN_PROGRESS"),
    REJECTED("REJECTED"),
    APPROVED("APPROVED"),
    NONE("NONE"),
}

enum CRPTKYCType: String {
  case kyc0 = “KYC0”
  case kyc1 = “KYC1”
  case kyc2 = “KYC2”
}

enum class CRPTKYCType(val type: String) {
    KYC0("KYC0"),
    KYC1("KYC1"),
    KYC2("KYC2"),
}

struct CRPTLimits {
  let minAmountFrom: Decimal
  let maxAmountFrom: Decimal
}

class CRPTLimits(
    var min: BigDecimal?,
    var max: BigDecimal?
)

enum CRPTTransactionStatus: String {
  case success = “SUCCESS”
  case pending = “PENDING”
  case confirmation = “CONFIRMATION”
  case failure = “FAILURE”
}

enum class CRPTTransactionStatus {
    SUCCESS, PENDING, CONFIRMATION, FAILURE
}

struct CrypteriumOperationView {
  var constraint: Constraint
  var kycLevelPermissibleList: [FoundationElement<KycLevelPermissibleList>]?
  var name: String
}

class CRPTCustomerOperation  {
    var name: OperationName? 
    var constraint: String? 
    var kycLevelPermissibleList: ArrayList<KycLevel>?
}

enum Constraint: String { 
    case _none = “NONE”
    case kycRequired = “KYC_REQUIRED”
    case kycVerifying = “KYC_VERIFYING”
    case kycDenied = “KYC_DENIED”
    case kycRejected = “KYC_REJECTED”
    case maintenance = “MAINTENANCE”
    case update = “UPDATE”
  }

enum KycLevelPermissibleList: String {
  case _none = “NONE”
  case kyc0 = “KYC_0”
  case kyc1 = “KYC_1"
  case kyc2 = “KYC_2”
}

enum class KycLevel {
    NONE,
    KYC_0,
    KYC_1,
    KYC_2;
}

payout.averageFee(for amount: Decimal, completion: (CRPTFeeResult) -> Void)

payout.averageFee(amount: BigDecimal, completion: (CRPTFeeResult) -> Unit)

struct WalletModel {
   var address: String?
   var balance: Decimal?  
   var currency: String
   var fiat: WalletFiatView?
   var id: Int64? 
   var scale: Int?   
}

class CRPTCustomerAccount {
    var balance: BigDecimal?,
    var currency: String?,
    var scale: Int
}

struct WalletFiatView {
     var amount: Decimal? 
     var change: Decimal? 
     var changePercent: Decimal? 
     var customerCurrency: String? 
}