Kotlin 协同路由异步等待+；改装+；密封类

我有两个API，第二个API取决于第一个API的结果。下面是ViewModel中的代码

fun coroutineDocs(jobRequest: JobRequest) {
    viewModelScope.launch {
        _mResult.postValue(Resource.loading())
        withContext(Dispatchers.IO) {
            try {
                coroutineScope {
                    val manifest = async {
                        manifestRepository.coroutineSendDocs(jobRequest)
                    }
                    val manifestResult = manifest.await()

                    val images = async {
                        manifestRepository.coroutineUploadAttachment(
                            userId,manifestResult.responseData?.transactionId
                        )
                    }
                    val imageResult = images.await()
                    _mResult.postValue(imageResult)
                }
            } catch (e: Exception) {
                _mResult.postValue(Resource.exception(e))
            }
        }
    }
}

我的网络解析代码如下：

data class Resource<out T>(
val status: Status,
val responseData: T? = null,
val headers: Headers?=null,
val errorData: ResponseBody? = null,
val responseCode: Int? = null,
val exception: Exception? = null) {
companion object {
    fun <T> success(data: T?, header: Headers): Resource<T> =
        Resource(Status.SUCCESS, data,header)

    fun <T> error(responseCode: Int?, errorData: ResponseBody?): Resource<T> =
        Resource(Status.ERROR, errorData = errorData, responseCode = responseCode)

    fun <T> exception(exception: Exception?): Resource<T> =
        Resource(Status.EXCEPTION, exception = exception)

    fun <T> loading(): Resource<T> =
        Resource(Status.LOADING)
}

数据类资源(
val状态：状态，
val响应数据：T？=null，
val头：头？=null，
val errorData:ResponseBody？=null，
val响应代码：Int？=null，
val异常：异常？=null）{
伴星{
乐趣成功（数据：T？，标题：标题）：资源=
资源（Status.SUCCESS、data、header）
有趣的错误（responseCode:Int？，errorData:ResponseBody？）：资源=
资源（Status.ERROR，errorData=errorData，responseCode=responseCode）
有趣的异常（异常：异常？）：资源=
资源（Status.EXCEPTION，EXCEPTION=EXCEPTION）
乐趣加载（）：资源=
资源（状态。正在加载）
}

}

现在我尝试将上述网络解析转换为密封类，如下所示：

sealed class Resource1<out T>{
class Loading<T> : Resource1<T>()
data class Success<T>(val data:T?,val header:Headers) : Resource1<T>()
data class Error<T>(val responseCode: Int?,val errorData: ResponseBody?) : Resource1<T>()
data class Failure<T>(val exception: Exception?):Resource1<T>()
companion object {
    fun <T> loading() = Loading<T>()
    fun <T> success(data: T?, header: Headers) = Success(data,header)
    fun <T> error(responseCode: Int?, errorData: ResponseBody?) =
        Error<T>(responseCode, errorData)
    fun <T> failure(exception: Exception?) = Failure<T>(exception)
}

密封类资源1{
类加载：Resource1（）
数据类成功（val数据：T？，val头：头）：Resource1（）
数据类错误（val-responseCode:Int？，val-errorData:ResponseBody？）：Resource1（）
数据类失败（val异常：异常？）：Resource1（）
伴星{
乐趣加载（）=加载（）
乐趣成功（数据：T？，标题：标题）=成功（数据，标题）
有趣的错误（响应代码：Int？，错误数据：响应代码？）=
错误（响应代码、错误数据）
有趣的失败（异常：异常？）=失败（异常）
}

}

因为我正在更新到密封类，所以我需要在（）时使用kotlin

如果不使用kotlin when（），如何直接获取值

manifestResult.responseData？.transactionId

提前谢谢