• Home
• io.github.vigoo
• zio-aws-datasync_2.13
• 3.17.76.1
• source code
• DescribeTaskExecutionResponse.scala

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

io.github.vigoo.zioaws.datasync.model.DescribeTaskExecutionResponse.scala Maven / Gradle / Ivy

package io.github.vigoo.zioaws.datasync.model
import zio.ZIO
import java.time.Instant
import io.github.vigoo.zioaws.core.{AwsError, BuilderHelper}
import io.github.vigoo.zioaws.datasync.model.primitives.{Time, TaskExecutionArn}
import scala.jdk.CollectionConverters._
final case class DescribeTaskExecutionResponse(
    taskExecutionArn: Option[TaskExecutionArn] = None,
    status: Option[io.github.vigoo.zioaws.datasync.model.TaskExecutionStatus] =
      None,
    options: Option[io.github.vigoo.zioaws.datasync.model.Options] = None,
    excludes: Option[
      Iterable[io.github.vigoo.zioaws.datasync.model.FilterRule]
    ] = None,
    includes: Option[
      Iterable[io.github.vigoo.zioaws.datasync.model.FilterRule]
    ] = None,
    startTime: Option[Time] = None,
    estimatedFilesToTransfer: Option[Long] = None,
    estimatedBytesToTransfer: Option[Long] = None,
    filesTransferred: Option[Long] = None,
    bytesWritten: Option[Long] = None,
    bytesTransferred: Option[Long] = None,
    result: Option[
      io.github.vigoo.zioaws.datasync.model.TaskExecutionResultDetail
    ] = None
) {
  def buildAwsValue()
      : software.amazon.awssdk.services.datasync.model.DescribeTaskExecutionResponse = {
    import DescribeTaskExecutionResponse.zioAwsBuilderHelper.BuilderOps
    software.amazon.awssdk.services.datasync.model.DescribeTaskExecutionResponse
      .builder()
      .optionallyWith(taskExecutionArn.map(value => value: java.lang.String))(
        _.taskExecutionArn
      )
      .optionallyWith(status.map(value => value.unwrap))(_.status)
      .optionallyWith(options.map(value => value.buildAwsValue()))(_.options)
      .optionallyWith(
        excludes.map(value =>
          value.map { item =>
            item.buildAwsValue()
          }.asJavaCollection
        )
      )(_.excludes)
      .optionallyWith(
        includes.map(value =>
          value.map { item =>
            item.buildAwsValue()
          }.asJavaCollection
        )
      )(_.includes)
      .optionallyWith(startTime.map(value => value: Instant))(_.startTime)
      .optionallyWith(
        estimatedFilesToTransfer.map(value => value: java.lang.Long)
      )(_.estimatedFilesToTransfer)
      .optionallyWith(
        estimatedBytesToTransfer.map(value => value: java.lang.Long)
      )(_.estimatedBytesToTransfer)
      .optionallyWith(filesTransferred.map(value => value: java.lang.Long))(
        _.filesTransferred
      )
      .optionallyWith(bytesWritten.map(value => value: java.lang.Long))(
        _.bytesWritten
      )
      .optionallyWith(bytesTransferred.map(value => value: java.lang.Long))(
        _.bytesTransferred
      )
      .optionallyWith(result.map(value => value.buildAwsValue()))(_.result)
      .build()
  }
  def asReadOnly
      : io.github.vigoo.zioaws.datasync.model.DescribeTaskExecutionResponse.ReadOnly =
    io.github.vigoo.zioaws.datasync.model.DescribeTaskExecutionResponse
      .wrap(buildAwsValue())
}
object DescribeTaskExecutionResponse {
  private lazy val zioAwsBuilderHelper: BuilderHelper[
    software.amazon.awssdk.services.datasync.model.DescribeTaskExecutionResponse
  ] = BuilderHelper.apply
  trait ReadOnly {
    def editable
        : io.github.vigoo.zioaws.datasync.model.DescribeTaskExecutionResponse =
      io.github.vigoo.zioaws.datasync.model.DescribeTaskExecutionResponse(
        taskExecutionArnValue.map(value => value),
        statusValue.map(value => value),
        optionsValue.map(value => value.editable),
        excludesValue.map(value =>
          value.map { item =>
            item.editable
          }
        ),
        includesValue.map(value =>
          value.map { item =>
            item.editable
          }
        ),
        startTimeValue.map(value => value),
        estimatedFilesToTransferValue.map(value => value),
        estimatedBytesToTransferValue.map(value => value),
        filesTransferredValue.map(value => value),
        bytesWrittenValue.map(value => value),
        bytesTransferredValue.map(value => value),
        resultValue.map(value => value.editable)
      )
    def taskExecutionArnValue: Option[TaskExecutionArn]
    def statusValue
        : Option[io.github.vigoo.zioaws.datasync.model.TaskExecutionStatus]
    def optionsValue
        : Option[io.github.vigoo.zioaws.datasync.model.Options.ReadOnly]
    def excludesValue: Option[
      List[io.github.vigoo.zioaws.datasync.model.FilterRule.ReadOnly]
    ]
    def includesValue: Option[
      List[io.github.vigoo.zioaws.datasync.model.FilterRule.ReadOnly]
    ]
    def startTimeValue: Option[Time]
    def estimatedFilesToTransferValue: Option[Long]
    def estimatedBytesToTransferValue: Option[Long]
    def filesTransferredValue: Option[Long]
    def bytesWrittenValue: Option[Long]
    def bytesTransferredValue: Option[Long]
    def resultValue: Option[
      io.github.vigoo.zioaws.datasync.model.TaskExecutionResultDetail.ReadOnly
    ]
    def taskExecutionArn: ZIO[Any, AwsError, TaskExecutionArn] =
      AwsError.unwrapOptionField("taskExecutionArn", taskExecutionArnValue)
    def status: ZIO[
      Any,
      AwsError,
      io.github.vigoo.zioaws.datasync.model.TaskExecutionStatus
    ] = AwsError.unwrapOptionField("status", statusValue)
    def options: ZIO[
      Any,
      AwsError,
      io.github.vigoo.zioaws.datasync.model.Options.ReadOnly
    ] = AwsError.unwrapOptionField("options", optionsValue)
    def excludes: ZIO[Any, AwsError, List[
      io.github.vigoo.zioaws.datasync.model.FilterRule.ReadOnly
    ]] = AwsError.unwrapOptionField("excludes", excludesValue)
    def includes: ZIO[Any, AwsError, List[
      io.github.vigoo.zioaws.datasync.model.FilterRule.ReadOnly
    ]] = AwsError.unwrapOptionField("includes", includesValue)
    def startTime: ZIO[Any, AwsError, Time] =
      AwsError.unwrapOptionField("startTime", startTimeValue)
    def estimatedFilesToTransfer: ZIO[Any, AwsError, Long] =
      AwsError.unwrapOptionField(
        "estimatedFilesToTransfer",
        estimatedFilesToTransferValue
      )
    def estimatedBytesToTransfer: ZIO[Any, AwsError, Long] =
      AwsError.unwrapOptionField(
        "estimatedBytesToTransfer",
        estimatedBytesToTransferValue
      )
    def filesTransferred: ZIO[Any, AwsError, Long] =
      AwsError.unwrapOptionField("filesTransferred", filesTransferredValue)
    def bytesWritten: ZIO[Any, AwsError, Long] =
      AwsError.unwrapOptionField("bytesWritten", bytesWrittenValue)
    def bytesTransferred: ZIO[Any, AwsError, Long] =
      AwsError.unwrapOptionField("bytesTransferred", bytesTransferredValue)
    def result: ZIO[
      Any,
      AwsError,
      io.github.vigoo.zioaws.datasync.model.TaskExecutionResultDetail.ReadOnly
    ] = AwsError.unwrapOptionField("result", resultValue)
  }
  private class Wrapper(
      impl: software.amazon.awssdk.services.datasync.model.DescribeTaskExecutionResponse
  ) extends io.github.vigoo.zioaws.datasync.model.DescribeTaskExecutionResponse.ReadOnly {
    override def taskExecutionArnValue: Option[TaskExecutionArn] = scala
      .Option(impl.taskExecutionArn())
      .map(value => value: TaskExecutionArn)
    override def statusValue
        : Option[io.github.vigoo.zioaws.datasync.model.TaskExecutionStatus] =
      scala
        .Option(impl.status())
        .map(value =>
          io.github.vigoo.zioaws.datasync.model.TaskExecutionStatus.wrap(value)
        )
    override def optionsValue
        : Option[io.github.vigoo.zioaws.datasync.model.Options.ReadOnly] = scala
      .Option(impl.options())
      .map(value => io.github.vigoo.zioaws.datasync.model.Options.wrap(value))
    override def excludesValue: Option[
      List[io.github.vigoo.zioaws.datasync.model.FilterRule.ReadOnly]
    ] = scala
      .Option(impl.excludes())
      .map(value =>
        value.asScala.map { item =>
          io.github.vigoo.zioaws.datasync.model.FilterRule.wrap(item)
        }.toList
      )
    override def includesValue: Option[
      List[io.github.vigoo.zioaws.datasync.model.FilterRule.ReadOnly]
    ] = scala
      .Option(impl.includes())
      .map(value =>
        value.asScala.map { item =>
          io.github.vigoo.zioaws.datasync.model.FilterRule.wrap(item)
        }.toList
      )
    override def startTimeValue: Option[Time] =
      scala.Option(impl.startTime()).map(value => value: Time)
    override def estimatedFilesToTransferValue: Option[Long] =
      scala.Option(impl.estimatedFilesToTransfer()).map(value => value: Long)
    override def estimatedBytesToTransferValue: Option[Long] =
      scala.Option(impl.estimatedBytesToTransfer()).map(value => value: Long)
    override def filesTransferredValue: Option[Long] =
      scala.Option(impl.filesTransferred()).map(value => value: Long)
    override def bytesWrittenValue: Option[Long] =
      scala.Option(impl.bytesWritten()).map(value => value: Long)
    override def bytesTransferredValue: Option[Long] =
      scala.Option(impl.bytesTransferred()).map(value => value: Long)
    override def resultValue: Option[
      io.github.vigoo.zioaws.datasync.model.TaskExecutionResultDetail.ReadOnly
    ] = scala
      .Option(impl.result())
      .map(value =>
        io.github.vigoo.zioaws.datasync.model.TaskExecutionResultDetail
          .wrap(value)
      )
  }
  def wrap(
      impl: software.amazon.awssdk.services.datasync.model.DescribeTaskExecutionResponse
  ): io.github.vigoo.zioaws.datasync.model.DescribeTaskExecutionResponse.ReadOnly =
    new Wrapper(impl)
}