KYC JAAK para Android

[versions]
agp = "8.7.3"
kotlin = "2.1.10"
coreKtx = "1.15.0"
kspVersion = "2.1.10-1.0.31"
hiltVersion = "2.51.1"
kotlinxCoroutinesAndroid = "1.8.0"
kotlinxCoroutinesAndroidVersion = "1.8.0"
kotlinxCoroutinesCore = "1.6.0"
kotlinxCoroutinesPlayServices = "1.8.0"
lifecycleRuntimeKtx = "2.8.7"
lifecycleRuntimeKtxVersion = "2.8.7"
okhttp = "5.0.0-alpha.2"
retrofit = "2.9.0"

appcompat = "1.7.0"
material = "1.12.0"
constraintLayout = "2.2.1"
activityKtx = "1.10.1"
coreSplashscreen = "1.0.1"
jaakDocumentDetector = "2.0.5"
jaakFaceDetector = "2.0.5"
mlkitFaceDetection = "17.1.0"
cameraX = "1.4.2"
playServicesLocation = "21.3.0"
lightCompressor = "1.2.0"

[libraries]
androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
androidx-lifecycle-runtime-ktx-v241 = { module = "androidx.lifecycle:lifecycle-runtime-ktx", version.ref = "lifecycleRuntimeKtxVersion" }
androidx-lifecycle-viewmodel-ktx = { module = "androidx.lifecycle:lifecycle-viewmodel-ktx", version.ref = "lifecycleRuntimeKtx" }
androidx-lifecycle-runtime-ktx = { group = "androidx.lifecycle", name = "lifecycle-runtime-ktx", version.ref = "lifecycleRuntimeKtx" }
kotlinx-coroutines-android = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-android", version.ref = "kotlinxCoroutinesAndroid" }
kotlinx-coroutines-android-v160 = {module = "org.jetbrains.kotlinx:kotlinx-coroutines-android", version.ref = "kotlinxCoroutinesAndroidVersion" }
kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlinxCoroutinesCore" }
kotlinx-coroutines-play-services = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-play-services", version.ref = "kotlinxCoroutinesPlayServices" }
hilt-android = { group = "com.google.dagger", name = "hilt-android" , version.ref = "hiltVersion"}
hilt-compiler = { group = "com.google.dagger", name = "hilt-compiler" , version.ref = "hiltVersion"}

androidx-appcompat = { group = "androidx.appcompat", name = "appcompat", version.ref = "appcompat" }
google-material = { group = "com.google.android.material", name = "material", version.ref = "material" }
androidx-constraintlayout = { group = "androidx.constraintlayout", name = "constraintlayout", version.ref = "constraintLayout" }
androidx-activity-ktx = { group = "androidx.activity", name = "activity-ktx", version.ref = "activityKtx" }
androidx-core-splashscreen = { module = "androidx.core:core-splashscreen", version.ref = "coreSplashscreen" }

jaak-document-detector = { module = "com.jaak.documentdetectorsdk:jaakdocumentdetector-sdk", version.ref = "jaakDocumentDetector" }
jaak-face-detector = { module = "com.jaak.facedetectorsdk:jaakfacedetector-sdk", version.ref = "jaakFaceDetector" }

google-mlkit-face-detection = { module = "com.google.android.gms:play-services-mlkit-face-detection", version.ref = "mlkitFaceDetection" }

androidx-camera-camera2 = { module = "androidx.camera:camera-camera2", version.ref = "cameraX" }
androidx-camera-lifecycle = { module = "androidx.camera:camera-lifecycle", version.ref = "cameraX" }
androidx-camera-core = { module = "androidx.camera:camera-core", version.ref = "cameraX" }
androidx-camera-view = { module = "androidx.camera:camera-view", version.ref = "cameraX" }
androidx-camera-video = { module = "androidx.camera:camera-video", version.ref = "cameraX" }

google-play-services-location = { module = "com.google.android.gms:play-services-location", version.ref = "playServicesLocation" }

light-compressor = { module = "com.github.AbedElazizShe:LightCompressor", version.ref = "lightCompressor" }
retrofit = { group = "com.squareup.retrofit2", name = "retrofit", version.ref = "retrofit" }
retrofit-converter-gson = { group = "com.squareup.retrofit2", name = "converter-gson", version.ref = "retrofit" }
okhttp = { group = "com.squareup.okhttp3", name = "okhttp", version.ref = "okhttp" }
logging-interceptor = { group = "com.squareup.okhttp3", name = "logging-interceptor", version.ref = "okhttp" }

