• Home
• io.github.vigoo
• zio-aws-codepipeline_2.13
• 3.17.58.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.codepipeline.package.scala Maven / Gradle / Ivy

package io.github.vigoo.zioaws
import io.github.vigoo.zioaws.codepipeline.model.GetThirdPartyJobDetailsResponse.ReadOnly
import io.github.vigoo.zioaws.codepipeline.CodePipeline
import io.github.vigoo.zioaws.core.{AwsServiceBase, AwsError}
import io.github.vigoo.zioaws.core.config.AwsConfig
import zio.{ZManaged, IO, ZIO, ZLayer, URLayer, Has}
import software.amazon.awssdk.services.codepipeline.paginators.{
  ListPipelineExecutionsPublisher,
  ListPipelinesPublisher,
  ListActionTypesPublisher,
  ListTagsForResourcePublisher,
  ListActionExecutionsPublisher
}
import io.github.vigoo.zioaws.core.aspects.{AwsCallAspect, AspectSupport}
import software.amazon.awssdk.services.codepipeline.model.{
  AcknowledgeJobResponse,
  AcknowledgeThirdPartyJobResponse,
  PollForJobsRequest,
  PollForThirdPartyJobsRequest,
  PutActionRevisionResponse,
  StopPipelineExecutionResponse,
  GetPipelineExecutionResponse,
  PutJobFailureResultRequest,
  ActionType,
  DeleteCustomActionTypeRequest,
  RetryStageExecutionResponse,
  ListWebhookItem,
  GetPipelineExecutionRequest,
  PutJobFailureResultResponse,
  GetJobDetailsResponse,
  PutJobSuccessResultRequest,
  ListPipelineExecutionsRequest,
  EnableStageTransitionRequest,
  PipelineSummary,
  DisableStageTransitionRequest,
  StopPipelineExecutionRequest,
  ListActionExecutionsRequest,
  RetryStageExecutionRequest,
  UpdateActionTypeRequest,
  PollForThirdPartyJobsResponse,
  GetActionTypeResponse,
  ListTagsForResourceRequest,
  Tag,
  GetJobDetailsRequest,
  ListActionTypesRequest,
  DeleteCustomActionTypeResponse,
  PutThirdPartyJobFailureResultResponse,
  PutThirdPartyJobSuccessResultResponse,
  PutWebhookResponse,
  ListPipelinesRequest,
  EnableStageTransitionResponse,
  ListWebhooksResponse,
  UntagResourceResponse,
  ActionExecutionDetail,
  GetPipelineStateRequest,
  UpdatePipelineResponse,
  UpdateActionTypeResponse,
  PutJobSuccessResultResponse,
  GetThirdPartyJobDetailsResponse,
  DeregisterWebhookWithThirdPartyRequest,
  GetThirdPartyJobDetailsRequest,
  PutWebhookRequest,
  PutActionRevisionRequest,
  CreatePipelineResponse,
  PutApprovalResultResponse,
  DeletePipelineRequest,
  AcknowledgeJobRequest,
  DisableStageTransitionResponse,
  RegisterWebhookWithThirdPartyRequest,
  GetActionTypeRequest,
  DeleteWebhookRequest,
  CreateCustomActionTypeRequest,
  UntagResourceRequest,
  RegisterWebhookWithThirdPartyResponse,
  ListWebhooksRequest,
  PollForJobsResponse,
  GetPipelineRequest,
  DeregisterWebhookWithThirdPartyResponse,
  CreatePipelineRequest,
  PutThirdPartyJobSuccessResultRequest,
  UpdatePipelineRequest,
  StartPipelineExecutionResponse,
  TagResourceResponse,
  PutApprovalResultRequest,
  DeletePipelineResponse,
  PipelineExecutionSummary,
  CreateCustomActionTypeResponse,
  GetPipelineResponse,
  GetPipelineStateResponse,
  TagResourceRequest,
  DeleteWebhookResponse,
  StartPipelineExecutionRequest,
  AcknowledgeThirdPartyJobRequest,
  PutThirdPartyJobFailureResultRequest
}
import software.amazon.awssdk.services.codepipeline.{
  CodePipelineAsyncClientBuilder,
  CodePipelineAsyncClient
}
import zio.stream.ZStream
import zio.test.mock.{Proxy, Mock}
package object codepipeline {
  import scala.jdk.CollectionConverters._
  type CodePipeline = Has[CodePipeline.Service]
  object CodePipeline {
    trait Service extends AspectSupport[Service] {
      val api: CodePipelineAsyncClient
      def retryStageExecution(
          request: io.github.vigoo.zioaws.codepipeline.model.RetryStageExecutionRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.codepipeline.model.RetryStageExecutionResponse.ReadOnly
      ]
      def getPipeline(
          request: io.github.vigoo.zioaws.codepipeline.model.GetPipelineRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.codepipeline.model.GetPipelineResponse.ReadOnly
      ]
      def listPipelineExecutions(
          request: io.github.vigoo.zioaws.codepipeline.model.ListPipelineExecutionsRequest
      ): ZStream[
        Any,
        AwsError,
        io.github.vigoo.zioaws.codepipeline.model.PipelineExecutionSummary.ReadOnly
      ]
      def listWebhooks(
          request: io.github.vigoo.zioaws.codepipeline.model.ListWebhooksRequest
      ): ZStream[
        Any,
        AwsError,
        io.github.vigoo.zioaws.codepipeline.model.ListWebhookItem.ReadOnly
      ]
      def listActionExecutions(
          request: io.github.vigoo.zioaws.codepipeline.model.ListActionExecutionsRequest
      ): ZStream[
        Any,
        AwsError,
        io.github.vigoo.zioaws.codepipeline.model.ActionExecutionDetail.ReadOnly
      ]
      def updatePipeline(
          request: io.github.vigoo.zioaws.codepipeline.model.UpdatePipelineRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.codepipeline.model.UpdatePipelineResponse.ReadOnly
      ]
      def startPipelineExecution(
          request: io.github.vigoo.zioaws.codepipeline.model.StartPipelineExecutionRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.codepipeline.model.StartPipelineExecutionResponse.ReadOnly
      ]
      def putJobSuccessResult(
          request: io.github.vigoo.zioaws.codepipeline.model.PutJobSuccessResultRequest
      ): IO[AwsError, Unit]
      def deleteWebhook(
          request: io.github.vigoo.zioaws.codepipeline.model.DeleteWebhookRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.codepipeline.model.DeleteWebhookResponse.ReadOnly
      ]
      def listActionTypes(
          request: io.github.vigoo.zioaws.codepipeline.model.ListActionTypesRequest
      ): ZStream[
        Any,
        AwsError,
        io.github.vigoo.zioaws.codepipeline.model.ActionType.ReadOnly
      ]
      def acknowledgeThirdPartyJob(
          request: io.github.vigoo.zioaws.codepipeline.model.AcknowledgeThirdPartyJobRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.codepipeline.model.AcknowledgeThirdPartyJobResponse.ReadOnly
      ]
      def putJobFailureResult(
          request: io.github.vigoo.zioaws.codepipeline.model.PutJobFailureResultRequest
      ): IO[AwsError, Unit]
      def listPipelines(
          request: io.github.vigoo.zioaws.codepipeline.model.ListPipelinesRequest
      ): ZStream[
        Any,
        AwsError,
        io.github.vigoo.zioaws.codepipeline.model.PipelineSummary.ReadOnly
      ]
      def acknowledgeJob(
          request: io.github.vigoo.zioaws.codepipeline.model.AcknowledgeJobRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.codepipeline.model.AcknowledgeJobResponse.ReadOnly
      ]
      def updateActionType(
          request: io.github.vigoo.zioaws.codepipeline.model.UpdateActionTypeRequest
      ): IO[AwsError, Unit]
      def putApprovalResult(
          request: io.github.vigoo.zioaws.codepipeline.model.PutApprovalResultRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.codepipeline.model.PutApprovalResultResponse.ReadOnly
      ]
      def getPipelineState(
          request: io.github.vigoo.zioaws.codepipeline.model.GetPipelineStateRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.codepipeline.model.GetPipelineStateResponse.ReadOnly
      ]
      def pollForJobs(
          request: io.github.vigoo.zioaws.codepipeline.model.PollForJobsRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.codepipeline.model.PollForJobsResponse.ReadOnly
      ]
      def untagResource(
          request: io.github.vigoo.zioaws.codepipeline.model.UntagResourceRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.codepipeline.model.UntagResourceResponse.ReadOnly
      ]
      def createCustomActionType(
          request: io.github.vigoo.zioaws.codepipeline.model.CreateCustomActionTypeRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.codepipeline.model.CreateCustomActionTypeResponse.ReadOnly
      ]
      def pollForThirdPartyJobs(
          request: io.github.vigoo.zioaws.codepipeline.model.PollForThirdPartyJobsRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.codepipeline.model.PollForThirdPartyJobsResponse.ReadOnly
      ]
      def putThirdPartyJobFailureResult(
          request: io.github.vigoo.zioaws.codepipeline.model.PutThirdPartyJobFailureResultRequest
      ): IO[AwsError, Unit]
      def putWebhook(
          request: io.github.vigoo.zioaws.codepipeline.model.PutWebhookRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.codepipeline.model.PutWebhookResponse.ReadOnly
      ]
      def deletePipeline(
          request: io.github.vigoo.zioaws.codepipeline.model.DeletePipelineRequest
      ): IO[AwsError, Unit]
      def listTagsForResource(
          request: io.github.vigoo.zioaws.codepipeline.model.ListTagsForResourceRequest
      ): ZStream[
        Any,
        AwsError,
        io.github.vigoo.zioaws.codepipeline.model.Tag.ReadOnly
      ]
      def tagResource(
          request: io.github.vigoo.zioaws.codepipeline.model.TagResourceRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.codepipeline.model.TagResourceResponse.ReadOnly
      ]
      def disableStageTransition(
          request: io.github.vigoo.zioaws.codepipeline.model.DisableStageTransitionRequest
      ): IO[AwsError, Unit]
      def deleteCustomActionType(
          request: io.github.vigoo.zioaws.codepipeline.model.DeleteCustomActionTypeRequest
      ): IO[AwsError, Unit]
      def putThirdPartyJobSuccessResult(
          request: io.github.vigoo.zioaws.codepipeline.model.PutThirdPartyJobSuccessResultRequest
      ): IO[AwsError, Unit]
      def getActionType(
          request: io.github.vigoo.zioaws.codepipeline.model.GetActionTypeRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.codepipeline.model.GetActionTypeResponse.ReadOnly
      ]
      def stopPipelineExecution(
          request: io.github.vigoo.zioaws.codepipeline.model.StopPipelineExecutionRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.codepipeline.model.StopPipelineExecutionResponse.ReadOnly
      ]
      def deregisterWebhookWithThirdParty(
          request: io.github.vigoo.zioaws.codepipeline.model.DeregisterWebhookWithThirdPartyRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.codepipeline.model.DeregisterWebhookWithThirdPartyResponse.ReadOnly
      ]
      def registerWebhookWithThirdParty(
          request: io.github.vigoo.zioaws.codepipeline.model.RegisterWebhookWithThirdPartyRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.codepipeline.model.RegisterWebhookWithThirdPartyResponse.ReadOnly
      ]
      def createPipeline(
          request: io.github.vigoo.zioaws.codepipeline.model.CreatePipelineRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.codepipeline.model.CreatePipelineResponse.ReadOnly
      ]
      def enableStageTransition(
          request: io.github.vigoo.zioaws.codepipeline.model.EnableStageTransitionRequest
      ): IO[AwsError, Unit]
      def getJobDetails(
          request: io.github.vigoo.zioaws.codepipeline.model.GetJobDetailsRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.codepipeline.model.GetJobDetailsResponse.ReadOnly
      ]
      def getThirdPartyJobDetails(
          request: io.github.vigoo.zioaws.codepipeline.model.GetThirdPartyJobDetailsRequest
      ): IO[AwsError, ReadOnly]
      def putActionRevision(
          request: io.github.vigoo.zioaws.codepipeline.model.PutActionRevisionRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.codepipeline.model.PutActionRevisionResponse.ReadOnly
      ]
      def getPipelineExecution(
          request: io.github.vigoo.zioaws.codepipeline.model.GetPipelineExecutionRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.codepipeline.model.GetPipelineExecutionResponse.ReadOnly
      ]
    }
    object CodePipelineMock extends Mock[CodePipeline] {
      object RetryStageExecution
          extends Effect[
            io.github.vigoo.zioaws.codepipeline.model.RetryStageExecutionRequest,
            AwsError,
            io.github.vigoo.zioaws.codepipeline.model.RetryStageExecutionResponse.ReadOnly
          ]
      object GetPipeline
          extends Effect[
            io.github.vigoo.zioaws.codepipeline.model.GetPipelineRequest,
            AwsError,
            io.github.vigoo.zioaws.codepipeline.model.GetPipelineResponse.ReadOnly
          ]
      object ListPipelineExecutions
          extends Stream[
            io.github.vigoo.zioaws.codepipeline.model.ListPipelineExecutionsRequest,
            AwsError,
            io.github.vigoo.zioaws.codepipeline.model.PipelineExecutionSummary.ReadOnly
          ]
      object ListWebhooks
          extends Stream[
            io.github.vigoo.zioaws.codepipeline.model.ListWebhooksRequest,
            AwsError,
            io.github.vigoo.zioaws.codepipeline.model.ListWebhookItem.ReadOnly
          ]
      object ListActionExecutions
          extends Stream[
            io.github.vigoo.zioaws.codepipeline.model.ListActionExecutionsRequest,
            AwsError,
            io.github.vigoo.zioaws.codepipeline.model.ActionExecutionDetail.ReadOnly
          ]
      object UpdatePipeline
          extends Effect[
            io.github.vigoo.zioaws.codepipeline.model.UpdatePipelineRequest,
            AwsError,
            io.github.vigoo.zioaws.codepipeline.model.UpdatePipelineResponse.ReadOnly
          ]
      object StartPipelineExecution
          extends Effect[
            io.github.vigoo.zioaws.codepipeline.model.StartPipelineExecutionRequest,
            AwsError,
            io.github.vigoo.zioaws.codepipeline.model.StartPipelineExecutionResponse.ReadOnly
          ]
      object PutJobSuccessResult
          extends Effect[
            io.github.vigoo.zioaws.codepipeline.model.PutJobSuccessResultRequest,
            AwsError,
            Unit
          ]
      object DeleteWebhook
          extends Effect[
            io.github.vigoo.zioaws.codepipeline.model.DeleteWebhookRequest,
            AwsError,
            io.github.vigoo.zioaws.codepipeline.model.DeleteWebhookResponse.ReadOnly
          ]
      object ListActionTypes
          extends Stream[
            io.github.vigoo.zioaws.codepipeline.model.ListActionTypesRequest,
            AwsError,
            io.github.vigoo.zioaws.codepipeline.model.ActionType.ReadOnly
          ]
      object AcknowledgeThirdPartyJob
          extends Effect[
            io.github.vigoo.zioaws.codepipeline.model.AcknowledgeThirdPartyJobRequest,
            AwsError,
            io.github.vigoo.zioaws.codepipeline.model.AcknowledgeThirdPartyJobResponse.ReadOnly
          ]
      object PutJobFailureResult
          extends Effect[
            io.github.vigoo.zioaws.codepipeline.model.PutJobFailureResultRequest,
            AwsError,
            Unit
          ]
      object ListPipelines
          extends Stream[
            io.github.vigoo.zioaws.codepipeline.model.ListPipelinesRequest,
            AwsError,
            io.github.vigoo.zioaws.codepipeline.model.PipelineSummary.ReadOnly
          ]
      object AcknowledgeJob
          extends Effect[
            io.github.vigoo.zioaws.codepipeline.model.AcknowledgeJobRequest,
            AwsError,
            io.github.vigoo.zioaws.codepipeline.model.AcknowledgeJobResponse.ReadOnly
          ]
      object UpdateActionType
          extends Effect[
            io.github.vigoo.zioaws.codepipeline.model.UpdateActionTypeRequest,
            AwsError,
            Unit
          ]
      object PutApprovalResult
          extends Effect[
            io.github.vigoo.zioaws.codepipeline.model.PutApprovalResultRequest,
            AwsError,
            io.github.vigoo.zioaws.codepipeline.model.PutApprovalResultResponse.ReadOnly
          ]
      object GetPipelineState
          extends Effect[
            io.github.vigoo.zioaws.codepipeline.model.GetPipelineStateRequest,
            AwsError,
            io.github.vigoo.zioaws.codepipeline.model.GetPipelineStateResponse.ReadOnly
          ]
      object PollForJobs
          extends Effect[
            io.github.vigoo.zioaws.codepipeline.model.PollForJobsRequest,
            AwsError,
            io.github.vigoo.zioaws.codepipeline.model.PollForJobsResponse.ReadOnly
          ]
      object UntagResource
          extends Effect[
            io.github.vigoo.zioaws.codepipeline.model.UntagResourceRequest,
            AwsError,
            io.github.vigoo.zioaws.codepipeline.model.UntagResourceResponse.ReadOnly
          ]
      object CreateCustomActionType
          extends Effect[
            io.github.vigoo.zioaws.codepipeline.model.CreateCustomActionTypeRequest,
            AwsError,
            io.github.vigoo.zioaws.codepipeline.model.CreateCustomActionTypeResponse.ReadOnly
          ]
      object PollForThirdPartyJobs
          extends Effect[
            io.github.vigoo.zioaws.codepipeline.model.PollForThirdPartyJobsRequest,
            AwsError,
            io.github.vigoo.zioaws.codepipeline.model.PollForThirdPartyJobsResponse.ReadOnly
          ]
      object PutThirdPartyJobFailureResult
          extends Effect[
            io.github.vigoo.zioaws.codepipeline.model.PutThirdPartyJobFailureResultRequest,
            AwsError,
            Unit
          ]
      object PutWebhook
          extends Effect[
            io.github.vigoo.zioaws.codepipeline.model.PutWebhookRequest,
            AwsError,
            io.github.vigoo.zioaws.codepipeline.model.PutWebhookResponse.ReadOnly
          ]
      object DeletePipeline
          extends Effect[
            io.github.vigoo.zioaws.codepipeline.model.DeletePipelineRequest,
            AwsError,
            Unit
          ]
      object ListTagsForResource
          extends Stream[
            io.github.vigoo.zioaws.codepipeline.model.ListTagsForResourceRequest,
            AwsError,
            io.github.vigoo.zioaws.codepipeline.model.Tag.ReadOnly
          ]
      object TagResource
          extends Effect[
            io.github.vigoo.zioaws.codepipeline.model.TagResourceRequest,
            AwsError,
            io.github.vigoo.zioaws.codepipeline.model.TagResourceResponse.ReadOnly
          ]
      object DisableStageTransition
          extends Effect[
            io.github.vigoo.zioaws.codepipeline.model.DisableStageTransitionRequest,
            AwsError,
            Unit
          ]
      object DeleteCustomActionType
          extends Effect[
            io.github.vigoo.zioaws.codepipeline.model.DeleteCustomActionTypeRequest,
            AwsError,
            Unit
          ]
      object PutThirdPartyJobSuccessResult
          extends Effect[
            io.github.vigoo.zioaws.codepipeline.model.PutThirdPartyJobSuccessResultRequest,
            AwsError,
            Unit
          ]
      object GetActionType
          extends Effect[
            io.github.vigoo.zioaws.codepipeline.model.GetActionTypeRequest,
            AwsError,
            io.github.vigoo.zioaws.codepipeline.model.GetActionTypeResponse.ReadOnly
          ]
      object StopPipelineExecution
          extends Effect[
            io.github.vigoo.zioaws.codepipeline.model.StopPipelineExecutionRequest,
            AwsError,
            io.github.vigoo.zioaws.codepipeline.model.StopPipelineExecutionResponse.ReadOnly
          ]
      object DeregisterWebhookWithThirdParty
          extends Effect[
            io.github.vigoo.zioaws.codepipeline.model.DeregisterWebhookWithThirdPartyRequest,
            AwsError,
            io.github.vigoo.zioaws.codepipeline.model.DeregisterWebhookWithThirdPartyResponse.ReadOnly
          ]
      object RegisterWebhookWithThirdParty
          extends Effect[
            io.github.vigoo.zioaws.codepipeline.model.RegisterWebhookWithThirdPartyRequest,
            AwsError,
            io.github.vigoo.zioaws.codepipeline.model.RegisterWebhookWithThirdPartyResponse.ReadOnly
          ]
      object CreatePipeline
          extends Effect[
            io.github.vigoo.zioaws.codepipeline.model.CreatePipelineRequest,
            AwsError,
            io.github.vigoo.zioaws.codepipeline.model.CreatePipelineResponse.ReadOnly
          ]
      object EnableStageTransition
          extends Effect[
            io.github.vigoo.zioaws.codepipeline.model.EnableStageTransitionRequest,
            AwsError,
            Unit
          ]
      object GetJobDetails
          extends Effect[
            io.github.vigoo.zioaws.codepipeline.model.GetJobDetailsRequest,
            AwsError,
            io.github.vigoo.zioaws.codepipeline.model.GetJobDetailsResponse.ReadOnly
          ]
      object GetThirdPartyJobDetails
          extends Effect[
            io.github.vigoo.zioaws.codepipeline.model.GetThirdPartyJobDetailsRequest,
            AwsError,
            ReadOnly
          ]
      object PutActionRevision
          extends Effect[
            io.github.vigoo.zioaws.codepipeline.model.PutActionRevisionRequest,
            AwsError,
            io.github.vigoo.zioaws.codepipeline.model.PutActionRevisionResponse.ReadOnly
          ]
      object GetPipelineExecution
          extends Effect[
            io.github.vigoo.zioaws.codepipeline.model.GetPipelineExecutionRequest,
            AwsError,
            io.github.vigoo.zioaws.codepipeline.model.GetPipelineExecutionResponse.ReadOnly
          ]
      val compose: URLayer[Has[Proxy], CodePipeline] = ZLayer.fromServiceM {
        proxy =>
          withRuntime.map { rts =>
            new CodePipeline.Service {
              val api: CodePipelineAsyncClient = null
              def withAspect[R1](
                  newAspect: AwsCallAspect[R1],
                  r: R1
              ): CodePipeline.Service = this
              def retryStageExecution(
                  request: io.github.vigoo.zioaws.codepipeline.model.RetryStageExecutionRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.codepipeline.model.RetryStageExecutionResponse.ReadOnly
              ] = proxy(RetryStageExecution, request)
              def getPipeline(
                  request: io.github.vigoo.zioaws.codepipeline.model.GetPipelineRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.codepipeline.model.GetPipelineResponse.ReadOnly
              ] = proxy(GetPipeline, request)
              def listPipelineExecutions(
                  request: io.github.vigoo.zioaws.codepipeline.model.ListPipelineExecutionsRequest
              ): ZStream[
                Any,
                AwsError,
                io.github.vigoo.zioaws.codepipeline.model.PipelineExecutionSummary.ReadOnly
              ] = rts.unsafeRun(proxy(ListPipelineExecutions, request))
              def listWebhooks(
                  request: io.github.vigoo.zioaws.codepipeline.model.ListWebhooksRequest
              ): ZStream[
                Any,
                AwsError,
                io.github.vigoo.zioaws.codepipeline.model.ListWebhookItem.ReadOnly
              ] = rts.unsafeRun(proxy(ListWebhooks, request))
              def listActionExecutions(
                  request: io.github.vigoo.zioaws.codepipeline.model.ListActionExecutionsRequest
              ): ZStream[
                Any,
                AwsError,
                io.github.vigoo.zioaws.codepipeline.model.ActionExecutionDetail.ReadOnly
              ] = rts.unsafeRun(proxy(ListActionExecutions, request))
              def updatePipeline(
                  request: io.github.vigoo.zioaws.codepipeline.model.UpdatePipelineRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.codepipeline.model.UpdatePipelineResponse.ReadOnly
              ] = proxy(UpdatePipeline, request)
              def startPipelineExecution(
                  request: io.github.vigoo.zioaws.codepipeline.model.StartPipelineExecutionRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.codepipeline.model.StartPipelineExecutionResponse.ReadOnly
              ] = proxy(StartPipelineExecution, request)
              def putJobSuccessResult(
                  request: io.github.vigoo.zioaws.codepipeline.model.PutJobSuccessResultRequest
              ): IO[AwsError, Unit] = proxy(PutJobSuccessResult, request)
              def deleteWebhook(
                  request: io.github.vigoo.zioaws.codepipeline.model.DeleteWebhookRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.codepipeline.model.DeleteWebhookResponse.ReadOnly
              ] = proxy(DeleteWebhook, request)
              def listActionTypes(
                  request: io.github.vigoo.zioaws.codepipeline.model.ListActionTypesRequest
              ): ZStream[
                Any,
                AwsError,
                io.github.vigoo.zioaws.codepipeline.model.ActionType.ReadOnly
              ] = rts.unsafeRun(proxy(ListActionTypes, request))
              def acknowledgeThirdPartyJob(
                  request: io.github.vigoo.zioaws.codepipeline.model.AcknowledgeThirdPartyJobRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.codepipeline.model.AcknowledgeThirdPartyJobResponse.ReadOnly
              ] = proxy(AcknowledgeThirdPartyJob, request)
              def putJobFailureResult(
                  request: io.github.vigoo.zioaws.codepipeline.model.PutJobFailureResultRequest
              ): IO[AwsError, Unit] = proxy(PutJobFailureResult, request)
              def listPipelines(
                  request: io.github.vigoo.zioaws.codepipeline.model.ListPipelinesRequest
              ): ZStream[
                Any,
                AwsError,
                io.github.vigoo.zioaws.codepipeline.model.PipelineSummary.ReadOnly
              ] = rts.unsafeRun(proxy(ListPipelines, request))
              def acknowledgeJob(
                  request: io.github.vigoo.zioaws.codepipeline.model.AcknowledgeJobRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.codepipeline.model.AcknowledgeJobResponse.ReadOnly
              ] = proxy(AcknowledgeJob, request)
              def updateActionType(
                  request: io.github.vigoo.zioaws.codepipeline.model.UpdateActionTypeRequest
              ): IO[AwsError, Unit] = proxy(UpdateActionType, request)
              def putApprovalResult(
                  request: io.github.vigoo.zioaws.codepipeline.model.PutApprovalResultRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.codepipeline.model.PutApprovalResultResponse.ReadOnly
              ] = proxy(PutApprovalResult, request)
              def getPipelineState(
                  request: io.github.vigoo.zioaws.codepipeline.model.GetPipelineStateRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.codepipeline.model.GetPipelineStateResponse.ReadOnly
              ] = proxy(GetPipelineState, request)
              def pollForJobs(
                  request: io.github.vigoo.zioaws.codepipeline.model.PollForJobsRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.codepipeline.model.PollForJobsResponse.ReadOnly
              ] = proxy(PollForJobs, request)
              def untagResource(
                  request: io.github.vigoo.zioaws.codepipeline.model.UntagResourceRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.codepipeline.model.UntagResourceResponse.ReadOnly
              ] = proxy(UntagResource, request)
              def createCustomActionType(
                  request: io.github.vigoo.zioaws.codepipeline.model.CreateCustomActionTypeRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.codepipeline.model.CreateCustomActionTypeResponse.ReadOnly
              ] = proxy(CreateCustomActionType, request)
              def pollForThirdPartyJobs(
                  request: io.github.vigoo.zioaws.codepipeline.model.PollForThirdPartyJobsRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.codepipeline.model.PollForThirdPartyJobsResponse.ReadOnly
              ] = proxy(PollForThirdPartyJobs, request)
              def putThirdPartyJobFailureResult(
                  request: io.github.vigoo.zioaws.codepipeline.model.PutThirdPartyJobFailureResultRequest
              ): IO[AwsError, Unit] =
                proxy(PutThirdPartyJobFailureResult, request)
              def putWebhook(
                  request: io.github.vigoo.zioaws.codepipeline.model.PutWebhookRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.codepipeline.model.PutWebhookResponse.ReadOnly
              ] = proxy(PutWebhook, request)
              def deletePipeline(
                  request: io.github.vigoo.zioaws.codepipeline.model.DeletePipelineRequest
              ): IO[AwsError, Unit] = proxy(DeletePipeline, request)
              def listTagsForResource(
                  request: io.github.vigoo.zioaws.codepipeline.model.ListTagsForResourceRequest
              ): ZStream[
                Any,
                AwsError,
                io.github.vigoo.zioaws.codepipeline.model.Tag.ReadOnly
              ] = rts.unsafeRun(proxy(ListTagsForResource, request))
              def tagResource(
                  request: io.github.vigoo.zioaws.codepipeline.model.TagResourceRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.codepipeline.model.TagResourceResponse.ReadOnly
              ] = proxy(TagResource, request)
              def disableStageTransition(
                  request: io.github.vigoo.zioaws.codepipeline.model.DisableStageTransitionRequest
              ): IO[AwsError, Unit] = proxy(DisableStageTransition, request)
              def deleteCustomActionType(
                  request: io.github.vigoo.zioaws.codepipeline.model.DeleteCustomActionTypeRequest
              ): IO[AwsError, Unit] = proxy(DeleteCustomActionType, request)
              def putThirdPartyJobSuccessResult(
                  request: io.github.vigoo.zioaws.codepipeline.model.PutThirdPartyJobSuccessResultRequest
              ): IO[AwsError, Unit] =
                proxy(PutThirdPartyJobSuccessResult, request)
              def getActionType(
                  request: io.github.vigoo.zioaws.codepipeline.model.GetActionTypeRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.codepipeline.model.GetActionTypeResponse.ReadOnly
              ] = proxy(GetActionType, request)
              def stopPipelineExecution(
                  request: io.github.vigoo.zioaws.codepipeline.model.StopPipelineExecutionRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.codepipeline.model.StopPipelineExecutionResponse.ReadOnly
              ] = proxy(StopPipelineExecution, request)
              def deregisterWebhookWithThirdParty(
                  request: io.github.vigoo.zioaws.codepipeline.model.DeregisterWebhookWithThirdPartyRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.codepipeline.model.DeregisterWebhookWithThirdPartyResponse.ReadOnly
              ] = proxy(DeregisterWebhookWithThirdParty, request)
              def registerWebhookWithThirdParty(
                  request: io.github.vigoo.zioaws.codepipeline.model.RegisterWebhookWithThirdPartyRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.codepipeline.model.RegisterWebhookWithThirdPartyResponse.ReadOnly
              ] = proxy(RegisterWebhookWithThirdParty, request)
              def createPipeline(
                  request: io.github.vigoo.zioaws.codepipeline.model.CreatePipelineRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.codepipeline.model.CreatePipelineResponse.ReadOnly
              ] = proxy(CreatePipeline, request)
              def enableStageTransition(
                  request: io.github.vigoo.zioaws.codepipeline.model.EnableStageTransitionRequest
              ): IO[AwsError, Unit] = proxy(EnableStageTransition, request)
              def getJobDetails(
                  request: io.github.vigoo.zioaws.codepipeline.model.GetJobDetailsRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.codepipeline.model.GetJobDetailsResponse.ReadOnly
              ] = proxy(GetJobDetails, request)
              def getThirdPartyJobDetails(
                  request: io.github.vigoo.zioaws.codepipeline.model.GetThirdPartyJobDetailsRequest
              ): IO[AwsError, ReadOnly] =
                proxy(GetThirdPartyJobDetails, request)
              def putActionRevision(
                  request: io.github.vigoo.zioaws.codepipeline.model.PutActionRevisionRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.codepipeline.model.PutActionRevisionResponse.ReadOnly
              ] = proxy(PutActionRevision, request)
              def getPipelineExecution(
                  request: io.github.vigoo.zioaws.codepipeline.model.GetPipelineExecutionRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.codepipeline.model.GetPipelineExecutionResponse.ReadOnly
              ] = proxy(GetPipelineExecution, request)
            }
          }
      }
    }
  }
  val live: ZLayer[AwsConfig, java.lang.Throwable, CodePipeline] = customized(
    identity
  )
  def customized(
      customization: CodePipelineAsyncClientBuilder => CodePipelineAsyncClientBuilder
  ): ZLayer[AwsConfig, java.lang.Throwable, CodePipeline] = managed(
    customization
  ).toLayer
  def managed(
      customization: CodePipelineAsyncClientBuilder => CodePipelineAsyncClientBuilder
  ): ZManaged[AwsConfig, java.lang.Throwable, CodePipeline.Service] = for (
    awsConfig <- ZManaged.service[AwsConfig.Service];
    executor <- ZIO.executor.toManaged_;
    builder = CodePipelineAsyncClient
      .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[CodePipelineAsyncClient, CodePipelineAsyncClientBuilder](
        builder
      )
      .toManaged_;
    b1 <- awsConfig
      .configureHttpClient[
        CodePipelineAsyncClient,
        CodePipelineAsyncClientBuilder
      ](
        b0,
        io.github.vigoo.zioaws.core.httpclient
          .ServiceHttpCapabilities(supportsHttp2 = false)
      )
      .toManaged_; client <- zio.ZIO(customization(b1).build()).toManaged_
  )
    yield new CodePipelineImpl(
      client,
      AwsCallAspect.identity,
      ().asInstanceOf[Any]
    )
  private class CodePipelineImpl[R](
      override val api: CodePipelineAsyncClient,
      override val aspect: AwsCallAspect[R],
      r: R
  ) extends CodePipeline.Service
      with AwsServiceBase[R, CodePipelineImpl] {
    override val serviceName: String = "CodePipeline"
    override def withAspect[R1](
        newAspect: AwsCallAspect[R1],
        r: R1
    ): CodePipelineImpl[R1] = new CodePipelineImpl(api, newAspect, r)
    def retryStageExecution(
        request: io.github.vigoo.zioaws.codepipeline.model.RetryStageExecutionRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.codepipeline.model.RetryStageExecutionResponse.ReadOnly
    ] = asyncRequestResponse[
      RetryStageExecutionRequest,
      RetryStageExecutionResponse
    ]("retryStageExecution", api.retryStageExecution)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.codepipeline.model.RetryStageExecutionResponse.wrap
      )
      .provide(r)
    def getPipeline(
        request: io.github.vigoo.zioaws.codepipeline.model.GetPipelineRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.codepipeline.model.GetPipelineResponse.ReadOnly
    ] = asyncRequestResponse[GetPipelineRequest, GetPipelineResponse](
      "getPipeline",
      api.getPipeline
    )(request.buildAwsValue())
      .map(io.github.vigoo.zioaws.codepipeline.model.GetPipelineResponse.wrap)
      .provide(r)
    def listPipelineExecutions(
        request: io.github.vigoo.zioaws.codepipeline.model.ListPipelineExecutionsRequest
    ): ZStream[
      Any,
      AwsError,
      io.github.vigoo.zioaws.codepipeline.model.PipelineExecutionSummary.ReadOnly
    ] = asyncJavaPaginatedRequest[
      ListPipelineExecutionsRequest,
      PipelineExecutionSummary,
      ListPipelineExecutionsPublisher
    ](
      "listPipelineExecutions",
      api.listPipelineExecutionsPaginator,
      _.pipelineExecutionSummaries()
    )(request.buildAwsValue())
      .map(item =>
        io.github.vigoo.zioaws.codepipeline.model.PipelineExecutionSummary
          .wrap(item)
      )
      .provide(r)
    def listWebhooks(
        request: io.github.vigoo.zioaws.codepipeline.model.ListWebhooksRequest
    ): ZStream[
      Any,
      AwsError,
      io.github.vigoo.zioaws.codepipeline.model.ListWebhookItem.ReadOnly
    ] = asyncSimplePaginatedRequest[
      ListWebhooksRequest,
      ListWebhooksResponse,
      ListWebhookItem
    ](
      "listWebhooks",
      api.listWebhooks,
      (r, token) => r.toBuilder().nextToken(token).build(),
      r => scala.Option(r.nextToken()),
      r => zio.Chunk.fromIterable(r.webhooks().asScala)
    )(request.buildAwsValue())
      .map(item =>
        io.github.vigoo.zioaws.codepipeline.model.ListWebhookItem.wrap(item)
      )
      .provide(r)
    def listActionExecutions(
        request: io.github.vigoo.zioaws.codepipeline.model.ListActionExecutionsRequest
    ): ZStream[
      Any,
      AwsError,
      io.github.vigoo.zioaws.codepipeline.model.ActionExecutionDetail.ReadOnly
    ] = asyncJavaPaginatedRequest[
      ListActionExecutionsRequest,
      ActionExecutionDetail,
      ListActionExecutionsPublisher
    ](
      "listActionExecutions",
      api.listActionExecutionsPaginator,
      _.actionExecutionDetails()
    )(request.buildAwsValue())
      .map(item =>
        io.github.vigoo.zioaws.codepipeline.model.ActionExecutionDetail
          .wrap(item)
      )
      .provide(r)
    def updatePipeline(
        request: io.github.vigoo.zioaws.codepipeline.model.UpdatePipelineRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.codepipeline.model.UpdatePipelineResponse.ReadOnly
    ] = asyncRequestResponse[UpdatePipelineRequest, UpdatePipelineResponse](
      "updatePipeline",
      api.updatePipeline
    )(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.codepipeline.model.UpdatePipelineResponse.wrap
      )
      .provide(r)
    def startPipelineExecution(
        request: io.github.vigoo.zioaws.codepipeline.model.StartPipelineExecutionRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.codepipeline.model.StartPipelineExecutionResponse.ReadOnly
    ] = asyncRequestResponse[
      StartPipelineExecutionRequest,
      StartPipelineExecutionResponse
    ]("startPipelineExecution", api.startPipelineExecution)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.codepipeline.model.StartPipelineExecutionResponse.wrap
    ).provide(r)
    def putJobSuccessResult(
        request: io.github.vigoo.zioaws.codepipeline.model.PutJobSuccessResultRequest
    ): IO[AwsError, Unit] = asyncRequestResponse[
      PutJobSuccessResultRequest,
      PutJobSuccessResultResponse
    ]("putJobSuccessResult", api.putJobSuccessResult)(
      request.buildAwsValue()
    ).unit.provide(r)
    def deleteWebhook(
        request: io.github.vigoo.zioaws.codepipeline.model.DeleteWebhookRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.codepipeline.model.DeleteWebhookResponse.ReadOnly
    ] = asyncRequestResponse[DeleteWebhookRequest, DeleteWebhookResponse](
      "deleteWebhook",
      api.deleteWebhook
    )(request.buildAwsValue())
      .map(io.github.vigoo.zioaws.codepipeline.model.DeleteWebhookResponse.wrap)
      .provide(r)
    def listActionTypes(
        request: io.github.vigoo.zioaws.codepipeline.model.ListActionTypesRequest
    ): ZStream[
      Any,
      AwsError,
      io.github.vigoo.zioaws.codepipeline.model.ActionType.ReadOnly
    ] = asyncJavaPaginatedRequest[
      ListActionTypesRequest,
      ActionType,
      ListActionTypesPublisher
    ]("listActionTypes", api.listActionTypesPaginator, _.actionTypes())(
      request.buildAwsValue()
    ).map(item =>
      io.github.vigoo.zioaws.codepipeline.model.ActionType.wrap(item)
    ).provide(r)
    def acknowledgeThirdPartyJob(
        request: io.github.vigoo.zioaws.codepipeline.model.AcknowledgeThirdPartyJobRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.codepipeline.model.AcknowledgeThirdPartyJobResponse.ReadOnly
    ] = asyncRequestResponse[
      AcknowledgeThirdPartyJobRequest,
      AcknowledgeThirdPartyJobResponse
    ]("acknowledgeThirdPartyJob", api.acknowledgeThirdPartyJob)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.codepipeline.model.AcknowledgeThirdPartyJobResponse.wrap
    ).provide(r)
    def putJobFailureResult(
        request: io.github.vigoo.zioaws.codepipeline.model.PutJobFailureResultRequest
    ): IO[AwsError, Unit] = asyncRequestResponse[
      PutJobFailureResultRequest,
      PutJobFailureResultResponse
    ]("putJobFailureResult", api.putJobFailureResult)(
      request.buildAwsValue()
    ).unit.provide(r)
    def listPipelines(
        request: io.github.vigoo.zioaws.codepipeline.model.ListPipelinesRequest
    ): ZStream[
      Any,
      AwsError,
      io.github.vigoo.zioaws.codepipeline.model.PipelineSummary.ReadOnly
    ] = asyncJavaPaginatedRequest[
      ListPipelinesRequest,
      PipelineSummary,
      ListPipelinesPublisher
    ]("listPipelines", api.listPipelinesPaginator, _.pipelines())(
      request.buildAwsValue()
    ).map(item =>
      io.github.vigoo.zioaws.codepipeline.model.PipelineSummary.wrap(item)
    ).provide(r)
    def acknowledgeJob(
        request: io.github.vigoo.zioaws.codepipeline.model.AcknowledgeJobRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.codepipeline.model.AcknowledgeJobResponse.ReadOnly
    ] = asyncRequestResponse[AcknowledgeJobRequest, AcknowledgeJobResponse](
      "acknowledgeJob",
      api.acknowledgeJob
    )(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.codepipeline.model.AcknowledgeJobResponse.wrap
      )
      .provide(r)
    def updateActionType(
        request: io.github.vigoo.zioaws.codepipeline.model.UpdateActionTypeRequest
    ): IO[AwsError, Unit] =
      asyncRequestResponse[UpdateActionTypeRequest, UpdateActionTypeResponse](
        "updateActionType",
        api.updateActionType
      )(request.buildAwsValue()).unit.provide(r)
    def putApprovalResult(
        request: io.github.vigoo.zioaws.codepipeline.model.PutApprovalResultRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.codepipeline.model.PutApprovalResultResponse.ReadOnly
    ] = asyncRequestResponse[
      PutApprovalResultRequest,
      PutApprovalResultResponse
    ]("putApprovalResult", api.putApprovalResult)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.codepipeline.model.PutApprovalResultResponse.wrap
      )
      .provide(r)
    def getPipelineState(
        request: io.github.vigoo.zioaws.codepipeline.model.GetPipelineStateRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.codepipeline.model.GetPipelineStateResponse.ReadOnly
    ] = asyncRequestResponse[GetPipelineStateRequest, GetPipelineStateResponse](
      "getPipelineState",
      api.getPipelineState
    )(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.codepipeline.model.GetPipelineStateResponse.wrap
      )
      .provide(r)
    def pollForJobs(
        request: io.github.vigoo.zioaws.codepipeline.model.PollForJobsRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.codepipeline.model.PollForJobsResponse.ReadOnly
    ] = asyncRequestResponse[PollForJobsRequest, PollForJobsResponse](
      "pollForJobs",
      api.pollForJobs
    )(request.buildAwsValue())
      .map(io.github.vigoo.zioaws.codepipeline.model.PollForJobsResponse.wrap)
      .provide(r)
    def untagResource(
        request: io.github.vigoo.zioaws.codepipeline.model.UntagResourceRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.codepipeline.model.UntagResourceResponse.ReadOnly
    ] = asyncRequestResponse[UntagResourceRequest, UntagResourceResponse](
      "untagResource",
      api.untagResource
    )(request.buildAwsValue())
      .map(io.github.vigoo.zioaws.codepipeline.model.UntagResourceResponse.wrap)
      .provide(r)
    def createCustomActionType(
        request: io.github.vigoo.zioaws.codepipeline.model.CreateCustomActionTypeRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.codepipeline.model.CreateCustomActionTypeResponse.ReadOnly
    ] = asyncRequestResponse[
      CreateCustomActionTypeRequest,
      CreateCustomActionTypeResponse
    ]("createCustomActionType", api.createCustomActionType)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.codepipeline.model.CreateCustomActionTypeResponse.wrap
    ).provide(r)
    def pollForThirdPartyJobs(
        request: io.github.vigoo.zioaws.codepipeline.model.PollForThirdPartyJobsRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.codepipeline.model.PollForThirdPartyJobsResponse.ReadOnly
    ] = asyncRequestResponse[
      PollForThirdPartyJobsRequest,
      PollForThirdPartyJobsResponse
    ]("pollForThirdPartyJobs", api.pollForThirdPartyJobs)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.codepipeline.model.PollForThirdPartyJobsResponse.wrap
    ).provide(r)
    def putThirdPartyJobFailureResult(
        request: io.github.vigoo.zioaws.codepipeline.model.PutThirdPartyJobFailureResultRequest
    ): IO[AwsError, Unit] = asyncRequestResponse[
      PutThirdPartyJobFailureResultRequest,
      PutThirdPartyJobFailureResultResponse
    ]("putThirdPartyJobFailureResult", api.putThirdPartyJobFailureResult)(
      request.buildAwsValue()
    ).unit.provide(r)
    def putWebhook(
        request: io.github.vigoo.zioaws.codepipeline.model.PutWebhookRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.codepipeline.model.PutWebhookResponse.ReadOnly
    ] = asyncRequestResponse[PutWebhookRequest, PutWebhookResponse](
      "putWebhook",
      api.putWebhook
    )(request.buildAwsValue())
      .map(io.github.vigoo.zioaws.codepipeline.model.PutWebhookResponse.wrap)
      .provide(r)
    def deletePipeline(
        request: io.github.vigoo.zioaws.codepipeline.model.DeletePipelineRequest
    ): IO[AwsError, Unit] =
      asyncRequestResponse[DeletePipelineRequest, DeletePipelineResponse](
        "deletePipeline",
        api.deletePipeline
      )(request.buildAwsValue()).unit.provide(r)
    def listTagsForResource(
        request: io.github.vigoo.zioaws.codepipeline.model.ListTagsForResourceRequest
    ): ZStream[
      Any,
      AwsError,
      io.github.vigoo.zioaws.codepipeline.model.Tag.ReadOnly
    ] = asyncJavaPaginatedRequest[
      ListTagsForResourceRequest,
      Tag,
      ListTagsForResourcePublisher
    ]("listTagsForResource", api.listTagsForResourcePaginator, _.tags())(
      request.buildAwsValue()
    ).map(item => io.github.vigoo.zioaws.codepipeline.model.Tag.wrap(item))
      .provide(r)
    def tagResource(
        request: io.github.vigoo.zioaws.codepipeline.model.TagResourceRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.codepipeline.model.TagResourceResponse.ReadOnly
    ] = asyncRequestResponse[TagResourceRequest, TagResourceResponse](
      "tagResource",
      api.tagResource
    )(request.buildAwsValue())
      .map(io.github.vigoo.zioaws.codepipeline.model.TagResourceResponse.wrap)
      .provide(r)
    def disableStageTransition(
        request: io.github.vigoo.zioaws.codepipeline.model.DisableStageTransitionRequest
    ): IO[AwsError, Unit] = asyncRequestResponse[
      DisableStageTransitionRequest,
      DisableStageTransitionResponse
    ]("disableStageTransition", api.disableStageTransition)(
      request.buildAwsValue()
    ).unit.provide(r)
    def deleteCustomActionType(
        request: io.github.vigoo.zioaws.codepipeline.model.DeleteCustomActionTypeRequest
    ): IO[AwsError, Unit] = asyncRequestResponse[
      DeleteCustomActionTypeRequest,
      DeleteCustomActionTypeResponse
    ]("deleteCustomActionType", api.deleteCustomActionType)(
      request.buildAwsValue()
    ).unit.provide(r)
    def putThirdPartyJobSuccessResult(
        request: io.github.vigoo.zioaws.codepipeline.model.PutThirdPartyJobSuccessResultRequest
    ): IO[AwsError, Unit] = asyncRequestResponse[
      PutThirdPartyJobSuccessResultRequest,
      PutThirdPartyJobSuccessResultResponse
    ]("putThirdPartyJobSuccessResult", api.putThirdPartyJobSuccessResult)(
      request.buildAwsValue()
    ).unit.provide(r)
    def getActionType(
        request: io.github.vigoo.zioaws.codepipeline.model.GetActionTypeRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.codepipeline.model.GetActionTypeResponse.ReadOnly
    ] = asyncRequestResponse[GetActionTypeRequest, GetActionTypeResponse](
      "getActionType",
      api.getActionType
    )(request.buildAwsValue())
      .map(io.github.vigoo.zioaws.codepipeline.model.GetActionTypeResponse.wrap)
      .provide(r)
    def stopPipelineExecution(
        request: io.github.vigoo.zioaws.codepipeline.model.StopPipelineExecutionRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.codepipeline.model.StopPipelineExecutionResponse.ReadOnly
    ] = asyncRequestResponse[
      StopPipelineExecutionRequest,
      StopPipelineExecutionResponse
    ]("stopPipelineExecution", api.stopPipelineExecution)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.codepipeline.model.StopPipelineExecutionResponse.wrap
    ).provide(r)
    def deregisterWebhookWithThirdParty(
        request: io.github.vigoo.zioaws.codepipeline.model.DeregisterWebhookWithThirdPartyRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.codepipeline.model.DeregisterWebhookWithThirdPartyResponse.ReadOnly
    ] = asyncRequestResponse[
      DeregisterWebhookWithThirdPartyRequest,
      DeregisterWebhookWithThirdPartyResponse
    ]("deregisterWebhookWithThirdParty", api.deregisterWebhookWithThirdParty)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.codepipeline.model.DeregisterWebhookWithThirdPartyResponse.wrap
    ).provide(r)
    def registerWebhookWithThirdParty(
        request: io.github.vigoo.zioaws.codepipeline.model.RegisterWebhookWithThirdPartyRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.codepipeline.model.RegisterWebhookWithThirdPartyResponse.ReadOnly
    ] = asyncRequestResponse[
      RegisterWebhookWithThirdPartyRequest,
      RegisterWebhookWithThirdPartyResponse
    ]("registerWebhookWithThirdParty", api.registerWebhookWithThirdParty)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.codepipeline.model.RegisterWebhookWithThirdPartyResponse.wrap
    ).provide(r)
    def createPipeline(
        request: io.github.vigoo.zioaws.codepipeline.model.CreatePipelineRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.codepipeline.model.CreatePipelineResponse.ReadOnly
    ] = asyncRequestResponse[CreatePipelineRequest, CreatePipelineResponse](
      "createPipeline",
      api.createPipeline
    )(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.codepipeline.model.CreatePipelineResponse.wrap
      )
      .provide(r)
    def enableStageTransition(
        request: io.github.vigoo.zioaws.codepipeline.model.EnableStageTransitionRequest
    ): IO[AwsError, Unit] = asyncRequestResponse[
      EnableStageTransitionRequest,
      EnableStageTransitionResponse
    ]("enableStageTransition", api.enableStageTransition)(
      request.buildAwsValue()
    ).unit.provide(r)
    def getJobDetails(
        request: io.github.vigoo.zioaws.codepipeline.model.GetJobDetailsRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.codepipeline.model.GetJobDetailsResponse.ReadOnly
    ] = asyncRequestResponse[GetJobDetailsRequest, GetJobDetailsResponse](
      "getJobDetails",
      api.getJobDetails
    )(request.buildAwsValue())
      .map(io.github.vigoo.zioaws.codepipeline.model.GetJobDetailsResponse.wrap)
      .provide(r)
    def getThirdPartyJobDetails(
        request: io.github.vigoo.zioaws.codepipeline.model.GetThirdPartyJobDetailsRequest
    ): IO[AwsError, ReadOnly] = asyncRequestResponse[
      GetThirdPartyJobDetailsRequest,
      GetThirdPartyJobDetailsResponse
    ]("getThirdPartyJobDetails", api.getThirdPartyJobDetails)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.codepipeline.model.GetThirdPartyJobDetailsResponse.wrap
    ).provide(r)
    def putActionRevision(
        request: io.github.vigoo.zioaws.codepipeline.model.PutActionRevisionRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.codepipeline.model.PutActionRevisionResponse.ReadOnly
    ] = asyncRequestResponse[
      PutActionRevisionRequest,
      PutActionRevisionResponse
    ]("putActionRevision", api.putActionRevision)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.codepipeline.model.PutActionRevisionResponse.wrap
      )
      .provide(r)
    def getPipelineExecution(
        request: io.github.vigoo.zioaws.codepipeline.model.GetPipelineExecutionRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.codepipeline.model.GetPipelineExecutionResponse.ReadOnly
    ] = asyncRequestResponse[
      GetPipelineExecutionRequest,
      GetPipelineExecutionResponse
    ]("getPipelineExecution", api.getPipelineExecution)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.codepipeline.model.GetPipelineExecutionResponse.wrap
      )
      .provide(r)
  }
  def retryStageExecution(
      request: io.github.vigoo.zioaws.codepipeline.model.RetryStageExecutionRequest
  ): ZIO[
    CodePipeline,
    AwsError,
    io.github.vigoo.zioaws.codepipeline.model.RetryStageExecutionResponse.ReadOnly
  ] = ZIO.accessM(_.get.retryStageExecution(request))
  def getPipeline(
      request: io.github.vigoo.zioaws.codepipeline.model.GetPipelineRequest
  ): ZIO[
    CodePipeline,
    AwsError,
    io.github.vigoo.zioaws.codepipeline.model.GetPipelineResponse.ReadOnly
  ] = ZIO.accessM(_.get.getPipeline(request))
  def listPipelineExecutions(
      request: io.github.vigoo.zioaws.codepipeline.model.ListPipelineExecutionsRequest
  ): ZStream[
    CodePipeline,
    AwsError,
    io.github.vigoo.zioaws.codepipeline.model.PipelineExecutionSummary.ReadOnly
  ] = ZStream.accessStream(_.get.listPipelineExecutions(request))
  def listWebhooks(
      request: io.github.vigoo.zioaws.codepipeline.model.ListWebhooksRequest
  ): ZStream[
    CodePipeline,
    AwsError,
    io.github.vigoo.zioaws.codepipeline.model.ListWebhookItem.ReadOnly
  ] = ZStream.accessStream(_.get.listWebhooks(request))
  def listActionExecutions(
      request: io.github.vigoo.zioaws.codepipeline.model.ListActionExecutionsRequest
  ): ZStream[
    CodePipeline,
    AwsError,
    io.github.vigoo.zioaws.codepipeline.model.ActionExecutionDetail.ReadOnly
  ] = ZStream.accessStream(_.get.listActionExecutions(request))
  def updatePipeline(
      request: io.github.vigoo.zioaws.codepipeline.model.UpdatePipelineRequest
  ): ZIO[
    CodePipeline,
    AwsError,
    io.github.vigoo.zioaws.codepipeline.model.UpdatePipelineResponse.ReadOnly
  ] = ZIO.accessM(_.get.updatePipeline(request))
  def startPipelineExecution(
      request: io.github.vigoo.zioaws.codepipeline.model.StartPipelineExecutionRequest
  ): ZIO[
    CodePipeline,
    AwsError,
    io.github.vigoo.zioaws.codepipeline.model.StartPipelineExecutionResponse.ReadOnly
  ] = ZIO.accessM(_.get.startPipelineExecution(request))
  def putJobSuccessResult(
      request: io.github.vigoo.zioaws.codepipeline.model.PutJobSuccessResultRequest
  ): ZIO[CodePipeline, AwsError, Unit] =
    ZIO.accessM(_.get.putJobSuccessResult(request))
  def deleteWebhook(
      request: io.github.vigoo.zioaws.codepipeline.model.DeleteWebhookRequest
  ): ZIO[
    CodePipeline,
    AwsError,
    io.github.vigoo.zioaws.codepipeline.model.DeleteWebhookResponse.ReadOnly
  ] = ZIO.accessM(_.get.deleteWebhook(request))
  def listActionTypes(
      request: io.github.vigoo.zioaws.codepipeline.model.ListActionTypesRequest
  ): ZStream[
    CodePipeline,
    AwsError,
    io.github.vigoo.zioaws.codepipeline.model.ActionType.ReadOnly
  ] = ZStream.accessStream(_.get.listActionTypes(request))
  def acknowledgeThirdPartyJob(
      request: io.github.vigoo.zioaws.codepipeline.model.AcknowledgeThirdPartyJobRequest
  ): ZIO[
    CodePipeline,
    AwsError,
    io.github.vigoo.zioaws.codepipeline.model.AcknowledgeThirdPartyJobResponse.ReadOnly
  ] = ZIO.accessM(_.get.acknowledgeThirdPartyJob(request))
  def putJobFailureResult(
      request: io.github.vigoo.zioaws.codepipeline.model.PutJobFailureResultRequest
  ): ZIO[CodePipeline, AwsError, Unit] =
    ZIO.accessM(_.get.putJobFailureResult(request))
  def listPipelines(
      request: io.github.vigoo.zioaws.codepipeline.model.ListPipelinesRequest
  ): ZStream[
    CodePipeline,
    AwsError,
    io.github.vigoo.zioaws.codepipeline.model.PipelineSummary.ReadOnly
  ] = ZStream.accessStream(_.get.listPipelines(request))
  def acknowledgeJob(
      request: io.github.vigoo.zioaws.codepipeline.model.AcknowledgeJobRequest
  ): ZIO[
    CodePipeline,
    AwsError,
    io.github.vigoo.zioaws.codepipeline.model.AcknowledgeJobResponse.ReadOnly
  ] = ZIO.accessM(_.get.acknowledgeJob(request))
  def updateActionType(
      request: io.github.vigoo.zioaws.codepipeline.model.UpdateActionTypeRequest
  ): ZIO[CodePipeline, AwsError, Unit] =
    ZIO.accessM(_.get.updateActionType(request))
  def putApprovalResult(
      request: io.github.vigoo.zioaws.codepipeline.model.PutApprovalResultRequest
  ): ZIO[
    CodePipeline,
    AwsError,
    io.github.vigoo.zioaws.codepipeline.model.PutApprovalResultResponse.ReadOnly
  ] = ZIO.accessM(_.get.putApprovalResult(request))
  def getPipelineState(
      request: io.github.vigoo.zioaws.codepipeline.model.GetPipelineStateRequest
  ): ZIO[
    CodePipeline,
    AwsError,
    io.github.vigoo.zioaws.codepipeline.model.GetPipelineStateResponse.ReadOnly
  ] = ZIO.accessM(_.get.getPipelineState(request))
  def pollForJobs(
      request: io.github.vigoo.zioaws.codepipeline.model.PollForJobsRequest
  ): ZIO[
    CodePipeline,
    AwsError,
    io.github.vigoo.zioaws.codepipeline.model.PollForJobsResponse.ReadOnly
  ] = ZIO.accessM(_.get.pollForJobs(request))
  def untagResource(
      request: io.github.vigoo.zioaws.codepipeline.model.UntagResourceRequest
  ): ZIO[
    CodePipeline,
    AwsError,
    io.github.vigoo.zioaws.codepipeline.model.UntagResourceResponse.ReadOnly
  ] = ZIO.accessM(_.get.untagResource(request))
  def createCustomActionType(
      request: io.github.vigoo.zioaws.codepipeline.model.CreateCustomActionTypeRequest
  ): ZIO[
    CodePipeline,
    AwsError,
    io.github.vigoo.zioaws.codepipeline.model.CreateCustomActionTypeResponse.ReadOnly
  ] = ZIO.accessM(_.get.createCustomActionType(request))
  def pollForThirdPartyJobs(
      request: io.github.vigoo.zioaws.codepipeline.model.PollForThirdPartyJobsRequest
  ): ZIO[
    CodePipeline,
    AwsError,
    io.github.vigoo.zioaws.codepipeline.model.PollForThirdPartyJobsResponse.ReadOnly
  ] = ZIO.accessM(_.get.pollForThirdPartyJobs(request))
  def putThirdPartyJobFailureResult(
      request: io.github.vigoo.zioaws.codepipeline.model.PutThirdPartyJobFailureResultRequest
  ): ZIO[CodePipeline, AwsError, Unit] =
    ZIO.accessM(_.get.putThirdPartyJobFailureResult(request))
  def putWebhook(
      request: io.github.vigoo.zioaws.codepipeline.model.PutWebhookRequest
  ): ZIO[
    CodePipeline,
    AwsError,
    io.github.vigoo.zioaws.codepipeline.model.PutWebhookResponse.ReadOnly
  ] = ZIO.accessM(_.get.putWebhook(request))
  def deletePipeline(
      request: io.github.vigoo.zioaws.codepipeline.model.DeletePipelineRequest
  ): ZIO[CodePipeline, AwsError, Unit] =
    ZIO.accessM(_.get.deletePipeline(request))
  def listTagsForResource(
      request: io.github.vigoo.zioaws.codepipeline.model.ListTagsForResourceRequest
  ): ZStream[
    CodePipeline,
    AwsError,
    io.github.vigoo.zioaws.codepipeline.model.Tag.ReadOnly
  ] = ZStream.accessStream(_.get.listTagsForResource(request))
  def tagResource(
      request: io.github.vigoo.zioaws.codepipeline.model.TagResourceRequest
  ): ZIO[
    CodePipeline,
    AwsError,
    io.github.vigoo.zioaws.codepipeline.model.TagResourceResponse.ReadOnly
  ] = ZIO.accessM(_.get.tagResource(request))
  def disableStageTransition(
      request: io.github.vigoo.zioaws.codepipeline.model.DisableStageTransitionRequest
  ): ZIO[CodePipeline, AwsError, Unit] =
    ZIO.accessM(_.get.disableStageTransition(request))
  def deleteCustomActionType(
      request: io.github.vigoo.zioaws.codepipeline.model.DeleteCustomActionTypeRequest
  ): ZIO[CodePipeline, AwsError, Unit] =
    ZIO.accessM(_.get.deleteCustomActionType(request))
  def putThirdPartyJobSuccessResult(
      request: io.github.vigoo.zioaws.codepipeline.model.PutThirdPartyJobSuccessResultRequest
  ): ZIO[CodePipeline, AwsError, Unit] =
    ZIO.accessM(_.get.putThirdPartyJobSuccessResult(request))
  def getActionType(
      request: io.github.vigoo.zioaws.codepipeline.model.GetActionTypeRequest
  ): ZIO[
    CodePipeline,
    AwsError,
    io.github.vigoo.zioaws.codepipeline.model.GetActionTypeResponse.ReadOnly
  ] = ZIO.accessM(_.get.getActionType(request))
  def stopPipelineExecution(
      request: io.github.vigoo.zioaws.codepipeline.model.StopPipelineExecutionRequest
  ): ZIO[
    CodePipeline,
    AwsError,
    io.github.vigoo.zioaws.codepipeline.model.StopPipelineExecutionResponse.ReadOnly
  ] = ZIO.accessM(_.get.stopPipelineExecution(request))
  def deregisterWebhookWithThirdParty(
      request: io.github.vigoo.zioaws.codepipeline.model.DeregisterWebhookWithThirdPartyRequest
  ): ZIO[
    CodePipeline,
    AwsError,
    io.github.vigoo.zioaws.codepipeline.model.DeregisterWebhookWithThirdPartyResponse.ReadOnly
  ] = ZIO.accessM(_.get.deregisterWebhookWithThirdParty(request))
  def registerWebhookWithThirdParty(
      request: io.github.vigoo.zioaws.codepipeline.model.RegisterWebhookWithThirdPartyRequest
  ): ZIO[
    CodePipeline,
    AwsError,
    io.github.vigoo.zioaws.codepipeline.model.RegisterWebhookWithThirdPartyResponse.ReadOnly
  ] = ZIO.accessM(_.get.registerWebhookWithThirdParty(request))
  def createPipeline(
      request: io.github.vigoo.zioaws.codepipeline.model.CreatePipelineRequest
  ): ZIO[
    CodePipeline,
    AwsError,
    io.github.vigoo.zioaws.codepipeline.model.CreatePipelineResponse.ReadOnly
  ] = ZIO.accessM(_.get.createPipeline(request))
  def enableStageTransition(
      request: io.github.vigoo.zioaws.codepipeline.model.EnableStageTransitionRequest
  ): ZIO[CodePipeline, AwsError, Unit] =
    ZIO.accessM(_.get.enableStageTransition(request))
  def getJobDetails(
      request: io.github.vigoo.zioaws.codepipeline.model.GetJobDetailsRequest
  ): ZIO[
    CodePipeline,
    AwsError,
    io.github.vigoo.zioaws.codepipeline.model.GetJobDetailsResponse.ReadOnly
  ] = ZIO.accessM(_.get.getJobDetails(request))
  def getThirdPartyJobDetails(
      request: io.github.vigoo.zioaws.codepipeline.model.GetThirdPartyJobDetailsRequest
  ): ZIO[CodePipeline, AwsError, ReadOnly] =
    ZIO.accessM(_.get.getThirdPartyJobDetails(request))
  def putActionRevision(
      request: io.github.vigoo.zioaws.codepipeline.model.PutActionRevisionRequest
  ): ZIO[
    CodePipeline,
    AwsError,
    io.github.vigoo.zioaws.codepipeline.model.PutActionRevisionResponse.ReadOnly
  ] = ZIO.accessM(_.get.putActionRevision(request))
  def getPipelineExecution(
      request: io.github.vigoo.zioaws.codepipeline.model.GetPipelineExecutionRequest
  ): ZIO[
    CodePipeline,
    AwsError,
    io.github.vigoo.zioaws.codepipeline.model.GetPipelineExecutionResponse.ReadOnly
  ] = ZIO.accessM(_.get.getPipelineExecution(request))
}