• Home
• io.github.vigoo
• zio-aws-swf_2.12
• 3.17.75.1
• 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.swf.package.scala Maven / Gradle / Ivy

package io.github.vigoo.zioaws
import io.github.vigoo.zioaws.swf.model.DescribeDomainResponse.ReadOnly
import io.github.vigoo.zioaws.swf.Swf
import io.github.vigoo.zioaws.swf.model.{
  ListActivityTypesRequest,
  DeprecateActivityTypeRequest,
  UndeprecateActivityTypeRequest,
  RequestCancelWorkflowExecutionRequest,
  CountPendingDecisionTasksRequest,
  RespondDecisionTaskCompletedRequest,
  PollForDecisionTaskRequest,
  CountClosedWorkflowExecutionsRequest,
  DescribeWorkflowExecutionRequest,
  DeprecateDomainRequest,
  ListTagsForResourceRequest,
  UndeprecateDomainRequest,
  ListOpenWorkflowExecutionsRequest,
  StartWorkflowExecutionRequest,
  SignalWorkflowExecutionRequest,
  GetWorkflowExecutionHistoryRequest,
  DescribeDomainRequest,
  RegisterWorkflowTypeRequest,
  DescribeActivityTypeRequest,
  RegisterActivityTypeRequest,
  UntagResourceRequest,
  DescribeWorkflowTypeRequest,
  PollForActivityTaskRequest,
  ListClosedWorkflowExecutionsRequest,
  ListWorkflowTypesRequest,
  RecordActivityTaskHeartbeatRequest,
  TerminateWorkflowExecutionRequest,
  RegisterDomainRequest,
  RespondActivityTaskCanceledRequest,
  UndeprecateWorkflowTypeRequest,
  RespondActivityTaskFailedRequest,
  CountOpenWorkflowExecutionsRequest,
  CountPendingActivityTasksRequest,
  ListDomainsRequest,
  TagResourceRequest,
  RespondActivityTaskCompletedRequest,
  DeprecateWorkflowTypeRequest
}
import io.github.vigoo.zioaws.core.{AwsServiceBase, AwsError}
import software.amazon.awssdk.services.swf.model.{
  DeprecateWorkflowTypeResponse,
  DescribeWorkflowTypeResponse,
  RespondActivityTaskCompletedResponse,
  DescribeDomainResponse,
  CountOpenWorkflowExecutionsResponse,
  RegisterWorkflowTypeResponse,
  PollForActivityTaskResponse,
  DeprecateActivityTypeResponse,
  UndeprecateDomainResponse,
  DescribeWorkflowExecutionResponse,
  RequestCancelWorkflowExecutionResponse,
  TerminateWorkflowExecutionResponse,
  StartWorkflowExecutionResponse,
  RegisterDomainResponse,
  ListTagsForResourceResponse,
  UntagResourceResponse,
  RespondActivityTaskFailedResponse,
  DomainInfo,
  DeprecateDomainResponse,
  UndeprecateActivityTypeResponse,
  RecordActivityTaskHeartbeatResponse,
  WorkflowExecutionInfo,
  RegisterActivityTypeResponse,
  CountPendingActivityTasksResponse,
  CountPendingDecisionTasksResponse,
  UndeprecateWorkflowTypeResponse,
  RespondActivityTaskCanceledResponse,
  CountClosedWorkflowExecutionsResponse,
  DescribeActivityTypeResponse,
  TagResourceResponse,
  SignalWorkflowExecutionResponse,
  HistoryEvent,
  RespondDecisionTaskCompletedResponse,
  ActivityTypeInfo,
  WorkflowTypeInfo
}
import io.github.vigoo.zioaws.core.config.AwsConfig
import zio.{ZManaged, IO, ZIO, ZLayer, URLayer, Has}
import io.github.vigoo.zioaws.core.aspects.{AwsCallAspect, AspectSupport}
import zio.stream.ZStream
import software.amazon.awssdk.services.swf.{
  SwfAsyncClientBuilder,
  SwfAsyncClient
}
import zio.test.mock.{Proxy, Mock}
import software.amazon.awssdk.services.swf.paginators.{
  ListClosedWorkflowExecutionsPublisher,
  ListWorkflowTypesPublisher,
  ListActivityTypesPublisher,
  ListDomainsPublisher,
  GetWorkflowExecutionHistoryPublisher,
  ListOpenWorkflowExecutionsPublisher,
  PollForDecisionTaskPublisher
}
package object swf {
  import scala.jdk.CollectionConverters._
  type Swf = Has[Swf.Service]
  object Swf {
    trait Service extends AspectSupport[Service] {
      val api: SwfAsyncClient
      def registerActivityType(
          request: RegisterActivityTypeRequest
      ): IO[AwsError, Unit]
      def describeActivityType(request: DescribeActivityTypeRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.swf.model.DescribeActivityTypeResponse.ReadOnly
      ]
      def describeDomain(request: DescribeDomainRequest): IO[AwsError, ReadOnly]
      def countClosedWorkflowExecutions(
          request: CountClosedWorkflowExecutionsRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.swf.model.CountClosedWorkflowExecutionsResponse.ReadOnly
      ]
      def startWorkflowExecution(request: StartWorkflowExecutionRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.swf.model.StartWorkflowExecutionResponse.ReadOnly
      ]
      def undeprecateDomain(
          request: UndeprecateDomainRequest
      ): IO[AwsError, Unit]
      def countPendingDecisionTasks(
          request: CountPendingDecisionTasksRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.swf.model.CountPendingDecisionTasksResponse.ReadOnly
      ]
      def signalWorkflowExecution(
          request: SignalWorkflowExecutionRequest
      ): IO[AwsError, Unit]
      def undeprecateActivityType(
          request: UndeprecateActivityTypeRequest
      ): IO[AwsError, Unit]
      def pollForActivityTask(request: PollForActivityTaskRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.swf.model.PollForActivityTaskResponse.ReadOnly
      ]
      def listDomains(request: ListDomainsRequest): ZStream[
        Any,
        AwsError,
        io.github.vigoo.zioaws.swf.model.DomainInfo.ReadOnly
      ]
      def listOpenWorkflowExecutions(
          request: ListOpenWorkflowExecutionsRequest
      ): ZStream[
        Any,
        AwsError,
        io.github.vigoo.zioaws.swf.model.WorkflowExecutionInfo.ReadOnly
      ]
      def listClosedWorkflowExecutions(
          request: ListClosedWorkflowExecutionsRequest
      ): ZStream[
        Any,
        AwsError,
        io.github.vigoo.zioaws.swf.model.WorkflowExecutionInfo.ReadOnly
      ]
      def registerDomain(request: RegisterDomainRequest): IO[AwsError, Unit]
      def getWorkflowExecutionHistory(
          request: GetWorkflowExecutionHistoryRequest
      ): ZStream[
        Any,
        AwsError,
        io.github.vigoo.zioaws.swf.model.HistoryEvent.ReadOnly
      ]
      def respondActivityTaskFailed(
          request: RespondActivityTaskFailedRequest
      ): IO[AwsError, Unit]
      def registerWorkflowType(
          request: RegisterWorkflowTypeRequest
      ): IO[AwsError, Unit]
      def listActivityTypes(request: ListActivityTypesRequest): ZStream[
        Any,
        AwsError,
        io.github.vigoo.zioaws.swf.model.ActivityTypeInfo.ReadOnly
      ]
      def untagResource(request: UntagResourceRequest): IO[AwsError, Unit]
      def respondActivityTaskCompleted(
          request: RespondActivityTaskCompletedRequest
      ): IO[AwsError, Unit]
      def countOpenWorkflowExecutions(
          request: CountOpenWorkflowExecutionsRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.swf.model.CountOpenWorkflowExecutionsResponse.ReadOnly
      ]
      def terminateWorkflowExecution(
          request: TerminateWorkflowExecutionRequest
      ): IO[AwsError, Unit]
      def countPendingActivityTasks(
          request: CountPendingActivityTasksRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.swf.model.CountPendingActivityTasksResponse.ReadOnly
      ]
      def respondDecisionTaskCompleted(
          request: RespondDecisionTaskCompletedRequest
      ): IO[AwsError, Unit]
      def listTagsForResource(request: ListTagsForResourceRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.swf.model.ListTagsForResourceResponse.ReadOnly
      ]
      def tagResource(request: TagResourceRequest): IO[AwsError, Unit]
      def deprecateWorkflowType(
          request: DeprecateWorkflowTypeRequest
      ): IO[AwsError, Unit]
      def pollForDecisionTask(request: PollForDecisionTaskRequest): ZStream[
        Any,
        AwsError,
        io.github.vigoo.zioaws.swf.model.HistoryEvent.ReadOnly
      ]
      def deprecateDomain(request: DeprecateDomainRequest): IO[AwsError, Unit]
      def respondActivityTaskCanceled(
          request: RespondActivityTaskCanceledRequest
      ): IO[AwsError, Unit]
      def requestCancelWorkflowExecution(
          request: RequestCancelWorkflowExecutionRequest
      ): IO[AwsError, Unit]
      def describeWorkflowType(request: DescribeWorkflowTypeRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.swf.model.DescribeWorkflowTypeResponse.ReadOnly
      ]
      def undeprecateWorkflowType(
          request: UndeprecateWorkflowTypeRequest
      ): IO[AwsError, Unit]
      def recordActivityTaskHeartbeat(
          request: RecordActivityTaskHeartbeatRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.swf.model.RecordActivityTaskHeartbeatResponse.ReadOnly
      ]
      def listWorkflowTypes(request: ListWorkflowTypesRequest): ZStream[
        Any,
        AwsError,
        io.github.vigoo.zioaws.swf.model.WorkflowTypeInfo.ReadOnly
      ]
      def describeWorkflowExecution(
          request: DescribeWorkflowExecutionRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.swf.model.DescribeWorkflowExecutionResponse.ReadOnly
      ]
      def deprecateActivityType(
          request: DeprecateActivityTypeRequest
      ): IO[AwsError, Unit]
    }
    object SwfMock extends Mock[Swf] {
      object RegisterActivityType
          extends Effect[RegisterActivityTypeRequest, AwsError, Unit]
      object DescribeActivityType
          extends Effect[
            DescribeActivityTypeRequest,
            AwsError,
            io.github.vigoo.zioaws.swf.model.DescribeActivityTypeResponse.ReadOnly
          ]
      object DescribeDomain
          extends Effect[DescribeDomainRequest, AwsError, ReadOnly]
      object CountClosedWorkflowExecutions
          extends Effect[
            CountClosedWorkflowExecutionsRequest,
            AwsError,
            io.github.vigoo.zioaws.swf.model.CountClosedWorkflowExecutionsResponse.ReadOnly
          ]
      object StartWorkflowExecution
          extends Effect[
            StartWorkflowExecutionRequest,
            AwsError,
            io.github.vigoo.zioaws.swf.model.StartWorkflowExecutionResponse.ReadOnly
          ]
      object UndeprecateDomain
          extends Effect[UndeprecateDomainRequest, AwsError, Unit]
      object CountPendingDecisionTasks
          extends Effect[
            CountPendingDecisionTasksRequest,
            AwsError,
            io.github.vigoo.zioaws.swf.model.CountPendingDecisionTasksResponse.ReadOnly
          ]
      object SignalWorkflowExecution
          extends Effect[SignalWorkflowExecutionRequest, AwsError, Unit]
      object UndeprecateActivityType
          extends Effect[UndeprecateActivityTypeRequest, AwsError, Unit]
      object PollForActivityTask
          extends Effect[
            PollForActivityTaskRequest,
            AwsError,
            io.github.vigoo.zioaws.swf.model.PollForActivityTaskResponse.ReadOnly
          ]
      object ListDomains
          extends Stream[
            ListDomainsRequest,
            AwsError,
            io.github.vigoo.zioaws.swf.model.DomainInfo.ReadOnly
          ]
      object ListOpenWorkflowExecutions
          extends Stream[
            ListOpenWorkflowExecutionsRequest,
            AwsError,
            io.github.vigoo.zioaws.swf.model.WorkflowExecutionInfo.ReadOnly
          ]
      object ListClosedWorkflowExecutions
          extends Stream[
            ListClosedWorkflowExecutionsRequest,
            AwsError,
            io.github.vigoo.zioaws.swf.model.WorkflowExecutionInfo.ReadOnly
          ]
      object RegisterDomain
          extends Effect[RegisterDomainRequest, AwsError, Unit]
      object GetWorkflowExecutionHistory
          extends Stream[
            GetWorkflowExecutionHistoryRequest,
            AwsError,
            io.github.vigoo.zioaws.swf.model.HistoryEvent.ReadOnly
          ]
      object RespondActivityTaskFailed
          extends Effect[RespondActivityTaskFailedRequest, AwsError, Unit]
      object RegisterWorkflowType
          extends Effect[RegisterWorkflowTypeRequest, AwsError, Unit]
      object ListActivityTypes
          extends Stream[
            ListActivityTypesRequest,
            AwsError,
            io.github.vigoo.zioaws.swf.model.ActivityTypeInfo.ReadOnly
          ]
      object UntagResource extends Effect[UntagResourceRequest, AwsError, Unit]
      object RespondActivityTaskCompleted
          extends Effect[RespondActivityTaskCompletedRequest, AwsError, Unit]
      object CountOpenWorkflowExecutions
          extends Effect[
            CountOpenWorkflowExecutionsRequest,
            AwsError,
            io.github.vigoo.zioaws.swf.model.CountOpenWorkflowExecutionsResponse.ReadOnly
          ]
      object TerminateWorkflowExecution
          extends Effect[TerminateWorkflowExecutionRequest, AwsError, Unit]
      object CountPendingActivityTasks
          extends Effect[
            CountPendingActivityTasksRequest,
            AwsError,
            io.github.vigoo.zioaws.swf.model.CountPendingActivityTasksResponse.ReadOnly
          ]
      object RespondDecisionTaskCompleted
          extends Effect[RespondDecisionTaskCompletedRequest, AwsError, Unit]
      object ListTagsForResource
          extends Effect[
            ListTagsForResourceRequest,
            AwsError,
            io.github.vigoo.zioaws.swf.model.ListTagsForResourceResponse.ReadOnly
          ]
      object TagResource extends Effect[TagResourceRequest, AwsError, Unit]
      object DeprecateWorkflowType
          extends Effect[DeprecateWorkflowTypeRequest, AwsError, Unit]
      object PollForDecisionTask
          extends Stream[
            PollForDecisionTaskRequest,
            AwsError,
            io.github.vigoo.zioaws.swf.model.HistoryEvent.ReadOnly
          ]
      object DeprecateDomain
          extends Effect[DeprecateDomainRequest, AwsError, Unit]
      object RespondActivityTaskCanceled
          extends Effect[RespondActivityTaskCanceledRequest, AwsError, Unit]
      object RequestCancelWorkflowExecution
          extends Effect[RequestCancelWorkflowExecutionRequest, AwsError, Unit]
      object DescribeWorkflowType
          extends Effect[
            DescribeWorkflowTypeRequest,
            AwsError,
            io.github.vigoo.zioaws.swf.model.DescribeWorkflowTypeResponse.ReadOnly
          ]
      object UndeprecateWorkflowType
          extends Effect[UndeprecateWorkflowTypeRequest, AwsError, Unit]
      object RecordActivityTaskHeartbeat
          extends Effect[
            RecordActivityTaskHeartbeatRequest,
            AwsError,
            io.github.vigoo.zioaws.swf.model.RecordActivityTaskHeartbeatResponse.ReadOnly
          ]
      object ListWorkflowTypes
          extends Stream[
            ListWorkflowTypesRequest,
            AwsError,
            io.github.vigoo.zioaws.swf.model.WorkflowTypeInfo.ReadOnly
          ]
      object DescribeWorkflowExecution
          extends Effect[
            DescribeWorkflowExecutionRequest,
            AwsError,
            io.github.vigoo.zioaws.swf.model.DescribeWorkflowExecutionResponse.ReadOnly
          ]
      object DeprecateActivityType
          extends Effect[DeprecateActivityTypeRequest, AwsError, Unit]
      val compose: URLayer[Has[Proxy], Swf] = ZLayer.fromServiceM { proxy =>
        withRuntime.map { rts =>
          new Swf.Service {
            val api: SwfAsyncClient = null
            def withAspect[R1](
                newAspect: AwsCallAspect[R1],
                r: R1
            ): Swf.Service = this
            def registerActivityType(
                request: RegisterActivityTypeRequest
            ): IO[AwsError, Unit] = proxy(RegisterActivityType, request)
            def describeActivityType(request: DescribeActivityTypeRequest): IO[
              AwsError,
              io.github.vigoo.zioaws.swf.model.DescribeActivityTypeResponse.ReadOnly
            ] = proxy(DescribeActivityType, request)
            def describeDomain(
                request: DescribeDomainRequest
            ): IO[AwsError, ReadOnly] = proxy(DescribeDomain, request)
            def countClosedWorkflowExecutions(
                request: CountClosedWorkflowExecutionsRequest
            ): IO[
              AwsError,
              io.github.vigoo.zioaws.swf.model.CountClosedWorkflowExecutionsResponse.ReadOnly
            ] = proxy(CountClosedWorkflowExecutions, request)
            def startWorkflowExecution(
                request: StartWorkflowExecutionRequest
            ): IO[
              AwsError,
              io.github.vigoo.zioaws.swf.model.StartWorkflowExecutionResponse.ReadOnly
            ] = proxy(StartWorkflowExecution, request)
            def undeprecateDomain(
                request: UndeprecateDomainRequest
            ): IO[AwsError, Unit] = proxy(UndeprecateDomain, request)
            def countPendingDecisionTasks(
                request: CountPendingDecisionTasksRequest
            ): IO[
              AwsError,
              io.github.vigoo.zioaws.swf.model.CountPendingDecisionTasksResponse.ReadOnly
            ] = proxy(CountPendingDecisionTasks, request)
            def signalWorkflowExecution(
                request: SignalWorkflowExecutionRequest
            ): IO[AwsError, Unit] = proxy(SignalWorkflowExecution, request)
            def undeprecateActivityType(
                request: UndeprecateActivityTypeRequest
            ): IO[AwsError, Unit] = proxy(UndeprecateActivityType, request)
            def pollForActivityTask(request: PollForActivityTaskRequest): IO[
              AwsError,
              io.github.vigoo.zioaws.swf.model.PollForActivityTaskResponse.ReadOnly
            ] = proxy(PollForActivityTask, request)
            def listDomains(request: ListDomainsRequest): ZStream[
              Any,
              AwsError,
              io.github.vigoo.zioaws.swf.model.DomainInfo.ReadOnly
            ] = rts.unsafeRun(proxy(ListDomains, request))
            def listOpenWorkflowExecutions(
                request: ListOpenWorkflowExecutionsRequest
            ): ZStream[
              Any,
              AwsError,
              io.github.vigoo.zioaws.swf.model.WorkflowExecutionInfo.ReadOnly
            ] = rts.unsafeRun(proxy(ListOpenWorkflowExecutions, request))
            def listClosedWorkflowExecutions(
                request: ListClosedWorkflowExecutionsRequest
            ): ZStream[
              Any,
              AwsError,
              io.github.vigoo.zioaws.swf.model.WorkflowExecutionInfo.ReadOnly
            ] = rts.unsafeRun(proxy(ListClosedWorkflowExecutions, request))
            def registerDomain(
                request: RegisterDomainRequest
            ): IO[AwsError, Unit] = proxy(RegisterDomain, request)
            def getWorkflowExecutionHistory(
                request: GetWorkflowExecutionHistoryRequest
            ): ZStream[
              Any,
              AwsError,
              io.github.vigoo.zioaws.swf.model.HistoryEvent.ReadOnly
            ] = rts.unsafeRun(proxy(GetWorkflowExecutionHistory, request))
            def respondActivityTaskFailed(
                request: RespondActivityTaskFailedRequest
            ): IO[AwsError, Unit] = proxy(RespondActivityTaskFailed, request)
            def registerWorkflowType(
                request: RegisterWorkflowTypeRequest
            ): IO[AwsError, Unit] = proxy(RegisterWorkflowType, request)
            def listActivityTypes(request: ListActivityTypesRequest): ZStream[
              Any,
              AwsError,
              io.github.vigoo.zioaws.swf.model.ActivityTypeInfo.ReadOnly
            ] = rts.unsafeRun(proxy(ListActivityTypes, request))
            def untagResource(
                request: UntagResourceRequest
            ): IO[AwsError, Unit] = proxy(UntagResource, request)
            def respondActivityTaskCompleted(
                request: RespondActivityTaskCompletedRequest
            ): IO[AwsError, Unit] = proxy(RespondActivityTaskCompleted, request)
            def countOpenWorkflowExecutions(
                request: CountOpenWorkflowExecutionsRequest
            ): IO[
              AwsError,
              io.github.vigoo.zioaws.swf.model.CountOpenWorkflowExecutionsResponse.ReadOnly
            ] = proxy(CountOpenWorkflowExecutions, request)
            def terminateWorkflowExecution(
                request: TerminateWorkflowExecutionRequest
            ): IO[AwsError, Unit] = proxy(TerminateWorkflowExecution, request)
            def countPendingActivityTasks(
                request: CountPendingActivityTasksRequest
            ): IO[
              AwsError,
              io.github.vigoo.zioaws.swf.model.CountPendingActivityTasksResponse.ReadOnly
            ] = proxy(CountPendingActivityTasks, request)
            def respondDecisionTaskCompleted(
                request: RespondDecisionTaskCompletedRequest
            ): IO[AwsError, Unit] = proxy(RespondDecisionTaskCompleted, request)
            def listTagsForResource(request: ListTagsForResourceRequest): IO[
              AwsError,
              io.github.vigoo.zioaws.swf.model.ListTagsForResourceResponse.ReadOnly
            ] = proxy(ListTagsForResource, request)
            def tagResource(request: TagResourceRequest): IO[AwsError, Unit] =
              proxy(TagResource, request)
            def deprecateWorkflowType(
                request: DeprecateWorkflowTypeRequest
            ): IO[AwsError, Unit] = proxy(DeprecateWorkflowType, request)
            def pollForDecisionTask(
                request: PollForDecisionTaskRequest
            ): ZStream[
              Any,
              AwsError,
              io.github.vigoo.zioaws.swf.model.HistoryEvent.ReadOnly
            ] = rts.unsafeRun(proxy(PollForDecisionTask, request))
            def deprecateDomain(
                request: DeprecateDomainRequest
            ): IO[AwsError, Unit] = proxy(DeprecateDomain, request)
            def respondActivityTaskCanceled(
                request: RespondActivityTaskCanceledRequest
            ): IO[AwsError, Unit] = proxy(RespondActivityTaskCanceled, request)
            def requestCancelWorkflowExecution(
                request: RequestCancelWorkflowExecutionRequest
            ): IO[AwsError, Unit] =
              proxy(RequestCancelWorkflowExecution, request)
            def describeWorkflowType(request: DescribeWorkflowTypeRequest): IO[
              AwsError,
              io.github.vigoo.zioaws.swf.model.DescribeWorkflowTypeResponse.ReadOnly
            ] = proxy(DescribeWorkflowType, request)
            def undeprecateWorkflowType(
                request: UndeprecateWorkflowTypeRequest
            ): IO[AwsError, Unit] = proxy(UndeprecateWorkflowType, request)
            def recordActivityTaskHeartbeat(
                request: RecordActivityTaskHeartbeatRequest
            ): IO[
              AwsError,
              io.github.vigoo.zioaws.swf.model.RecordActivityTaskHeartbeatResponse.ReadOnly
            ] = proxy(RecordActivityTaskHeartbeat, request)
            def listWorkflowTypes(request: ListWorkflowTypesRequest): ZStream[
              Any,
              AwsError,
              io.github.vigoo.zioaws.swf.model.WorkflowTypeInfo.ReadOnly
            ] = rts.unsafeRun(proxy(ListWorkflowTypes, request))
            def describeWorkflowExecution(
                request: DescribeWorkflowExecutionRequest
            ): IO[
              AwsError,
              io.github.vigoo.zioaws.swf.model.DescribeWorkflowExecutionResponse.ReadOnly
            ] = proxy(DescribeWorkflowExecution, request)
            def deprecateActivityType(
                request: DeprecateActivityTypeRequest
            ): IO[AwsError, Unit] = proxy(DeprecateActivityType, request)
          }
        }
      }
    }
  }
  val live: ZLayer[AwsConfig, java.lang.Throwable, Swf] = customized(identity)
  def customized(
      customization: SwfAsyncClientBuilder => SwfAsyncClientBuilder
  ): ZLayer[AwsConfig, java.lang.Throwable, Swf] = managed(
    customization
  ).toLayer
  def managed(
      customization: SwfAsyncClientBuilder => SwfAsyncClientBuilder
  ): ZManaged[AwsConfig, java.lang.Throwable, Swf.Service] = for (
    awsConfig <- ZManaged.service[AwsConfig.Service];
    executor <- ZIO.executor.toManaged_;
    builder = SwfAsyncClient
      .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[SwfAsyncClient, SwfAsyncClientBuilder](builder)
      .toManaged_;
    b1 <- awsConfig
      .configureHttpClient[SwfAsyncClient, SwfAsyncClientBuilder](
        b0,
        io.github.vigoo.zioaws.core.httpclient
          .ServiceHttpCapabilities(supportsHttp2 = false)
      )
      .toManaged_; client <- zio.ZIO(customization(b1).build()).toManaged_
  ) yield new SwfImpl(client, AwsCallAspect.identity, ().asInstanceOf[Any])
  private class SwfImpl[R](
      override val api: SwfAsyncClient,
      override val aspect: AwsCallAspect[R],
      r: R
  ) extends Swf.Service
      with AwsServiceBase[R, SwfImpl] {
    override val serviceName: String = "Swf"
    override def withAspect[R1](
        newAspect: AwsCallAspect[R1],
        r: R1
    ): SwfImpl[R1] = new SwfImpl(api, newAspect, r)
    def registerActivityType(
        request: RegisterActivityTypeRequest
    ): IO[AwsError, Unit] = asyncRequestResponse[
      software.amazon.awssdk.services.swf.model.RegisterActivityTypeRequest,
      RegisterActivityTypeResponse
    ]("registerActivityType", api.registerActivityType)(
      request.buildAwsValue()
    ).unit.provide(r)
    def describeActivityType(request: DescribeActivityTypeRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.swf.model.DescribeActivityTypeResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.swf.model.DescribeActivityTypeRequest,
      DescribeActivityTypeResponse
    ]("describeActivityType", api.describeActivityType)(request.buildAwsValue())
      .map(io.github.vigoo.zioaws.swf.model.DescribeActivityTypeResponse.wrap)
      .provide(r)
    def describeDomain(request: DescribeDomainRequest): IO[AwsError, ReadOnly] =
      asyncRequestResponse[
        software.amazon.awssdk.services.swf.model.DescribeDomainRequest,
        DescribeDomainResponse
      ]("describeDomain", api.describeDomain)(request.buildAwsValue())
        .map(io.github.vigoo.zioaws.swf.model.DescribeDomainResponse.wrap)
        .provide(r)
    def countClosedWorkflowExecutions(
        request: CountClosedWorkflowExecutionsRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.swf.model.CountClosedWorkflowExecutionsResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.swf.model.CountClosedWorkflowExecutionsRequest,
      CountClosedWorkflowExecutionsResponse
    ]("countClosedWorkflowExecutions", api.countClosedWorkflowExecutions)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.swf.model.CountClosedWorkflowExecutionsResponse.wrap
    ).provide(r)
    def startWorkflowExecution(request: StartWorkflowExecutionRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.swf.model.StartWorkflowExecutionResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.swf.model.StartWorkflowExecutionRequest,
      StartWorkflowExecutionResponse
    ]("startWorkflowExecution", api.startWorkflowExecution)(
      request.buildAwsValue()
    ).map(io.github.vigoo.zioaws.swf.model.StartWorkflowExecutionResponse.wrap)
      .provide(r)
    def undeprecateDomain(
        request: UndeprecateDomainRequest
    ): IO[AwsError, Unit] = asyncRequestResponse[
      software.amazon.awssdk.services.swf.model.UndeprecateDomainRequest,
      UndeprecateDomainResponse
    ]("undeprecateDomain", api.undeprecateDomain)(request.buildAwsValue()).unit
      .provide(r)
    def countPendingDecisionTasks(
        request: CountPendingDecisionTasksRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.swf.model.CountPendingDecisionTasksResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.swf.model.CountPendingDecisionTasksRequest,
      CountPendingDecisionTasksResponse
    ]("countPendingDecisionTasks", api.countPendingDecisionTasks)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.swf.model.CountPendingDecisionTasksResponse.wrap
    ).provide(r)
    def signalWorkflowExecution(
        request: SignalWorkflowExecutionRequest
    ): IO[AwsError, Unit] = asyncRequestResponse[
      software.amazon.awssdk.services.swf.model.SignalWorkflowExecutionRequest,
      SignalWorkflowExecutionResponse
    ]("signalWorkflowExecution", api.signalWorkflowExecution)(
      request.buildAwsValue()
    ).unit.provide(r)
    def undeprecateActivityType(
        request: UndeprecateActivityTypeRequest
    ): IO[AwsError, Unit] = asyncRequestResponse[
      software.amazon.awssdk.services.swf.model.UndeprecateActivityTypeRequest,
      UndeprecateActivityTypeResponse
    ]("undeprecateActivityType", api.undeprecateActivityType)(
      request.buildAwsValue()
    ).unit.provide(r)
    def pollForActivityTask(request: PollForActivityTaskRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.swf.model.PollForActivityTaskResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.swf.model.PollForActivityTaskRequest,
      PollForActivityTaskResponse
    ]("pollForActivityTask", api.pollForActivityTask)(request.buildAwsValue())
      .map(io.github.vigoo.zioaws.swf.model.PollForActivityTaskResponse.wrap)
      .provide(r)
    def listDomains(request: ListDomainsRequest): ZStream[
      Any,
      AwsError,
      io.github.vigoo.zioaws.swf.model.DomainInfo.ReadOnly
    ] = asyncJavaPaginatedRequest[
      software.amazon.awssdk.services.swf.model.ListDomainsRequest,
      DomainInfo,
      ListDomainsPublisher
    ]("listDomains", api.listDomainsPaginator, _.domainInfos())(
      request.buildAwsValue()
    ).map(item => io.github.vigoo.zioaws.swf.model.DomainInfo.wrap(item))
      .provide(r)
    def listOpenWorkflowExecutions(
        request: ListOpenWorkflowExecutionsRequest
    ): ZStream[
      Any,
      AwsError,
      io.github.vigoo.zioaws.swf.model.WorkflowExecutionInfo.ReadOnly
    ] = asyncJavaPaginatedRequest[
      software.amazon.awssdk.services.swf.model.ListOpenWorkflowExecutionsRequest,
      WorkflowExecutionInfo,
      ListOpenWorkflowExecutionsPublisher
    ](
      "listOpenWorkflowExecutions",
      api.listOpenWorkflowExecutionsPaginator,
      _.executionInfos()
    )(request.buildAwsValue())
      .map(item =>
        io.github.vigoo.zioaws.swf.model.WorkflowExecutionInfo.wrap(item)
      )
      .provide(r)
    def listClosedWorkflowExecutions(
        request: ListClosedWorkflowExecutionsRequest
    ): ZStream[
      Any,
      AwsError,
      io.github.vigoo.zioaws.swf.model.WorkflowExecutionInfo.ReadOnly
    ] = asyncJavaPaginatedRequest[
      software.amazon.awssdk.services.swf.model.ListClosedWorkflowExecutionsRequest,
      WorkflowExecutionInfo,
      ListClosedWorkflowExecutionsPublisher
    ](
      "listClosedWorkflowExecutions",
      api.listClosedWorkflowExecutionsPaginator,
      _.executionInfos()
    )(request.buildAwsValue())
      .map(item =>
        io.github.vigoo.zioaws.swf.model.WorkflowExecutionInfo.wrap(item)
      )
      .provide(r)
    def registerDomain(request: RegisterDomainRequest): IO[AwsError, Unit] =
      asyncRequestResponse[
        software.amazon.awssdk.services.swf.model.RegisterDomainRequest,
        RegisterDomainResponse
      ]("registerDomain", api.registerDomain)(request.buildAwsValue()).unit
        .provide(r)
    def getWorkflowExecutionHistory(
        request: GetWorkflowExecutionHistoryRequest
    ): ZStream[
      Any,
      AwsError,
      io.github.vigoo.zioaws.swf.model.HistoryEvent.ReadOnly
    ] = asyncJavaPaginatedRequest[
      software.amazon.awssdk.services.swf.model.GetWorkflowExecutionHistoryRequest,
      HistoryEvent,
      GetWorkflowExecutionHistoryPublisher
    ](
      "getWorkflowExecutionHistory",
      api.getWorkflowExecutionHistoryPaginator,
      _.events()
    )(request.buildAwsValue())
      .map(item => io.github.vigoo.zioaws.swf.model.HistoryEvent.wrap(item))
      .provide(r)
    def respondActivityTaskFailed(
        request: RespondActivityTaskFailedRequest
    ): IO[AwsError, Unit] = asyncRequestResponse[
      software.amazon.awssdk.services.swf.model.RespondActivityTaskFailedRequest,
      RespondActivityTaskFailedResponse
    ]("respondActivityTaskFailed", api.respondActivityTaskFailed)(
      request.buildAwsValue()
    ).unit.provide(r)
    def registerWorkflowType(
        request: RegisterWorkflowTypeRequest
    ): IO[AwsError, Unit] = asyncRequestResponse[
      software.amazon.awssdk.services.swf.model.RegisterWorkflowTypeRequest,
      RegisterWorkflowTypeResponse
    ]("registerWorkflowType", api.registerWorkflowType)(
      request.buildAwsValue()
    ).unit.provide(r)
    def listActivityTypes(request: ListActivityTypesRequest): ZStream[
      Any,
      AwsError,
      io.github.vigoo.zioaws.swf.model.ActivityTypeInfo.ReadOnly
    ] = asyncJavaPaginatedRequest[
      software.amazon.awssdk.services.swf.model.ListActivityTypesRequest,
      ActivityTypeInfo,
      ListActivityTypesPublisher
    ]("listActivityTypes", api.listActivityTypesPaginator, _.typeInfos())(
      request.buildAwsValue()
    ).map(item => io.github.vigoo.zioaws.swf.model.ActivityTypeInfo.wrap(item))
      .provide(r)
    def untagResource(request: UntagResourceRequest): IO[AwsError, Unit] =
      asyncRequestResponse[
        software.amazon.awssdk.services.swf.model.UntagResourceRequest,
        UntagResourceResponse
      ]("untagResource", api.untagResource)(request.buildAwsValue()).unit
        .provide(r)
    def respondActivityTaskCompleted(
        request: RespondActivityTaskCompletedRequest
    ): IO[AwsError, Unit] = asyncRequestResponse[
      software.amazon.awssdk.services.swf.model.RespondActivityTaskCompletedRequest,
      RespondActivityTaskCompletedResponse
    ]("respondActivityTaskCompleted", api.respondActivityTaskCompleted)(
      request.buildAwsValue()
    ).unit.provide(r)
    def countOpenWorkflowExecutions(
        request: CountOpenWorkflowExecutionsRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.swf.model.CountOpenWorkflowExecutionsResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.swf.model.CountOpenWorkflowExecutionsRequest,
      CountOpenWorkflowExecutionsResponse
    ]("countOpenWorkflowExecutions", api.countOpenWorkflowExecutions)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.swf.model.CountOpenWorkflowExecutionsResponse.wrap
    ).provide(r)
    def terminateWorkflowExecution(
        request: TerminateWorkflowExecutionRequest
    ): IO[AwsError, Unit] = asyncRequestResponse[
      software.amazon.awssdk.services.swf.model.TerminateWorkflowExecutionRequest,
      TerminateWorkflowExecutionResponse
    ]("terminateWorkflowExecution", api.terminateWorkflowExecution)(
      request.buildAwsValue()
    ).unit.provide(r)
    def countPendingActivityTasks(
        request: CountPendingActivityTasksRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.swf.model.CountPendingActivityTasksResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.swf.model.CountPendingActivityTasksRequest,
      CountPendingActivityTasksResponse
    ]("countPendingActivityTasks", api.countPendingActivityTasks)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.swf.model.CountPendingActivityTasksResponse.wrap
    ).provide(r)
    def respondDecisionTaskCompleted(
        request: RespondDecisionTaskCompletedRequest
    ): IO[AwsError, Unit] = asyncRequestResponse[
      software.amazon.awssdk.services.swf.model.RespondDecisionTaskCompletedRequest,
      RespondDecisionTaskCompletedResponse
    ]("respondDecisionTaskCompleted", api.respondDecisionTaskCompleted)(
      request.buildAwsValue()
    ).unit.provide(r)
    def listTagsForResource(request: ListTagsForResourceRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.swf.model.ListTagsForResourceResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.swf.model.ListTagsForResourceRequest,
      ListTagsForResourceResponse
    ]("listTagsForResource", api.listTagsForResource)(request.buildAwsValue())
      .map(io.github.vigoo.zioaws.swf.model.ListTagsForResourceResponse.wrap)
      .provide(r)
    def tagResource(request: TagResourceRequest): IO[AwsError, Unit] =
      asyncRequestResponse[
        software.amazon.awssdk.services.swf.model.TagResourceRequest,
        TagResourceResponse
      ]("tagResource", api.tagResource)(request.buildAwsValue()).unit.provide(r)
    def deprecateWorkflowType(
        request: DeprecateWorkflowTypeRequest
    ): IO[AwsError, Unit] = asyncRequestResponse[
      software.amazon.awssdk.services.swf.model.DeprecateWorkflowTypeRequest,
      DeprecateWorkflowTypeResponse
    ]("deprecateWorkflowType", api.deprecateWorkflowType)(
      request.buildAwsValue()
    ).unit.provide(r)
    def pollForDecisionTask(request: PollForDecisionTaskRequest): ZStream[
      Any,
      AwsError,
      io.github.vigoo.zioaws.swf.model.HistoryEvent.ReadOnly
    ] = asyncJavaPaginatedRequest[
      software.amazon.awssdk.services.swf.model.PollForDecisionTaskRequest,
      HistoryEvent,
      PollForDecisionTaskPublisher
    ]("pollForDecisionTask", api.pollForDecisionTaskPaginator, _.events())(
      request.buildAwsValue()
    ).map(item => io.github.vigoo.zioaws.swf.model.HistoryEvent.wrap(item))
      .provide(r)
    def deprecateDomain(request: DeprecateDomainRequest): IO[AwsError, Unit] =
      asyncRequestResponse[
        software.amazon.awssdk.services.swf.model.DeprecateDomainRequest,
        DeprecateDomainResponse
      ]("deprecateDomain", api.deprecateDomain)(request.buildAwsValue()).unit
        .provide(r)
    def respondActivityTaskCanceled(
        request: RespondActivityTaskCanceledRequest
    ): IO[AwsError, Unit] = asyncRequestResponse[
      software.amazon.awssdk.services.swf.model.RespondActivityTaskCanceledRequest,
      RespondActivityTaskCanceledResponse
    ]("respondActivityTaskCanceled", api.respondActivityTaskCanceled)(
      request.buildAwsValue()
    ).unit.provide(r)
    def requestCancelWorkflowExecution(
        request: RequestCancelWorkflowExecutionRequest
    ): IO[AwsError, Unit] = asyncRequestResponse[
      software.amazon.awssdk.services.swf.model.RequestCancelWorkflowExecutionRequest,
      RequestCancelWorkflowExecutionResponse
    ]("requestCancelWorkflowExecution", api.requestCancelWorkflowExecution)(
      request.buildAwsValue()
    ).unit.provide(r)
    def describeWorkflowType(request: DescribeWorkflowTypeRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.swf.model.DescribeWorkflowTypeResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.swf.model.DescribeWorkflowTypeRequest,
      DescribeWorkflowTypeResponse
    ]("describeWorkflowType", api.describeWorkflowType)(request.buildAwsValue())
      .map(io.github.vigoo.zioaws.swf.model.DescribeWorkflowTypeResponse.wrap)
      .provide(r)
    def undeprecateWorkflowType(
        request: UndeprecateWorkflowTypeRequest
    ): IO[AwsError, Unit] = asyncRequestResponse[
      software.amazon.awssdk.services.swf.model.UndeprecateWorkflowTypeRequest,
      UndeprecateWorkflowTypeResponse
    ]("undeprecateWorkflowType", api.undeprecateWorkflowType)(
      request.buildAwsValue()
    ).unit.provide(r)
    def recordActivityTaskHeartbeat(
        request: RecordActivityTaskHeartbeatRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.swf.model.RecordActivityTaskHeartbeatResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.swf.model.RecordActivityTaskHeartbeatRequest,
      RecordActivityTaskHeartbeatResponse
    ]("recordActivityTaskHeartbeat", api.recordActivityTaskHeartbeat)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.swf.model.RecordActivityTaskHeartbeatResponse.wrap
    ).provide(r)
    def listWorkflowTypes(request: ListWorkflowTypesRequest): ZStream[
      Any,
      AwsError,
      io.github.vigoo.zioaws.swf.model.WorkflowTypeInfo.ReadOnly
    ] = asyncJavaPaginatedRequest[
      software.amazon.awssdk.services.swf.model.ListWorkflowTypesRequest,
      WorkflowTypeInfo,
      ListWorkflowTypesPublisher
    ]("listWorkflowTypes", api.listWorkflowTypesPaginator, _.typeInfos())(
      request.buildAwsValue()
    ).map(item => io.github.vigoo.zioaws.swf.model.WorkflowTypeInfo.wrap(item))
      .provide(r)
    def describeWorkflowExecution(
        request: DescribeWorkflowExecutionRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.swf.model.DescribeWorkflowExecutionResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.swf.model.DescribeWorkflowExecutionRequest,
      DescribeWorkflowExecutionResponse
    ]("describeWorkflowExecution", api.describeWorkflowExecution)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.swf.model.DescribeWorkflowExecutionResponse.wrap
    ).provide(r)
    def deprecateActivityType(
        request: DeprecateActivityTypeRequest
    ): IO[AwsError, Unit] = asyncRequestResponse[
      software.amazon.awssdk.services.swf.model.DeprecateActivityTypeRequest,
      DeprecateActivityTypeResponse
    ]("deprecateActivityType", api.deprecateActivityType)(
      request.buildAwsValue()
    ).unit.provide(r)
  }
  def registerActivityType(
      request: RegisterActivityTypeRequest
  ): ZIO[Swf, AwsError, Unit] = ZIO.accessM(_.get.registerActivityType(request))
  def describeActivityType(request: DescribeActivityTypeRequest): ZIO[
    Swf,
    AwsError,
    io.github.vigoo.zioaws.swf.model.DescribeActivityTypeResponse.ReadOnly
  ] = ZIO.accessM(_.get.describeActivityType(request))
  def describeDomain(
      request: DescribeDomainRequest
  ): ZIO[Swf, AwsError, ReadOnly] = ZIO.accessM(_.get.describeDomain(request))
  def countClosedWorkflowExecutions(
      request: CountClosedWorkflowExecutionsRequest
  ): ZIO[
    Swf,
    AwsError,
    io.github.vigoo.zioaws.swf.model.CountClosedWorkflowExecutionsResponse.ReadOnly
  ] = ZIO.accessM(_.get.countClosedWorkflowExecutions(request))
  def startWorkflowExecution(request: StartWorkflowExecutionRequest): ZIO[
    Swf,
    AwsError,
    io.github.vigoo.zioaws.swf.model.StartWorkflowExecutionResponse.ReadOnly
  ] = ZIO.accessM(_.get.startWorkflowExecution(request))
  def undeprecateDomain(
      request: UndeprecateDomainRequest
  ): ZIO[Swf, AwsError, Unit] = ZIO.accessM(_.get.undeprecateDomain(request))
  def countPendingDecisionTasks(request: CountPendingDecisionTasksRequest): ZIO[
    Swf,
    AwsError,
    io.github.vigoo.zioaws.swf.model.CountPendingDecisionTasksResponse.ReadOnly
  ] = ZIO.accessM(_.get.countPendingDecisionTasks(request))
  def signalWorkflowExecution(
      request: SignalWorkflowExecutionRequest
  ): ZIO[Swf, AwsError, Unit] =
    ZIO.accessM(_.get.signalWorkflowExecution(request))
  def undeprecateActivityType(
      request: UndeprecateActivityTypeRequest
  ): ZIO[Swf, AwsError, Unit] =
    ZIO.accessM(_.get.undeprecateActivityType(request))
  def pollForActivityTask(request: PollForActivityTaskRequest): ZIO[
    Swf,
    AwsError,
    io.github.vigoo.zioaws.swf.model.PollForActivityTaskResponse.ReadOnly
  ] = ZIO.accessM(_.get.pollForActivityTask(request))
  def listDomains(request: ListDomainsRequest): ZStream[
    Swf,
    AwsError,
    io.github.vigoo.zioaws.swf.model.DomainInfo.ReadOnly
  ] = ZStream.accessStream(_.get.listDomains(request))
  def listOpenWorkflowExecutions(
      request: ListOpenWorkflowExecutionsRequest
  ): ZStream[
    Swf,
    AwsError,
    io.github.vigoo.zioaws.swf.model.WorkflowExecutionInfo.ReadOnly
  ] = ZStream.accessStream(_.get.listOpenWorkflowExecutions(request))
  def listClosedWorkflowExecutions(
      request: ListClosedWorkflowExecutionsRequest
  ): ZStream[
    Swf,
    AwsError,
    io.github.vigoo.zioaws.swf.model.WorkflowExecutionInfo.ReadOnly
  ] = ZStream.accessStream(_.get.listClosedWorkflowExecutions(request))
  def registerDomain(request: RegisterDomainRequest): ZIO[Swf, AwsError, Unit] =
    ZIO.accessM(_.get.registerDomain(request))
  def getWorkflowExecutionHistory(
      request: GetWorkflowExecutionHistoryRequest
  ): ZStream[
    Swf,
    AwsError,
    io.github.vigoo.zioaws.swf.model.HistoryEvent.ReadOnly
  ] = ZStream.accessStream(_.get.getWorkflowExecutionHistory(request))
  def respondActivityTaskFailed(
      request: RespondActivityTaskFailedRequest
  ): ZIO[Swf, AwsError, Unit] =
    ZIO.accessM(_.get.respondActivityTaskFailed(request))
  def registerWorkflowType(
      request: RegisterWorkflowTypeRequest
  ): ZIO[Swf, AwsError, Unit] = ZIO.accessM(_.get.registerWorkflowType(request))
  def listActivityTypes(request: ListActivityTypesRequest): ZStream[
    Swf,
    AwsError,
    io.github.vigoo.zioaws.swf.model.ActivityTypeInfo.ReadOnly
  ] = ZStream.accessStream(_.get.listActivityTypes(request))
  def untagResource(request: UntagResourceRequest): ZIO[Swf, AwsError, Unit] =
    ZIO.accessM(_.get.untagResource(request))
  def respondActivityTaskCompleted(
      request: RespondActivityTaskCompletedRequest
  ): ZIO[Swf, AwsError, Unit] =
    ZIO.accessM(_.get.respondActivityTaskCompleted(request))
  def countOpenWorkflowExecutions(
      request: CountOpenWorkflowExecutionsRequest
  ): ZIO[
    Swf,
    AwsError,
    io.github.vigoo.zioaws.swf.model.CountOpenWorkflowExecutionsResponse.ReadOnly
  ] = ZIO.accessM(_.get.countOpenWorkflowExecutions(request))
  def terminateWorkflowExecution(
      request: TerminateWorkflowExecutionRequest
  ): ZIO[Swf, AwsError, Unit] =
    ZIO.accessM(_.get.terminateWorkflowExecution(request))
  def countPendingActivityTasks(request: CountPendingActivityTasksRequest): ZIO[
    Swf,
    AwsError,
    io.github.vigoo.zioaws.swf.model.CountPendingActivityTasksResponse.ReadOnly
  ] = ZIO.accessM(_.get.countPendingActivityTasks(request))
  def respondDecisionTaskCompleted(
      request: RespondDecisionTaskCompletedRequest
  ): ZIO[Swf, AwsError, Unit] =
    ZIO.accessM(_.get.respondDecisionTaskCompleted(request))
  def listTagsForResource(request: ListTagsForResourceRequest): ZIO[
    Swf,
    AwsError,
    io.github.vigoo.zioaws.swf.model.ListTagsForResourceResponse.ReadOnly
  ] = ZIO.accessM(_.get.listTagsForResource(request))
  def tagResource(request: TagResourceRequest): ZIO[Swf, AwsError, Unit] =
    ZIO.accessM(_.get.tagResource(request))
  def deprecateWorkflowType(
      request: DeprecateWorkflowTypeRequest
  ): ZIO[Swf, AwsError, Unit] =
    ZIO.accessM(_.get.deprecateWorkflowType(request))
  def pollForDecisionTask(request: PollForDecisionTaskRequest): ZStream[
    Swf,
    AwsError,
    io.github.vigoo.zioaws.swf.model.HistoryEvent.ReadOnly
  ] = ZStream.accessStream(_.get.pollForDecisionTask(request))
  def deprecateDomain(
      request: DeprecateDomainRequest
  ): ZIO[Swf, AwsError, Unit] = ZIO.accessM(_.get.deprecateDomain(request))
  def respondActivityTaskCanceled(
      request: RespondActivityTaskCanceledRequest
  ): ZIO[Swf, AwsError, Unit] =
    ZIO.accessM(_.get.respondActivityTaskCanceled(request))
  def requestCancelWorkflowExecution(
      request: RequestCancelWorkflowExecutionRequest
  ): ZIO[Swf, AwsError, Unit] =
    ZIO.accessM(_.get.requestCancelWorkflowExecution(request))
  def describeWorkflowType(request: DescribeWorkflowTypeRequest): ZIO[
    Swf,
    AwsError,
    io.github.vigoo.zioaws.swf.model.DescribeWorkflowTypeResponse.ReadOnly
  ] = ZIO.accessM(_.get.describeWorkflowType(request))
  def undeprecateWorkflowType(
      request: UndeprecateWorkflowTypeRequest
  ): ZIO[Swf, AwsError, Unit] =
    ZIO.accessM(_.get.undeprecateWorkflowType(request))
  def recordActivityTaskHeartbeat(
      request: RecordActivityTaskHeartbeatRequest
  ): ZIO[
    Swf,
    AwsError,
    io.github.vigoo.zioaws.swf.model.RecordActivityTaskHeartbeatResponse.ReadOnly
  ] = ZIO.accessM(_.get.recordActivityTaskHeartbeat(request))
  def listWorkflowTypes(request: ListWorkflowTypesRequest): ZStream[
    Swf,
    AwsError,
    io.github.vigoo.zioaws.swf.model.WorkflowTypeInfo.ReadOnly
  ] = ZStream.accessStream(_.get.listWorkflowTypes(request))
  def describeWorkflowExecution(request: DescribeWorkflowExecutionRequest): ZIO[
    Swf,
    AwsError,
    io.github.vigoo.zioaws.swf.model.DescribeWorkflowExecutionResponse.ReadOnly
  ] = ZIO.accessM(_.get.describeWorkflowExecution(request))
  def deprecateActivityType(
      request: DeprecateActivityTypeRequest
  ): ZIO[Swf, AwsError, Unit] =
    ZIO.accessM(_.get.deprecateActivityType(request))
}