[plugins]
android-application = { id = "com.android.application", version.ref = "agp" }
kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
kotlinAndroidKsp = { id = "com.google.devtools.ksp", version.ref ="kspVersion" }
hiltAndroid = { id = "com.google.dagger.hilt.android", version.ref ="hiltVersion" }

plugins {
alias(libs.plugins.android.application) apply false
    alias(libs.plugins.kotlin.android) apply false
    alias(libs.plugins.hiltAndroid) apply false
    alias(libs.plugins.kotlinAndroidKsp) apply false
}

dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
        maven {
            url 'https://us-maven.pkg.dev/jaak-platform/jaak-android'
        }
        maven { url 'https://jitpack.io' }
        maven { url 'https://maven.microblink.com' }
    }
}

plugins {
    alias(libs.plugins.android.application)
    alias(libs.plugins.kotlin.android)
    alias(libs.plugins.kotlinAndroidKsp)
    alias(libs.plugins.hiltAndroid)
}
android {
    compileSdk 35
    defaultConfig {
        minSdk 24
        targetSdk 35
    }
  	compileOptions {
        sourceCompatibility JavaVersion.VERSION_11
        targetCompatibility JavaVersion.VERSION_11
    }
     kotlinOptions {
        jvmTarget = '11'
    }

    buildFeatures{
        viewBinding = true
    }
}
dependencies {

    // Core Android dependencies
    implementation libs.androidx.core.ktx
    implementation libs.androidx.lifecycle.runtime.ktx

    // Coroutine Lifecycle Scopes
    implementation libs.androidx.lifecycle.viewmodel.ktx
    implementation libs.androidx.lifecycle.runtime.ktx.v241

    // Coroutines
    implementation libs.kotlinx.coroutines.core
    implementation libs.kotlinx.coroutines.android

    implementation libs.kotlinx.coroutines.core
    implementation libs.kotlinx.coroutines.android.v160
    implementation libs.kotlinx.coroutines.play.services


    implementation(libs.hilt.android)
    ksp(libs.hilt.compiler)

    implementation libs.androidx.appcompat
    implementation libs.google.material
    implementation libs.androidx.constraintlayout
    implementation libs.androidx.activity.ktx
    implementation libs.androidx.lifecycle.viewmodel.ktx
    implementation libs.androidx.core.splashscreen

    implementation(libs.jaak.document.detector)
    implementation(libs.jaak.face.detector)

    implementation(libs.google.mlkit.face.detection)

    implementation(libs.androidx.camera.camera2)
    implementation(libs.androidx.camera.lifecycle)
    implementation(libs.androidx.camera.core)
    implementation(libs.androidx.camera.view)
    implementation(libs.androidx.camera.video)

    implementation(libs.google.play.services.location)

    implementation(libs.light.compressor)
    // Retrofit
    implementation(libs.retrofit)
    implementation(libs.retrofit.converter.gson)

    // OkHttp
    implementation(libs.okhttp)
    implementation(libs.logging.interceptor)
}

@POST("api/v1/kyc/session")
    suspend fun sessionApi(@Header("Short-Key") shortKey: String,
                        @Header("Origin-Device") originDevice: String
    ): Response<SessionResponse>

{}

{
  "accessToken": String,
  "step": Integer,
  "sessionId": String,
  "assets": {
    "document": null | String,
    "liveness": null | String,
  },
  "document": String
}

data class SessionResponse(
    @SerializedName("accessToken") val accessToken: String,
    @SerializedName("step") val step: Int,
    @SerializedName("sessionId") val sessionId: String,
    @SerializedName("assets") val assets: SessionAssets,
    @SerializedName("document") val document: String
)

data class SessionAssets(
    @SerializedName("document") val document: String?, 
    @SerializedName("liveness") val liveness: String? 
)

dependencies {
    implementation 'com.google.android.gms:play-services-location:21.0.1'
}

import android.Manifest
import android.annotation.SuppressLint
import android.content.pm.PackageManager
import android.os.Bundle
import android.util.Log
import androidx.activity.result.contract.ActivityResultContracts
import androidx.appcompat.app.AppCompatActivity
import androidx.core.content.ContextCompat
import com.google.android.gms.location.*

