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