• Home
• io.github.vigoo
• zio-aws-elasticloadbalancing_2.12
• 4.0.5
• 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.elasticloadbalancing.package.scala Maven / Gradle / Ivy

package io.github.vigoo.zioaws
import io.github.vigoo.zioaws.elasticloadbalancing.model.ModifyLoadBalancerAttributesResponse.ReadOnly
import io.github.vigoo.zioaws.core.{AwsServiceBase, AwsError}
import software.amazon.awssdk.services.elasticloadbalancing.{
  ElasticLoadBalancingAsyncClientBuilder,
  ElasticLoadBalancingAsyncClient
}
import software.amazon.awssdk.services.elasticloadbalancing.paginators.DescribeLoadBalancersPublisher
import io.github.vigoo.zioaws.core.config.AwsConfig
import zio.{ZManaged, IO, ZIO, ZLayer, URLayer, Has}
import software.amazon.awssdk.services.elasticloadbalancing.model.{
  DeleteLoadBalancerPolicyRequest,
  CreateAppCookieStickinessPolicyResponse,
  DeleteLoadBalancerListenersRequest,
  LoadBalancerDescription,
  DeregisterInstancesFromLoadBalancerRequest,
  DescribeAccountLimitsResponse,
  DeleteLoadBalancerListenersResponse,
  SetLoadBalancerPoliciesForBackendServerResponse,
  DescribeInstanceHealthRequest,
  SetLoadBalancerPoliciesForBackendServerRequest,
  DeregisterInstancesFromLoadBalancerResponse,
  ApplySecurityGroupsToLoadBalancerRequest,
  DeleteLoadBalancerPolicyResponse,
  SetLoadBalancerListenerSslCertificateResponse,
  RemoveTagsResponse,
  DeleteLoadBalancerResponse,
  DetachLoadBalancerFromSubnetsRequest,
  DescribeLoadBalancerPoliciesResponse,
  EnableAvailabilityZonesForLoadBalancerResponse,
  ApplySecurityGroupsToLoadBalancerResponse,
  AttachLoadBalancerToSubnetsRequest,
  DescribeLoadBalancerAttributesRequest,
  DisableAvailabilityZonesForLoadBalancerRequest,
  AddTagsRequest,
  DisableAvailabilityZonesForLoadBalancerResponse,
  CreateLoadBalancerPolicyRequest,
  DetachLoadBalancerFromSubnetsResponse,
  CreateLoadBalancerRequest,
  ModifyLoadBalancerAttributesRequest,
  CreateLoadBalancerResponse,
  RegisterInstancesWithLoadBalancerRequest,
  AddTagsResponse,
  RegisterInstancesWithLoadBalancerResponse,
  DescribeTagsRequest,
  DeleteLoadBalancerRequest,
  CreateLoadBalancerListenersRequest,
  CreateLbCookieStickinessPolicyRequest,
  CreateLoadBalancerPolicyResponse,
  DescribeLoadBalancersRequest,
  SetLoadBalancerListenerSslCertificateRequest,
  DescribeAccountLimitsRequest,
  DescribeInstanceHealthResponse,
  CreateLoadBalancerListenersResponse,
  ConfigureHealthCheckRequest,
  AttachLoadBalancerToSubnetsResponse,
  CreateAppCookieStickinessPolicyRequest,
  SetLoadBalancerPoliciesOfListenerRequest,
  DescribeLoadBalancerPolicyTypesResponse,
  DescribeTagsResponse,
  CreateLbCookieStickinessPolicyResponse,
  ModifyLoadBalancerAttributesResponse,
  RemoveTagsRequest,
  SetLoadBalancerPoliciesOfListenerResponse,
  DescribeLoadBalancerAttributesResponse,
  EnableAvailabilityZonesForLoadBalancerRequest,
  DescribeLoadBalancerPoliciesRequest,
  ConfigureHealthCheckResponse,
  DescribeLoadBalancerPolicyTypesRequest
}
import io.github.vigoo.zioaws.core.aspects.{AwsCallAspect, AspectSupport}
import zio.stream.ZStream
import io.github.vigoo.zioaws.elasticloadbalancing.ElasticLoadBalancing
import zio.test.mock.{Proxy, Mock}
package object elasticloadbalancing {
  import scala.jdk.CollectionConverters._
  type ElasticLoadBalancing = Has[ElasticLoadBalancing.Service]
  object ElasticLoadBalancing {
    trait Service extends AspectSupport[Service] {
      val api: ElasticLoadBalancingAsyncClient
      def describeTags(
          request: io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeTagsRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeTagsResponse.ReadOnly
      ]
      def createLoadBalancerListeners(
          request: io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLoadBalancerListenersRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLoadBalancerListenersResponse.ReadOnly
      ]
      def createLBCookieStickinessPolicy(
          request: io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLbCookieStickinessPolicyRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLbCookieStickinessPolicyResponse.ReadOnly
      ]
      def describeLoadBalancerAttributes(
          request: io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeLoadBalancerAttributesRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeLoadBalancerAttributesResponse.ReadOnly
      ]
      def setLoadBalancerPoliciesForBackendServer(
          request: io.github.vigoo.zioaws.elasticloadbalancing.model.SetLoadBalancerPoliciesForBackendServerRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.elasticloadbalancing.model.SetLoadBalancerPoliciesForBackendServerResponse.ReadOnly
      ]
      def describeInstanceHealth(
          request: io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeInstanceHealthRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeInstanceHealthResponse.ReadOnly
      ]
      def addTags(
          request: io.github.vigoo.zioaws.elasticloadbalancing.model.AddTagsRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.elasticloadbalancing.model.AddTagsResponse.ReadOnly
      ]
      def registerInstancesWithLoadBalancer(
          request: io.github.vigoo.zioaws.elasticloadbalancing.model.RegisterInstancesWithLoadBalancerRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.elasticloadbalancing.model.RegisterInstancesWithLoadBalancerResponse.ReadOnly
      ]
      def detachLoadBalancerFromSubnets(
          request: io.github.vigoo.zioaws.elasticloadbalancing.model.DetachLoadBalancerFromSubnetsRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.elasticloadbalancing.model.DetachLoadBalancerFromSubnetsResponse.ReadOnly
      ]
      def describeAccountLimits(
          request: io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeAccountLimitsRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeAccountLimitsResponse.ReadOnly
      ]
      def createAppCookieStickinessPolicy(
          request: io.github.vigoo.zioaws.elasticloadbalancing.model.CreateAppCookieStickinessPolicyRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.elasticloadbalancing.model.CreateAppCookieStickinessPolicyResponse.ReadOnly
      ]
      def configureHealthCheck(
          request: io.github.vigoo.zioaws.elasticloadbalancing.model.ConfigureHealthCheckRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.elasticloadbalancing.model.ConfigureHealthCheckResponse.ReadOnly
      ]
      def deleteLoadBalancer(
          request: io.github.vigoo.zioaws.elasticloadbalancing.model.DeleteLoadBalancerRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.elasticloadbalancing.model.DeleteLoadBalancerResponse.ReadOnly
      ]
      def removeTags(
          request: io.github.vigoo.zioaws.elasticloadbalancing.model.RemoveTagsRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.elasticloadbalancing.model.RemoveTagsResponse.ReadOnly
      ]
      def describeLoadBalancerPolicyTypes(
          request: io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeLoadBalancerPolicyTypesRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeLoadBalancerPolicyTypesResponse.ReadOnly
      ]
      def attachLoadBalancerToSubnets(
          request: io.github.vigoo.zioaws.elasticloadbalancing.model.AttachLoadBalancerToSubnetsRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.elasticloadbalancing.model.AttachLoadBalancerToSubnetsResponse.ReadOnly
      ]
      def modifyLoadBalancerAttributes(
          request: io.github.vigoo.zioaws.elasticloadbalancing.model.ModifyLoadBalancerAttributesRequest
      ): IO[AwsError, ReadOnly]
      def deleteLoadBalancerListeners(
          request: io.github.vigoo.zioaws.elasticloadbalancing.model.DeleteLoadBalancerListenersRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.elasticloadbalancing.model.DeleteLoadBalancerListenersResponse.ReadOnly
      ]
      def createLoadBalancerPolicy(
          request: io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLoadBalancerPolicyRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLoadBalancerPolicyResponse.ReadOnly
      ]
      def describeLoadBalancerPolicies(
          request: io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeLoadBalancerPoliciesRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeLoadBalancerPoliciesResponse.ReadOnly
      ]
      def disableAvailabilityZonesForLoadBalancer(
          request: io.github.vigoo.zioaws.elasticloadbalancing.model.DisableAvailabilityZonesForLoadBalancerRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.elasticloadbalancing.model.DisableAvailabilityZonesForLoadBalancerResponse.ReadOnly
      ]
      def deregisterInstancesFromLoadBalancer(
          request: io.github.vigoo.zioaws.elasticloadbalancing.model.DeregisterInstancesFromLoadBalancerRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.elasticloadbalancing.model.DeregisterInstancesFromLoadBalancerResponse.ReadOnly
      ]
      def setLoadBalancerPoliciesOfListener(
          request: io.github.vigoo.zioaws.elasticloadbalancing.model.SetLoadBalancerPoliciesOfListenerRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.elasticloadbalancing.model.SetLoadBalancerPoliciesOfListenerResponse.ReadOnly
      ]
      def applySecurityGroupsToLoadBalancer(
          request: io.github.vigoo.zioaws.elasticloadbalancing.model.ApplySecurityGroupsToLoadBalancerRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.elasticloadbalancing.model.ApplySecurityGroupsToLoadBalancerResponse.ReadOnly
      ]
      def createLoadBalancer(
          request: io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLoadBalancerRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLoadBalancerResponse.ReadOnly
      ]
      def enableAvailabilityZonesForLoadBalancer(
          request: io.github.vigoo.zioaws.elasticloadbalancing.model.EnableAvailabilityZonesForLoadBalancerRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.elasticloadbalancing.model.EnableAvailabilityZonesForLoadBalancerResponse.ReadOnly
      ]
      def setLoadBalancerListenerSSLCertificate(
          request: io.github.vigoo.zioaws.elasticloadbalancing.model.SetLoadBalancerListenerSslCertificateRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.elasticloadbalancing.model.SetLoadBalancerListenerSslCertificateResponse.ReadOnly
      ]
      def deleteLoadBalancerPolicy(
          request: io.github.vigoo.zioaws.elasticloadbalancing.model.DeleteLoadBalancerPolicyRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.elasticloadbalancing.model.DeleteLoadBalancerPolicyResponse.ReadOnly
      ]
      def describeLoadBalancers(
          request: io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeLoadBalancersRequest
      ): ZStream[
        Any,
        AwsError,
        io.github.vigoo.zioaws.elasticloadbalancing.model.LoadBalancerDescription.ReadOnly
      ]
    }
    object ElasticLoadBalancingMock extends Mock[ElasticLoadBalancing] {
      object DescribeTags
          extends Effect[
            io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeTagsRequest,
            AwsError,
            io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeTagsResponse.ReadOnly
          ]
      object CreateLoadBalancerListeners
          extends Effect[
            io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLoadBalancerListenersRequest,
            AwsError,
            io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLoadBalancerListenersResponse.ReadOnly
          ]
      object CreateLBCookieStickinessPolicy
          extends Effect[
            io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLbCookieStickinessPolicyRequest,
            AwsError,
            io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLbCookieStickinessPolicyResponse.ReadOnly
          ]
      object DescribeLoadBalancerAttributes
          extends Effect[
            io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeLoadBalancerAttributesRequest,
            AwsError,
            io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeLoadBalancerAttributesResponse.ReadOnly
          ]
      object SetLoadBalancerPoliciesForBackendServer
          extends Effect[
            io.github.vigoo.zioaws.elasticloadbalancing.model.SetLoadBalancerPoliciesForBackendServerRequest,
            AwsError,
            io.github.vigoo.zioaws.elasticloadbalancing.model.SetLoadBalancerPoliciesForBackendServerResponse.ReadOnly
          ]
      object DescribeInstanceHealth
          extends Effect[
            io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeInstanceHealthRequest,
            AwsError,
            io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeInstanceHealthResponse.ReadOnly
          ]
      object AddTags
          extends Effect[
            io.github.vigoo.zioaws.elasticloadbalancing.model.AddTagsRequest,
            AwsError,
            io.github.vigoo.zioaws.elasticloadbalancing.model.AddTagsResponse.ReadOnly
          ]
      object RegisterInstancesWithLoadBalancer
          extends Effect[
            io.github.vigoo.zioaws.elasticloadbalancing.model.RegisterInstancesWithLoadBalancerRequest,
            AwsError,
            io.github.vigoo.zioaws.elasticloadbalancing.model.RegisterInstancesWithLoadBalancerResponse.ReadOnly
          ]
      object DetachLoadBalancerFromSubnets
          extends Effect[
            io.github.vigoo.zioaws.elasticloadbalancing.model.DetachLoadBalancerFromSubnetsRequest,
            AwsError,
            io.github.vigoo.zioaws.elasticloadbalancing.model.DetachLoadBalancerFromSubnetsResponse.ReadOnly
          ]
      object DescribeAccountLimits
          extends Effect[
            io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeAccountLimitsRequest,
            AwsError,
            io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeAccountLimitsResponse.ReadOnly
          ]
      object CreateAppCookieStickinessPolicy
          extends Effect[
            io.github.vigoo.zioaws.elasticloadbalancing.model.CreateAppCookieStickinessPolicyRequest,
            AwsError,
            io.github.vigoo.zioaws.elasticloadbalancing.model.CreateAppCookieStickinessPolicyResponse.ReadOnly
          ]
      object ConfigureHealthCheck
          extends Effect[
            io.github.vigoo.zioaws.elasticloadbalancing.model.ConfigureHealthCheckRequest,
            AwsError,
            io.github.vigoo.zioaws.elasticloadbalancing.model.ConfigureHealthCheckResponse.ReadOnly
          ]
      object DeleteLoadBalancer
          extends Effect[
            io.github.vigoo.zioaws.elasticloadbalancing.model.DeleteLoadBalancerRequest,
            AwsError,
            io.github.vigoo.zioaws.elasticloadbalancing.model.DeleteLoadBalancerResponse.ReadOnly
          ]
      object RemoveTags
          extends Effect[
            io.github.vigoo.zioaws.elasticloadbalancing.model.RemoveTagsRequest,
            AwsError,
            io.github.vigoo.zioaws.elasticloadbalancing.model.RemoveTagsResponse.ReadOnly
          ]
      object DescribeLoadBalancerPolicyTypes
          extends Effect[
            io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeLoadBalancerPolicyTypesRequest,
            AwsError,
            io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeLoadBalancerPolicyTypesResponse.ReadOnly
          ]
      object AttachLoadBalancerToSubnets
          extends Effect[
            io.github.vigoo.zioaws.elasticloadbalancing.model.AttachLoadBalancerToSubnetsRequest,
            AwsError,
            io.github.vigoo.zioaws.elasticloadbalancing.model.AttachLoadBalancerToSubnetsResponse.ReadOnly
          ]
      object ModifyLoadBalancerAttributes
          extends Effect[
            io.github.vigoo.zioaws.elasticloadbalancing.model.ModifyLoadBalancerAttributesRequest,
            AwsError,
            ReadOnly
          ]
      object DeleteLoadBalancerListeners
          extends Effect[
            io.github.vigoo.zioaws.elasticloadbalancing.model.DeleteLoadBalancerListenersRequest,
            AwsError,
            io.github.vigoo.zioaws.elasticloadbalancing.model.DeleteLoadBalancerListenersResponse.ReadOnly
          ]
      object CreateLoadBalancerPolicy
          extends Effect[
            io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLoadBalancerPolicyRequest,
            AwsError,
            io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLoadBalancerPolicyResponse.ReadOnly
          ]
      object DescribeLoadBalancerPolicies
          extends Effect[
            io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeLoadBalancerPoliciesRequest,
            AwsError,
            io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeLoadBalancerPoliciesResponse.ReadOnly
          ]
      object DisableAvailabilityZonesForLoadBalancer
          extends Effect[
            io.github.vigoo.zioaws.elasticloadbalancing.model.DisableAvailabilityZonesForLoadBalancerRequest,
            AwsError,
            io.github.vigoo.zioaws.elasticloadbalancing.model.DisableAvailabilityZonesForLoadBalancerResponse.ReadOnly
          ]
      object DeregisterInstancesFromLoadBalancer
          extends Effect[
            io.github.vigoo.zioaws.elasticloadbalancing.model.DeregisterInstancesFromLoadBalancerRequest,
            AwsError,
            io.github.vigoo.zioaws.elasticloadbalancing.model.DeregisterInstancesFromLoadBalancerResponse.ReadOnly
          ]
      object SetLoadBalancerPoliciesOfListener
          extends Effect[
            io.github.vigoo.zioaws.elasticloadbalancing.model.SetLoadBalancerPoliciesOfListenerRequest,
            AwsError,
            io.github.vigoo.zioaws.elasticloadbalancing.model.SetLoadBalancerPoliciesOfListenerResponse.ReadOnly
          ]
      object ApplySecurityGroupsToLoadBalancer
          extends Effect[
            io.github.vigoo.zioaws.elasticloadbalancing.model.ApplySecurityGroupsToLoadBalancerRequest,
            AwsError,
            io.github.vigoo.zioaws.elasticloadbalancing.model.ApplySecurityGroupsToLoadBalancerResponse.ReadOnly
          ]
      object CreateLoadBalancer
          extends Effect[
            io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLoadBalancerRequest,
            AwsError,
            io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLoadBalancerResponse.ReadOnly
          ]
      object EnableAvailabilityZonesForLoadBalancer
          extends Effect[
            io.github.vigoo.zioaws.elasticloadbalancing.model.EnableAvailabilityZonesForLoadBalancerRequest,
            AwsError,
            io.github.vigoo.zioaws.elasticloadbalancing.model.EnableAvailabilityZonesForLoadBalancerResponse.ReadOnly
          ]
      object SetLoadBalancerListenerSSLCertificate
          extends Effect[
            io.github.vigoo.zioaws.elasticloadbalancing.model.SetLoadBalancerListenerSslCertificateRequest,
            AwsError,
            io.github.vigoo.zioaws.elasticloadbalancing.model.SetLoadBalancerListenerSslCertificateResponse.ReadOnly
          ]
      object DeleteLoadBalancerPolicy
          extends Effect[
            io.github.vigoo.zioaws.elasticloadbalancing.model.DeleteLoadBalancerPolicyRequest,
            AwsError,
            io.github.vigoo.zioaws.elasticloadbalancing.model.DeleteLoadBalancerPolicyResponse.ReadOnly
          ]
      object DescribeLoadBalancers
          extends Stream[
            io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeLoadBalancersRequest,
            AwsError,
            io.github.vigoo.zioaws.elasticloadbalancing.model.LoadBalancerDescription.ReadOnly
          ]
      val compose: URLayer[Has[Proxy], ElasticLoadBalancing] =
        ZLayer.fromServiceM { proxy =>
          withRuntime.map { rts =>
            new ElasticLoadBalancing.Service {
              val api: ElasticLoadBalancingAsyncClient = null
              def withAspect[R1](
                  newAspect: AwsCallAspect[R1],
                  r: R1
              ): ElasticLoadBalancing.Service = this
              def describeTags(
                  request: io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeTagsRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeTagsResponse.ReadOnly
              ] = proxy(DescribeTags, request)
              def createLoadBalancerListeners(
                  request: io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLoadBalancerListenersRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLoadBalancerListenersResponse.ReadOnly
              ] = proxy(CreateLoadBalancerListeners, request)
              def createLBCookieStickinessPolicy(
                  request: io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLbCookieStickinessPolicyRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLbCookieStickinessPolicyResponse.ReadOnly
              ] = proxy(CreateLBCookieStickinessPolicy, request)
              def describeLoadBalancerAttributes(
                  request: io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeLoadBalancerAttributesRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeLoadBalancerAttributesResponse.ReadOnly
              ] = proxy(DescribeLoadBalancerAttributes, request)
              def setLoadBalancerPoliciesForBackendServer(
                  request: io.github.vigoo.zioaws.elasticloadbalancing.model.SetLoadBalancerPoliciesForBackendServerRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.elasticloadbalancing.model.SetLoadBalancerPoliciesForBackendServerResponse.ReadOnly
              ] = proxy(SetLoadBalancerPoliciesForBackendServer, request)
              def describeInstanceHealth(
                  request: io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeInstanceHealthRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeInstanceHealthResponse.ReadOnly
              ] = proxy(DescribeInstanceHealth, request)
              def addTags(
                  request: io.github.vigoo.zioaws.elasticloadbalancing.model.AddTagsRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.elasticloadbalancing.model.AddTagsResponse.ReadOnly
              ] = proxy(AddTags, request)
              def registerInstancesWithLoadBalancer(
                  request: io.github.vigoo.zioaws.elasticloadbalancing.model.RegisterInstancesWithLoadBalancerRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.elasticloadbalancing.model.RegisterInstancesWithLoadBalancerResponse.ReadOnly
              ] = proxy(RegisterInstancesWithLoadBalancer, request)
              def detachLoadBalancerFromSubnets(
                  request: io.github.vigoo.zioaws.elasticloadbalancing.model.DetachLoadBalancerFromSubnetsRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.elasticloadbalancing.model.DetachLoadBalancerFromSubnetsResponse.ReadOnly
              ] = proxy(DetachLoadBalancerFromSubnets, request)
              def describeAccountLimits(
                  request: io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeAccountLimitsRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeAccountLimitsResponse.ReadOnly
              ] = proxy(DescribeAccountLimits, request)
              def createAppCookieStickinessPolicy(
                  request: io.github.vigoo.zioaws.elasticloadbalancing.model.CreateAppCookieStickinessPolicyRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.elasticloadbalancing.model.CreateAppCookieStickinessPolicyResponse.ReadOnly
              ] = proxy(CreateAppCookieStickinessPolicy, request)
              def configureHealthCheck(
                  request: io.github.vigoo.zioaws.elasticloadbalancing.model.ConfigureHealthCheckRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.elasticloadbalancing.model.ConfigureHealthCheckResponse.ReadOnly
              ] = proxy(ConfigureHealthCheck, request)
              def deleteLoadBalancer(
                  request: io.github.vigoo.zioaws.elasticloadbalancing.model.DeleteLoadBalancerRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.elasticloadbalancing.model.DeleteLoadBalancerResponse.ReadOnly
              ] = proxy(DeleteLoadBalancer, request)
              def removeTags(
                  request: io.github.vigoo.zioaws.elasticloadbalancing.model.RemoveTagsRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.elasticloadbalancing.model.RemoveTagsResponse.ReadOnly
              ] = proxy(RemoveTags, request)
              def describeLoadBalancerPolicyTypes(
                  request: io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeLoadBalancerPolicyTypesRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeLoadBalancerPolicyTypesResponse.ReadOnly
              ] = proxy(DescribeLoadBalancerPolicyTypes, request)
              def attachLoadBalancerToSubnets(
                  request: io.github.vigoo.zioaws.elasticloadbalancing.model.AttachLoadBalancerToSubnetsRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.elasticloadbalancing.model.AttachLoadBalancerToSubnetsResponse.ReadOnly
              ] = proxy(AttachLoadBalancerToSubnets, request)
              def modifyLoadBalancerAttributes(
                  request: io.github.vigoo.zioaws.elasticloadbalancing.model.ModifyLoadBalancerAttributesRequest
              ): IO[AwsError, ReadOnly] =
                proxy(ModifyLoadBalancerAttributes, request)
              def deleteLoadBalancerListeners(
                  request: io.github.vigoo.zioaws.elasticloadbalancing.model.DeleteLoadBalancerListenersRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.elasticloadbalancing.model.DeleteLoadBalancerListenersResponse.ReadOnly
              ] = proxy(DeleteLoadBalancerListeners, request)
              def createLoadBalancerPolicy(
                  request: io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLoadBalancerPolicyRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLoadBalancerPolicyResponse.ReadOnly
              ] = proxy(CreateLoadBalancerPolicy, request)
              def describeLoadBalancerPolicies(
                  request: io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeLoadBalancerPoliciesRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeLoadBalancerPoliciesResponse.ReadOnly
              ] = proxy(DescribeLoadBalancerPolicies, request)
              def disableAvailabilityZonesForLoadBalancer(
                  request: io.github.vigoo.zioaws.elasticloadbalancing.model.DisableAvailabilityZonesForLoadBalancerRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.elasticloadbalancing.model.DisableAvailabilityZonesForLoadBalancerResponse.ReadOnly
              ] = proxy(DisableAvailabilityZonesForLoadBalancer, request)
              def deregisterInstancesFromLoadBalancer(
                  request: io.github.vigoo.zioaws.elasticloadbalancing.model.DeregisterInstancesFromLoadBalancerRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.elasticloadbalancing.model.DeregisterInstancesFromLoadBalancerResponse.ReadOnly
              ] = proxy(DeregisterInstancesFromLoadBalancer, request)
              def setLoadBalancerPoliciesOfListener(
                  request: io.github.vigoo.zioaws.elasticloadbalancing.model.SetLoadBalancerPoliciesOfListenerRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.elasticloadbalancing.model.SetLoadBalancerPoliciesOfListenerResponse.ReadOnly
              ] = proxy(SetLoadBalancerPoliciesOfListener, request)
              def applySecurityGroupsToLoadBalancer(
                  request: io.github.vigoo.zioaws.elasticloadbalancing.model.ApplySecurityGroupsToLoadBalancerRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.elasticloadbalancing.model.ApplySecurityGroupsToLoadBalancerResponse.ReadOnly
              ] = proxy(ApplySecurityGroupsToLoadBalancer, request)
              def createLoadBalancer(
                  request: io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLoadBalancerRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLoadBalancerResponse.ReadOnly
              ] = proxy(CreateLoadBalancer, request)
              def enableAvailabilityZonesForLoadBalancer(
                  request: io.github.vigoo.zioaws.elasticloadbalancing.model.EnableAvailabilityZonesForLoadBalancerRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.elasticloadbalancing.model.EnableAvailabilityZonesForLoadBalancerResponse.ReadOnly
              ] = proxy(EnableAvailabilityZonesForLoadBalancer, request)
              def setLoadBalancerListenerSSLCertificate(
                  request: io.github.vigoo.zioaws.elasticloadbalancing.model.SetLoadBalancerListenerSslCertificateRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.elasticloadbalancing.model.SetLoadBalancerListenerSslCertificateResponse.ReadOnly
              ] = proxy(SetLoadBalancerListenerSSLCertificate, request)
              def deleteLoadBalancerPolicy(
                  request: io.github.vigoo.zioaws.elasticloadbalancing.model.DeleteLoadBalancerPolicyRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.elasticloadbalancing.model.DeleteLoadBalancerPolicyResponse.ReadOnly
              ] = proxy(DeleteLoadBalancerPolicy, request)
              def describeLoadBalancers(
                  request: io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeLoadBalancersRequest
              ): ZStream[
                Any,
                AwsError,
                io.github.vigoo.zioaws.elasticloadbalancing.model.LoadBalancerDescription.ReadOnly
              ] = rts.unsafeRun(proxy(DescribeLoadBalancers, request))
            }
          }
        }
    }
  }
  val live: ZLayer[AwsConfig, java.lang.Throwable, ElasticLoadBalancing] =
    customized(identity)
  def customized(
      customization: ElasticLoadBalancingAsyncClientBuilder => ElasticLoadBalancingAsyncClientBuilder
  ): ZLayer[AwsConfig, java.lang.Throwable, ElasticLoadBalancing] = managed(
    customization
  ).toLayer
  def managed(
      customization: ElasticLoadBalancingAsyncClientBuilder => ElasticLoadBalancingAsyncClientBuilder
  ): ZManaged[AwsConfig, java.lang.Throwable, ElasticLoadBalancing.Service] =
    for (
      awsConfig <- ZManaged.service[AwsConfig.Service];
      executor <- ZIO.executor.toManaged_;
      builder = ElasticLoadBalancingAsyncClient
        .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[
          ElasticLoadBalancingAsyncClient,
          ElasticLoadBalancingAsyncClientBuilder
        ](builder)
        .toManaged_;
      b1 <- awsConfig
        .configureHttpClient[
          ElasticLoadBalancingAsyncClient,
          ElasticLoadBalancingAsyncClientBuilder
        ](
          b0,
          io.github.vigoo.zioaws.core.httpclient
            .ServiceHttpCapabilities(supportsHttp2 = false)
        )
        .toManaged_; client <- zio.ZIO(customization(b1).build()).toManaged_
    )
      yield new ElasticLoadBalancingImpl(
        client,
        AwsCallAspect.identity,
        ().asInstanceOf[Any]
      )
  private class ElasticLoadBalancingImpl[R](
      override val api: ElasticLoadBalancingAsyncClient,
      override val aspect: AwsCallAspect[R],
      r: R
  ) extends ElasticLoadBalancing.Service
      with AwsServiceBase[R, ElasticLoadBalancingImpl] {
    override val serviceName: String = "ElasticLoadBalancing"
    override def withAspect[R1](
        newAspect: AwsCallAspect[R1],
        r: R1
    ): ElasticLoadBalancingImpl[R1] =
      new ElasticLoadBalancingImpl(api, newAspect, r)
    def describeTags(
        request: io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeTagsRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeTagsResponse.ReadOnly
    ] = asyncRequestResponse[DescribeTagsRequest, DescribeTagsResponse](
      "describeTags",
      api.describeTags
    )(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeTagsResponse.wrap
      )
      .provide(r)
    def createLoadBalancerListeners(
        request: io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLoadBalancerListenersRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLoadBalancerListenersResponse.ReadOnly
    ] = asyncRequestResponse[
      CreateLoadBalancerListenersRequest,
      CreateLoadBalancerListenersResponse
    ]("createLoadBalancerListeners", api.createLoadBalancerListeners)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLoadBalancerListenersResponse.wrap
    ).provide(r)
    def createLBCookieStickinessPolicy(
        request: io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLbCookieStickinessPolicyRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLbCookieStickinessPolicyResponse.ReadOnly
    ] = asyncRequestResponse[
      CreateLbCookieStickinessPolicyRequest,
      CreateLbCookieStickinessPolicyResponse
    ]("createLBCookieStickinessPolicy", api.createLBCookieStickinessPolicy)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLbCookieStickinessPolicyResponse.wrap
    ).provide(r)
    def describeLoadBalancerAttributes(
        request: io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeLoadBalancerAttributesRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeLoadBalancerAttributesResponse.ReadOnly
    ] = asyncRequestResponse[
      DescribeLoadBalancerAttributesRequest,
      DescribeLoadBalancerAttributesResponse
    ]("describeLoadBalancerAttributes", api.describeLoadBalancerAttributes)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeLoadBalancerAttributesResponse.wrap
    ).provide(r)
    def setLoadBalancerPoliciesForBackendServer(
        request: io.github.vigoo.zioaws.elasticloadbalancing.model.SetLoadBalancerPoliciesForBackendServerRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.elasticloadbalancing.model.SetLoadBalancerPoliciesForBackendServerResponse.ReadOnly
    ] = asyncRequestResponse[
      SetLoadBalancerPoliciesForBackendServerRequest,
      SetLoadBalancerPoliciesForBackendServerResponse
    ](
      "setLoadBalancerPoliciesForBackendServer",
      api.setLoadBalancerPoliciesForBackendServer
    )(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.elasticloadbalancing.model.SetLoadBalancerPoliciesForBackendServerResponse.wrap
      )
      .provide(r)
    def describeInstanceHealth(
        request: io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeInstanceHealthRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeInstanceHealthResponse.ReadOnly
    ] = asyncRequestResponse[
      DescribeInstanceHealthRequest,
      DescribeInstanceHealthResponse
    ]("describeInstanceHealth", api.describeInstanceHealth)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeInstanceHealthResponse.wrap
    ).provide(r)
    def addTags(
        request: io.github.vigoo.zioaws.elasticloadbalancing.model.AddTagsRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.elasticloadbalancing.model.AddTagsResponse.ReadOnly
    ] = asyncRequestResponse[AddTagsRequest, AddTagsResponse](
      "addTags",
      api.addTags
    )(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.elasticloadbalancing.model.AddTagsResponse.wrap
      )
      .provide(r)
    def registerInstancesWithLoadBalancer(
        request: io.github.vigoo.zioaws.elasticloadbalancing.model.RegisterInstancesWithLoadBalancerRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.elasticloadbalancing.model.RegisterInstancesWithLoadBalancerResponse.ReadOnly
    ] = asyncRequestResponse[
      RegisterInstancesWithLoadBalancerRequest,
      RegisterInstancesWithLoadBalancerResponse
    ](
      "registerInstancesWithLoadBalancer",
      api.registerInstancesWithLoadBalancer
    )(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.elasticloadbalancing.model.RegisterInstancesWithLoadBalancerResponse.wrap
      )
      .provide(r)
    def detachLoadBalancerFromSubnets(
        request: io.github.vigoo.zioaws.elasticloadbalancing.model.DetachLoadBalancerFromSubnetsRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.elasticloadbalancing.model.DetachLoadBalancerFromSubnetsResponse.ReadOnly
    ] = asyncRequestResponse[
      DetachLoadBalancerFromSubnetsRequest,
      DetachLoadBalancerFromSubnetsResponse
    ]("detachLoadBalancerFromSubnets", api.detachLoadBalancerFromSubnets)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.elasticloadbalancing.model.DetachLoadBalancerFromSubnetsResponse.wrap
    ).provide(r)
    def describeAccountLimits(
        request: io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeAccountLimitsRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeAccountLimitsResponse.ReadOnly
    ] = asyncRequestResponse[
      DescribeAccountLimitsRequest,
      DescribeAccountLimitsResponse
    ]("describeAccountLimits", api.describeAccountLimits)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeAccountLimitsResponse.wrap
    ).provide(r)
    def createAppCookieStickinessPolicy(
        request: io.github.vigoo.zioaws.elasticloadbalancing.model.CreateAppCookieStickinessPolicyRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.elasticloadbalancing.model.CreateAppCookieStickinessPolicyResponse.ReadOnly
    ] = asyncRequestResponse[
      CreateAppCookieStickinessPolicyRequest,
      CreateAppCookieStickinessPolicyResponse
    ]("createAppCookieStickinessPolicy", api.createAppCookieStickinessPolicy)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.elasticloadbalancing.model.CreateAppCookieStickinessPolicyResponse.wrap
    ).provide(r)
    def configureHealthCheck(
        request: io.github.vigoo.zioaws.elasticloadbalancing.model.ConfigureHealthCheckRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.elasticloadbalancing.model.ConfigureHealthCheckResponse.ReadOnly
    ] = asyncRequestResponse[
      ConfigureHealthCheckRequest,
      ConfigureHealthCheckResponse
    ]("configureHealthCheck", api.configureHealthCheck)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.elasticloadbalancing.model.ConfigureHealthCheckResponse.wrap
      )
      .provide(r)
    def deleteLoadBalancer(
        request: io.github.vigoo.zioaws.elasticloadbalancing.model.DeleteLoadBalancerRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.elasticloadbalancing.model.DeleteLoadBalancerResponse.ReadOnly
    ] = asyncRequestResponse[
      DeleteLoadBalancerRequest,
      DeleteLoadBalancerResponse
    ]("deleteLoadBalancer", api.deleteLoadBalancer)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.elasticloadbalancing.model.DeleteLoadBalancerResponse.wrap
      )
      .provide(r)
    def removeTags(
        request: io.github.vigoo.zioaws.elasticloadbalancing.model.RemoveTagsRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.elasticloadbalancing.model.RemoveTagsResponse.ReadOnly
    ] = asyncRequestResponse[RemoveTagsRequest, RemoveTagsResponse](
      "removeTags",
      api.removeTags
    )(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.elasticloadbalancing.model.RemoveTagsResponse.wrap
      )
      .provide(r)
    def describeLoadBalancerPolicyTypes(
        request: io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeLoadBalancerPolicyTypesRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeLoadBalancerPolicyTypesResponse.ReadOnly
    ] = asyncRequestResponse[
      DescribeLoadBalancerPolicyTypesRequest,
      DescribeLoadBalancerPolicyTypesResponse
    ]("describeLoadBalancerPolicyTypes", api.describeLoadBalancerPolicyTypes)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeLoadBalancerPolicyTypesResponse.wrap
    ).provide(r)
    def attachLoadBalancerToSubnets(
        request: io.github.vigoo.zioaws.elasticloadbalancing.model.AttachLoadBalancerToSubnetsRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.elasticloadbalancing.model.AttachLoadBalancerToSubnetsResponse.ReadOnly
    ] = asyncRequestResponse[
      AttachLoadBalancerToSubnetsRequest,
      AttachLoadBalancerToSubnetsResponse
    ]("attachLoadBalancerToSubnets", api.attachLoadBalancerToSubnets)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.elasticloadbalancing.model.AttachLoadBalancerToSubnetsResponse.wrap
    ).provide(r)
    def modifyLoadBalancerAttributes(
        request: io.github.vigoo.zioaws.elasticloadbalancing.model.ModifyLoadBalancerAttributesRequest
    ): IO[AwsError, ReadOnly] = asyncRequestResponse[
      ModifyLoadBalancerAttributesRequest,
      ModifyLoadBalancerAttributesResponse
    ]("modifyLoadBalancerAttributes", api.modifyLoadBalancerAttributes)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.elasticloadbalancing.model.ModifyLoadBalancerAttributesResponse.wrap
    ).provide(r)
    def deleteLoadBalancerListeners(
        request: io.github.vigoo.zioaws.elasticloadbalancing.model.DeleteLoadBalancerListenersRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.elasticloadbalancing.model.DeleteLoadBalancerListenersResponse.ReadOnly
    ] = asyncRequestResponse[
      DeleteLoadBalancerListenersRequest,
      DeleteLoadBalancerListenersResponse
    ]("deleteLoadBalancerListeners", api.deleteLoadBalancerListeners)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.elasticloadbalancing.model.DeleteLoadBalancerListenersResponse.wrap
    ).provide(r)
    def createLoadBalancerPolicy(
        request: io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLoadBalancerPolicyRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLoadBalancerPolicyResponse.ReadOnly
    ] = asyncRequestResponse[
      CreateLoadBalancerPolicyRequest,
      CreateLoadBalancerPolicyResponse
    ]("createLoadBalancerPolicy", api.createLoadBalancerPolicy)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLoadBalancerPolicyResponse.wrap
    ).provide(r)
    def describeLoadBalancerPolicies(
        request: io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeLoadBalancerPoliciesRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeLoadBalancerPoliciesResponse.ReadOnly
    ] = asyncRequestResponse[
      DescribeLoadBalancerPoliciesRequest,
      DescribeLoadBalancerPoliciesResponse
    ]("describeLoadBalancerPolicies", api.describeLoadBalancerPolicies)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeLoadBalancerPoliciesResponse.wrap
    ).provide(r)
    def disableAvailabilityZonesForLoadBalancer(
        request: io.github.vigoo.zioaws.elasticloadbalancing.model.DisableAvailabilityZonesForLoadBalancerRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.elasticloadbalancing.model.DisableAvailabilityZonesForLoadBalancerResponse.ReadOnly
    ] = asyncRequestResponse[
      DisableAvailabilityZonesForLoadBalancerRequest,
      DisableAvailabilityZonesForLoadBalancerResponse
    ](
      "disableAvailabilityZonesForLoadBalancer",
      api.disableAvailabilityZonesForLoadBalancer
    )(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.elasticloadbalancing.model.DisableAvailabilityZonesForLoadBalancerResponse.wrap
      )
      .provide(r)
    def deregisterInstancesFromLoadBalancer(
        request: io.github.vigoo.zioaws.elasticloadbalancing.model.DeregisterInstancesFromLoadBalancerRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.elasticloadbalancing.model.DeregisterInstancesFromLoadBalancerResponse.ReadOnly
    ] = asyncRequestResponse[
      DeregisterInstancesFromLoadBalancerRequest,
      DeregisterInstancesFromLoadBalancerResponse
    ](
      "deregisterInstancesFromLoadBalancer",
      api.deregisterInstancesFromLoadBalancer
    )(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.elasticloadbalancing.model.DeregisterInstancesFromLoadBalancerResponse.wrap
      )
      .provide(r)
    def setLoadBalancerPoliciesOfListener(
        request: io.github.vigoo.zioaws.elasticloadbalancing.model.SetLoadBalancerPoliciesOfListenerRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.elasticloadbalancing.model.SetLoadBalancerPoliciesOfListenerResponse.ReadOnly
    ] = asyncRequestResponse[
      SetLoadBalancerPoliciesOfListenerRequest,
      SetLoadBalancerPoliciesOfListenerResponse
    ](
      "setLoadBalancerPoliciesOfListener",
      api.setLoadBalancerPoliciesOfListener
    )(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.elasticloadbalancing.model.SetLoadBalancerPoliciesOfListenerResponse.wrap
      )
      .provide(r)
    def applySecurityGroupsToLoadBalancer(
        request: io.github.vigoo.zioaws.elasticloadbalancing.model.ApplySecurityGroupsToLoadBalancerRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.elasticloadbalancing.model.ApplySecurityGroupsToLoadBalancerResponse.ReadOnly
    ] = asyncRequestResponse[
      ApplySecurityGroupsToLoadBalancerRequest,
      ApplySecurityGroupsToLoadBalancerResponse
    ](
      "applySecurityGroupsToLoadBalancer",
      api.applySecurityGroupsToLoadBalancer
    )(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.elasticloadbalancing.model.ApplySecurityGroupsToLoadBalancerResponse.wrap
      )
      .provide(r)
    def createLoadBalancer(
        request: io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLoadBalancerRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLoadBalancerResponse.ReadOnly
    ] = asyncRequestResponse[
      CreateLoadBalancerRequest,
      CreateLoadBalancerResponse
    ]("createLoadBalancer", api.createLoadBalancer)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLoadBalancerResponse.wrap
      )
      .provide(r)
    def enableAvailabilityZonesForLoadBalancer(
        request: io.github.vigoo.zioaws.elasticloadbalancing.model.EnableAvailabilityZonesForLoadBalancerRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.elasticloadbalancing.model.EnableAvailabilityZonesForLoadBalancerResponse.ReadOnly
    ] = asyncRequestResponse[
      EnableAvailabilityZonesForLoadBalancerRequest,
      EnableAvailabilityZonesForLoadBalancerResponse
    ](
      "enableAvailabilityZonesForLoadBalancer",
      api.enableAvailabilityZonesForLoadBalancer
    )(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.elasticloadbalancing.model.EnableAvailabilityZonesForLoadBalancerResponse.wrap
      )
      .provide(r)
    def setLoadBalancerListenerSSLCertificate(
        request: io.github.vigoo.zioaws.elasticloadbalancing.model.SetLoadBalancerListenerSslCertificateRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.elasticloadbalancing.model.SetLoadBalancerListenerSslCertificateResponse.ReadOnly
    ] = asyncRequestResponse[
      SetLoadBalancerListenerSslCertificateRequest,
      SetLoadBalancerListenerSslCertificateResponse
    ](
      "setLoadBalancerListenerSSLCertificate",
      api.setLoadBalancerListenerSSLCertificate
    )(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.elasticloadbalancing.model.SetLoadBalancerListenerSslCertificateResponse.wrap
      )
      .provide(r)
    def deleteLoadBalancerPolicy(
        request: io.github.vigoo.zioaws.elasticloadbalancing.model.DeleteLoadBalancerPolicyRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.elasticloadbalancing.model.DeleteLoadBalancerPolicyResponse.ReadOnly
    ] = asyncRequestResponse[
      DeleteLoadBalancerPolicyRequest,
      DeleteLoadBalancerPolicyResponse
    ]("deleteLoadBalancerPolicy", api.deleteLoadBalancerPolicy)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.elasticloadbalancing.model.DeleteLoadBalancerPolicyResponse.wrap
    ).provide(r)
    def describeLoadBalancers(
        request: io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeLoadBalancersRequest
    ): ZStream[
      Any,
      AwsError,
      io.github.vigoo.zioaws.elasticloadbalancing.model.LoadBalancerDescription.ReadOnly
    ] = asyncJavaPaginatedRequest[
      DescribeLoadBalancersRequest,
      LoadBalancerDescription,
      DescribeLoadBalancersPublisher
    ](
      "describeLoadBalancers",
      api.describeLoadBalancersPaginator,
      _.loadBalancerDescriptions()
    )(request.buildAwsValue())
      .map(item =>
        io.github.vigoo.zioaws.elasticloadbalancing.model.LoadBalancerDescription
          .wrap(item)
      )
      .provide(r)
  }
  def describeTags(
      request: io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeTagsRequest
  ): ZIO[
    ElasticLoadBalancing,
    AwsError,
    io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeTagsResponse.ReadOnly
  ] = ZIO.accessM(_.get.describeTags(request))
  def createLoadBalancerListeners(
      request: io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLoadBalancerListenersRequest
  ): ZIO[
    ElasticLoadBalancing,
    AwsError,
    io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLoadBalancerListenersResponse.ReadOnly
  ] = ZIO.accessM(_.get.createLoadBalancerListeners(request))
  def createLBCookieStickinessPolicy(
      request: io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLbCookieStickinessPolicyRequest
  ): ZIO[
    ElasticLoadBalancing,
    AwsError,
    io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLbCookieStickinessPolicyResponse.ReadOnly
  ] = ZIO.accessM(_.get.createLBCookieStickinessPolicy(request))
  def describeLoadBalancerAttributes(
      request: io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeLoadBalancerAttributesRequest
  ): ZIO[
    ElasticLoadBalancing,
    AwsError,
    io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeLoadBalancerAttributesResponse.ReadOnly
  ] = ZIO.accessM(_.get.describeLoadBalancerAttributes(request))
  def setLoadBalancerPoliciesForBackendServer(
      request: io.github.vigoo.zioaws.elasticloadbalancing.model.SetLoadBalancerPoliciesForBackendServerRequest
  ): ZIO[
    ElasticLoadBalancing,
    AwsError,
    io.github.vigoo.zioaws.elasticloadbalancing.model.SetLoadBalancerPoliciesForBackendServerResponse.ReadOnly
  ] = ZIO.accessM(_.get.setLoadBalancerPoliciesForBackendServer(request))
  def describeInstanceHealth(
      request: io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeInstanceHealthRequest
  ): ZIO[
    ElasticLoadBalancing,
    AwsError,
    io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeInstanceHealthResponse.ReadOnly
  ] = ZIO.accessM(_.get.describeInstanceHealth(request))
  def addTags(
      request: io.github.vigoo.zioaws.elasticloadbalancing.model.AddTagsRequest
  ): ZIO[
    ElasticLoadBalancing,
    AwsError,
    io.github.vigoo.zioaws.elasticloadbalancing.model.AddTagsResponse.ReadOnly
  ] = ZIO.accessM(_.get.addTags(request))
  def registerInstancesWithLoadBalancer(
      request: io.github.vigoo.zioaws.elasticloadbalancing.model.RegisterInstancesWithLoadBalancerRequest
  ): ZIO[
    ElasticLoadBalancing,
    AwsError,
    io.github.vigoo.zioaws.elasticloadbalancing.model.RegisterInstancesWithLoadBalancerResponse.ReadOnly
  ] = ZIO.accessM(_.get.registerInstancesWithLoadBalancer(request))
  def detachLoadBalancerFromSubnets(
      request: io.github.vigoo.zioaws.elasticloadbalancing.model.DetachLoadBalancerFromSubnetsRequest
  ): ZIO[
    ElasticLoadBalancing,
    AwsError,
    io.github.vigoo.zioaws.elasticloadbalancing.model.DetachLoadBalancerFromSubnetsResponse.ReadOnly
  ] = ZIO.accessM(_.get.detachLoadBalancerFromSubnets(request))
  def describeAccountLimits(
      request: io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeAccountLimitsRequest
  ): ZIO[
    ElasticLoadBalancing,
    AwsError,
    io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeAccountLimitsResponse.ReadOnly
  ] = ZIO.accessM(_.get.describeAccountLimits(request))
  def createAppCookieStickinessPolicy(
      request: io.github.vigoo.zioaws.elasticloadbalancing.model.CreateAppCookieStickinessPolicyRequest
  ): ZIO[
    ElasticLoadBalancing,
    AwsError,
    io.github.vigoo.zioaws.elasticloadbalancing.model.CreateAppCookieStickinessPolicyResponse.ReadOnly
  ] = ZIO.accessM(_.get.createAppCookieStickinessPolicy(request))
  def configureHealthCheck(
      request: io.github.vigoo.zioaws.elasticloadbalancing.model.ConfigureHealthCheckRequest
  ): ZIO[
    ElasticLoadBalancing,
    AwsError,
    io.github.vigoo.zioaws.elasticloadbalancing.model.ConfigureHealthCheckResponse.ReadOnly
  ] = ZIO.accessM(_.get.configureHealthCheck(request))
  def deleteLoadBalancer(
      request: io.github.vigoo.zioaws.elasticloadbalancing.model.DeleteLoadBalancerRequest
  ): ZIO[
    ElasticLoadBalancing,
    AwsError,
    io.github.vigoo.zioaws.elasticloadbalancing.model.DeleteLoadBalancerResponse.ReadOnly
  ] = ZIO.accessM(_.get.deleteLoadBalancer(request))
  def removeTags(
      request: io.github.vigoo.zioaws.elasticloadbalancing.model.RemoveTagsRequest
  ): ZIO[
    ElasticLoadBalancing,
    AwsError,
    io.github.vigoo.zioaws.elasticloadbalancing.model.RemoveTagsResponse.ReadOnly
  ] = ZIO.accessM(_.get.removeTags(request))
  def describeLoadBalancerPolicyTypes(
      request: io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeLoadBalancerPolicyTypesRequest
  ): ZIO[
    ElasticLoadBalancing,
    AwsError,
    io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeLoadBalancerPolicyTypesResponse.ReadOnly
  ] = ZIO.accessM(_.get.describeLoadBalancerPolicyTypes(request))
  def attachLoadBalancerToSubnets(
      request: io.github.vigoo.zioaws.elasticloadbalancing.model.AttachLoadBalancerToSubnetsRequest
  ): ZIO[
    ElasticLoadBalancing,
    AwsError,
    io.github.vigoo.zioaws.elasticloadbalancing.model.AttachLoadBalancerToSubnetsResponse.ReadOnly
  ] = ZIO.accessM(_.get.attachLoadBalancerToSubnets(request))
  def modifyLoadBalancerAttributes(
      request: io.github.vigoo.zioaws.elasticloadbalancing.model.ModifyLoadBalancerAttributesRequest
  ): ZIO[ElasticLoadBalancing, AwsError, ReadOnly] =
    ZIO.accessM(_.get.modifyLoadBalancerAttributes(request))
  def deleteLoadBalancerListeners(
      request: io.github.vigoo.zioaws.elasticloadbalancing.model.DeleteLoadBalancerListenersRequest
  ): ZIO[
    ElasticLoadBalancing,
    AwsError,
    io.github.vigoo.zioaws.elasticloadbalancing.model.DeleteLoadBalancerListenersResponse.ReadOnly
  ] = ZIO.accessM(_.get.deleteLoadBalancerListeners(request))
  def createLoadBalancerPolicy(
      request: io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLoadBalancerPolicyRequest
  ): ZIO[
    ElasticLoadBalancing,
    AwsError,
    io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLoadBalancerPolicyResponse.ReadOnly
  ] = ZIO.accessM(_.get.createLoadBalancerPolicy(request))
  def describeLoadBalancerPolicies(
      request: io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeLoadBalancerPoliciesRequest
  ): ZIO[
    ElasticLoadBalancing,
    AwsError,
    io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeLoadBalancerPoliciesResponse.ReadOnly
  ] = ZIO.accessM(_.get.describeLoadBalancerPolicies(request))
  def disableAvailabilityZonesForLoadBalancer(
      request: io.github.vigoo.zioaws.elasticloadbalancing.model.DisableAvailabilityZonesForLoadBalancerRequest
  ): ZIO[
    ElasticLoadBalancing,
    AwsError,
    io.github.vigoo.zioaws.elasticloadbalancing.model.DisableAvailabilityZonesForLoadBalancerResponse.ReadOnly
  ] = ZIO.accessM(_.get.disableAvailabilityZonesForLoadBalancer(request))
  def deregisterInstancesFromLoadBalancer(
      request: io.github.vigoo.zioaws.elasticloadbalancing.model.DeregisterInstancesFromLoadBalancerRequest
  ): ZIO[
    ElasticLoadBalancing,
    AwsError,
    io.github.vigoo.zioaws.elasticloadbalancing.model.DeregisterInstancesFromLoadBalancerResponse.ReadOnly
  ] = ZIO.accessM(_.get.deregisterInstancesFromLoadBalancer(request))
  def setLoadBalancerPoliciesOfListener(
      request: io.github.vigoo.zioaws.elasticloadbalancing.model.SetLoadBalancerPoliciesOfListenerRequest
  ): ZIO[
    ElasticLoadBalancing,
    AwsError,
    io.github.vigoo.zioaws.elasticloadbalancing.model.SetLoadBalancerPoliciesOfListenerResponse.ReadOnly
  ] = ZIO.accessM(_.get.setLoadBalancerPoliciesOfListener(request))
  def applySecurityGroupsToLoadBalancer(
      request: io.github.vigoo.zioaws.elasticloadbalancing.model.ApplySecurityGroupsToLoadBalancerRequest
  ): ZIO[
    ElasticLoadBalancing,
    AwsError,
    io.github.vigoo.zioaws.elasticloadbalancing.model.ApplySecurityGroupsToLoadBalancerResponse.ReadOnly
  ] = ZIO.accessM(_.get.applySecurityGroupsToLoadBalancer(request))
  def createLoadBalancer(
      request: io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLoadBalancerRequest
  ): ZIO[
    ElasticLoadBalancing,
    AwsError,
    io.github.vigoo.zioaws.elasticloadbalancing.model.CreateLoadBalancerResponse.ReadOnly
  ] = ZIO.accessM(_.get.createLoadBalancer(request))
  def enableAvailabilityZonesForLoadBalancer(
      request: io.github.vigoo.zioaws.elasticloadbalancing.model.EnableAvailabilityZonesForLoadBalancerRequest
  ): ZIO[
    ElasticLoadBalancing,
    AwsError,
    io.github.vigoo.zioaws.elasticloadbalancing.model.EnableAvailabilityZonesForLoadBalancerResponse.ReadOnly
  ] = ZIO.accessM(_.get.enableAvailabilityZonesForLoadBalancer(request))
  def setLoadBalancerListenerSSLCertificate(
      request: io.github.vigoo.zioaws.elasticloadbalancing.model.SetLoadBalancerListenerSslCertificateRequest
  ): ZIO[
    ElasticLoadBalancing,
    AwsError,
    io.github.vigoo.zioaws.elasticloadbalancing.model.SetLoadBalancerListenerSslCertificateResponse.ReadOnly
  ] = ZIO.accessM(_.get.setLoadBalancerListenerSSLCertificate(request))
  def deleteLoadBalancerPolicy(
      request: io.github.vigoo.zioaws.elasticloadbalancing.model.DeleteLoadBalancerPolicyRequest
  ): ZIO[
    ElasticLoadBalancing,
    AwsError,
    io.github.vigoo.zioaws.elasticloadbalancing.model.DeleteLoadBalancerPolicyResponse.ReadOnly
  ] = ZIO.accessM(_.get.deleteLoadBalancerPolicy(request))
  def describeLoadBalancers(
      request: io.github.vigoo.zioaws.elasticloadbalancing.model.DescribeLoadBalancersRequest
  ): ZStream[
    ElasticLoadBalancing,
    AwsError,
    io.github.vigoo.zioaws.elasticloadbalancing.model.LoadBalancerDescription.ReadOnly
  ] = ZStream.accessStream(_.get.describeLoadBalancers(request))
}