class MainActivity : AppCompatActivity() {
    private lateinit var fusedLocationClient: FusedLocationProviderClient

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        fusedLocationClient = LocationServices.getFusedLocationProviderClient(this)

        checkLocationPermission()
    }

    private fun checkLocationPermission() {
        when {
            ContextCompat.checkSelfPermission(
                this, Manifest.permission.ACCESS_FINE_LOCATION
            ) == PackageManager.PERMISSION_GRANTED -> {
                getLastKnownLocation()
            }
            else -> {
                requestPermissionLauncher.launch(Manifest.permission.ACCESS_FINE_LOCATION)
            }
        }
    }

    private val requestPermissionLauncher = registerForActivityResult(
        ActivityResultContracts.RequestPermission()
    ) { isGranted: Boolean ->
        if (isGranted) {
            getLastKnownLocation()
        } else {
            Log.e("Location", "Permiso denegado")
        }
    }

    @SuppressLint("MissingPermission")
    private fun getLastKnownLocation() {
        fusedLocationClient.lastLocation.addOnSuccessListener { location ->
            if (location != null) {
                Log.d("Location", "Latitud: ${location.latitude}, Longitud: ${location.longitude}")
            } else {
                Log.e("Location", "No se pudo obtener la ubicación")
            }
        }
    }
}

@POST("api/v1/kyc/session/location")
    suspend fun locationApi(@Body request: LocationRequest): Response<LocationResponse>

{ 
    "latitude": Double,
    "longitude": Double
}

data class LocationRequest(
       @SerializedName("latitude") val latitude: Double, 
			 @SerializedName("longitude") val longitude: Double
)

   @POST("api/v3/document/verify")
    suspend fun verifyApi(@Header("Authorization") auth: String,
                          @Body request: VerifyRequest): Response<VerifyResponse>

{
    "imageFront": String,
    "imageBack": String,
    "dataVerification": Boolean
}

data class VerifyRequest(
       @SerializedName("imageFront") val document: String, //base64
			 @SerializedName("imageBack") val document2: String?, //base64
			 @SerializedName("dataVerification") val dataVerification: Boolean
)

{
    "eventId": String,
    "requestId": String,
    "evaluation": String,
    "document": {
        "type": String,
        "side": String,
        "country": String,
        "icaoCode": String
    },
    "state": {
        "documentCompleteSides": Boolean,
        "dataConsistent": Boolean,
        "documentLiveness": Boolean,
        "securityFeatures": Boolean,
        "documentValidity": Boolean,
        "imageQuality": Boolean,
        "handPresence": Boolean,
        "message": String,
        "validations": {
            "namesMatch": Boolean,
            "lastNameMatch": Boolean,
            "birthDateMatch": Boolean,
            "personalIdNumberMatch": Boolean,
            "message": String
        },
        "photoForgery": Boolean
    },
    "processTime": Integer
}

data class VeifyResponse(
    @SerializedName("document") val document: Document,
    @SerializedName("documentType") val documentType: Int,
    @SerializedName("eventId") val eventId: String,
    @SerializedName("processTime") val processTime: Long,
    @SerializedName("requestId") val requestId: String,
    @SerializedName("state") val state: State
)
data class Document(
    @SerializedName("country") val country: String,
    @SerializedName("icaoCode") val icaoCode: String,
    @SerializedName("side") val side: String,
    @SerializedName("type") val type: String,
    @SerializedName("evaluation") val evaluation: String
)
data class State(
    @SerializedName("dataConsistent") val dataConsistent: Boolean,
    @SerializedName("documentCompleteSides") val documentCompleteSides: Boolean,
    @SerializedName("documentLiveness") val documentLiveness: Boolean,
    @SerializedName("documentValidity") val documentValidity: Boolean,
    @SerializedName("handPresence") val handPresence: Boolean,
    @SerializedName("imageQuality") val imageQuality: Boolean,
    @SerializedName("message") val message: String,
    @SerializedName("securityFeatures") val securityFeatures: Boolean
)

   @POST("api/v3/document/extract-both")
    suspend fun documentExtraBothApi(@Header("Authorization") auth: String,
                                     @Body request: DocumentExtraBothRequest): Response<DocumentExtraBothResponse>

{
  "imageFront": String,
  "imageBack": String,
  "documentSessionSelected": {
    "country": String
  }
}

