io.github.vigoo.zioaws.swf.model.ScheduleActivityTaskDecisionAttributes.scala Maven / Gradle / Ivy

Go to download
package io.github.vigoo.zioaws.swf.model
import zio.ZIO
import io.github.vigoo.zioaws.swf.model.primitives.{
  TaskPriority,
  DurationInSecondsOptional,
  Data,
  ActivityId
}
import io.github.vigoo.zioaws.core.{AwsError, BuilderHelper}
import scala.jdk.CollectionConverters._
final case class ScheduleActivityTaskDecisionAttributes(
    activityType: io.github.vigoo.zioaws.swf.model.ActivityType,
    activityId: ActivityId,
    control: Option[Data] = None,
    input: Option[Data] = None,
    scheduleToCloseTimeout: Option[DurationInSecondsOptional] = None,
    taskList: Option[io.github.vigoo.zioaws.swf.model.TaskList] = None,
    taskPriority: Option[TaskPriority] = None,
    scheduleToStartTimeout: Option[DurationInSecondsOptional] = None,
    startToCloseTimeout: Option[DurationInSecondsOptional] = None,
    heartbeatTimeout: Option[DurationInSecondsOptional] = None
) {
  def buildAwsValue()
      : software.amazon.awssdk.services.swf.model.ScheduleActivityTaskDecisionAttributes = {
    import ScheduleActivityTaskDecisionAttributes.zioAwsBuilderHelper.BuilderOps
    software.amazon.awssdk.services.swf.model.ScheduleActivityTaskDecisionAttributes
      .builder()
      .activityType(activityType.buildAwsValue())
      .activityId(activityId: java.lang.String)
      .optionallyWith(control.map(value => value: java.lang.String))(_.control)
      .optionallyWith(input.map(value => value: java.lang.String))(_.input)
      .optionallyWith(
        scheduleToCloseTimeout.map(value => value: java.lang.String)
      )(_.scheduleToCloseTimeout)
      .optionallyWith(taskList.map(value => value.buildAwsValue()))(_.taskList)
      .optionallyWith(taskPriority.map(value => value: java.lang.String))(
        _.taskPriority
      )
      .optionallyWith(
        scheduleToStartTimeout.map(value => value: java.lang.String)
      )(_.scheduleToStartTimeout)
      .optionallyWith(
        startToCloseTimeout.map(value => value: java.lang.String)
      )(_.startToCloseTimeout)
      .optionallyWith(heartbeatTimeout.map(value => value: java.lang.String))(
        _.heartbeatTimeout
      )
      .build()
  }
  def asReadOnly
      : io.github.vigoo.zioaws.swf.model.ScheduleActivityTaskDecisionAttributes.ReadOnly =
    io.github.vigoo.zioaws.swf.model.ScheduleActivityTaskDecisionAttributes
      .wrap(buildAwsValue())
}
object ScheduleActivityTaskDecisionAttributes {
  private lazy val zioAwsBuilderHelper: BuilderHelper[
    software.amazon.awssdk.services.swf.model.ScheduleActivityTaskDecisionAttributes
  ] = BuilderHelper.apply
  trait ReadOnly {
    def editable
        : io.github.vigoo.zioaws.swf.model.ScheduleActivityTaskDecisionAttributes =
      io.github.vigoo.zioaws.swf.model.ScheduleActivityTaskDecisionAttributes(
        activityTypeValue.editable,
        activityIdValue,
        controlValue.map(value => value),
        inputValue.map(value => value),
        scheduleToCloseTimeoutValue.map(value => value),
        taskListValue.map(value => value.editable),
        taskPriorityValue.map(value => value),
        scheduleToStartTimeoutValue.map(value => value),
        startToCloseTimeoutValue.map(value => value),
        heartbeatTimeoutValue.map(value => value)
      )
    def activityTypeValue
        : io.github.vigoo.zioaws.swf.model.ActivityType.ReadOnly
    def activityIdValue: ActivityId
    def controlValue: Option[Data]
    def inputValue: Option[Data]
    def scheduleToCloseTimeoutValue: Option[DurationInSecondsOptional]
    def taskListValue
        : Option[io.github.vigoo.zioaws.swf.model.TaskList.ReadOnly]
    def taskPriorityValue: Option[TaskPriority]
    def scheduleToStartTimeoutValue: Option[DurationInSecondsOptional]
    def startToCloseTimeoutValue: Option[DurationInSecondsOptional]
    def heartbeatTimeoutValue: Option[DurationInSecondsOptional]
    def activityType: ZIO[
      Any,
      Nothing,
      io.github.vigoo.zioaws.swf.model.ActivityType.ReadOnly
    ] = ZIO.succeed(activityTypeValue)
    def activityId: ZIO[Any, Nothing, ActivityId] = ZIO.succeed(activityIdValue)
    def control: ZIO[Any, AwsError, Data] =
      AwsError.unwrapOptionField("control", controlValue)
    def input: ZIO[Any, AwsError, Data] =
      AwsError.unwrapOptionField("input", inputValue)
    def scheduleToCloseTimeout: ZIO[Any, AwsError, DurationInSecondsOptional] =
      AwsError.unwrapOptionField(
        "scheduleToCloseTimeout",
        scheduleToCloseTimeoutValue
      )
    def taskList: ZIO[
      Any,
      AwsError,
      io.github.vigoo.zioaws.swf.model.TaskList.ReadOnly
    ] = AwsError.unwrapOptionField("taskList", taskListValue)
    def taskPriority: ZIO[Any, AwsError, TaskPriority] =
      AwsError.unwrapOptionField("taskPriority", taskPriorityValue)
    def scheduleToStartTimeout: ZIO[Any, AwsError, DurationInSecondsOptional] =
      AwsError.unwrapOptionField(
        "scheduleToStartTimeout",
        scheduleToStartTimeoutValue
      )
    def startToCloseTimeout: ZIO[Any, AwsError, DurationInSecondsOptional] =
      AwsError.unwrapOptionField(
        "startToCloseTimeout",
        startToCloseTimeoutValue
      )
    def heartbeatTimeout: ZIO[Any, AwsError, DurationInSecondsOptional] =
      AwsError.unwrapOptionField("heartbeatTimeout", heartbeatTimeoutValue)
  }
  private class Wrapper(
      impl: software.amazon.awssdk.services.swf.model.ScheduleActivityTaskDecisionAttributes
  ) extends io.github.vigoo.zioaws.swf.model.ScheduleActivityTaskDecisionAttributes.ReadOnly {
    override def activityTypeValue
        : io.github.vigoo.zioaws.swf.model.ActivityType.ReadOnly =
      io.github.vigoo.zioaws.swf.model.ActivityType.wrap(impl.activityType())
    override def activityIdValue: ActivityId = impl.activityId(): ActivityId
    override def controlValue: Option[Data] =
      scala.Option(impl.control()).map(value => value: Data)
    override def inputValue: Option[Data] =
      scala.Option(impl.input()).map(value => value: Data)
    override def scheduleToCloseTimeoutValue
        : Option[DurationInSecondsOptional] = scala
      .Option(impl.scheduleToCloseTimeout())
      .map(value => value: DurationInSecondsOptional)
    override def taskListValue
        : Option[io.github.vigoo.zioaws.swf.model.TaskList.ReadOnly] = scala
      .Option(impl.taskList())
      .map(value => io.github.vigoo.zioaws.swf.model.TaskList.wrap(value))
    override def taskPriorityValue: Option[TaskPriority] =
      scala.Option(impl.taskPriority()).map(value => value: TaskPriority)
    override def scheduleToStartTimeoutValue
        : Option[DurationInSecondsOptional] = scala
      .Option(impl.scheduleToStartTimeout())
      .map(value => value: DurationInSecondsOptional)
    override def startToCloseTimeoutValue: Option[DurationInSecondsOptional] =
      scala
        .Option(impl.startToCloseTimeout())
        .map(value => value: DurationInSecondsOptional)
    override def heartbeatTimeoutValue: Option[DurationInSecondsOptional] =
      scala
        .Option(impl.heartbeatTimeout())
        .map(value => value: DurationInSecondsOptional)
  }
  def wrap(
      impl: software.amazon.awssdk.services.swf.model.ScheduleActivityTaskDecisionAttributes
  ): io.github.vigoo.zioaws.swf.model.ScheduleActivityTaskDecisionAttributes.ReadOnly =
    new Wrapper(impl)
}