• Home
• io.github.vigoo
• zio-aws-sfn_2.13
• 3.17.102.6
• source code
• package.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.sfn.package.scala Maven / Gradle / Ivy

package io.github.vigoo.zioaws
import io.github.vigoo.zioaws.sfn.model.StartExecutionResponse.ReadOnly
import software.amazon.awssdk.services.sfn.model.{
  SendTaskFailureRequest,
  DescribeStateMachineForExecutionRequest,
  SendTaskHeartbeatRequest,
  CreateStateMachineResponse,
  StopExecutionResponse,
  UpdateStateMachineRequest,
  DeleteStateMachineResponse,
  DescribeExecutionResponse,
  GetActivityTaskRequest,
  ListTagsForResourceRequest,
  DeleteActivityResponse,
  StartSyncExecutionRequest,
  GetExecutionHistoryRequest,
  CreateActivityResponse,
  ExecutionListItem,
  ListTagsForResourceResponse,
  UntagResourceResponse,
  StartExecutionRequest,
  ListExecutionsRequest,
  SendTaskSuccessResponse,
  CreateStateMachineRequest,
  StateMachineListItem,
  DescribeStateMachineForExecutionResponse,
  CreateActivityRequest,
  DescribeActivityRequest,
  ListActivitiesRequest,
  GetActivityTaskResponse,
  SendTaskFailureResponse,
  SendTaskHeartbeatResponse,
  StopExecutionRequest,
  DescribeStateMachineRequest,
  DeleteStateMachineRequest,
  UntagResourceRequest,
  ListStateMachinesRequest,
  ActivityListItem,
  DeleteActivityRequest,
  StartExecutionResponse,
  UpdateStateMachineResponse,
  SendTaskSuccessRequest,
  TagResourceResponse,
  DescribeStateMachineResponse,
  DescribeExecutionRequest,
  HistoryEvent,
  TagResourceRequest,
  StartSyncExecutionResponse,
  DescribeActivityResponse
}
import io.github.vigoo.zioaws.core.{AwsServiceBase, AwsError}
import software.amazon.awssdk.services.sfn.{
  SfnAsyncClientBuilder,
  SfnAsyncClient
}
import software.amazon.awssdk.services.sfn.paginators.{
  ListExecutionsPublisher,
  ListStateMachinesPublisher,
  ListActivitiesPublisher,
  GetExecutionHistoryPublisher
}
import io.github.vigoo.zioaws.core.config.AwsConfig
import zio.{ZManaged, IO, ZIO, ZLayer, URLayer, Has}
import io.github.vigoo.zioaws.sfn.Sfn
import io.github.vigoo.zioaws.core.aspects.{AwsCallAspect, AspectSupport}
import zio.stream.ZStream
import zio.test.mock.{Proxy, Mock}
package object sfn {
  import scala.jdk.CollectionConverters._
  type Sfn = Has[Sfn.Service]
  object Sfn {
    trait Service extends AspectSupport[Service] {
      val api: SfnAsyncClient
      def startExecution(
          request: io.github.vigoo.zioaws.sfn.model.StartExecutionRequest
      ): IO[AwsError, ReadOnly]
      def getExecutionHistory(
          request: io.github.vigoo.zioaws.sfn.model.GetExecutionHistoryRequest
      ): ZStream[
        Any,
        AwsError,
        io.github.vigoo.zioaws.sfn.model.HistoryEvent.ReadOnly
      ]
      def deleteStateMachine(
          request: io.github.vigoo.zioaws.sfn.model.DeleteStateMachineRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.sfn.model.DeleteStateMachineResponse.ReadOnly
      ]
      def createStateMachine(
          request: io.github.vigoo.zioaws.sfn.model.CreateStateMachineRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.sfn.model.CreateStateMachineResponse.ReadOnly
      ]
      def describeStateMachineForExecution(
          request: io.github.vigoo.zioaws.sfn.model.DescribeStateMachineForExecutionRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.sfn.model.DescribeStateMachineForExecutionResponse.ReadOnly
      ]
      def stopExecution(
          request: io.github.vigoo.zioaws.sfn.model.StopExecutionRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.sfn.model.StopExecutionResponse.ReadOnly
      ]
      def getActivityTask(
          request: io.github.vigoo.zioaws.sfn.model.GetActivityTaskRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.sfn.model.GetActivityTaskResponse.ReadOnly
      ]
      def describeExecution(
          request: io.github.vigoo.zioaws.sfn.model.DescribeExecutionRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.sfn.model.DescribeExecutionResponse.ReadOnly
      ]
      def startSyncExecution(
          request: io.github.vigoo.zioaws.sfn.model.StartSyncExecutionRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.sfn.model.StartSyncExecutionResponse.ReadOnly
      ]
      def sendTaskSuccess(
          request: io.github.vigoo.zioaws.sfn.model.SendTaskSuccessRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.sfn.model.SendTaskSuccessResponse.ReadOnly
      ]
      def sendTaskHeartbeat(
          request: io.github.vigoo.zioaws.sfn.model.SendTaskHeartbeatRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.sfn.model.SendTaskHeartbeatResponse.ReadOnly
      ]
      def describeStateMachine(
          request: io.github.vigoo.zioaws.sfn.model.DescribeStateMachineRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.sfn.model.DescribeStateMachineResponse.ReadOnly
      ]
      def deleteActivity(
          request: io.github.vigoo.zioaws.sfn.model.DeleteActivityRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.sfn.model.DeleteActivityResponse.ReadOnly
      ]
      def updateStateMachine(
          request: io.github.vigoo.zioaws.sfn.model.UpdateStateMachineRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.sfn.model.UpdateStateMachineResponse.ReadOnly
      ]
      def untagResource(
          request: io.github.vigoo.zioaws.sfn.model.UntagResourceRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.sfn.model.UntagResourceResponse.ReadOnly
      ]
      def listActivities(
          request: io.github.vigoo.zioaws.sfn.model.ListActivitiesRequest
      ): ZStream[
        Any,
        AwsError,
        io.github.vigoo.zioaws.sfn.model.ActivityListItem.ReadOnly
      ]
      def listStateMachines(
          request: io.github.vigoo.zioaws.sfn.model.ListStateMachinesRequest
      ): ZStream[
        Any,
        AwsError,
        io.github.vigoo.zioaws.sfn.model.StateMachineListItem.ReadOnly
      ]
      def listExecutions(
          request: io.github.vigoo.zioaws.sfn.model.ListExecutionsRequest
      ): ZStream[
        Any,
        AwsError,
        io.github.vigoo.zioaws.sfn.model.ExecutionListItem.ReadOnly
      ]
      def createActivity(
          request: io.github.vigoo.zioaws.sfn.model.CreateActivityRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.sfn.model.CreateActivityResponse.ReadOnly
      ]
      def listTagsForResource(
          request: io.github.vigoo.zioaws.sfn.model.ListTagsForResourceRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.sfn.model.ListTagsForResourceResponse.ReadOnly
      ]
      def sendTaskFailure(
          request: io.github.vigoo.zioaws.sfn.model.SendTaskFailureRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.sfn.model.SendTaskFailureResponse.ReadOnly
      ]
      def tagResource(
          request: io.github.vigoo.zioaws.sfn.model.TagResourceRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.sfn.model.TagResourceResponse.ReadOnly
      ]
      def describeActivity(
          request: io.github.vigoo.zioaws.sfn.model.DescribeActivityRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.sfn.model.DescribeActivityResponse.ReadOnly
      ]
    }
    object SfnMock extends Mock[Sfn] {
      object StartExecution
          extends Effect[
            io.github.vigoo.zioaws.sfn.model.StartExecutionRequest,
            AwsError,
            ReadOnly
          ]
      object GetExecutionHistory
          extends Stream[
            io.github.vigoo.zioaws.sfn.model.GetExecutionHistoryRequest,
            AwsError,
            io.github.vigoo.zioaws.sfn.model.HistoryEvent.ReadOnly
          ]
      object DeleteStateMachine
          extends Effect[
            io.github.vigoo.zioaws.sfn.model.DeleteStateMachineRequest,
            AwsError,
            io.github.vigoo.zioaws.sfn.model.DeleteStateMachineResponse.ReadOnly
          ]
      object CreateStateMachine
          extends Effect[
            io.github.vigoo.zioaws.sfn.model.CreateStateMachineRequest,
            AwsError,
            io.github.vigoo.zioaws.sfn.model.CreateStateMachineResponse.ReadOnly
          ]
      object DescribeStateMachineForExecution
          extends Effect[
            io.github.vigoo.zioaws.sfn.model.DescribeStateMachineForExecutionRequest,
            AwsError,
            io.github.vigoo.zioaws.sfn.model.DescribeStateMachineForExecutionResponse.ReadOnly
          ]
      object StopExecution
          extends Effect[
            io.github.vigoo.zioaws.sfn.model.StopExecutionRequest,
            AwsError,
            io.github.vigoo.zioaws.sfn.model.StopExecutionResponse.ReadOnly
          ]
      object GetActivityTask
          extends Effect[
            io.github.vigoo.zioaws.sfn.model.GetActivityTaskRequest,
            AwsError,
            io.github.vigoo.zioaws.sfn.model.GetActivityTaskResponse.ReadOnly
          ]
      object DescribeExecution
          extends Effect[
            io.github.vigoo.zioaws.sfn.model.DescribeExecutionRequest,
            AwsError,
            io.github.vigoo.zioaws.sfn.model.DescribeExecutionResponse.ReadOnly
          ]
      object StartSyncExecution
          extends Effect[
            io.github.vigoo.zioaws.sfn.model.StartSyncExecutionRequest,
            AwsError,
            io.github.vigoo.zioaws.sfn.model.StartSyncExecutionResponse.ReadOnly
          ]
      object SendTaskSuccess
          extends Effect[
            io.github.vigoo.zioaws.sfn.model.SendTaskSuccessRequest,
            AwsError,
            io.github.vigoo.zioaws.sfn.model.SendTaskSuccessResponse.ReadOnly
          ]
      object SendTaskHeartbeat
          extends Effect[
            io.github.vigoo.zioaws.sfn.model.SendTaskHeartbeatRequest,
            AwsError,
            io.github.vigoo.zioaws.sfn.model.SendTaskHeartbeatResponse.ReadOnly
          ]
      object DescribeStateMachine
          extends Effect[
            io.github.vigoo.zioaws.sfn.model.DescribeStateMachineRequest,
            AwsError,
            io.github.vigoo.zioaws.sfn.model.DescribeStateMachineResponse.ReadOnly
          ]
      object DeleteActivity
          extends Effect[
            io.github.vigoo.zioaws.sfn.model.DeleteActivityRequest,
            AwsError,
            io.github.vigoo.zioaws.sfn.model.DeleteActivityResponse.ReadOnly
          ]
      object UpdateStateMachine
          extends Effect[
            io.github.vigoo.zioaws.sfn.model.UpdateStateMachineRequest,
            AwsError,
            io.github.vigoo.zioaws.sfn.model.UpdateStateMachineResponse.ReadOnly
          ]
      object UntagResource
          extends Effect[
            io.github.vigoo.zioaws.sfn.model.UntagResourceRequest,
            AwsError,
            io.github.vigoo.zioaws.sfn.model.UntagResourceResponse.ReadOnly
          ]
      object ListActivities
          extends Stream[
            io.github.vigoo.zioaws.sfn.model.ListActivitiesRequest,
            AwsError,
            io.github.vigoo.zioaws.sfn.model.ActivityListItem.ReadOnly
          ]
      object ListStateMachines
          extends Stream[
            io.github.vigoo.zioaws.sfn.model.ListStateMachinesRequest,
            AwsError,
            io.github.vigoo.zioaws.sfn.model.StateMachineListItem.ReadOnly
          ]
      object ListExecutions
          extends Stream[
            io.github.vigoo.zioaws.sfn.model.ListExecutionsRequest,
            AwsError,
            io.github.vigoo.zioaws.sfn.model.ExecutionListItem.ReadOnly
          ]
      object CreateActivity
          extends Effect[
            io.github.vigoo.zioaws.sfn.model.CreateActivityRequest,
            AwsError,
            io.github.vigoo.zioaws.sfn.model.CreateActivityResponse.ReadOnly
          ]
      object ListTagsForResource
          extends Effect[
            io.github.vigoo.zioaws.sfn.model.ListTagsForResourceRequest,
            AwsError,
            io.github.vigoo.zioaws.sfn.model.ListTagsForResourceResponse.ReadOnly
          ]
      object SendTaskFailure
          extends Effect[
            io.github.vigoo.zioaws.sfn.model.SendTaskFailureRequest,
            AwsError,
            io.github.vigoo.zioaws.sfn.model.SendTaskFailureResponse.ReadOnly
          ]
      object TagResource
          extends Effect[
            io.github.vigoo.zioaws.sfn.model.TagResourceRequest,
            AwsError,
            io.github.vigoo.zioaws.sfn.model.TagResourceResponse.ReadOnly
          ]
      object DescribeActivity
          extends Effect[
            io.github.vigoo.zioaws.sfn.model.DescribeActivityRequest,
            AwsError,
            io.github.vigoo.zioaws.sfn.model.DescribeActivityResponse.ReadOnly
          ]
      val compose: URLayer[Has[Proxy], Sfn] = ZLayer.fromServiceM { proxy =>
        withRuntime.map { rts =>
          new Sfn.Service {
            val api: SfnAsyncClient = null
            def withAspect[R1](
                newAspect: AwsCallAspect[R1],
                r: R1
            ): Sfn.Service = this
            def startExecution(
                request: io.github.vigoo.zioaws.sfn.model.StartExecutionRequest
            ): IO[AwsError, ReadOnly] = proxy(StartExecution, request)
            def getExecutionHistory(
                request: io.github.vigoo.zioaws.sfn.model.GetExecutionHistoryRequest
            ): ZStream[
              Any,
              AwsError,
              io.github.vigoo.zioaws.sfn.model.HistoryEvent.ReadOnly
            ] = rts.unsafeRun(proxy(GetExecutionHistory, request))
            def deleteStateMachine(
                request: io.github.vigoo.zioaws.sfn.model.DeleteStateMachineRequest
            ): IO[
              AwsError,
              io.github.vigoo.zioaws.sfn.model.DeleteStateMachineResponse.ReadOnly
            ] = proxy(DeleteStateMachine, request)
            def createStateMachine(
                request: io.github.vigoo.zioaws.sfn.model.CreateStateMachineRequest
            ): IO[
              AwsError,
              io.github.vigoo.zioaws.sfn.model.CreateStateMachineResponse.ReadOnly
            ] = proxy(CreateStateMachine, request)
            def describeStateMachineForExecution(
                request: io.github.vigoo.zioaws.sfn.model.DescribeStateMachineForExecutionRequest
            ): IO[
              AwsError,
              io.github.vigoo.zioaws.sfn.model.DescribeStateMachineForExecutionResponse.ReadOnly
            ] = proxy(DescribeStateMachineForExecution, request)
            def stopExecution(
                request: io.github.vigoo.zioaws.sfn.model.StopExecutionRequest
            ): IO[
              AwsError,
              io.github.vigoo.zioaws.sfn.model.StopExecutionResponse.ReadOnly
            ] = proxy(StopExecution, request)
            def getActivityTask(
                request: io.github.vigoo.zioaws.sfn.model.GetActivityTaskRequest
            ): IO[
              AwsError,
              io.github.vigoo.zioaws.sfn.model.GetActivityTaskResponse.ReadOnly
            ] = proxy(GetActivityTask, request)
            def describeExecution(
                request: io.github.vigoo.zioaws.sfn.model.DescribeExecutionRequest
            ): IO[
              AwsError,
              io.github.vigoo.zioaws.sfn.model.DescribeExecutionResponse.ReadOnly
            ] = proxy(DescribeExecution, request)
            def startSyncExecution(
                request: io.github.vigoo.zioaws.sfn.model.StartSyncExecutionRequest
            ): IO[
              AwsError,
              io.github.vigoo.zioaws.sfn.model.StartSyncExecutionResponse.ReadOnly
            ] = proxy(StartSyncExecution, request)
            def sendTaskSuccess(
                request: io.github.vigoo.zioaws.sfn.model.SendTaskSuccessRequest
            ): IO[
              AwsError,
              io.github.vigoo.zioaws.sfn.model.SendTaskSuccessResponse.ReadOnly
            ] = proxy(SendTaskSuccess, request)
            def sendTaskHeartbeat(
                request: io.github.vigoo.zioaws.sfn.model.SendTaskHeartbeatRequest
            ): IO[
              AwsError,
              io.github.vigoo.zioaws.sfn.model.SendTaskHeartbeatResponse.ReadOnly
            ] = proxy(SendTaskHeartbeat, request)
            def describeStateMachine(
                request: io.github.vigoo.zioaws.sfn.model.DescribeStateMachineRequest
            ): IO[
              AwsError,
              io.github.vigoo.zioaws.sfn.model.DescribeStateMachineResponse.ReadOnly
            ] = proxy(DescribeStateMachine, request)
            def deleteActivity(
                request: io.github.vigoo.zioaws.sfn.model.DeleteActivityRequest
            ): IO[
              AwsError,
              io.github.vigoo.zioaws.sfn.model.DeleteActivityResponse.ReadOnly
            ] = proxy(DeleteActivity, request)
            def updateStateMachine(
                request: io.github.vigoo.zioaws.sfn.model.UpdateStateMachineRequest
            ): IO[
              AwsError,
              io.github.vigoo.zioaws.sfn.model.UpdateStateMachineResponse.ReadOnly
            ] = proxy(UpdateStateMachine, request)
            def untagResource(
                request: io.github.vigoo.zioaws.sfn.model.UntagResourceRequest
            ): IO[
              AwsError,
              io.github.vigoo.zioaws.sfn.model.UntagResourceResponse.ReadOnly
            ] = proxy(UntagResource, request)
            def listActivities(
                request: io.github.vigoo.zioaws.sfn.model.ListActivitiesRequest
            ): ZStream[
              Any,
              AwsError,
              io.github.vigoo.zioaws.sfn.model.ActivityListItem.ReadOnly
            ] = rts.unsafeRun(proxy(ListActivities, request))
            def listStateMachines(
                request: io.github.vigoo.zioaws.sfn.model.ListStateMachinesRequest
            ): ZStream[
              Any,
              AwsError,
              io.github.vigoo.zioaws.sfn.model.StateMachineListItem.ReadOnly
            ] = rts.unsafeRun(proxy(ListStateMachines, request))
            def listExecutions(
                request: io.github.vigoo.zioaws.sfn.model.ListExecutionsRequest
            ): ZStream[
              Any,
              AwsError,
              io.github.vigoo.zioaws.sfn.model.ExecutionListItem.ReadOnly
            ] = rts.unsafeRun(proxy(ListExecutions, request))
            def createActivity(
                request: io.github.vigoo.zioaws.sfn.model.CreateActivityRequest
            ): IO[
              AwsError,
              io.github.vigoo.zioaws.sfn.model.CreateActivityResponse.ReadOnly
            ] = proxy(CreateActivity, request)
            def listTagsForResource(
                request: io.github.vigoo.zioaws.sfn.model.ListTagsForResourceRequest
            ): IO[
              AwsError,
              io.github.vigoo.zioaws.sfn.model.ListTagsForResourceResponse.ReadOnly
            ] = proxy(ListTagsForResource, request)
            def sendTaskFailure(
                request: io.github.vigoo.zioaws.sfn.model.SendTaskFailureRequest
            ): IO[
              AwsError,
              io.github.vigoo.zioaws.sfn.model.SendTaskFailureResponse.ReadOnly
            ] = proxy(SendTaskFailure, request)
            def tagResource(
                request: io.github.vigoo.zioaws.sfn.model.TagResourceRequest
            ): IO[
              AwsError,
              io.github.vigoo.zioaws.sfn.model.TagResourceResponse.ReadOnly
            ] = proxy(TagResource, request)
            def describeActivity(
                request: io.github.vigoo.zioaws.sfn.model.DescribeActivityRequest
            ): IO[
              AwsError,
              io.github.vigoo.zioaws.sfn.model.DescribeActivityResponse.ReadOnly
            ] = proxy(DescribeActivity, request)
          }
        }
      }
    }
  }
  val live: ZLayer[AwsConfig, java.lang.Throwable, Sfn] = customized(identity)
  def customized(
      customization: SfnAsyncClientBuilder => SfnAsyncClientBuilder
  ): ZLayer[AwsConfig, java.lang.Throwable, Sfn] = managed(
    customization
  ).toLayer
  def managed(
      customization: SfnAsyncClientBuilder => SfnAsyncClientBuilder
  ): ZManaged[AwsConfig, java.lang.Throwable, Sfn.Service] = for (
    awsConfig <- ZManaged.service[AwsConfig.Service];
    executor <- ZIO.executor.toManaged_;
    builder = SfnAsyncClient
      .builder()
      .asyncConfiguration(
        software.amazon.awssdk.core.client.config.ClientAsyncConfiguration
          .builder()
          .advancedOption(
            software.amazon.awssdk.core.client.config.SdkAdvancedAsyncClientOption.FUTURE_COMPLETION_EXECUTOR,
            executor.asJava
          )
          .build()
      );
    b0 <- awsConfig
      .configure[SfnAsyncClient, SfnAsyncClientBuilder](builder)
      .toManaged_;
    b1 <- awsConfig
      .configureHttpClient[SfnAsyncClient, SfnAsyncClientBuilder](
        b0,
        io.github.vigoo.zioaws.core.httpclient
          .ServiceHttpCapabilities(supportsHttp2 = false)
      )
      .toManaged_; client <- zio.ZIO(customization(b1).build()).toManaged_
  ) yield new SfnImpl(client, AwsCallAspect.identity, ().asInstanceOf[Any])
  private class SfnImpl[R](
      override val api: SfnAsyncClient,
      override val aspect: AwsCallAspect[R],
      r: R
  ) extends Sfn.Service
      with AwsServiceBase[R, SfnImpl] {
    override val serviceName: String = "Sfn"
    override def withAspect[R1](
        newAspect: AwsCallAspect[R1],
        r: R1
    ): SfnImpl[R1] = new SfnImpl(api, newAspect, r)
    def startExecution(
        request: io.github.vigoo.zioaws.sfn.model.StartExecutionRequest
    ): IO[AwsError, ReadOnly] =
      asyncRequestResponse[StartExecutionRequest, StartExecutionResponse](
        "startExecution",
        api.startExecution
      )(request.buildAwsValue())
        .map(io.github.vigoo.zioaws.sfn.model.StartExecutionResponse.wrap)
        .provide(r)
    def getExecutionHistory(
        request: io.github.vigoo.zioaws.sfn.model.GetExecutionHistoryRequest
    ): ZStream[
      Any,
      AwsError,
      io.github.vigoo.zioaws.sfn.model.HistoryEvent.ReadOnly
    ] = asyncJavaPaginatedRequest[
      GetExecutionHistoryRequest,
      HistoryEvent,
      GetExecutionHistoryPublisher
    ]("getExecutionHistory", api.getExecutionHistoryPaginator, _.events())(
      request.buildAwsValue()
    ).map(item => io.github.vigoo.zioaws.sfn.model.HistoryEvent.wrap(item))
      .provide(r)
    def deleteStateMachine(
        request: io.github.vigoo.zioaws.sfn.model.DeleteStateMachineRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.sfn.model.DeleteStateMachineResponse.ReadOnly
    ] = asyncRequestResponse[
      DeleteStateMachineRequest,
      DeleteStateMachineResponse
    ]("deleteStateMachine", api.deleteStateMachine)(request.buildAwsValue())
      .map(io.github.vigoo.zioaws.sfn.model.DeleteStateMachineResponse.wrap)
      .provide(r)
    def createStateMachine(
        request: io.github.vigoo.zioaws.sfn.model.CreateStateMachineRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.sfn.model.CreateStateMachineResponse.ReadOnly
    ] = asyncRequestResponse[
      CreateStateMachineRequest,
      CreateStateMachineResponse
    ]("createStateMachine", api.createStateMachine)(request.buildAwsValue())
      .map(io.github.vigoo.zioaws.sfn.model.CreateStateMachineResponse.wrap)
      .provide(r)
    def describeStateMachineForExecution(
        request: io.github.vigoo.zioaws.sfn.model.DescribeStateMachineForExecutionRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.sfn.model.DescribeStateMachineForExecutionResponse.ReadOnly
    ] = asyncRequestResponse[
      DescribeStateMachineForExecutionRequest,
      DescribeStateMachineForExecutionResponse
    ]("describeStateMachineForExecution", api.describeStateMachineForExecution)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.sfn.model.DescribeStateMachineForExecutionResponse.wrap
    ).provide(r)
    def stopExecution(
        request: io.github.vigoo.zioaws.sfn.model.StopExecutionRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.sfn.model.StopExecutionResponse.ReadOnly
    ] = asyncRequestResponse[StopExecutionRequest, StopExecutionResponse](
      "stopExecution",
      api.stopExecution
    )(request.buildAwsValue())
      .map(io.github.vigoo.zioaws.sfn.model.StopExecutionResponse.wrap)
      .provide(r)
    def getActivityTask(
        request: io.github.vigoo.zioaws.sfn.model.GetActivityTaskRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.sfn.model.GetActivityTaskResponse.ReadOnly
    ] = asyncRequestResponse[GetActivityTaskRequest, GetActivityTaskResponse](
      "getActivityTask",
      api.getActivityTask
    )(request.buildAwsValue())
      .map(io.github.vigoo.zioaws.sfn.model.GetActivityTaskResponse.wrap)
      .provide(r)
    def describeExecution(
        request: io.github.vigoo.zioaws.sfn.model.DescribeExecutionRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.sfn.model.DescribeExecutionResponse.ReadOnly
    ] =
      asyncRequestResponse[DescribeExecutionRequest, DescribeExecutionResponse](
        "describeExecution",
        api.describeExecution
      )(request.buildAwsValue())
        .map(io.github.vigoo.zioaws.sfn.model.DescribeExecutionResponse.wrap)
        .provide(r)
    def startSyncExecution(
        request: io.github.vigoo.zioaws.sfn.model.StartSyncExecutionRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.sfn.model.StartSyncExecutionResponse.ReadOnly
    ] = asyncRequestResponse[
      StartSyncExecutionRequest,
      StartSyncExecutionResponse
    ]("startSyncExecution", api.startSyncExecution)(request.buildAwsValue())
      .map(io.github.vigoo.zioaws.sfn.model.StartSyncExecutionResponse.wrap)
      .provide(r)
    def sendTaskSuccess(
        request: io.github.vigoo.zioaws.sfn.model.SendTaskSuccessRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.sfn.model.SendTaskSuccessResponse.ReadOnly
    ] = asyncRequestResponse[SendTaskSuccessRequest, SendTaskSuccessResponse](
      "sendTaskSuccess",
      api.sendTaskSuccess
    )(request.buildAwsValue())
      .map(io.github.vigoo.zioaws.sfn.model.SendTaskSuccessResponse.wrap)
      .provide(r)
    def sendTaskHeartbeat(
        request: io.github.vigoo.zioaws.sfn.model.SendTaskHeartbeatRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.sfn.model.SendTaskHeartbeatResponse.ReadOnly
    ] =
      asyncRequestResponse[SendTaskHeartbeatRequest, SendTaskHeartbeatResponse](
        "sendTaskHeartbeat",
        api.sendTaskHeartbeat
      )(request.buildAwsValue())
        .map(io.github.vigoo.zioaws.sfn.model.SendTaskHeartbeatResponse.wrap)
        .provide(r)
    def describeStateMachine(
        request: io.github.vigoo.zioaws.sfn.model.DescribeStateMachineRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.sfn.model.DescribeStateMachineResponse.ReadOnly
    ] = asyncRequestResponse[
      DescribeStateMachineRequest,
      DescribeStateMachineResponse
    ]("describeStateMachine", api.describeStateMachine)(request.buildAwsValue())
      .map(io.github.vigoo.zioaws.sfn.model.DescribeStateMachineResponse.wrap)
      .provide(r)
    def deleteActivity(
        request: io.github.vigoo.zioaws.sfn.model.DeleteActivityRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.sfn.model.DeleteActivityResponse.ReadOnly
    ] = asyncRequestResponse[DeleteActivityRequest, DeleteActivityResponse](
      "deleteActivity",
      api.deleteActivity
    )(request.buildAwsValue())
      .map(io.github.vigoo.zioaws.sfn.model.DeleteActivityResponse.wrap)
      .provide(r)
    def updateStateMachine(
        request: io.github.vigoo.zioaws.sfn.model.UpdateStateMachineRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.sfn.model.UpdateStateMachineResponse.ReadOnly
    ] = asyncRequestResponse[
      UpdateStateMachineRequest,
      UpdateStateMachineResponse
    ]("updateStateMachine", api.updateStateMachine)(request.buildAwsValue())
      .map(io.github.vigoo.zioaws.sfn.model.UpdateStateMachineResponse.wrap)
      .provide(r)
    def untagResource(
        request: io.github.vigoo.zioaws.sfn.model.UntagResourceRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.sfn.model.UntagResourceResponse.ReadOnly
    ] = asyncRequestResponse[UntagResourceRequest, UntagResourceResponse](
      "untagResource",
      api.untagResource
    )(request.buildAwsValue())
      .map(io.github.vigoo.zioaws.sfn.model.UntagResourceResponse.wrap)
      .provide(r)
    def listActivities(
        request: io.github.vigoo.zioaws.sfn.model.ListActivitiesRequest
    ): ZStream[
      Any,
      AwsError,
      io.github.vigoo.zioaws.sfn.model.ActivityListItem.ReadOnly
    ] = asyncJavaPaginatedRequest[
      ListActivitiesRequest,
      ActivityListItem,
      ListActivitiesPublisher
    ]("listActivities", api.listActivitiesPaginator, _.activities())(
      request.buildAwsValue()
    ).map(item => io.github.vigoo.zioaws.sfn.model.ActivityListItem.wrap(item))
      .provide(r)
    def listStateMachines(
        request: io.github.vigoo.zioaws.sfn.model.ListStateMachinesRequest
    ): ZStream[
      Any,
      AwsError,
      io.github.vigoo.zioaws.sfn.model.StateMachineListItem.ReadOnly
    ] = asyncJavaPaginatedRequest[
      ListStateMachinesRequest,
      StateMachineListItem,
      ListStateMachinesPublisher
    ]("listStateMachines", api.listStateMachinesPaginator, _.stateMachines())(
      request.buildAwsValue()
    ).map(item =>
      io.github.vigoo.zioaws.sfn.model.StateMachineListItem.wrap(item)
    ).provide(r)
    def listExecutions(
        request: io.github.vigoo.zioaws.sfn.model.ListExecutionsRequest
    ): ZStream[
      Any,
      AwsError,
      io.github.vigoo.zioaws.sfn.model.ExecutionListItem.ReadOnly
    ] = asyncJavaPaginatedRequest[
      ListExecutionsRequest,
      ExecutionListItem,
      ListExecutionsPublisher
    ]("listExecutions", api.listExecutionsPaginator, _.executions())(
      request.buildAwsValue()
    ).map(item => io.github.vigoo.zioaws.sfn.model.ExecutionListItem.wrap(item))
      .provide(r)
    def createActivity(
        request: io.github.vigoo.zioaws.sfn.model.CreateActivityRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.sfn.model.CreateActivityResponse.ReadOnly
    ] = asyncRequestResponse[CreateActivityRequest, CreateActivityResponse](
      "createActivity",
      api.createActivity
    )(request.buildAwsValue())
      .map(io.github.vigoo.zioaws.sfn.model.CreateActivityResponse.wrap)
      .provide(r)
    def listTagsForResource(
        request: io.github.vigoo.zioaws.sfn.model.ListTagsForResourceRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.sfn.model.ListTagsForResourceResponse.ReadOnly
    ] = asyncRequestResponse[
      ListTagsForResourceRequest,
      ListTagsForResourceResponse
    ]("listTagsForResource", api.listTagsForResource)(request.buildAwsValue())
      .map(io.github.vigoo.zioaws.sfn.model.ListTagsForResourceResponse.wrap)
      .provide(r)
    def sendTaskFailure(
        request: io.github.vigoo.zioaws.sfn.model.SendTaskFailureRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.sfn.model.SendTaskFailureResponse.ReadOnly
    ] = asyncRequestResponse[SendTaskFailureRequest, SendTaskFailureResponse](
      "sendTaskFailure",
      api.sendTaskFailure
    )(request.buildAwsValue())
      .map(io.github.vigoo.zioaws.sfn.model.SendTaskFailureResponse.wrap)
      .provide(r)
    def tagResource(
        request: io.github.vigoo.zioaws.sfn.model.TagResourceRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.sfn.model.TagResourceResponse.ReadOnly
    ] = asyncRequestResponse[TagResourceRequest, TagResourceResponse](
      "tagResource",
      api.tagResource
    )(request.buildAwsValue())
      .map(io.github.vigoo.zioaws.sfn.model.TagResourceResponse.wrap)
      .provide(r)
    def describeActivity(
        request: io.github.vigoo.zioaws.sfn.model.DescribeActivityRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.sfn.model.DescribeActivityResponse.ReadOnly
    ] = asyncRequestResponse[DescribeActivityRequest, DescribeActivityResponse](
      "describeActivity",
      api.describeActivity
    )(request.buildAwsValue())
      .map(io.github.vigoo.zioaws.sfn.model.DescribeActivityResponse.wrap)
      .provide(r)
  }
  def startExecution(
      request: io.github.vigoo.zioaws.sfn.model.StartExecutionRequest
  ): ZIO[Sfn, AwsError, ReadOnly] = ZIO.accessM(_.get.startExecution(request))
  def getExecutionHistory(
      request: io.github.vigoo.zioaws.sfn.model.GetExecutionHistoryRequest
  ): ZStream[
    Sfn,
    AwsError,
    io.github.vigoo.zioaws.sfn.model.HistoryEvent.ReadOnly
  ] = ZStream.accessStream(_.get.getExecutionHistory(request))
  def deleteStateMachine(
      request: io.github.vigoo.zioaws.sfn.model.DeleteStateMachineRequest
  ): ZIO[
    Sfn,
    AwsError,
    io.github.vigoo.zioaws.sfn.model.DeleteStateMachineResponse.ReadOnly
  ] = ZIO.accessM(_.get.deleteStateMachine(request))
  def createStateMachine(
      request: io.github.vigoo.zioaws.sfn.model.CreateStateMachineRequest
  ): ZIO[
    Sfn,
    AwsError,
    io.github.vigoo.zioaws.sfn.model.CreateStateMachineResponse.ReadOnly
  ] = ZIO.accessM(_.get.createStateMachine(request))
  def describeStateMachineForExecution(
      request: io.github.vigoo.zioaws.sfn.model.DescribeStateMachineForExecutionRequest
  ): ZIO[
    Sfn,
    AwsError,
    io.github.vigoo.zioaws.sfn.model.DescribeStateMachineForExecutionResponse.ReadOnly
  ] = ZIO.accessM(_.get.describeStateMachineForExecution(request))
  def stopExecution(
      request: io.github.vigoo.zioaws.sfn.model.StopExecutionRequest
  ): ZIO[
    Sfn,
    AwsError,
    io.github.vigoo.zioaws.sfn.model.StopExecutionResponse.ReadOnly
  ] = ZIO.accessM(_.get.stopExecution(request))
  def getActivityTask(
      request: io.github.vigoo.zioaws.sfn.model.GetActivityTaskRequest
  ): ZIO[
    Sfn,
    AwsError,
    io.github.vigoo.zioaws.sfn.model.GetActivityTaskResponse.ReadOnly
  ] = ZIO.accessM(_.get.getActivityTask(request))
  def describeExecution(
      request: io.github.vigoo.zioaws.sfn.model.DescribeExecutionRequest
  ): ZIO[
    Sfn,
    AwsError,
    io.github.vigoo.zioaws.sfn.model.DescribeExecutionResponse.ReadOnly
  ] = ZIO.accessM(_.get.describeExecution(request))
  def startSyncExecution(
      request: io.github.vigoo.zioaws.sfn.model.StartSyncExecutionRequest
  ): ZIO[
    Sfn,
    AwsError,
    io.github.vigoo.zioaws.sfn.model.StartSyncExecutionResponse.ReadOnly
  ] = ZIO.accessM(_.get.startSyncExecution(request))
  def sendTaskSuccess(
      request: io.github.vigoo.zioaws.sfn.model.SendTaskSuccessRequest
  ): ZIO[
    Sfn,
    AwsError,
    io.github.vigoo.zioaws.sfn.model.SendTaskSuccessResponse.ReadOnly
  ] = ZIO.accessM(_.get.sendTaskSuccess(request))
  def sendTaskHeartbeat(
      request: io.github.vigoo.zioaws.sfn.model.SendTaskHeartbeatRequest
  ): ZIO[
    Sfn,
    AwsError,
    io.github.vigoo.zioaws.sfn.model.SendTaskHeartbeatResponse.ReadOnly
  ] = ZIO.accessM(_.get.sendTaskHeartbeat(request))
  def describeStateMachine(
      request: io.github.vigoo.zioaws.sfn.model.DescribeStateMachineRequest
  ): ZIO[
    Sfn,
    AwsError,
    io.github.vigoo.zioaws.sfn.model.DescribeStateMachineResponse.ReadOnly
  ] = ZIO.accessM(_.get.describeStateMachine(request))
  def deleteActivity(
      request: io.github.vigoo.zioaws.sfn.model.DeleteActivityRequest
  ): ZIO[
    Sfn,
    AwsError,
    io.github.vigoo.zioaws.sfn.model.DeleteActivityResponse.ReadOnly
  ] = ZIO.accessM(_.get.deleteActivity(request))
  def updateStateMachine(
      request: io.github.vigoo.zioaws.sfn.model.UpdateStateMachineRequest
  ): ZIO[
    Sfn,
    AwsError,
    io.github.vigoo.zioaws.sfn.model.UpdateStateMachineResponse.ReadOnly
  ] = ZIO.accessM(_.get.updateStateMachine(request))
  def untagResource(
      request: io.github.vigoo.zioaws.sfn.model.UntagResourceRequest
  ): ZIO[
    Sfn,
    AwsError,
    io.github.vigoo.zioaws.sfn.model.UntagResourceResponse.ReadOnly
  ] = ZIO.accessM(_.get.untagResource(request))
  def listActivities(
      request: io.github.vigoo.zioaws.sfn.model.ListActivitiesRequest
  ): ZStream[
    Sfn,
    AwsError,
    io.github.vigoo.zioaws.sfn.model.ActivityListItem.ReadOnly
  ] = ZStream.accessStream(_.get.listActivities(request))
  def listStateMachines(
      request: io.github.vigoo.zioaws.sfn.model.ListStateMachinesRequest
  ): ZStream[
    Sfn,
    AwsError,
    io.github.vigoo.zioaws.sfn.model.StateMachineListItem.ReadOnly
  ] = ZStream.accessStream(_.get.listStateMachines(request))
  def listExecutions(
      request: io.github.vigoo.zioaws.sfn.model.ListExecutionsRequest
  ): ZStream[
    Sfn,
    AwsError,
    io.github.vigoo.zioaws.sfn.model.ExecutionListItem.ReadOnly
  ] = ZStream.accessStream(_.get.listExecutions(request))
  def createActivity(
      request: io.github.vigoo.zioaws.sfn.model.CreateActivityRequest
  ): ZIO[
    Sfn,
    AwsError,
    io.github.vigoo.zioaws.sfn.model.CreateActivityResponse.ReadOnly
  ] = ZIO.accessM(_.get.createActivity(request))
  def listTagsForResource(
      request: io.github.vigoo.zioaws.sfn.model.ListTagsForResourceRequest
  ): ZIO[
    Sfn,
    AwsError,
    io.github.vigoo.zioaws.sfn.model.ListTagsForResourceResponse.ReadOnly
  ] = ZIO.accessM(_.get.listTagsForResource(request))
  def sendTaskFailure(
      request: io.github.vigoo.zioaws.sfn.model.SendTaskFailureRequest
  ): ZIO[
    Sfn,
    AwsError,
    io.github.vigoo.zioaws.sfn.model.SendTaskFailureResponse.ReadOnly
  ] = ZIO.accessM(_.get.sendTaskFailure(request))
  def tagResource(
      request: io.github.vigoo.zioaws.sfn.model.TagResourceRequest
  ): ZIO[
    Sfn,
    AwsError,
    io.github.vigoo.zioaws.sfn.model.TagResourceResponse.ReadOnly
  ] = ZIO.accessM(_.get.tagResource(request))
  def describeActivity(
      request: io.github.vigoo.zioaws.sfn.model.DescribeActivityRequest
  ): ZIO[
    Sfn,
    AwsError,
    io.github.vigoo.zioaws.sfn.model.DescribeActivityResponse.ReadOnly
  ] = ZIO.accessM(_.get.describeActivity(request))
}