data class DocumentExtraBothRequest(
    @SerializedName("imageFront") val documentFront: String, //base64
    @SerializedName("imageBack") val documentBack: String //base64
    @SerializedName("documentSessionSelected") val documentSessionSelected: DocumentSessionSelected
)

data class DocumentSessionSelected(
    @SerializedName("country") val country: String,
)

{
    "eventId": String,
    "requestId": String,
    "status": String,
 		"processingTime": String,
     "state": {
        "message": String,
        "documentCompleteSides": Boolean
    },
    "content": {
        "data": {
            "personal": {
                "firstName": String,
                "secondName": String,
                "surname": String,
                "motherSurname": String,
                "fullName": String,
                "sex": String,
                "dateOfBirth": String,
                "face": String,
                "placeOfBirth": String,
                "nationality": String,
                "maritalStatus": String,
                "extra": {
                    "ocr": String,
                    "registerYear": String,
                    "rfc": String
                }
            },
            "address": {
                "fullAddress": String,
                "postalCode": String,
                "extra": {
                    "street": String,
                    "externalNumber": String,
                    "internalNumber": String,
                    "neighborhood": String,
                    "city": String,
                    "state": String
                }
            },
            "document": {
                "type": String,
                "side": String,
                "country": {
                    "name": String,
                    "isoAlpha3Code": String,
                    "isoAlpha2Code": String,
                    "icaoCode": String
                },
                "number": String,
                "personalIdNumber": String,
                "additionalNumber": String,
                "dateOfIssue": String,
                "expiration": {
                    "date": String,
                    "isPermanent": Boolean
                },
                "issuingAuthority": String,
                "extra": {}
            }
        }
    }
}

data class DocumentExtraBothResponse(
    @SerializedName("eventId") val eventId: String,
    @SerializedName("requestId") val requestId: String,
    @SerializedName("status") val status: Boolean,
    @SerializedName("message") val message: String,
    @SerializedName("documentType") val documentType: DocumentTypeExtraBoth,
    @SerializedName("documentData") val documentData: DocumentDataExtraBoth,
    @SerializedName("documentMetadata") val documentMetadata: String,
    @SerializedName("processingTime") val processingTime: String, // milliseconds
    @SerializedName("state") val state: DocumentStateExtraBoth
)
    data class DocumentTypeExtraBoth(
    @SerializedName("type") val type: String,
    @SerializedName("side") val side: String,
    @SerializedName("country") val country: String,
    @SerializedName("icaoCode") val icaoCode: String
)
data class DocumentDataExtraBoth(
    @SerializedName("generalData") val generalData: GeneralDataExtraBoth,
    @SerializedName("mechanicalReadingZone") val mechanicalReadingZone: String,
    @SerializedName("specificData") val specificData: List<SpecificDataExtraBoth>
)
data class GeneralDataExtraBoth(
    @SerializedName("name") val name: String,
    @SerializedName("birthdate") val birthdate: String, // yyyy-mm-dd
    @SerializedName("gender") val gender: String,
    @SerializedName("nationality") val nationality: String,
    @SerializedName("documentNumber") val documentNumber: String
)
data class SpecificDataExtraBoth(
    @SerializedName("field") val field: String?,
    @SerializedName("value") val value: String?
)
data class DocumentStateExtraBoth(
    @SerializedName("message") val message: String,
    @SerializedName("isExpired") val isExpired: Boolean,
    @SerializedName("isUnderAge") val isUnderAge: Boolean,
    @SerializedName("supportedDocument") val supportedDocument: Boolean
)

@POST("api/v2/blacklist/investigate")
    suspend fun livenessVerifyApi(@Header("Authorization") auth: String,
                                  @Body request: InvestigateRequest): Response<InvestigateResponse>

{
    "services": {
        "ine": Boolean,
        "interpol": Boolean,
        "ofac": Boolean,
        "renapo": {
            "curp": Boolean
        },
        "sat": {
            "sat69b": Boolean
        },
        "cdc": {
            "rccFico": Boolean
        }
    },
    "payload": {
        "person": {
            "name": String,
            "secondName": String,
            "lastName": String,
            "secondLastName": String,
            "birthDate": String,
            "nationality": String,
            "additionalLastName": String
        },
        "address": {
            "address": String,
            "neighborhood": String,
            "municipality": String,
            "city": String,
            "state": String,
            "postalCode": String
        },
        "identifications": {
            "curp": String,
            "rfc": String,
            "socialSecurityNumber": String,
            "electorKey": String,
            "ine": {
                "cic": String,
                "ocr": String
            }
        },
        "extras": {
            "commonId": String,
            "wantedIn": String
        }
    }
}

 data class InvestigateRequest(
    @SerializedName("services") val services: Services,
    @SerializedName("payload") val payload: Payload
)

