• Home
• io.github.vigoo
• zio-aws-swf_2.12
• 3.15.42.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.core._
import io.github.vigoo.zioaws.core.aspects._
import io.github.vigoo.zioaws.core.config.AwsConfig
import io.github.vigoo.zioaws.core.httpclient.ServiceHttpCapabilities
import software.amazon.awssdk.services.swf.paginators._
import software.amazon.awssdk.services.swf.{ SwfAsyncClient, SwfAsyncClientBuilder }
import zio.{ Chunk, Has, IO, ZIO, ZLayer, ZManaged }
import zio.stream.ZStream
import org.reactivestreams.Publisher
import scala.jdk.CollectionConverters._
package object swf {
  import model._
  type Swf = Has[Swf.Service]
  object Swf {
    trait Service extends AspectSupport[Service] {
      val api: SwfAsyncClient
      def registerActivityType(request: RegisterActivityTypeRequest): IO[AwsError, scala.Unit]
      def describeActivityType(request: DescribeActivityTypeRequest): IO[AwsError, DescribeActivityTypeResponse.ReadOnly]
      def describeDomain(request: DescribeDomainRequest): IO[AwsError, DescribeDomainResponse.ReadOnly]
      def countClosedWorkflowExecutions(request: CountClosedWorkflowExecutionsRequest): IO[AwsError, CountClosedWorkflowExecutionsResponse.ReadOnly]
      def startWorkflowExecution(request: StartWorkflowExecutionRequest): IO[AwsError, StartWorkflowExecutionResponse.ReadOnly]
      def undeprecateDomain(request: UndeprecateDomainRequest): IO[AwsError, scala.Unit]
      def countPendingDecisionTasks(request: CountPendingDecisionTasksRequest): IO[AwsError, CountPendingDecisionTasksResponse.ReadOnly]
      def signalWorkflowExecution(request: SignalWorkflowExecutionRequest): IO[AwsError, scala.Unit]
      def undeprecateActivityType(request: UndeprecateActivityTypeRequest): IO[AwsError, scala.Unit]
      def pollForActivityTask(request: PollForActivityTaskRequest): IO[AwsError, PollForActivityTaskResponse.ReadOnly]
      def listDomains(request: ListDomainsRequest): zio.stream.ZStream[Any, AwsError, DomainInfo.ReadOnly]
      def listOpenWorkflowExecutions(request: ListOpenWorkflowExecutionsRequest): zio.stream.ZStream[Any, AwsError, WorkflowExecutionInfo.ReadOnly]
      def listClosedWorkflowExecutions(request: ListClosedWorkflowExecutionsRequest): zio.stream.ZStream[Any, AwsError, WorkflowExecutionInfo.ReadOnly]
      def registerDomain(request: RegisterDomainRequest): IO[AwsError, scala.Unit]
      def getWorkflowExecutionHistory(request: GetWorkflowExecutionHistoryRequest): zio.stream.ZStream[Any, AwsError, HistoryEvent.ReadOnly]
      def respondActivityTaskFailed(request: RespondActivityTaskFailedRequest): IO[AwsError, scala.Unit]
      def registerWorkflowType(request: RegisterWorkflowTypeRequest): IO[AwsError, scala.Unit]
      def listActivityTypes(request: ListActivityTypesRequest): zio.stream.ZStream[Any, AwsError, ActivityTypeInfo.ReadOnly]
      def untagResource(request: UntagResourceRequest): IO[AwsError, scala.Unit]
      def respondActivityTaskCompleted(request: RespondActivityTaskCompletedRequest): IO[AwsError, scala.Unit]
      def countOpenWorkflowExecutions(request: CountOpenWorkflowExecutionsRequest): IO[AwsError, CountOpenWorkflowExecutionsResponse.ReadOnly]
      def terminateWorkflowExecution(request: TerminateWorkflowExecutionRequest): IO[AwsError, scala.Unit]
      def countPendingActivityTasks(request: CountPendingActivityTasksRequest): IO[AwsError, CountPendingActivityTasksResponse.ReadOnly]
      def respondDecisionTaskCompleted(request: RespondDecisionTaskCompletedRequest): IO[AwsError, scala.Unit]
      def listTagsForResource(request: ListTagsForResourceRequest): IO[AwsError, ListTagsForResourceResponse.ReadOnly]
      def tagResource(request: TagResourceRequest): IO[AwsError, scala.Unit]
      def deprecateWorkflowType(request: DeprecateWorkflowTypeRequest): IO[AwsError, scala.Unit]
      def pollForDecisionTask(request: PollForDecisionTaskRequest): zio.stream.ZStream[Any, AwsError, HistoryEvent.ReadOnly]
      def deprecateDomain(request: DeprecateDomainRequest): IO[AwsError, scala.Unit]
      def respondActivityTaskCanceled(request: RespondActivityTaskCanceledRequest): IO[AwsError, scala.Unit]
      def requestCancelWorkflowExecution(request: RequestCancelWorkflowExecutionRequest): IO[AwsError, scala.Unit]
      def describeWorkflowType(request: DescribeWorkflowTypeRequest): IO[AwsError, DescribeWorkflowTypeResponse.ReadOnly]
      def undeprecateWorkflowType(request: UndeprecateWorkflowTypeRequest): IO[AwsError, scala.Unit]
      def recordActivityTaskHeartbeat(request: RecordActivityTaskHeartbeatRequest): IO[AwsError, RecordActivityTaskHeartbeatResponse.ReadOnly]
      def listWorkflowTypes(request: ListWorkflowTypesRequest): zio.stream.ZStream[Any, AwsError, WorkflowTypeInfo.ReadOnly]
      def describeWorkflowExecution(request: DescribeWorkflowExecutionRequest): IO[AwsError, DescribeWorkflowExecutionResponse.ReadOnly]
      def deprecateActivityType(request: DeprecateActivityTypeRequest): IO[AwsError, scala.Unit]
    }
  }
  val live: ZLayer[AwsConfig, Throwable, Swf] = customized(identity)
  def customized(customization: SwfAsyncClientBuilder => SwfAsyncClientBuilder): ZLayer[AwsConfig, Throwable, Swf] = managed(customization).toLayer
  def managed(customization: SwfAsyncClientBuilder => SwfAsyncClientBuilder): ZManaged[AwsConfig, Throwable, Swf.Service] = for (awsConfig <- ZManaged.service[AwsConfig.Service]; b0 <- awsConfig.configure[SwfAsyncClient, SwfAsyncClientBuilder](SwfAsyncClient.builder()).toManaged_; b1 <- awsConfig.configureHttpClient[SwfAsyncClient, SwfAsyncClientBuilder](b0, ServiceHttpCapabilities(supportsHttp2 = false)).toManaged_; client <- 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, scala.Unit] = asyncRequestResponse[software.amazon.awssdk.services.swf.model.RegisterActivityTypeRequest, software.amazon.awssdk.services.swf.model.RegisterActivityTypeResponse]("registerActivityType", api.registerActivityType)(request.buildAwsValue()).unit.provide(r)
    def describeActivityType(request: DescribeActivityTypeRequest): IO[AwsError, DescribeActivityTypeResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.swf.model.DescribeActivityTypeRequest, software.amazon.awssdk.services.swf.model.DescribeActivityTypeResponse]("describeActivityType", api.describeActivityType)(request.buildAwsValue()).map(DescribeActivityTypeResponse.wrap).provide(r)
    def describeDomain(request: DescribeDomainRequest): IO[AwsError, DescribeDomainResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.swf.model.DescribeDomainRequest, software.amazon.awssdk.services.swf.model.DescribeDomainResponse]("describeDomain", api.describeDomain)(request.buildAwsValue()).map(DescribeDomainResponse.wrap).provide(r)
    def countClosedWorkflowExecutions(request: CountClosedWorkflowExecutionsRequest): IO[AwsError, CountClosedWorkflowExecutionsResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.swf.model.CountClosedWorkflowExecutionsRequest, software.amazon.awssdk.services.swf.model.CountClosedWorkflowExecutionsResponse]("countClosedWorkflowExecutions", api.countClosedWorkflowExecutions)(request.buildAwsValue()).map(CountClosedWorkflowExecutionsResponse.wrap).provide(r)
    def startWorkflowExecution(request: StartWorkflowExecutionRequest): IO[AwsError, StartWorkflowExecutionResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.swf.model.StartWorkflowExecutionRequest, software.amazon.awssdk.services.swf.model.StartWorkflowExecutionResponse]("startWorkflowExecution", api.startWorkflowExecution)(request.buildAwsValue()).map(StartWorkflowExecutionResponse.wrap).provide(r)
    def undeprecateDomain(request: UndeprecateDomainRequest): IO[AwsError, scala.Unit] = asyncRequestResponse[software.amazon.awssdk.services.swf.model.UndeprecateDomainRequest, software.amazon.awssdk.services.swf.model.UndeprecateDomainResponse]("undeprecateDomain", api.undeprecateDomain)(request.buildAwsValue()).unit.provide(r)
    def countPendingDecisionTasks(request: CountPendingDecisionTasksRequest): IO[AwsError, CountPendingDecisionTasksResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.swf.model.CountPendingDecisionTasksRequest, software.amazon.awssdk.services.swf.model.CountPendingDecisionTasksResponse]("countPendingDecisionTasks", api.countPendingDecisionTasks)(request.buildAwsValue()).map(CountPendingDecisionTasksResponse.wrap).provide(r)
    def signalWorkflowExecution(request: SignalWorkflowExecutionRequest): IO[AwsError, scala.Unit] = asyncRequestResponse[software.amazon.awssdk.services.swf.model.SignalWorkflowExecutionRequest, software.amazon.awssdk.services.swf.model.SignalWorkflowExecutionResponse]("signalWorkflowExecution", api.signalWorkflowExecution)(request.buildAwsValue()).unit.provide(r)
    def undeprecateActivityType(request: UndeprecateActivityTypeRequest): IO[AwsError, scala.Unit] = asyncRequestResponse[software.amazon.awssdk.services.swf.model.UndeprecateActivityTypeRequest, software.amazon.awssdk.services.swf.model.UndeprecateActivityTypeResponse]("undeprecateActivityType", api.undeprecateActivityType)(request.buildAwsValue()).unit.provide(r)
    def pollForActivityTask(request: PollForActivityTaskRequest): IO[AwsError, PollForActivityTaskResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.swf.model.PollForActivityTaskRequest, software.amazon.awssdk.services.swf.model.PollForActivityTaskResponse]("pollForActivityTask", api.pollForActivityTask)(request.buildAwsValue()).map(PollForActivityTaskResponse.wrap).provide(r)
    def listDomains(request: ListDomainsRequest): zio.stream.ZStream[Any, AwsError, DomainInfo.ReadOnly] = asyncJavaPaginatedRequest[software.amazon.awssdk.services.swf.model.ListDomainsRequest, software.amazon.awssdk.services.swf.model.DomainInfo, software.amazon.awssdk.services.swf.paginators.ListDomainsPublisher]("listDomains", api.listDomainsPaginator, _.domainInfos())(request.buildAwsValue()).map(item => DomainInfo.wrap(item)).provide(r)
    def listOpenWorkflowExecutions(request: ListOpenWorkflowExecutionsRequest): zio.stream.ZStream[Any, AwsError, WorkflowExecutionInfo.ReadOnly] = asyncJavaPaginatedRequest[software.amazon.awssdk.services.swf.model.ListOpenWorkflowExecutionsRequest, software.amazon.awssdk.services.swf.model.WorkflowExecutionInfo, software.amazon.awssdk.services.swf.paginators.ListOpenWorkflowExecutionsPublisher]("listOpenWorkflowExecutions", api.listOpenWorkflowExecutionsPaginator, _.executionInfos())(request.buildAwsValue()).map(item => WorkflowExecutionInfo.wrap(item)).provide(r)
    def listClosedWorkflowExecutions(request: ListClosedWorkflowExecutionsRequest): zio.stream.ZStream[Any, AwsError, WorkflowExecutionInfo.ReadOnly] = asyncJavaPaginatedRequest[software.amazon.awssdk.services.swf.model.ListClosedWorkflowExecutionsRequest, software.amazon.awssdk.services.swf.model.WorkflowExecutionInfo, software.amazon.awssdk.services.swf.paginators.ListClosedWorkflowExecutionsPublisher]("listClosedWorkflowExecutions", api.listClosedWorkflowExecutionsPaginator, _.executionInfos())(request.buildAwsValue()).map(item => WorkflowExecutionInfo.wrap(item)).provide(r)
    def registerDomain(request: RegisterDomainRequest): IO[AwsError, scala.Unit] = asyncRequestResponse[software.amazon.awssdk.services.swf.model.RegisterDomainRequest, software.amazon.awssdk.services.swf.model.RegisterDomainResponse]("registerDomain", api.registerDomain)(request.buildAwsValue()).unit.provide(r)
    def getWorkflowExecutionHistory(request: GetWorkflowExecutionHistoryRequest): zio.stream.ZStream[Any, AwsError, HistoryEvent.ReadOnly] = asyncJavaPaginatedRequest[software.amazon.awssdk.services.swf.model.GetWorkflowExecutionHistoryRequest, software.amazon.awssdk.services.swf.model.HistoryEvent, software.amazon.awssdk.services.swf.paginators.GetWorkflowExecutionHistoryPublisher]("getWorkflowExecutionHistory", api.getWorkflowExecutionHistoryPaginator, _.events())(request.buildAwsValue()).map(item => HistoryEvent.wrap(item)).provide(r)
    def respondActivityTaskFailed(request: RespondActivityTaskFailedRequest): IO[AwsError, scala.Unit] = asyncRequestResponse[software.amazon.awssdk.services.swf.model.RespondActivityTaskFailedRequest, software.amazon.awssdk.services.swf.model.RespondActivityTaskFailedResponse]("respondActivityTaskFailed", api.respondActivityTaskFailed)(request.buildAwsValue()).unit.provide(r)
    def registerWorkflowType(request: RegisterWorkflowTypeRequest): IO[AwsError, scala.Unit] = asyncRequestResponse[software.amazon.awssdk.services.swf.model.RegisterWorkflowTypeRequest, software.amazon.awssdk.services.swf.model.RegisterWorkflowTypeResponse]("registerWorkflowType", api.registerWorkflowType)(request.buildAwsValue()).unit.provide(r)
    def listActivityTypes(request: ListActivityTypesRequest): zio.stream.ZStream[Any, AwsError, ActivityTypeInfo.ReadOnly] = asyncJavaPaginatedRequest[software.amazon.awssdk.services.swf.model.ListActivityTypesRequest, software.amazon.awssdk.services.swf.model.ActivityTypeInfo, software.amazon.awssdk.services.swf.paginators.ListActivityTypesPublisher]("listActivityTypes", api.listActivityTypesPaginator, _.typeInfos())(request.buildAwsValue()).map(item => ActivityTypeInfo.wrap(item)).provide(r)
    def untagResource(request: UntagResourceRequest): IO[AwsError, scala.Unit] = asyncRequestResponse[software.amazon.awssdk.services.swf.model.UntagResourceRequest, software.amazon.awssdk.services.swf.model.UntagResourceResponse]("untagResource", api.untagResource)(request.buildAwsValue()).unit.provide(r)
    def respondActivityTaskCompleted(request: RespondActivityTaskCompletedRequest): IO[AwsError, scala.Unit] = asyncRequestResponse[software.amazon.awssdk.services.swf.model.RespondActivityTaskCompletedRequest, software.amazon.awssdk.services.swf.model.RespondActivityTaskCompletedResponse]("respondActivityTaskCompleted", api.respondActivityTaskCompleted)(request.buildAwsValue()).unit.provide(r)
    def countOpenWorkflowExecutions(request: CountOpenWorkflowExecutionsRequest): IO[AwsError, CountOpenWorkflowExecutionsResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.swf.model.CountOpenWorkflowExecutionsRequest, software.amazon.awssdk.services.swf.model.CountOpenWorkflowExecutionsResponse]("countOpenWorkflowExecutions", api.countOpenWorkflowExecutions)(request.buildAwsValue()).map(CountOpenWorkflowExecutionsResponse.wrap).provide(r)
    def terminateWorkflowExecution(request: TerminateWorkflowExecutionRequest): IO[AwsError, scala.Unit] = asyncRequestResponse[software.amazon.awssdk.services.swf.model.TerminateWorkflowExecutionRequest, software.amazon.awssdk.services.swf.model.TerminateWorkflowExecutionResponse]("terminateWorkflowExecution", api.terminateWorkflowExecution)(request.buildAwsValue()).unit.provide(r)
    def countPendingActivityTasks(request: CountPendingActivityTasksRequest): IO[AwsError, CountPendingActivityTasksResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.swf.model.CountPendingActivityTasksRequest, software.amazon.awssdk.services.swf.model.CountPendingActivityTasksResponse]("countPendingActivityTasks", api.countPendingActivityTasks)(request.buildAwsValue()).map(CountPendingActivityTasksResponse.wrap).provide(r)
    def respondDecisionTaskCompleted(request: RespondDecisionTaskCompletedRequest): IO[AwsError, scala.Unit] = asyncRequestResponse[software.amazon.awssdk.services.swf.model.RespondDecisionTaskCompletedRequest, software.amazon.awssdk.services.swf.model.RespondDecisionTaskCompletedResponse]("respondDecisionTaskCompleted", api.respondDecisionTaskCompleted)(request.buildAwsValue()).unit.provide(r)
    def listTagsForResource(request: ListTagsForResourceRequest): IO[AwsError, ListTagsForResourceResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.swf.model.ListTagsForResourceRequest, software.amazon.awssdk.services.swf.model.ListTagsForResourceResponse]("listTagsForResource", api.listTagsForResource)(request.buildAwsValue()).map(ListTagsForResourceResponse.wrap).provide(r)
    def tagResource(request: TagResourceRequest): IO[AwsError, scala.Unit] = asyncRequestResponse[software.amazon.awssdk.services.swf.model.TagResourceRequest, software.amazon.awssdk.services.swf.model.TagResourceResponse]("tagResource", api.tagResource)(request.buildAwsValue()).unit.provide(r)
    def deprecateWorkflowType(request: DeprecateWorkflowTypeRequest): IO[AwsError, scala.Unit] = asyncRequestResponse[software.amazon.awssdk.services.swf.model.DeprecateWorkflowTypeRequest, software.amazon.awssdk.services.swf.model.DeprecateWorkflowTypeResponse]("deprecateWorkflowType", api.deprecateWorkflowType)(request.buildAwsValue()).unit.provide(r)
    def pollForDecisionTask(request: PollForDecisionTaskRequest): zio.stream.ZStream[Any, AwsError, HistoryEvent.ReadOnly] = asyncJavaPaginatedRequest[software.amazon.awssdk.services.swf.model.PollForDecisionTaskRequest, software.amazon.awssdk.services.swf.model.HistoryEvent, software.amazon.awssdk.services.swf.paginators.PollForDecisionTaskPublisher]("pollForDecisionTask", api.pollForDecisionTaskPaginator, _.events())(request.buildAwsValue()).map(item => HistoryEvent.wrap(item)).provide(r)
    def deprecateDomain(request: DeprecateDomainRequest): IO[AwsError, scala.Unit] = asyncRequestResponse[software.amazon.awssdk.services.swf.model.DeprecateDomainRequest, software.amazon.awssdk.services.swf.model.DeprecateDomainResponse]("deprecateDomain", api.deprecateDomain)(request.buildAwsValue()).unit.provide(r)
    def respondActivityTaskCanceled(request: RespondActivityTaskCanceledRequest): IO[AwsError, scala.Unit] = asyncRequestResponse[software.amazon.awssdk.services.swf.model.RespondActivityTaskCanceledRequest, software.amazon.awssdk.services.swf.model.RespondActivityTaskCanceledResponse]("respondActivityTaskCanceled", api.respondActivityTaskCanceled)(request.buildAwsValue()).unit.provide(r)
    def requestCancelWorkflowExecution(request: RequestCancelWorkflowExecutionRequest): IO[AwsError, scala.Unit] = asyncRequestResponse[software.amazon.awssdk.services.swf.model.RequestCancelWorkflowExecutionRequest, software.amazon.awssdk.services.swf.model.RequestCancelWorkflowExecutionResponse]("requestCancelWorkflowExecution", api.requestCancelWorkflowExecution)(request.buildAwsValue()).unit.provide(r)
    def describeWorkflowType(request: DescribeWorkflowTypeRequest): IO[AwsError, DescribeWorkflowTypeResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.swf.model.DescribeWorkflowTypeRequest, software.amazon.awssdk.services.swf.model.DescribeWorkflowTypeResponse]("describeWorkflowType", api.describeWorkflowType)(request.buildAwsValue()).map(DescribeWorkflowTypeResponse.wrap).provide(r)
    def undeprecateWorkflowType(request: UndeprecateWorkflowTypeRequest): IO[AwsError, scala.Unit] = asyncRequestResponse[software.amazon.awssdk.services.swf.model.UndeprecateWorkflowTypeRequest, software.amazon.awssdk.services.swf.model.UndeprecateWorkflowTypeResponse]("undeprecateWorkflowType", api.undeprecateWorkflowType)(request.buildAwsValue()).unit.provide(r)
    def recordActivityTaskHeartbeat(request: RecordActivityTaskHeartbeatRequest): IO[AwsError, RecordActivityTaskHeartbeatResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.swf.model.RecordActivityTaskHeartbeatRequest, software.amazon.awssdk.services.swf.model.RecordActivityTaskHeartbeatResponse]("recordActivityTaskHeartbeat", api.recordActivityTaskHeartbeat)(request.buildAwsValue()).map(RecordActivityTaskHeartbeatResponse.wrap).provide(r)
    def listWorkflowTypes(request: ListWorkflowTypesRequest): zio.stream.ZStream[Any, AwsError, WorkflowTypeInfo.ReadOnly] = asyncJavaPaginatedRequest[software.amazon.awssdk.services.swf.model.ListWorkflowTypesRequest, software.amazon.awssdk.services.swf.model.WorkflowTypeInfo, software.amazon.awssdk.services.swf.paginators.ListWorkflowTypesPublisher]("listWorkflowTypes", api.listWorkflowTypesPaginator, _.typeInfos())(request.buildAwsValue()).map(item => WorkflowTypeInfo.wrap(item)).provide(r)
    def describeWorkflowExecution(request: DescribeWorkflowExecutionRequest): IO[AwsError, DescribeWorkflowExecutionResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.swf.model.DescribeWorkflowExecutionRequest, software.amazon.awssdk.services.swf.model.DescribeWorkflowExecutionResponse]("describeWorkflowExecution", api.describeWorkflowExecution)(request.buildAwsValue()).map(DescribeWorkflowExecutionResponse.wrap).provide(r)
    def deprecateActivityType(request: DeprecateActivityTypeRequest): IO[AwsError, scala.Unit] = asyncRequestResponse[software.amazon.awssdk.services.swf.model.DeprecateActivityTypeRequest, software.amazon.awssdk.services.swf.model.DeprecateActivityTypeResponse]("deprecateActivityType", api.deprecateActivityType)(request.buildAwsValue()).unit.provide(r)
  }
  def registerActivityType(request: RegisterActivityTypeRequest): ZIO[Swf, AwsError, scala.Unit] = ZIO.accessM(_.get.registerActivityType(request))
  def describeActivityType(request: DescribeActivityTypeRequest): ZIO[Swf, AwsError, DescribeActivityTypeResponse.ReadOnly] = ZIO.accessM(_.get.describeActivityType(request))
  def describeDomain(request: DescribeDomainRequest): ZIO[Swf, AwsError, DescribeDomainResponse.ReadOnly] = ZIO.accessM(_.get.describeDomain(request))
  def countClosedWorkflowExecutions(request: CountClosedWorkflowExecutionsRequest): ZIO[Swf, AwsError, CountClosedWorkflowExecutionsResponse.ReadOnly] = ZIO.accessM(_.get.countClosedWorkflowExecutions(request))
  def startWorkflowExecution(request: StartWorkflowExecutionRequest): ZIO[Swf, AwsError, StartWorkflowExecutionResponse.ReadOnly] = ZIO.accessM(_.get.startWorkflowExecution(request))
  def undeprecateDomain(request: UndeprecateDomainRequest): ZIO[Swf, AwsError, scala.Unit] = ZIO.accessM(_.get.undeprecateDomain(request))
  def countPendingDecisionTasks(request: CountPendingDecisionTasksRequest): ZIO[Swf, AwsError, CountPendingDecisionTasksResponse.ReadOnly] = ZIO.accessM(_.get.countPendingDecisionTasks(request))
  def signalWorkflowExecution(request: SignalWorkflowExecutionRequest): ZIO[Swf, AwsError, scala.Unit] = ZIO.accessM(_.get.signalWorkflowExecution(request))
  def undeprecateActivityType(request: UndeprecateActivityTypeRequest): ZIO[Swf, AwsError, scala.Unit] = ZIO.accessM(_.get.undeprecateActivityType(request))
  def pollForActivityTask(request: PollForActivityTaskRequest): ZIO[Swf, AwsError, PollForActivityTaskResponse.ReadOnly] = ZIO.accessM(_.get.pollForActivityTask(request))
  def listDomains(request: ListDomainsRequest): zio.stream.ZStream[Swf, AwsError, DomainInfo.ReadOnly] = ZStream.accessStream(_.get.listDomains(request))
  def listOpenWorkflowExecutions(request: ListOpenWorkflowExecutionsRequest): zio.stream.ZStream[Swf, AwsError, WorkflowExecutionInfo.ReadOnly] = ZStream.accessStream(_.get.listOpenWorkflowExecutions(request))
  def listClosedWorkflowExecutions(request: ListClosedWorkflowExecutionsRequest): zio.stream.ZStream[Swf, AwsError, WorkflowExecutionInfo.ReadOnly] = ZStream.accessStream(_.get.listClosedWorkflowExecutions(request))
  def registerDomain(request: RegisterDomainRequest): ZIO[Swf, AwsError, scala.Unit] = ZIO.accessM(_.get.registerDomain(request))
  def getWorkflowExecutionHistory(request: GetWorkflowExecutionHistoryRequest): zio.stream.ZStream[Swf, AwsError, HistoryEvent.ReadOnly] = ZStream.accessStream(_.get.getWorkflowExecutionHistory(request))
  def respondActivityTaskFailed(request: RespondActivityTaskFailedRequest): ZIO[Swf, AwsError, scala.Unit] = ZIO.accessM(_.get.respondActivityTaskFailed(request))
  def registerWorkflowType(request: RegisterWorkflowTypeRequest): ZIO[Swf, AwsError, scala.Unit] = ZIO.accessM(_.get.registerWorkflowType(request))
  def listActivityTypes(request: ListActivityTypesRequest): zio.stream.ZStream[Swf, AwsError, ActivityTypeInfo.ReadOnly] = ZStream.accessStream(_.get.listActivityTypes(request))
  def untagResource(request: UntagResourceRequest): ZIO[Swf, AwsError, scala.Unit] = ZIO.accessM(_.get.untagResource(request))
  def respondActivityTaskCompleted(request: RespondActivityTaskCompletedRequest): ZIO[Swf, AwsError, scala.Unit] = ZIO.accessM(_.get.respondActivityTaskCompleted(request))
  def countOpenWorkflowExecutions(request: CountOpenWorkflowExecutionsRequest): ZIO[Swf, AwsError, CountOpenWorkflowExecutionsResponse.ReadOnly] = ZIO.accessM(_.get.countOpenWorkflowExecutions(request))
  def terminateWorkflowExecution(request: TerminateWorkflowExecutionRequest): ZIO[Swf, AwsError, scala.Unit] = ZIO.accessM(_.get.terminateWorkflowExecution(request))
  def countPendingActivityTasks(request: CountPendingActivityTasksRequest): ZIO[Swf, AwsError, CountPendingActivityTasksResponse.ReadOnly] = ZIO.accessM(_.get.countPendingActivityTasks(request))
  def respondDecisionTaskCompleted(request: RespondDecisionTaskCompletedRequest): ZIO[Swf, AwsError, scala.Unit] = ZIO.accessM(_.get.respondDecisionTaskCompleted(request))
  def listTagsForResource(request: ListTagsForResourceRequest): ZIO[Swf, AwsError, ListTagsForResourceResponse.ReadOnly] = ZIO.accessM(_.get.listTagsForResource(request))
  def tagResource(request: TagResourceRequest): ZIO[Swf, AwsError, scala.Unit] = ZIO.accessM(_.get.tagResource(request))
  def deprecateWorkflowType(request: DeprecateWorkflowTypeRequest): ZIO[Swf, AwsError, scala.Unit] = ZIO.accessM(_.get.deprecateWorkflowType(request))
  def pollForDecisionTask(request: PollForDecisionTaskRequest): zio.stream.ZStream[Swf, AwsError, HistoryEvent.ReadOnly] = ZStream.accessStream(_.get.pollForDecisionTask(request))
  def deprecateDomain(request: DeprecateDomainRequest): ZIO[Swf, AwsError, scala.Unit] = ZIO.accessM(_.get.deprecateDomain(request))
  def respondActivityTaskCanceled(request: RespondActivityTaskCanceledRequest): ZIO[Swf, AwsError, scala.Unit] = ZIO.accessM(_.get.respondActivityTaskCanceled(request))
  def requestCancelWorkflowExecution(request: RequestCancelWorkflowExecutionRequest): ZIO[Swf, AwsError, scala.Unit] = ZIO.accessM(_.get.requestCancelWorkflowExecution(request))
  def describeWorkflowType(request: DescribeWorkflowTypeRequest): ZIO[Swf, AwsError, DescribeWorkflowTypeResponse.ReadOnly] = ZIO.accessM(_.get.describeWorkflowType(request))
  def undeprecateWorkflowType(request: UndeprecateWorkflowTypeRequest): ZIO[Swf, AwsError, scala.Unit] = ZIO.accessM(_.get.undeprecateWorkflowType(request))
  def recordActivityTaskHeartbeat(request: RecordActivityTaskHeartbeatRequest): ZIO[Swf, AwsError, RecordActivityTaskHeartbeatResponse.ReadOnly] = ZIO.accessM(_.get.recordActivityTaskHeartbeat(request))
  def listWorkflowTypes(request: ListWorkflowTypesRequest): zio.stream.ZStream[Swf, AwsError, WorkflowTypeInfo.ReadOnly] = ZStream.accessStream(_.get.listWorkflowTypes(request))
  def describeWorkflowExecution(request: DescribeWorkflowExecutionRequest): ZIO[Swf, AwsError, DescribeWorkflowExecutionResponse.ReadOnly] = ZIO.accessM(_.get.describeWorkflowExecution(request))
  def deprecateActivityType(request: DeprecateActivityTypeRequest): ZIO[Swf, AwsError, scala.Unit] = ZIO.accessM(_.get.deprecateActivityType(request))
}