data class Services(
    @SerializedName("ine") val ine: Boolean,
    @SerializedName("interpol") val interpol: Boolean,
    @SerializedName("ofac") val ofac: Boolean,
    @SerializedName("renapo") val renapo: Renapo,
    @SerializedName("sat") val sat: Sat,
    @SerializedName("cdc") val cdc: Cdc
)

data class Renapo(
    @SerializedName("curp") val curp: Boolean
)

data class Sat(
    @SerializedName("sat69b") val sat69b: Boolean
)

data class Cdc(
    @SerializedName("rccFico") val rccFico: Boolean
)

data class Payload(
    @SerializedName("person") val person: Person,
    @SerializedName("address") val address: Address,
    @SerializedName("identifications") val identifications: Identifications,
    @SerializedName("extras") val extras: Extras
)

data class Person(
    @SerializedName("name") val name: String,
    @SerializedName("secondName") val secondName: String,
    @SerializedName("lastName") val lastName: String,
    @SerializedName("secondLastName") val secondLastName: String,
    @SerializedName("birthDate") val birthDate: String,
    @SerializedName("nationality") val nationality: String,
    @SerializedName("additionalLastName") val additionalLastName: String
)

data class Address(
    @SerializedName("address") val address: String,
    @SerializedName("neighborhood") val neighborhood: String,
    @SerializedName("municipality") val municipality: String,
    @SerializedName("city") val city: String,
    @SerializedName("state") val state: String,
    @SerializedName("postalCode") val postalCode: String
)

data class Identifications(
    @SerializedName("curp") val curp: String,
    @SerializedName("rfc") val rfc: String,
    @SerializedName("socialSecurityNumber") val socialSecurityNumber: String,
    @SerializedName("electorKey") val electorKey: String,
    @SerializedName("ine") val ine: Ine
)

data class Ine(
    @SerializedName("cic") val cic: String,
    @SerializedName("ocr") val ocr: String
)

data class Extras(
    @SerializedName("commonId") val commonId: String,
    @SerializedName("wantedIn") val wantedIn: String
)

{
    "eventId": String,
    "responseId": String,
    "processTime": Double,
    "organization": String,
    "service": String,
    "result": {},
    "state": {
        "foundInService": Bolean,
        "mustBeFound": Boolean,
        "message": String
    }
}

data class InvestigateResponse(
    @SerializedName("eventId") val eventId: String,
    @SerializedName("responseId") val responseId: String,
    @SerializedName("processTime") val processTime: Double,
    @SerializedName("organization") val organization: String,
    @SerializedName("service") val service: String,
    @SerializedName("result") val result: Any?, // Puede ser null o un objeto, depende del uso
    @SerializedName("state") val state: InvestigationState
)

data class InvestigationState(
    @SerializedName("message") val message: String,
    @SerializedName("foundInService") val foundInService: Boolean,
    @SerializedName("mustBeFound") val mustBeFound: Boolean
)

{
    "services": {
        "ine": false,
        "interpool": false,
        "ofac": false,
        "renapo": {
            "curp": true
        },
        "sat": {
            "sat69b": false
        },
        "cdc": {
            "rccFico": false
        }
    },
    "payload": {
        "identifications": {
            "curp": "aqui va la curp"
        }
    }
}

{
    "eventId": "749f88b9-ecce-4f4c-920a-f8ece706501a",
    "responseId": "",
    "processTime": 0.23123526573181152,
    "organization": "curp",
    "service": "validaCurp",
    "result": null,
    "state": {
        "message": "Investigation completed successfully",
        "foundInService": false,
        "mustBeFound": true
    }
}

@POST("api/v1/liveness/verify-and-bestframe")
    suspend fun livenessVerifyApi(@Header("Authorization") auth: String,
                                  @Body request: LivenessVerifyRequest): Response<LivenessVerifyResponse>

{
  "video": String
}

data class LivenessVerifyBestframeRequest(
@SerializedName("video") val video: String, //base64
)

{
    "eventId": String,
    "requestId": String,
    "processTime": String,
    "score": Double,
    "bestFrame": String,
    "state": {
        "isRealPerson": Boolean,
        "message": String
    }
}

  data class LivenessVerifyResponse(
  @SerializedName("eventId") val eventId: String,
  @SerializedName("requestId") val requestId: String,
  @SerializedName("processTime") val processTime: Long,
  @SerializedName("score") val score: Double,
  @SerializedName("bestFrame") val bestFrame: String,  // base64 encoded string
  @SerializedName("state") val state: LivenessState
  )

  data class LivenessState(
  @SerializedName("isRealPerson") val isRealPerson: Boolean,
  @SerializedName("message") val message: String
  )

@POST("api/v2/oto/verify")
    suspend fun otoVerifyApi(@Header("Authorization") auth: String,
                             @Body request: OtoVerifyRequest): Response<OtoVerifyResponse>

{
    "eventId": String,
    "image1": String,
    "image2": String
}

data class OtoVerifyV2Request(
    @SerializedName("eventId") val eventId: String, //base64
    @SerializedName("image1") val image1: String, //base64
    @SerializedName("image2") val image2: String, //base64
)

{
    "eventId": String,
    "requestId": String,
    "score": Double,
    "distance": Double,
    "process_time": Integer,
    "metadata": {
        "image1": {
            "accessories": {
                "glass": Boolean,
                "sunGlass": Boolean,
                "hat": Boolean,
                "mask": Boolean
            },
            "image_quality": {
                "isCorrectBrightness": Boolean,
                "isCorrectBlur": Boolean,
                "isCorrectHeight": Boolean,
                "isCorrectWidth": Boolean,
                "isCorrectResolution": Boolean,
                "isCorrectVerticalRotation": Boolean,
                "isCorrectHorizontalRotation": Boolean,
                "isCorrectRotation": Boolean,
                "isCorrectSizeFace": Boolean,
                "isCorrectNumberFaces": Boolean
            }
        },
        "image2": {
            "accessories": {
                "glass": Boolean,
                "sunGlass": Boolean,
                "hat": Boolean,
                "mask": Boolean
            },
            "image_quality": {
                "isCorrectBrightness": Boolean,
                "isCorrectBlur": Boolean,
                "isCorrectHeight": Boolean,
                "isCorrectWidth": Boolean,
                "isCorrectResolution": Boolean,
                "isCorrectVerticalRotation": Boolean,
                "isCorrectHorizontalRotation": Boolean,
                "isCorrectRotation": Boolean,
                "isCorrectSizeFace": Boolean,
                "isCorrectNumberFaces": Boolean
            }
        }
    },
    "codes": null,
    "state": {
        "rejectedBadQuality": Boolean,
        "rejectedAccessories": Boolean,
        "isSamePerson": Boolean,
        "message": String
    }
}

data class OtoVerifyV2Response(
    @SerializedName("eventId") val eventId: String,
    @SerializedName("requestId") val requestId: String,
    @SerializedName("score") val score: Double,
    @SerializedName("distance") val distance: Double,
    @SerializedName("process_time") val processTime: Long,
    @SerializedName("metadata") val metadata: Metadata,
    @SerializedName("codes") val codes: List<Int>?,
    @SerializedName("state") val state: State
)

data class Metadata(
    @SerializedName("image1") val image1: ImageMetadata,
    @SerializedName("image2") val image2: ImageMetadata
)

data class ImageMetadata(
    @SerializedName("accessories") val accessories: Accessories,
    @SerializedName("image_quality") val imageQuality: String?
)

data class Accessories(
    @SerializedName("glass") val glass: Boolean,
    @SerializedName("sunGlass") val sunGlass: Boolean,
    @SerializedName("hat") val hat: Boolean,
    @SerializedName("mask") val mask: Boolean
)

data class State(
    @SerializedName("rejectedBadQuality") val rejectedBadQuality: Boolean,
    @SerializedName("rejectedAccessories") val rejectedAccessories: Boolean,
    @SerializedName("isSamePerson") val isSamePerson: Boolean,
    @SerializedName("message") val message: String
)

@POST("api/v1/kyc/session/finish")
    suspend fun finishApi(@Header("Authorization") auth: String): Response<FinishResponse>

{}

{}