• Home
• io.github.vigoo
• zio-aws-route53resolver_2.13
• 4.0.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.route53resolver.package.scala Maven / Gradle / Ivy

package io.github.vigoo.zioaws
import io.github.vigoo.zioaws.route53resolver.model.PutFirewallRuleGroupPolicyResponse.ReadOnly
import io.github.vigoo.zioaws.route53resolver.model.{
  DeleteFirewallDomainListRequest,
  AssociateResolverRuleRequest,
  ListFirewallConfigsRequest,
  DeleteResolverEndpointRequest,
  GetResolverQueryLogConfigPolicyRequest,
  UpdateFirewallDomainsRequest,
  ListFirewallDomainsRequest,
  ListResolverEndpointsRequest,
  AssociateResolverEndpointIpAddressRequest,
  AssociateFirewallRuleGroupRequest,
  ListFirewallRulesRequest,
  GetResolverRulePolicyRequest,
  GetResolverConfigRequest,
  ListResolverEndpointIpAddressesRequest,
  DisassociateResolverQueryLogConfigRequest,
  UpdateResolverConfigRequest,
  PutFirewallRuleGroupPolicyRequest,
  ListResolverQueryLogConfigAssociationsRequest,
  PutResolverRulePolicyRequest,
  DisassociateResolverEndpointIpAddressRequest,
  CreateResolverQueryLogConfigRequest,
  DisassociateFirewallRuleGroupRequest,
  GetResolverQueryLogConfigAssociationRequest,
  ListTagsForResourceRequest,
  PutResolverQueryLogConfigPolicyRequest,
  ListFirewallRuleGroupsRequest,
  DeleteResolverRuleRequest,
  UpdateResolverEndpointRequest,
  GetResolverEndpointRequest,
  CreateResolverEndpointRequest,
  UpdateFirewallRuleGroupAssociationRequest,
  GetResolverRuleAssociationRequest,
  ListResolverConfigsRequest,
  UpdateFirewallRuleRequest,
  ImportFirewallDomainsRequest,
  ListFirewallRuleGroupAssociationsRequest,
  GetFirewallRuleGroupPolicyRequest,
  GetResolverDnssecConfigRequest,
  ListResolverRuleAssociationsRequest,
  CreateFirewallRuleRequest,
  DeleteFirewallRuleRequest,
  DeleteFirewallRuleGroupRequest,
  CreateFirewallDomainListRequest,
  UntagResourceRequest,
  DisassociateResolverRuleRequest,
  ListFirewallDomainListsRequest,
  CreateFirewallRuleGroupRequest,
  UpdateResolverDnssecConfigRequest,
  AssociateResolverQueryLogConfigRequest,
  GetFirewallConfigRequest,
  ListResolverRulesRequest,
  ListResolverQueryLogConfigsRequest,
  UpdateFirewallConfigRequest,
  GetFirewallDomainListRequest,
  GetFirewallRuleGroupAssociationRequest,
  GetResolverRuleRequest,
  TagResourceRequest,
  CreateResolverRuleRequest,
  GetResolverQueryLogConfigRequest,
  GetFirewallRuleGroupRequest,
  ListResolverDnssecConfigsRequest,
  DeleteResolverQueryLogConfigRequest,
  UpdateResolverRuleRequest
}
import io.github.vigoo.zioaws.route53resolver.Route53Resolver
import software.amazon.awssdk.services.route53resolver.{
  Route53ResolverAsyncClientBuilder,
  Route53ResolverAsyncClient
}
import io.github.vigoo.zioaws.core.{
  AwsServiceBase,
  StreamingOutputResult,
  AwsError
}
import software.amazon.awssdk.services.route53resolver.model.{
  ListResolverQueryLogConfigAssociationsResponse,
  ResolverDnssecConfig,
  FirewallDomainListMetadata,
  GetFirewallRuleGroupPolicyResponse,
  GetResolverQueryLogConfigResponse,
  ListFirewallRuleGroupAssociationsResponse,
  ResolverConfig,
  ListFirewallRuleGroupsResponse,
  AssociateResolverEndpointIpAddressResponse,
  IpAddressResponse,
  DeleteFirewallDomainListResponse,
  ResolverQueryLogConfigAssociation,
  GetFirewallRuleGroupAssociationResponse,
  ResolverEndpoint,
  CreateFirewallRuleGroupResponse,
  DisassociateFirewallRuleGroupResponse,
  ImportFirewallDomainsResponse,
  UpdateFirewallConfigResponse,
  ListFirewallRulesResponse,
  UpdateResolverRuleResponse,
  DeleteFirewallRuleGroupResponse,
  DisassociateResolverRuleResponse,
  FirewallRuleGroupAssociation,
  GetResolverRuleResponse,
  PutResolverQueryLogConfigPolicyResponse,
  Tag,
  UpdateResolverEndpointResponse,
  UpdateResolverConfigResponse,
  ResolverQueryLogConfig,
  ResolverRule,
  AssociateResolverQueryLogConfigResponse,
  GetFirewallConfigResponse,
  ListResolverDnssecConfigsResponse,
  GetResolverRulePolicyResponse,
  ListTagsForResourceResponse,
  CreateResolverEndpointResponse,
  UntagResourceResponse,
  CreateFirewallDomainListResponse,
  AssociateFirewallRuleGroupResponse,
  PutFirewallRuleGroupPolicyResponse,
  GetResolverConfigResponse,
  ResolverRuleAssociation,
  DisassociateResolverEndpointIpAddressResponse,
  GetResolverEndpointResponse,
  ListResolverRulesResponse,
  ListResolverQueryLogConfigsResponse,
  FirewallRuleGroupMetadata,
  UpdateFirewallDomainsResponse,
  DeleteResolverRuleResponse,
  CreateResolverRuleResponse,
  FirewallConfig,
  GetResolverQueryLogConfigAssociationResponse,
  AssociateResolverRuleResponse,
  ListResolverRuleAssociationsResponse,
  UpdateResolverDnssecConfigResponse,
  ListFirewallDomainListsResponse,
  DisassociateResolverQueryLogConfigResponse,
  ListFirewallConfigsResponse,
  CreateFirewallRuleResponse,
  ListResolverConfigsResponse,
  UpdateFirewallRuleGroupAssociationResponse,
  GetFirewallDomainListResponse,
  CreateResolverQueryLogConfigResponse,
  DeleteFirewallRuleResponse,
  GetFirewallRuleGroupResponse,
  DeleteResolverEndpointResponse,
  TagResourceResponse,
  GetResolverDnssecConfigResponse,
  DeleteResolverQueryLogConfigResponse,
  GetResolverQueryLogConfigPolicyResponse,
  ListFirewallDomainsResponse,
  UpdateFirewallRuleResponse,
  GetResolverRuleAssociationResponse,
  PutResolverRulePolicyResponse,
  FirewallRule,
  ListResolverEndpointIpAddressesResponse,
  ListResolverEndpointsResponse
}
import io.github.vigoo.zioaws.route53resolver.model.primitives.FirewallDomainName
import io.github.vigoo.zioaws.core.config.AwsConfig
import zio.{ZManaged, IO, ZIO, ZLayer, URLayer, Has}
import io.github.vigoo.zioaws.core.aspects.{AwsCallAspect, AspectSupport}
import zio.stream.ZStream
import zio.test.mock.{Proxy, Mock}
package object route53resolver {
  import scala.jdk.CollectionConverters._
  type Route53Resolver = Has[Route53Resolver.Service]
  object Route53Resolver {
    trait Service extends AspectSupport[Service] {
      val api: Route53ResolverAsyncClient
      def updateFirewallConfig(request: UpdateFirewallConfigRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.UpdateFirewallConfigResponse.ReadOnly
      ]
      def deleteFirewallRuleGroup(request: DeleteFirewallRuleGroupRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.DeleteFirewallRuleGroupResponse.ReadOnly
      ]
      def listFirewallDomainLists(
          request: ListFirewallDomainListsRequest
      ): ZStream[
        Any,
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.FirewallDomainListMetadata.ReadOnly
      ]
      def deleteResolverQueryLogConfig(
          request: DeleteResolverQueryLogConfigRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.DeleteResolverQueryLogConfigResponse.ReadOnly
      ]
      def getResolverQueryLogConfig(
          request: GetResolverQueryLogConfigRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.GetResolverQueryLogConfigResponse.ReadOnly
      ]
      def createFirewallRule(request: CreateFirewallRuleRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.CreateFirewallRuleResponse.ReadOnly
      ]
      def updateResolverConfig(request: UpdateResolverConfigRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.UpdateResolverConfigResponse.ReadOnly
      ]
      def listResolverEndpointIpAddresses(
          request: ListResolverEndpointIpAddressesRequest
      ): ZIO[Any, AwsError, StreamingOutputResult[
        Any,
        io.github.vigoo.zioaws.route53resolver.model.ListResolverEndpointIpAddressesResponse.ReadOnly,
        io.github.vigoo.zioaws.route53resolver.model.IpAddressResponse.ReadOnly
      ]]
      def listResolverEndpoints(
          request: ListResolverEndpointsRequest
      ): ZIO[Any, AwsError, StreamingOutputResult[
        Any,
        io.github.vigoo.zioaws.route53resolver.model.ListResolverEndpointsResponse.ReadOnly,
        io.github.vigoo.zioaws.route53resolver.model.ResolverEndpoint.ReadOnly
      ]]
      def listResolverRules(
          request: ListResolverRulesRequest
      ): ZIO[Any, AwsError, StreamingOutputResult[
        Any,
        io.github.vigoo.zioaws.route53resolver.model.ListResolverRulesResponse.ReadOnly,
        io.github.vigoo.zioaws.route53resolver.model.ResolverRule.ReadOnly
      ]]
      def deleteFirewallRule(request: DeleteFirewallRuleRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.DeleteFirewallRuleResponse.ReadOnly
      ]
      def associateResolverQueryLogConfig(
          request: AssociateResolverQueryLogConfigRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.AssociateResolverQueryLogConfigResponse.ReadOnly
      ]
      def listFirewallDomains(
          request: ListFirewallDomainsRequest
      ): ZStream[Any, AwsError, FirewallDomainName]
      def getFirewallDomainList(request: GetFirewallDomainListRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.GetFirewallDomainListResponse.ReadOnly
      ]
      def createFirewallRuleGroup(request: CreateFirewallRuleGroupRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.CreateFirewallRuleGroupResponse.ReadOnly
      ]
      def disassociateResolverEndpointIpAddress(
          request: DisassociateResolverEndpointIpAddressRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.DisassociateResolverEndpointIpAddressResponse.ReadOnly
      ]
      def updateResolverRule(request: UpdateResolverRuleRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.UpdateResolverRuleResponse.ReadOnly
      ]
      def createResolverEndpoint(request: CreateResolverEndpointRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.CreateResolverEndpointResponse.ReadOnly
      ]
      def listResolverRuleAssociations(
          request: ListResolverRuleAssociationsRequest
      ): ZIO[Any, AwsError, StreamingOutputResult[
        Any,
        io.github.vigoo.zioaws.route53resolver.model.ListResolverRuleAssociationsResponse.ReadOnly,
        io.github.vigoo.zioaws.route53resolver.model.ResolverRuleAssociation.ReadOnly
      ]]
      def updateResolverEndpoint(request: UpdateResolverEndpointRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.UpdateResolverEndpointResponse.ReadOnly
      ]
      def putResolverRulePolicy(request: PutResolverRulePolicyRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.PutResolverRulePolicyResponse.ReadOnly
      ]
      def getFirewallRuleGroupPolicy(
          request: GetFirewallRuleGroupPolicyRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.GetFirewallRuleGroupPolicyResponse.ReadOnly
      ]
      def getResolverRuleAssociation(
          request: GetResolverRuleAssociationRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.GetResolverRuleAssociationResponse.ReadOnly
      ]
      def disassociateFirewallRuleGroup(
          request: DisassociateFirewallRuleGroupRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.DisassociateFirewallRuleGroupResponse.ReadOnly
      ]
      def associateFirewallRuleGroup(
          request: AssociateFirewallRuleGroupRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.AssociateFirewallRuleGroupResponse.ReadOnly
      ]
      def disassociateResolverRule(
          request: DisassociateResolverRuleRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.DisassociateResolverRuleResponse.ReadOnly
      ]
      def getResolverDnssecConfig(request: GetResolverDnssecConfigRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.GetResolverDnssecConfigResponse.ReadOnly
      ]
      def listResolverDnssecConfigs(
          request: ListResolverDnssecConfigsRequest
      ): ZStream[
        Any,
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.ResolverDnssecConfig.ReadOnly
      ]
      def getResolverRule(request: GetResolverRuleRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.GetResolverRuleResponse.ReadOnly
      ]
      def disassociateResolverQueryLogConfig(
          request: DisassociateResolverQueryLogConfigRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.DisassociateResolverQueryLogConfigResponse.ReadOnly
      ]
      def listFirewallConfigs(request: ListFirewallConfigsRequest): ZStream[
        Any,
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.FirewallConfig.ReadOnly
      ]
      def updateFirewallRuleGroupAssociation(
          request: UpdateFirewallRuleGroupAssociationRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.UpdateFirewallRuleGroupAssociationResponse.ReadOnly
      ]
      def updateFirewallDomains(request: UpdateFirewallDomainsRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.UpdateFirewallDomainsResponse.ReadOnly
      ]
      def getResolverRulePolicy(request: GetResolverRulePolicyRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.GetResolverRulePolicyResponse.ReadOnly
      ]
      def createResolverQueryLogConfig(
          request: CreateResolverQueryLogConfigRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.CreateResolverQueryLogConfigResponse.ReadOnly
      ]
      def deleteFirewallDomainList(
          request: DeleteFirewallDomainListRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.DeleteFirewallDomainListResponse.ReadOnly
      ]
      def getResolverEndpoint(request: GetResolverEndpointRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.GetResolverEndpointResponse.ReadOnly
      ]
      def untagResource(request: UntagResourceRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.UntagResourceResponse.ReadOnly
      ]
      def getResolverQueryLogConfigAssociation(
          request: GetResolverQueryLogConfigAssociationRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.GetResolverQueryLogConfigAssociationResponse.ReadOnly
      ]
      def listResolverConfigs(request: ListResolverConfigsRequest): ZStream[
        Any,
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.ResolverConfig.ReadOnly
      ]
      def listResolverQueryLogConfigs(
          request: ListResolverQueryLogConfigsRequest
      ): ZIO[Any, AwsError, StreamingOutputResult[
        Any,
        io.github.vigoo.zioaws.route53resolver.model.ListResolverQueryLogConfigsResponse.ReadOnly,
        io.github.vigoo.zioaws.route53resolver.model.ResolverQueryLogConfig.ReadOnly
      ]]
      def listResolverQueryLogConfigAssociations(
          request: ListResolverQueryLogConfigAssociationsRequest
      ): ZIO[Any, AwsError, StreamingOutputResult[
        Any,
        io.github.vigoo.zioaws.route53resolver.model.ListResolverQueryLogConfigAssociationsResponse.ReadOnly,
        io.github.vigoo.zioaws.route53resolver.model.ResolverQueryLogConfigAssociation.ReadOnly
      ]]
      def putFirewallRuleGroupPolicy(
          request: PutFirewallRuleGroupPolicyRequest
      ): IO[AwsError, ReadOnly]
      def listTagsForResource(request: ListTagsForResourceRequest): ZStream[
        Any,
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.Tag.ReadOnly
      ]
      def getFirewallRuleGroupAssociation(
          request: GetFirewallRuleGroupAssociationRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.GetFirewallRuleGroupAssociationResponse.ReadOnly
      ]
      def associateResolverEndpointIpAddress(
          request: AssociateResolverEndpointIpAddressRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.AssociateResolverEndpointIpAddressResponse.ReadOnly
      ]
      def tagResource(request: TagResourceRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.TagResourceResponse.ReadOnly
      ]
      def importFirewallDomains(request: ImportFirewallDomainsRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.ImportFirewallDomainsResponse.ReadOnly
      ]
      def deleteResolverEndpoint(request: DeleteResolverEndpointRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.DeleteResolverEndpointResponse.ReadOnly
      ]
      def listFirewallRuleGroupAssociations(
          request: ListFirewallRuleGroupAssociationsRequest
      ): ZStream[
        Any,
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.FirewallRuleGroupAssociation.ReadOnly
      ]
      def listFirewallRules(request: ListFirewallRulesRequest): ZStream[
        Any,
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.FirewallRule.ReadOnly
      ]
      def listFirewallRuleGroups(
          request: ListFirewallRuleGroupsRequest
      ): ZStream[
        Any,
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.FirewallRuleGroupMetadata.ReadOnly
      ]
      def deleteResolverRule(request: DeleteResolverRuleRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.DeleteResolverRuleResponse.ReadOnly
      ]
      def getResolverConfig(request: GetResolverConfigRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.GetResolverConfigResponse.ReadOnly
      ]
      def updateFirewallRule(request: UpdateFirewallRuleRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.UpdateFirewallRuleResponse.ReadOnly
      ]
      def getResolverQueryLogConfigPolicy(
          request: GetResolverQueryLogConfigPolicyRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.GetResolverQueryLogConfigPolicyResponse.ReadOnly
      ]
      def createFirewallDomainList(
          request: CreateFirewallDomainListRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.CreateFirewallDomainListResponse.ReadOnly
      ]
      def getFirewallConfig(request: GetFirewallConfigRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.GetFirewallConfigResponse.ReadOnly
      ]
      def updateResolverDnssecConfig(
          request: UpdateResolverDnssecConfigRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.UpdateResolverDnssecConfigResponse.ReadOnly
      ]
      def associateResolverRule(request: AssociateResolverRuleRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.AssociateResolverRuleResponse.ReadOnly
      ]
      def createResolverRule(request: CreateResolverRuleRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.CreateResolverRuleResponse.ReadOnly
      ]
      def putResolverQueryLogConfigPolicy(
          request: PutResolverQueryLogConfigPolicyRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.PutResolverQueryLogConfigPolicyResponse.ReadOnly
      ]
      def getFirewallRuleGroup(request: GetFirewallRuleGroupRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.route53resolver.model.GetFirewallRuleGroupResponse.ReadOnly
      ]
    }
    object Route53ResolverMock extends Mock[Route53Resolver] {
      object UpdateFirewallConfig
          extends Effect[
            UpdateFirewallConfigRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.UpdateFirewallConfigResponse.ReadOnly
          ]
      object DeleteFirewallRuleGroup
          extends Effect[
            DeleteFirewallRuleGroupRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.DeleteFirewallRuleGroupResponse.ReadOnly
          ]
      object ListFirewallDomainLists
          extends Stream[
            ListFirewallDomainListsRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.FirewallDomainListMetadata.ReadOnly
          ]
      object DeleteResolverQueryLogConfig
          extends Effect[
            DeleteResolverQueryLogConfigRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.DeleteResolverQueryLogConfigResponse.ReadOnly
          ]
      object GetResolverQueryLogConfig
          extends Effect[
            GetResolverQueryLogConfigRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.GetResolverQueryLogConfigResponse.ReadOnly
          ]
      object CreateFirewallRule
          extends Effect[
            CreateFirewallRuleRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.CreateFirewallRuleResponse.ReadOnly
          ]
      object UpdateResolverConfig
          extends Effect[
            UpdateResolverConfigRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.UpdateResolverConfigResponse.ReadOnly
          ]
      object ListResolverEndpointIpAddresses
          extends Effect[
            ListResolverEndpointIpAddressesRequest,
            AwsError,
            StreamingOutputResult[
              Any,
              io.github.vigoo.zioaws.route53resolver.model.ListResolverEndpointIpAddressesResponse.ReadOnly,
              io.github.vigoo.zioaws.route53resolver.model.IpAddressResponse.ReadOnly
            ]
          ]
      object ListResolverEndpoints
          extends Effect[
            ListResolverEndpointsRequest,
            AwsError,
            StreamingOutputResult[
              Any,
              io.github.vigoo.zioaws.route53resolver.model.ListResolverEndpointsResponse.ReadOnly,
              io.github.vigoo.zioaws.route53resolver.model.ResolverEndpoint.ReadOnly
            ]
          ]
      object ListResolverRules
          extends Effect[
            ListResolverRulesRequest,
            AwsError,
            StreamingOutputResult[
              Any,
              io.github.vigoo.zioaws.route53resolver.model.ListResolverRulesResponse.ReadOnly,
              io.github.vigoo.zioaws.route53resolver.model.ResolverRule.ReadOnly
            ]
          ]
      object DeleteFirewallRule
          extends Effect[
            DeleteFirewallRuleRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.DeleteFirewallRuleResponse.ReadOnly
          ]
      object AssociateResolverQueryLogConfig
          extends Effect[
            AssociateResolverQueryLogConfigRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.AssociateResolverQueryLogConfigResponse.ReadOnly
          ]
      object ListFirewallDomains
          extends Stream[
            ListFirewallDomainsRequest,
            AwsError,
            FirewallDomainName
          ]
      object GetFirewallDomainList
          extends Effect[
            GetFirewallDomainListRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.GetFirewallDomainListResponse.ReadOnly
          ]
      object CreateFirewallRuleGroup
          extends Effect[
            CreateFirewallRuleGroupRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.CreateFirewallRuleGroupResponse.ReadOnly
          ]
      object DisassociateResolverEndpointIpAddress
          extends Effect[
            DisassociateResolverEndpointIpAddressRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.DisassociateResolverEndpointIpAddressResponse.ReadOnly
          ]
      object UpdateResolverRule
          extends Effect[
            UpdateResolverRuleRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.UpdateResolverRuleResponse.ReadOnly
          ]
      object CreateResolverEndpoint
          extends Effect[
            CreateResolverEndpointRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.CreateResolverEndpointResponse.ReadOnly
          ]
      object ListResolverRuleAssociations
          extends Effect[
            ListResolverRuleAssociationsRequest,
            AwsError,
            StreamingOutputResult[
              Any,
              io.github.vigoo.zioaws.route53resolver.model.ListResolverRuleAssociationsResponse.ReadOnly,
              io.github.vigoo.zioaws.route53resolver.model.ResolverRuleAssociation.ReadOnly
            ]
          ]
      object UpdateResolverEndpoint
          extends Effect[
            UpdateResolverEndpointRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.UpdateResolverEndpointResponse.ReadOnly
          ]
      object PutResolverRulePolicy
          extends Effect[
            PutResolverRulePolicyRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.PutResolverRulePolicyResponse.ReadOnly
          ]
      object GetFirewallRuleGroupPolicy
          extends Effect[
            GetFirewallRuleGroupPolicyRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.GetFirewallRuleGroupPolicyResponse.ReadOnly
          ]
      object GetResolverRuleAssociation
          extends Effect[
            GetResolverRuleAssociationRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.GetResolverRuleAssociationResponse.ReadOnly
          ]
      object DisassociateFirewallRuleGroup
          extends Effect[
            DisassociateFirewallRuleGroupRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.DisassociateFirewallRuleGroupResponse.ReadOnly
          ]
      object AssociateFirewallRuleGroup
          extends Effect[
            AssociateFirewallRuleGroupRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.AssociateFirewallRuleGroupResponse.ReadOnly
          ]
      object DisassociateResolverRule
          extends Effect[
            DisassociateResolverRuleRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.DisassociateResolverRuleResponse.ReadOnly
          ]
      object GetResolverDnssecConfig
          extends Effect[
            GetResolverDnssecConfigRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.GetResolverDnssecConfigResponse.ReadOnly
          ]
      object ListResolverDnssecConfigs
          extends Stream[
            ListResolverDnssecConfigsRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.ResolverDnssecConfig.ReadOnly
          ]
      object GetResolverRule
          extends Effect[
            GetResolverRuleRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.GetResolverRuleResponse.ReadOnly
          ]
      object DisassociateResolverQueryLogConfig
          extends Effect[
            DisassociateResolverQueryLogConfigRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.DisassociateResolverQueryLogConfigResponse.ReadOnly
          ]
      object ListFirewallConfigs
          extends Stream[
            ListFirewallConfigsRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.FirewallConfig.ReadOnly
          ]
      object UpdateFirewallRuleGroupAssociation
          extends Effect[
            UpdateFirewallRuleGroupAssociationRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.UpdateFirewallRuleGroupAssociationResponse.ReadOnly
          ]
      object UpdateFirewallDomains
          extends Effect[
            UpdateFirewallDomainsRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.UpdateFirewallDomainsResponse.ReadOnly
          ]
      object GetResolverRulePolicy
          extends Effect[
            GetResolverRulePolicyRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.GetResolverRulePolicyResponse.ReadOnly
          ]
      object CreateResolverQueryLogConfig
          extends Effect[
            CreateResolverQueryLogConfigRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.CreateResolverQueryLogConfigResponse.ReadOnly
          ]
      object DeleteFirewallDomainList
          extends Effect[
            DeleteFirewallDomainListRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.DeleteFirewallDomainListResponse.ReadOnly
          ]
      object GetResolverEndpoint
          extends Effect[
            GetResolverEndpointRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.GetResolverEndpointResponse.ReadOnly
          ]
      object UntagResource
          extends Effect[
            UntagResourceRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.UntagResourceResponse.ReadOnly
          ]
      object GetResolverQueryLogConfigAssociation
          extends Effect[
            GetResolverQueryLogConfigAssociationRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.GetResolverQueryLogConfigAssociationResponse.ReadOnly
          ]
      object ListResolverConfigs
          extends Stream[
            ListResolverConfigsRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.ResolverConfig.ReadOnly
          ]
      object ListResolverQueryLogConfigs
          extends Effect[ListResolverQueryLogConfigsRequest, AwsError, StreamingOutputResult[
            Any,
            io.github.vigoo.zioaws.route53resolver.model.ListResolverQueryLogConfigsResponse.ReadOnly,
            io.github.vigoo.zioaws.route53resolver.model.ResolverQueryLogConfig.ReadOnly
          ]]
      object ListResolverQueryLogConfigAssociations
          extends Effect[
            ListResolverQueryLogConfigAssociationsRequest,
            AwsError,
            StreamingOutputResult[
              Any,
              io.github.vigoo.zioaws.route53resolver.model.ListResolverQueryLogConfigAssociationsResponse.ReadOnly,
              io.github.vigoo.zioaws.route53resolver.model.ResolverQueryLogConfigAssociation.ReadOnly
            ]
          ]
      object PutFirewallRuleGroupPolicy
          extends Effect[PutFirewallRuleGroupPolicyRequest, AwsError, ReadOnly]
      object ListTagsForResource
          extends Stream[
            ListTagsForResourceRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.Tag.ReadOnly
          ]
      object GetFirewallRuleGroupAssociation
          extends Effect[
            GetFirewallRuleGroupAssociationRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.GetFirewallRuleGroupAssociationResponse.ReadOnly
          ]
      object AssociateResolverEndpointIpAddress
          extends Effect[
            AssociateResolverEndpointIpAddressRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.AssociateResolverEndpointIpAddressResponse.ReadOnly
          ]
      object TagResource
          extends Effect[
            TagResourceRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.TagResourceResponse.ReadOnly
          ]
      object ImportFirewallDomains
          extends Effect[
            ImportFirewallDomainsRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.ImportFirewallDomainsResponse.ReadOnly
          ]
      object DeleteResolverEndpoint
          extends Effect[
            DeleteResolverEndpointRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.DeleteResolverEndpointResponse.ReadOnly
          ]
      object ListFirewallRuleGroupAssociations
          extends Stream[
            ListFirewallRuleGroupAssociationsRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.FirewallRuleGroupAssociation.ReadOnly
          ]
      object ListFirewallRules
          extends Stream[
            ListFirewallRulesRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.FirewallRule.ReadOnly
          ]
      object ListFirewallRuleGroups
          extends Stream[
            ListFirewallRuleGroupsRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.FirewallRuleGroupMetadata.ReadOnly
          ]
      object DeleteResolverRule
          extends Effect[
            DeleteResolverRuleRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.DeleteResolverRuleResponse.ReadOnly
          ]
      object GetResolverConfig
          extends Effect[
            GetResolverConfigRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.GetResolverConfigResponse.ReadOnly
          ]
      object UpdateFirewallRule
          extends Effect[
            UpdateFirewallRuleRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.UpdateFirewallRuleResponse.ReadOnly
          ]
      object GetResolverQueryLogConfigPolicy
          extends Effect[
            GetResolverQueryLogConfigPolicyRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.GetResolverQueryLogConfigPolicyResponse.ReadOnly
          ]
      object CreateFirewallDomainList
          extends Effect[
            CreateFirewallDomainListRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.CreateFirewallDomainListResponse.ReadOnly
          ]
      object GetFirewallConfig
          extends Effect[
            GetFirewallConfigRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.GetFirewallConfigResponse.ReadOnly
          ]
      object UpdateResolverDnssecConfig
          extends Effect[
            UpdateResolverDnssecConfigRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.UpdateResolverDnssecConfigResponse.ReadOnly
          ]
      object AssociateResolverRule
          extends Effect[
            AssociateResolverRuleRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.AssociateResolverRuleResponse.ReadOnly
          ]
      object CreateResolverRule
          extends Effect[
            CreateResolverRuleRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.CreateResolverRuleResponse.ReadOnly
          ]
      object PutResolverQueryLogConfigPolicy
          extends Effect[
            PutResolverQueryLogConfigPolicyRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.PutResolverQueryLogConfigPolicyResponse.ReadOnly
          ]
      object GetFirewallRuleGroup
          extends Effect[
            GetFirewallRuleGroupRequest,
            AwsError,
            io.github.vigoo.zioaws.route53resolver.model.GetFirewallRuleGroupResponse.ReadOnly
          ]
      val compose: URLayer[Has[Proxy], Route53Resolver] = ZLayer.fromServiceM {
        proxy =>
          withRuntime.map { rts =>
            new Route53Resolver.Service {
              val api: Route53ResolverAsyncClient = null
              def withAspect[R1](
                  newAspect: AwsCallAspect[R1],
                  r: R1
              ): Route53Resolver.Service = this
              def updateFirewallConfig(
                  request: UpdateFirewallConfigRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.UpdateFirewallConfigResponse.ReadOnly
              ] = proxy(UpdateFirewallConfig, request)
              def deleteFirewallRuleGroup(
                  request: DeleteFirewallRuleGroupRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.DeleteFirewallRuleGroupResponse.ReadOnly
              ] = proxy(DeleteFirewallRuleGroup, request)
              def listFirewallDomainLists(
                  request: ListFirewallDomainListsRequest
              ): ZStream[
                Any,
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.FirewallDomainListMetadata.ReadOnly
              ] = rts.unsafeRun(proxy(ListFirewallDomainLists, request))
              def deleteResolverQueryLogConfig(
                  request: DeleteResolverQueryLogConfigRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.DeleteResolverQueryLogConfigResponse.ReadOnly
              ] = proxy(DeleteResolverQueryLogConfig, request)
              def getResolverQueryLogConfig(
                  request: GetResolverQueryLogConfigRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.GetResolverQueryLogConfigResponse.ReadOnly
              ] = proxy(GetResolverQueryLogConfig, request)
              def createFirewallRule(request: CreateFirewallRuleRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.CreateFirewallRuleResponse.ReadOnly
              ] = proxy(CreateFirewallRule, request)
              def updateResolverConfig(
                  request: UpdateResolverConfigRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.UpdateResolverConfigResponse.ReadOnly
              ] = proxy(UpdateResolverConfig, request)
              def listResolverEndpointIpAddresses(
                  request: ListResolverEndpointIpAddressesRequest
              ): ZIO[Any, AwsError, StreamingOutputResult[
                Any,
                io.github.vigoo.zioaws.route53resolver.model.ListResolverEndpointIpAddressesResponse.ReadOnly,
                io.github.vigoo.zioaws.route53resolver.model.IpAddressResponse.ReadOnly
              ]] = proxy(ListResolverEndpointIpAddresses, request)
              def listResolverEndpoints(
                  request: ListResolverEndpointsRequest
              ): ZIO[Any, AwsError, StreamingOutputResult[
                Any,
                io.github.vigoo.zioaws.route53resolver.model.ListResolverEndpointsResponse.ReadOnly,
                io.github.vigoo.zioaws.route53resolver.model.ResolverEndpoint.ReadOnly
              ]] = proxy(ListResolverEndpoints, request)
              def listResolverRules(
                  request: ListResolverRulesRequest
              ): ZIO[Any, AwsError, StreamingOutputResult[
                Any,
                io.github.vigoo.zioaws.route53resolver.model.ListResolverRulesResponse.ReadOnly,
                io.github.vigoo.zioaws.route53resolver.model.ResolverRule.ReadOnly
              ]] = proxy(ListResolverRules, request)
              def deleteFirewallRule(request: DeleteFirewallRuleRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.DeleteFirewallRuleResponse.ReadOnly
              ] = proxy(DeleteFirewallRule, request)
              def associateResolverQueryLogConfig(
                  request: AssociateResolverQueryLogConfigRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.AssociateResolverQueryLogConfigResponse.ReadOnly
              ] = proxy(AssociateResolverQueryLogConfig, request)
              def listFirewallDomains(
                  request: ListFirewallDomainsRequest
              ): ZStream[Any, AwsError, FirewallDomainName] =
                rts.unsafeRun(proxy(ListFirewallDomains, request))
              def getFirewallDomainList(
                  request: GetFirewallDomainListRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.GetFirewallDomainListResponse.ReadOnly
              ] = proxy(GetFirewallDomainList, request)
              def createFirewallRuleGroup(
                  request: CreateFirewallRuleGroupRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.CreateFirewallRuleGroupResponse.ReadOnly
              ] = proxy(CreateFirewallRuleGroup, request)
              def disassociateResolverEndpointIpAddress(
                  request: DisassociateResolverEndpointIpAddressRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.DisassociateResolverEndpointIpAddressResponse.ReadOnly
              ] = proxy(DisassociateResolverEndpointIpAddress, request)
              def updateResolverRule(request: UpdateResolverRuleRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.UpdateResolverRuleResponse.ReadOnly
              ] = proxy(UpdateResolverRule, request)
              def createResolverEndpoint(
                  request: CreateResolverEndpointRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.CreateResolverEndpointResponse.ReadOnly
              ] = proxy(CreateResolverEndpoint, request)
              def listResolverRuleAssociations(
                  request: ListResolverRuleAssociationsRequest
              ): ZIO[Any, AwsError, StreamingOutputResult[
                Any,
                io.github.vigoo.zioaws.route53resolver.model.ListResolverRuleAssociationsResponse.ReadOnly,
                io.github.vigoo.zioaws.route53resolver.model.ResolverRuleAssociation.ReadOnly
              ]] = proxy(ListResolverRuleAssociations, request)
              def updateResolverEndpoint(
                  request: UpdateResolverEndpointRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.UpdateResolverEndpointResponse.ReadOnly
              ] = proxy(UpdateResolverEndpoint, request)
              def putResolverRulePolicy(
                  request: PutResolverRulePolicyRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.PutResolverRulePolicyResponse.ReadOnly
              ] = proxy(PutResolverRulePolicy, request)
              def getFirewallRuleGroupPolicy(
                  request: GetFirewallRuleGroupPolicyRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.GetFirewallRuleGroupPolicyResponse.ReadOnly
              ] = proxy(GetFirewallRuleGroupPolicy, request)
              def getResolverRuleAssociation(
                  request: GetResolverRuleAssociationRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.GetResolverRuleAssociationResponse.ReadOnly
              ] = proxy(GetResolverRuleAssociation, request)
              def disassociateFirewallRuleGroup(
                  request: DisassociateFirewallRuleGroupRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.DisassociateFirewallRuleGroupResponse.ReadOnly
              ] = proxy(DisassociateFirewallRuleGroup, request)
              def associateFirewallRuleGroup(
                  request: AssociateFirewallRuleGroupRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.AssociateFirewallRuleGroupResponse.ReadOnly
              ] = proxy(AssociateFirewallRuleGroup, request)
              def disassociateResolverRule(
                  request: DisassociateResolverRuleRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.DisassociateResolverRuleResponse.ReadOnly
              ] = proxy(DisassociateResolverRule, request)
              def getResolverDnssecConfig(
                  request: GetResolverDnssecConfigRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.GetResolverDnssecConfigResponse.ReadOnly
              ] = proxy(GetResolverDnssecConfig, request)
              def listResolverDnssecConfigs(
                  request: ListResolverDnssecConfigsRequest
              ): ZStream[
                Any,
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.ResolverDnssecConfig.ReadOnly
              ] = rts.unsafeRun(proxy(ListResolverDnssecConfigs, request))
              def getResolverRule(request: GetResolverRuleRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.GetResolverRuleResponse.ReadOnly
              ] = proxy(GetResolverRule, request)
              def disassociateResolverQueryLogConfig(
                  request: DisassociateResolverQueryLogConfigRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.DisassociateResolverQueryLogConfigResponse.ReadOnly
              ] = proxy(DisassociateResolverQueryLogConfig, request)
              def listFirewallConfigs(
                  request: ListFirewallConfigsRequest
              ): ZStream[
                Any,
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.FirewallConfig.ReadOnly
              ] = rts.unsafeRun(proxy(ListFirewallConfigs, request))
              def updateFirewallRuleGroupAssociation(
                  request: UpdateFirewallRuleGroupAssociationRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.UpdateFirewallRuleGroupAssociationResponse.ReadOnly
              ] = proxy(UpdateFirewallRuleGroupAssociation, request)
              def updateFirewallDomains(
                  request: UpdateFirewallDomainsRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.UpdateFirewallDomainsResponse.ReadOnly
              ] = proxy(UpdateFirewallDomains, request)
              def getResolverRulePolicy(
                  request: GetResolverRulePolicyRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.GetResolverRulePolicyResponse.ReadOnly
              ] = proxy(GetResolverRulePolicy, request)
              def createResolverQueryLogConfig(
                  request: CreateResolverQueryLogConfigRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.CreateResolverQueryLogConfigResponse.ReadOnly
              ] = proxy(CreateResolverQueryLogConfig, request)
              def deleteFirewallDomainList(
                  request: DeleteFirewallDomainListRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.DeleteFirewallDomainListResponse.ReadOnly
              ] = proxy(DeleteFirewallDomainList, request)
              def getResolverEndpoint(request: GetResolverEndpointRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.GetResolverEndpointResponse.ReadOnly
              ] = proxy(GetResolverEndpoint, request)
              def untagResource(request: UntagResourceRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.UntagResourceResponse.ReadOnly
              ] = proxy(UntagResource, request)
              def getResolverQueryLogConfigAssociation(
                  request: GetResolverQueryLogConfigAssociationRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.GetResolverQueryLogConfigAssociationResponse.ReadOnly
              ] = proxy(GetResolverQueryLogConfigAssociation, request)
              def listResolverConfigs(
                  request: ListResolverConfigsRequest
              ): ZStream[
                Any,
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.ResolverConfig.ReadOnly
              ] = rts.unsafeRun(proxy(ListResolverConfigs, request))
              def listResolverQueryLogConfigs(
                  request: ListResolverQueryLogConfigsRequest
              ): ZIO[Any, AwsError, StreamingOutputResult[
                Any,
                io.github.vigoo.zioaws.route53resolver.model.ListResolverQueryLogConfigsResponse.ReadOnly,
                io.github.vigoo.zioaws.route53resolver.model.ResolverQueryLogConfig.ReadOnly
              ]] = proxy(ListResolverQueryLogConfigs, request)
              def listResolverQueryLogConfigAssociations(
                  request: ListResolverQueryLogConfigAssociationsRequest
              ): ZIO[Any, AwsError, StreamingOutputResult[
                Any,
                io.github.vigoo.zioaws.route53resolver.model.ListResolverQueryLogConfigAssociationsResponse.ReadOnly,
                io.github.vigoo.zioaws.route53resolver.model.ResolverQueryLogConfigAssociation.ReadOnly
              ]] = proxy(ListResolverQueryLogConfigAssociations, request)
              def putFirewallRuleGroupPolicy(
                  request: PutFirewallRuleGroupPolicyRequest
              ): IO[AwsError, ReadOnly] =
                proxy(PutFirewallRuleGroupPolicy, request)
              def listTagsForResource(
                  request: ListTagsForResourceRequest
              ): ZStream[
                Any,
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.Tag.ReadOnly
              ] = rts.unsafeRun(proxy(ListTagsForResource, request))
              def getFirewallRuleGroupAssociation(
                  request: GetFirewallRuleGroupAssociationRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.GetFirewallRuleGroupAssociationResponse.ReadOnly
              ] = proxy(GetFirewallRuleGroupAssociation, request)
              def associateResolverEndpointIpAddress(
                  request: AssociateResolverEndpointIpAddressRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.AssociateResolverEndpointIpAddressResponse.ReadOnly
              ] = proxy(AssociateResolverEndpointIpAddress, request)
              def tagResource(request: TagResourceRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.TagResourceResponse.ReadOnly
              ] = proxy(TagResource, request)
              def importFirewallDomains(
                  request: ImportFirewallDomainsRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.ImportFirewallDomainsResponse.ReadOnly
              ] = proxy(ImportFirewallDomains, request)
              def deleteResolverEndpoint(
                  request: DeleteResolverEndpointRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.DeleteResolverEndpointResponse.ReadOnly
              ] = proxy(DeleteResolverEndpoint, request)
              def listFirewallRuleGroupAssociations(
                  request: ListFirewallRuleGroupAssociationsRequest
              ): ZStream[
                Any,
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.FirewallRuleGroupAssociation.ReadOnly
              ] =
                rts.unsafeRun(proxy(ListFirewallRuleGroupAssociations, request))
              def listFirewallRules(request: ListFirewallRulesRequest): ZStream[
                Any,
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.FirewallRule.ReadOnly
              ] = rts.unsafeRun(proxy(ListFirewallRules, request))
              def listFirewallRuleGroups(
                  request: ListFirewallRuleGroupsRequest
              ): ZStream[
                Any,
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.FirewallRuleGroupMetadata.ReadOnly
              ] = rts.unsafeRun(proxy(ListFirewallRuleGroups, request))
              def deleteResolverRule(request: DeleteResolverRuleRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.DeleteResolverRuleResponse.ReadOnly
              ] = proxy(DeleteResolverRule, request)
              def getResolverConfig(request: GetResolverConfigRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.GetResolverConfigResponse.ReadOnly
              ] = proxy(GetResolverConfig, request)
              def updateFirewallRule(request: UpdateFirewallRuleRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.UpdateFirewallRuleResponse.ReadOnly
              ] = proxy(UpdateFirewallRule, request)
              def getResolverQueryLogConfigPolicy(
                  request: GetResolverQueryLogConfigPolicyRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.GetResolverQueryLogConfigPolicyResponse.ReadOnly
              ] = proxy(GetResolverQueryLogConfigPolicy, request)
              def createFirewallDomainList(
                  request: CreateFirewallDomainListRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.CreateFirewallDomainListResponse.ReadOnly
              ] = proxy(CreateFirewallDomainList, request)
              def getFirewallConfig(request: GetFirewallConfigRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.GetFirewallConfigResponse.ReadOnly
              ] = proxy(GetFirewallConfig, request)
              def updateResolverDnssecConfig(
                  request: UpdateResolverDnssecConfigRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.UpdateResolverDnssecConfigResponse.ReadOnly
              ] = proxy(UpdateResolverDnssecConfig, request)
              def associateResolverRule(
                  request: AssociateResolverRuleRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.AssociateResolverRuleResponse.ReadOnly
              ] = proxy(AssociateResolverRule, request)
              def createResolverRule(request: CreateResolverRuleRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.CreateResolverRuleResponse.ReadOnly
              ] = proxy(CreateResolverRule, request)
              def putResolverQueryLogConfigPolicy(
                  request: PutResolverQueryLogConfigPolicyRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.PutResolverQueryLogConfigPolicyResponse.ReadOnly
              ] = proxy(PutResolverQueryLogConfigPolicy, request)
              def getFirewallRuleGroup(
                  request: GetFirewallRuleGroupRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.route53resolver.model.GetFirewallRuleGroupResponse.ReadOnly
              ] = proxy(GetFirewallRuleGroup, request)
            }
          }
      }
    }
  }
  val live: ZLayer[AwsConfig, java.lang.Throwable, Route53Resolver] =
    customized(identity)
  def customized(
      customization: Route53ResolverAsyncClientBuilder => Route53ResolverAsyncClientBuilder
  ): ZLayer[AwsConfig, java.lang.Throwable, Route53Resolver] = managed(
    customization
  ).toLayer
  def managed(
      customization: Route53ResolverAsyncClientBuilder => Route53ResolverAsyncClientBuilder
  ): ZManaged[AwsConfig, java.lang.Throwable, Route53Resolver.Service] = for (
    awsConfig <- ZManaged.service[AwsConfig.Service];
    executor <- ZIO.executor.toManaged_;
    builder = Route53ResolverAsyncClient
      .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[Route53ResolverAsyncClient, Route53ResolverAsyncClientBuilder](
        builder
      )
      .toManaged_;
    b1 <- awsConfig
      .configureHttpClient[
        Route53ResolverAsyncClient,
        Route53ResolverAsyncClientBuilder
      ](
        b0,
        io.github.vigoo.zioaws.core.httpclient
          .ServiceHttpCapabilities(supportsHttp2 = false)
      )
      .toManaged_; client <- zio.ZIO(customization(b1).build()).toManaged_
  )
    yield new Route53ResolverImpl(
      client,
      AwsCallAspect.identity,
      ().asInstanceOf[Any]
    )
  private class Route53ResolverImpl[R](
      override val api: Route53ResolverAsyncClient,
      override val aspect: AwsCallAspect[R],
      r: R
  ) extends Route53Resolver.Service
      with AwsServiceBase[R, Route53ResolverImpl] {
    override val serviceName: String = "Route53Resolver"
    override def withAspect[R1](
        newAspect: AwsCallAspect[R1],
        r: R1
    ): Route53ResolverImpl[R1] = new Route53ResolverImpl(api, newAspect, r)
    def updateFirewallConfig(request: UpdateFirewallConfigRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.UpdateFirewallConfigResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.UpdateFirewallConfigRequest,
      UpdateFirewallConfigResponse
    ]("updateFirewallConfig", api.updateFirewallConfig)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.route53resolver.model.UpdateFirewallConfigResponse.wrap
      )
      .provide(r)
    def deleteFirewallRuleGroup(request: DeleteFirewallRuleGroupRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.DeleteFirewallRuleGroupResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.DeleteFirewallRuleGroupRequest,
      DeleteFirewallRuleGroupResponse
    ]("deleteFirewallRuleGroup", api.deleteFirewallRuleGroup)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.route53resolver.model.DeleteFirewallRuleGroupResponse.wrap
    ).provide(r)
    def listFirewallDomainLists(
        request: ListFirewallDomainListsRequest
    ): ZStream[
      Any,
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.FirewallDomainListMetadata.ReadOnly
    ] = asyncSimplePaginatedRequest[
      software.amazon.awssdk.services.route53resolver.model.ListFirewallDomainListsRequest,
      ListFirewallDomainListsResponse,
      FirewallDomainListMetadata
    ](
      "listFirewallDomainLists",
      api.listFirewallDomainLists,
      (r, token) => r.toBuilder().nextToken(token).build(),
      r => scala.Option(r.nextToken()),
      r => zio.Chunk.fromIterable(r.firewallDomainLists().asScala)
    )(request.buildAwsValue())
      .map(item =>
        io.github.vigoo.zioaws.route53resolver.model.FirewallDomainListMetadata
          .wrap(item)
      )
      .provide(r)
    def deleteResolverQueryLogConfig(
        request: DeleteResolverQueryLogConfigRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.DeleteResolverQueryLogConfigResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.DeleteResolverQueryLogConfigRequest,
      DeleteResolverQueryLogConfigResponse
    ]("deleteResolverQueryLogConfig", api.deleteResolverQueryLogConfig)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.route53resolver.model.DeleteResolverQueryLogConfigResponse.wrap
    ).provide(r)
    def getResolverQueryLogConfig(
        request: GetResolverQueryLogConfigRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.GetResolverQueryLogConfigResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.GetResolverQueryLogConfigRequest,
      GetResolverQueryLogConfigResponse
    ]("getResolverQueryLogConfig", api.getResolverQueryLogConfig)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.route53resolver.model.GetResolverQueryLogConfigResponse.wrap
    ).provide(r)
    def createFirewallRule(request: CreateFirewallRuleRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.CreateFirewallRuleResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.CreateFirewallRuleRequest,
      CreateFirewallRuleResponse
    ]("createFirewallRule", api.createFirewallRule)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.route53resolver.model.CreateFirewallRuleResponse.wrap
      )
      .provide(r)
    def updateResolverConfig(request: UpdateResolverConfigRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.UpdateResolverConfigResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.UpdateResolverConfigRequest,
      UpdateResolverConfigResponse
    ]("updateResolverConfig", api.updateResolverConfig)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.route53resolver.model.UpdateResolverConfigResponse.wrap
      )
      .provide(r)
    def listResolverEndpointIpAddresses(
        request: ListResolverEndpointIpAddressesRequest
    ): ZIO[Any, AwsError, StreamingOutputResult[
      Any,
      io.github.vigoo.zioaws.route53resolver.model.ListResolverEndpointIpAddressesResponse.ReadOnly,
      io.github.vigoo.zioaws.route53resolver.model.IpAddressResponse.ReadOnly
    ]] = asyncPaginatedRequest[
      software.amazon.awssdk.services.route53resolver.model.ListResolverEndpointIpAddressesRequest,
      ListResolverEndpointIpAddressesResponse,
      IpAddressResponse
    ](
      "listResolverEndpointIpAddresses",
      api.listResolverEndpointIpAddresses,
      (r, token) => r.toBuilder().nextToken(token).build(),
      r => scala.Option(r.nextToken()),
      r => zio.Chunk.fromIterable(r.ipAddresses().asScala)
    )(request.buildAwsValue())
      .map(result =>
        result
          .mapResponse(
            io.github.vigoo.zioaws.route53resolver.model.ListResolverEndpointIpAddressesResponse.wrap
          )
          .mapOutput(
            _.map(item =>
              io.github.vigoo.zioaws.route53resolver.model.IpAddressResponse
                .wrap(item)
            )
          )
          .provide(r)
      )
      .provide(r)
    def listResolverEndpoints(
        request: ListResolverEndpointsRequest
    ): ZIO[Any, AwsError, StreamingOutputResult[
      Any,
      io.github.vigoo.zioaws.route53resolver.model.ListResolverEndpointsResponse.ReadOnly,
      io.github.vigoo.zioaws.route53resolver.model.ResolverEndpoint.ReadOnly
    ]] = asyncPaginatedRequest[
      software.amazon.awssdk.services.route53resolver.model.ListResolverEndpointsRequest,
      ListResolverEndpointsResponse,
      ResolverEndpoint
    ](
      "listResolverEndpoints",
      api.listResolverEndpoints,
      (r, token) => r.toBuilder().nextToken(token).build(),
      r => scala.Option(r.nextToken()),
      r => zio.Chunk.fromIterable(r.resolverEndpoints().asScala)
    )(request.buildAwsValue())
      .map(result =>
        result
          .mapResponse(
            io.github.vigoo.zioaws.route53resolver.model.ListResolverEndpointsResponse.wrap
          )
          .mapOutput(
            _.map(item =>
              io.github.vigoo.zioaws.route53resolver.model.ResolverEndpoint
                .wrap(item)
            )
          )
          .provide(r)
      )
      .provide(r)
    def listResolverRules(
        request: ListResolverRulesRequest
    ): ZIO[Any, AwsError, StreamingOutputResult[
      Any,
      io.github.vigoo.zioaws.route53resolver.model.ListResolverRulesResponse.ReadOnly,
      io.github.vigoo.zioaws.route53resolver.model.ResolverRule.ReadOnly
    ]] = asyncPaginatedRequest[
      software.amazon.awssdk.services.route53resolver.model.ListResolverRulesRequest,
      ListResolverRulesResponse,
      ResolverRule
    ](
      "listResolverRules",
      api.listResolverRules,
      (r, token) => r.toBuilder().nextToken(token).build(),
      r => scala.Option(r.nextToken()),
      r => zio.Chunk.fromIterable(r.resolverRules().asScala)
    )(request.buildAwsValue())
      .map(result =>
        result
          .mapResponse(
            io.github.vigoo.zioaws.route53resolver.model.ListResolverRulesResponse.wrap
          )
          .mapOutput(
            _.map(item =>
              io.github.vigoo.zioaws.route53resolver.model.ResolverRule
                .wrap(item)
            )
          )
          .provide(r)
      )
      .provide(r)
    def deleteFirewallRule(request: DeleteFirewallRuleRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.DeleteFirewallRuleResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.DeleteFirewallRuleRequest,
      DeleteFirewallRuleResponse
    ]("deleteFirewallRule", api.deleteFirewallRule)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.route53resolver.model.DeleteFirewallRuleResponse.wrap
      )
      .provide(r)
    def associateResolverQueryLogConfig(
        request: AssociateResolverQueryLogConfigRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.AssociateResolverQueryLogConfigResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.AssociateResolverQueryLogConfigRequest,
      AssociateResolverQueryLogConfigResponse
    ]("associateResolverQueryLogConfig", api.associateResolverQueryLogConfig)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.route53resolver.model.AssociateResolverQueryLogConfigResponse.wrap
    ).provide(r)
    def listFirewallDomains(
        request: ListFirewallDomainsRequest
    ): ZStream[Any, AwsError, FirewallDomainName] = asyncSimplePaginatedRequest[
      software.amazon.awssdk.services.route53resolver.model.ListFirewallDomainsRequest,
      ListFirewallDomainsResponse,
      java.lang.String
    ](
      "listFirewallDomains",
      api.listFirewallDomains,
      (r, token) => r.toBuilder().nextToken(token).build(),
      r => scala.Option(r.nextToken()),
      r => zio.Chunk.fromIterable(r.domains().asScala)
    )(request.buildAwsValue()).map(item => item: FirewallDomainName).provide(r)
    def getFirewallDomainList(request: GetFirewallDomainListRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.GetFirewallDomainListResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.GetFirewallDomainListRequest,
      GetFirewallDomainListResponse
    ]("getFirewallDomainList", api.getFirewallDomainList)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.route53resolver.model.GetFirewallDomainListResponse.wrap
    ).provide(r)
    def createFirewallRuleGroup(request: CreateFirewallRuleGroupRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.CreateFirewallRuleGroupResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.CreateFirewallRuleGroupRequest,
      CreateFirewallRuleGroupResponse
    ]("createFirewallRuleGroup", api.createFirewallRuleGroup)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.route53resolver.model.CreateFirewallRuleGroupResponse.wrap
    ).provide(r)
    def disassociateResolverEndpointIpAddress(
        request: DisassociateResolverEndpointIpAddressRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.DisassociateResolverEndpointIpAddressResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.DisassociateResolverEndpointIpAddressRequest,
      DisassociateResolverEndpointIpAddressResponse
    ](
      "disassociateResolverEndpointIpAddress",
      api.disassociateResolverEndpointIpAddress
    )(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.route53resolver.model.DisassociateResolverEndpointIpAddressResponse.wrap
      )
      .provide(r)
    def updateResolverRule(request: UpdateResolverRuleRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.UpdateResolverRuleResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.UpdateResolverRuleRequest,
      UpdateResolverRuleResponse
    ]("updateResolverRule", api.updateResolverRule)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.route53resolver.model.UpdateResolverRuleResponse.wrap
      )
      .provide(r)
    def createResolverEndpoint(request: CreateResolverEndpointRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.CreateResolverEndpointResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.CreateResolverEndpointRequest,
      CreateResolverEndpointResponse
    ]("createResolverEndpoint", api.createResolverEndpoint)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.route53resolver.model.CreateResolverEndpointResponse.wrap
    ).provide(r)
    def listResolverRuleAssociations(
        request: ListResolverRuleAssociationsRequest
    ): ZIO[Any, AwsError, StreamingOutputResult[
      Any,
      io.github.vigoo.zioaws.route53resolver.model.ListResolverRuleAssociationsResponse.ReadOnly,
      io.github.vigoo.zioaws.route53resolver.model.ResolverRuleAssociation.ReadOnly
    ]] = asyncPaginatedRequest[
      software.amazon.awssdk.services.route53resolver.model.ListResolverRuleAssociationsRequest,
      ListResolverRuleAssociationsResponse,
      ResolverRuleAssociation
    ](
      "listResolverRuleAssociations",
      api.listResolverRuleAssociations,
      (r, token) => r.toBuilder().nextToken(token).build(),
      r => scala.Option(r.nextToken()),
      r => zio.Chunk.fromIterable(r.resolverRuleAssociations().asScala)
    )(request.buildAwsValue())
      .map(result =>
        result
          .mapResponse(
            io.github.vigoo.zioaws.route53resolver.model.ListResolverRuleAssociationsResponse.wrap
          )
          .mapOutput(
            _.map(item =>
              io.github.vigoo.zioaws.route53resolver.model.ResolverRuleAssociation
                .wrap(item)
            )
          )
          .provide(r)
      )
      .provide(r)
    def updateResolverEndpoint(request: UpdateResolverEndpointRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.UpdateResolverEndpointResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.UpdateResolverEndpointRequest,
      UpdateResolverEndpointResponse
    ]("updateResolverEndpoint", api.updateResolverEndpoint)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.route53resolver.model.UpdateResolverEndpointResponse.wrap
    ).provide(r)
    def putResolverRulePolicy(request: PutResolverRulePolicyRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.PutResolverRulePolicyResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.PutResolverRulePolicyRequest,
      PutResolverRulePolicyResponse
    ]("putResolverRulePolicy", api.putResolverRulePolicy)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.route53resolver.model.PutResolverRulePolicyResponse.wrap
    ).provide(r)
    def getFirewallRuleGroupPolicy(
        request: GetFirewallRuleGroupPolicyRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.GetFirewallRuleGroupPolicyResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.GetFirewallRuleGroupPolicyRequest,
      GetFirewallRuleGroupPolicyResponse
    ]("getFirewallRuleGroupPolicy", api.getFirewallRuleGroupPolicy)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.route53resolver.model.GetFirewallRuleGroupPolicyResponse.wrap
    ).provide(r)
    def getResolverRuleAssociation(
        request: GetResolverRuleAssociationRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.GetResolverRuleAssociationResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.GetResolverRuleAssociationRequest,
      GetResolverRuleAssociationResponse
    ]("getResolverRuleAssociation", api.getResolverRuleAssociation)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.route53resolver.model.GetResolverRuleAssociationResponse.wrap
    ).provide(r)
    def disassociateFirewallRuleGroup(
        request: DisassociateFirewallRuleGroupRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.DisassociateFirewallRuleGroupResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.DisassociateFirewallRuleGroupRequest,
      DisassociateFirewallRuleGroupResponse
    ]("disassociateFirewallRuleGroup", api.disassociateFirewallRuleGroup)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.route53resolver.model.DisassociateFirewallRuleGroupResponse.wrap
    ).provide(r)
    def associateFirewallRuleGroup(
        request: AssociateFirewallRuleGroupRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.AssociateFirewallRuleGroupResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.AssociateFirewallRuleGroupRequest,
      AssociateFirewallRuleGroupResponse
    ]("associateFirewallRuleGroup", api.associateFirewallRuleGroup)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.route53resolver.model.AssociateFirewallRuleGroupResponse.wrap
    ).provide(r)
    def disassociateResolverRule(request: DisassociateResolverRuleRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.DisassociateResolverRuleResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.DisassociateResolverRuleRequest,
      DisassociateResolverRuleResponse
    ]("disassociateResolverRule", api.disassociateResolverRule)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.route53resolver.model.DisassociateResolverRuleResponse.wrap
    ).provide(r)
    def getResolverDnssecConfig(request: GetResolverDnssecConfigRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.GetResolverDnssecConfigResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.GetResolverDnssecConfigRequest,
      GetResolverDnssecConfigResponse
    ]("getResolverDnssecConfig", api.getResolverDnssecConfig)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.route53resolver.model.GetResolverDnssecConfigResponse.wrap
    ).provide(r)
    def listResolverDnssecConfigs(
        request: ListResolverDnssecConfigsRequest
    ): ZStream[
      Any,
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.ResolverDnssecConfig.ReadOnly
    ] = asyncSimplePaginatedRequest[
      software.amazon.awssdk.services.route53resolver.model.ListResolverDnssecConfigsRequest,
      ListResolverDnssecConfigsResponse,
      ResolverDnssecConfig
    ](
      "listResolverDnssecConfigs",
      api.listResolverDnssecConfigs,
      (r, token) => r.toBuilder().nextToken(token).build(),
      r => scala.Option(r.nextToken()),
      r => zio.Chunk.fromIterable(r.resolverDnssecConfigs().asScala)
    )(request.buildAwsValue())
      .map(item =>
        io.github.vigoo.zioaws.route53resolver.model.ResolverDnssecConfig
          .wrap(item)
      )
      .provide(r)
    def getResolverRule(request: GetResolverRuleRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.GetResolverRuleResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.GetResolverRuleRequest,
      GetResolverRuleResponse
    ]("getResolverRule", api.getResolverRule)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.route53resolver.model.GetResolverRuleResponse.wrap
      )
      .provide(r)
    def disassociateResolverQueryLogConfig(
        request: DisassociateResolverQueryLogConfigRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.DisassociateResolverQueryLogConfigResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.DisassociateResolverQueryLogConfigRequest,
      DisassociateResolverQueryLogConfigResponse
    ](
      "disassociateResolverQueryLogConfig",
      api.disassociateResolverQueryLogConfig
    )(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.route53resolver.model.DisassociateResolverQueryLogConfigResponse.wrap
      )
      .provide(r)
    def listFirewallConfigs(request: ListFirewallConfigsRequest): ZStream[
      Any,
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.FirewallConfig.ReadOnly
    ] = asyncSimplePaginatedRequest[
      software.amazon.awssdk.services.route53resolver.model.ListFirewallConfigsRequest,
      ListFirewallConfigsResponse,
      FirewallConfig
    ](
      "listFirewallConfigs",
      api.listFirewallConfigs,
      (r, token) => r.toBuilder().nextToken(token).build(),
      r => scala.Option(r.nextToken()),
      r => zio.Chunk.fromIterable(r.firewallConfigs().asScala)
    )(request.buildAwsValue())
      .map(item =>
        io.github.vigoo.zioaws.route53resolver.model.FirewallConfig.wrap(item)
      )
      .provide(r)
    def updateFirewallRuleGroupAssociation(
        request: UpdateFirewallRuleGroupAssociationRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.UpdateFirewallRuleGroupAssociationResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.UpdateFirewallRuleGroupAssociationRequest,
      UpdateFirewallRuleGroupAssociationResponse
    ](
      "updateFirewallRuleGroupAssociation",
      api.updateFirewallRuleGroupAssociation
    )(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.route53resolver.model.UpdateFirewallRuleGroupAssociationResponse.wrap
      )
      .provide(r)
    def updateFirewallDomains(request: UpdateFirewallDomainsRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.UpdateFirewallDomainsResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.UpdateFirewallDomainsRequest,
      UpdateFirewallDomainsResponse
    ]("updateFirewallDomains", api.updateFirewallDomains)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.route53resolver.model.UpdateFirewallDomainsResponse.wrap
    ).provide(r)
    def getResolverRulePolicy(request: GetResolverRulePolicyRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.GetResolverRulePolicyResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.GetResolverRulePolicyRequest,
      GetResolverRulePolicyResponse
    ]("getResolverRulePolicy", api.getResolverRulePolicy)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.route53resolver.model.GetResolverRulePolicyResponse.wrap
    ).provide(r)
    def createResolverQueryLogConfig(
        request: CreateResolverQueryLogConfigRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.CreateResolverQueryLogConfigResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.CreateResolverQueryLogConfigRequest,
      CreateResolverQueryLogConfigResponse
    ]("createResolverQueryLogConfig", api.createResolverQueryLogConfig)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.route53resolver.model.CreateResolverQueryLogConfigResponse.wrap
    ).provide(r)
    def deleteFirewallDomainList(request: DeleteFirewallDomainListRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.DeleteFirewallDomainListResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.DeleteFirewallDomainListRequest,
      DeleteFirewallDomainListResponse
    ]("deleteFirewallDomainList", api.deleteFirewallDomainList)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.route53resolver.model.DeleteFirewallDomainListResponse.wrap
    ).provide(r)
    def getResolverEndpoint(request: GetResolverEndpointRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.GetResolverEndpointResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.GetResolverEndpointRequest,
      GetResolverEndpointResponse
    ]("getResolverEndpoint", api.getResolverEndpoint)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.route53resolver.model.GetResolverEndpointResponse.wrap
      )
      .provide(r)
    def untagResource(request: UntagResourceRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.UntagResourceResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.UntagResourceRequest,
      UntagResourceResponse
    ]("untagResource", api.untagResource)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.route53resolver.model.UntagResourceResponse.wrap
      )
      .provide(r)
    def getResolverQueryLogConfigAssociation(
        request: GetResolverQueryLogConfigAssociationRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.GetResolverQueryLogConfigAssociationResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.GetResolverQueryLogConfigAssociationRequest,
      GetResolverQueryLogConfigAssociationResponse
    ](
      "getResolverQueryLogConfigAssociation",
      api.getResolverQueryLogConfigAssociation
    )(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.route53resolver.model.GetResolverQueryLogConfigAssociationResponse.wrap
      )
      .provide(r)
    def listResolverConfigs(request: ListResolverConfigsRequest): ZStream[
      Any,
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.ResolverConfig.ReadOnly
    ] = asyncSimplePaginatedRequest[
      software.amazon.awssdk.services.route53resolver.model.ListResolverConfigsRequest,
      ListResolverConfigsResponse,
      ResolverConfig
    ](
      "listResolverConfigs",
      api.listResolverConfigs,
      (r, token) => r.toBuilder().nextToken(token).build(),
      r => scala.Option(r.nextToken()),
      r => zio.Chunk.fromIterable(r.resolverConfigs().asScala)
    )(request.buildAwsValue())
      .map(item =>
        io.github.vigoo.zioaws.route53resolver.model.ResolverConfig.wrap(item)
      )
      .provide(r)
    def listResolverQueryLogConfigs(
        request: ListResolverQueryLogConfigsRequest
    ): ZIO[Any, AwsError, StreamingOutputResult[
      Any,
      io.github.vigoo.zioaws.route53resolver.model.ListResolverQueryLogConfigsResponse.ReadOnly,
      io.github.vigoo.zioaws.route53resolver.model.ResolverQueryLogConfig.ReadOnly
    ]] = asyncPaginatedRequest[
      software.amazon.awssdk.services.route53resolver.model.ListResolverQueryLogConfigsRequest,
      ListResolverQueryLogConfigsResponse,
      ResolverQueryLogConfig
    ](
      "listResolverQueryLogConfigs",
      api.listResolverQueryLogConfigs,
      (r, token) => r.toBuilder().nextToken(token).build(),
      r => scala.Option(r.nextToken()),
      r => zio.Chunk.fromIterable(r.resolverQueryLogConfigs().asScala)
    )(request.buildAwsValue())
      .map(result =>
        result
          .mapResponse(
            io.github.vigoo.zioaws.route53resolver.model.ListResolverQueryLogConfigsResponse.wrap
          )
          .mapOutput(
            _.map(item =>
              io.github.vigoo.zioaws.route53resolver.model.ResolverQueryLogConfig
                .wrap(item)
            )
          )
          .provide(r)
      )
      .provide(r)
    def listResolverQueryLogConfigAssociations(
        request: ListResolverQueryLogConfigAssociationsRequest
    ): ZIO[Any, AwsError, StreamingOutputResult[
      Any,
      io.github.vigoo.zioaws.route53resolver.model.ListResolverQueryLogConfigAssociationsResponse.ReadOnly,
      io.github.vigoo.zioaws.route53resolver.model.ResolverQueryLogConfigAssociation.ReadOnly
    ]] = asyncPaginatedRequest[
      software.amazon.awssdk.services.route53resolver.model.ListResolverQueryLogConfigAssociationsRequest,
      ListResolverQueryLogConfigAssociationsResponse,
      ResolverQueryLogConfigAssociation
    ](
      "listResolverQueryLogConfigAssociations",
      api.listResolverQueryLogConfigAssociations,
      (r, token) => r.toBuilder().nextToken(token).build(),
      r => scala.Option(r.nextToken()),
      r =>
        zio.Chunk.fromIterable(r.resolverQueryLogConfigAssociations().asScala)
    )(request.buildAwsValue())
      .map(result =>
        result
          .mapResponse(
            io.github.vigoo.zioaws.route53resolver.model.ListResolverQueryLogConfigAssociationsResponse.wrap
          )
          .mapOutput(
            _.map(item =>
              io.github.vigoo.zioaws.route53resolver.model.ResolverQueryLogConfigAssociation
                .wrap(item)
            )
          )
          .provide(r)
      )
      .provide(r)
    def putFirewallRuleGroupPolicy(
        request: PutFirewallRuleGroupPolicyRequest
    ): IO[AwsError, ReadOnly] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.PutFirewallRuleGroupPolicyRequest,
      PutFirewallRuleGroupPolicyResponse
    ]("putFirewallRuleGroupPolicy", api.putFirewallRuleGroupPolicy)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.route53resolver.model.PutFirewallRuleGroupPolicyResponse.wrap
    ).provide(r)
    def listTagsForResource(request: ListTagsForResourceRequest): ZStream[
      Any,
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.Tag.ReadOnly
    ] = asyncSimplePaginatedRequest[
      software.amazon.awssdk.services.route53resolver.model.ListTagsForResourceRequest,
      ListTagsForResourceResponse,
      Tag
    ](
      "listTagsForResource",
      api.listTagsForResource,
      (r, token) => r.toBuilder().nextToken(token).build(),
      r => scala.Option(r.nextToken()),
      r => zio.Chunk.fromIterable(r.tags().asScala)
    )(request.buildAwsValue())
      .map(item => io.github.vigoo.zioaws.route53resolver.model.Tag.wrap(item))
      .provide(r)
    def getFirewallRuleGroupAssociation(
        request: GetFirewallRuleGroupAssociationRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.GetFirewallRuleGroupAssociationResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.GetFirewallRuleGroupAssociationRequest,
      GetFirewallRuleGroupAssociationResponse
    ]("getFirewallRuleGroupAssociation", api.getFirewallRuleGroupAssociation)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.route53resolver.model.GetFirewallRuleGroupAssociationResponse.wrap
    ).provide(r)
    def associateResolverEndpointIpAddress(
        request: AssociateResolverEndpointIpAddressRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.AssociateResolverEndpointIpAddressResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.AssociateResolverEndpointIpAddressRequest,
      AssociateResolverEndpointIpAddressResponse
    ](
      "associateResolverEndpointIpAddress",
      api.associateResolverEndpointIpAddress
    )(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.route53resolver.model.AssociateResolverEndpointIpAddressResponse.wrap
      )
      .provide(r)
    def tagResource(request: TagResourceRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.TagResourceResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.TagResourceRequest,
      TagResourceResponse
    ]("tagResource", api.tagResource)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.route53resolver.model.TagResourceResponse.wrap
      )
      .provide(r)
    def importFirewallDomains(request: ImportFirewallDomainsRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.ImportFirewallDomainsResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.ImportFirewallDomainsRequest,
      ImportFirewallDomainsResponse
    ]("importFirewallDomains", api.importFirewallDomains)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.route53resolver.model.ImportFirewallDomainsResponse.wrap
    ).provide(r)
    def deleteResolverEndpoint(request: DeleteResolverEndpointRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.DeleteResolverEndpointResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.DeleteResolverEndpointRequest,
      DeleteResolverEndpointResponse
    ]("deleteResolverEndpoint", api.deleteResolverEndpoint)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.route53resolver.model.DeleteResolverEndpointResponse.wrap
    ).provide(r)
    def listFirewallRuleGroupAssociations(
        request: ListFirewallRuleGroupAssociationsRequest
    ): ZStream[
      Any,
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.FirewallRuleGroupAssociation.ReadOnly
    ] = asyncSimplePaginatedRequest[
      software.amazon.awssdk.services.route53resolver.model.ListFirewallRuleGroupAssociationsRequest,
      ListFirewallRuleGroupAssociationsResponse,
      FirewallRuleGroupAssociation
    ](
      "listFirewallRuleGroupAssociations",
      api.listFirewallRuleGroupAssociations,
      (r, token) => r.toBuilder().nextToken(token).build(),
      r => scala.Option(r.nextToken()),
      r => zio.Chunk.fromIterable(r.firewallRuleGroupAssociations().asScala)
    )(request.buildAwsValue())
      .map(item =>
        io.github.vigoo.zioaws.route53resolver.model.FirewallRuleGroupAssociation
          .wrap(item)
      )
      .provide(r)
    def listFirewallRules(request: ListFirewallRulesRequest): ZStream[
      Any,
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.FirewallRule.ReadOnly
    ] = asyncSimplePaginatedRequest[
      software.amazon.awssdk.services.route53resolver.model.ListFirewallRulesRequest,
      ListFirewallRulesResponse,
      FirewallRule
    ](
      "listFirewallRules",
      api.listFirewallRules,
      (r, token) => r.toBuilder().nextToken(token).build(),
      r => scala.Option(r.nextToken()),
      r => zio.Chunk.fromIterable(r.firewallRules().asScala)
    )(request.buildAwsValue())
      .map(item =>
        io.github.vigoo.zioaws.route53resolver.model.FirewallRule.wrap(item)
      )
      .provide(r)
    def listFirewallRuleGroups(request: ListFirewallRuleGroupsRequest): ZStream[
      Any,
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.FirewallRuleGroupMetadata.ReadOnly
    ] = asyncSimplePaginatedRequest[
      software.amazon.awssdk.services.route53resolver.model.ListFirewallRuleGroupsRequest,
      ListFirewallRuleGroupsResponse,
      FirewallRuleGroupMetadata
    ](
      "listFirewallRuleGroups",
      api.listFirewallRuleGroups,
      (r, token) => r.toBuilder().nextToken(token).build(),
      r => scala.Option(r.nextToken()),
      r => zio.Chunk.fromIterable(r.firewallRuleGroups().asScala)
    )(request.buildAwsValue())
      .map(item =>
        io.github.vigoo.zioaws.route53resolver.model.FirewallRuleGroupMetadata
          .wrap(item)
      )
      .provide(r)
    def deleteResolverRule(request: DeleteResolverRuleRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.DeleteResolverRuleResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.DeleteResolverRuleRequest,
      DeleteResolverRuleResponse
    ]("deleteResolverRule", api.deleteResolverRule)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.route53resolver.model.DeleteResolverRuleResponse.wrap
      )
      .provide(r)
    def getResolverConfig(request: GetResolverConfigRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.GetResolverConfigResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.GetResolverConfigRequest,
      GetResolverConfigResponse
    ]("getResolverConfig", api.getResolverConfig)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.route53resolver.model.GetResolverConfigResponse.wrap
      )
      .provide(r)
    def updateFirewallRule(request: UpdateFirewallRuleRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.UpdateFirewallRuleResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.UpdateFirewallRuleRequest,
      UpdateFirewallRuleResponse
    ]("updateFirewallRule", api.updateFirewallRule)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.route53resolver.model.UpdateFirewallRuleResponse.wrap
      )
      .provide(r)
    def getResolverQueryLogConfigPolicy(
        request: GetResolverQueryLogConfigPolicyRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.GetResolverQueryLogConfigPolicyResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.GetResolverQueryLogConfigPolicyRequest,
      GetResolverQueryLogConfigPolicyResponse
    ]("getResolverQueryLogConfigPolicy", api.getResolverQueryLogConfigPolicy)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.route53resolver.model.GetResolverQueryLogConfigPolicyResponse.wrap
    ).provide(r)
    def createFirewallDomainList(request: CreateFirewallDomainListRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.CreateFirewallDomainListResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.CreateFirewallDomainListRequest,
      CreateFirewallDomainListResponse
    ]("createFirewallDomainList", api.createFirewallDomainList)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.route53resolver.model.CreateFirewallDomainListResponse.wrap
    ).provide(r)
    def getFirewallConfig(request: GetFirewallConfigRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.GetFirewallConfigResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.GetFirewallConfigRequest,
      GetFirewallConfigResponse
    ]("getFirewallConfig", api.getFirewallConfig)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.route53resolver.model.GetFirewallConfigResponse.wrap
      )
      .provide(r)
    def updateResolverDnssecConfig(
        request: UpdateResolverDnssecConfigRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.UpdateResolverDnssecConfigResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.UpdateResolverDnssecConfigRequest,
      UpdateResolverDnssecConfigResponse
    ]("updateResolverDnssecConfig", api.updateResolverDnssecConfig)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.route53resolver.model.UpdateResolverDnssecConfigResponse.wrap
    ).provide(r)
    def associateResolverRule(request: AssociateResolverRuleRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.AssociateResolverRuleResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.AssociateResolverRuleRequest,
      AssociateResolverRuleResponse
    ]("associateResolverRule", api.associateResolverRule)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.route53resolver.model.AssociateResolverRuleResponse.wrap
    ).provide(r)
    def createResolverRule(request: CreateResolverRuleRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.CreateResolverRuleResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.CreateResolverRuleRequest,
      CreateResolverRuleResponse
    ]("createResolverRule", api.createResolverRule)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.route53resolver.model.CreateResolverRuleResponse.wrap
      )
      .provide(r)
    def putResolverQueryLogConfigPolicy(
        request: PutResolverQueryLogConfigPolicyRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.PutResolverQueryLogConfigPolicyResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.PutResolverQueryLogConfigPolicyRequest,
      PutResolverQueryLogConfigPolicyResponse
    ]("putResolverQueryLogConfigPolicy", api.putResolverQueryLogConfigPolicy)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.route53resolver.model.PutResolverQueryLogConfigPolicyResponse.wrap
    ).provide(r)
    def getFirewallRuleGroup(request: GetFirewallRuleGroupRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.route53resolver.model.GetFirewallRuleGroupResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.route53resolver.model.GetFirewallRuleGroupRequest,
      GetFirewallRuleGroupResponse
    ]("getFirewallRuleGroup", api.getFirewallRuleGroup)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.route53resolver.model.GetFirewallRuleGroupResponse.wrap
      )
      .provide(r)
  }
  def updateFirewallConfig(request: UpdateFirewallConfigRequest): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.UpdateFirewallConfigResponse.ReadOnly
  ] = ZIO.accessM(_.get.updateFirewallConfig(request))
  def deleteFirewallRuleGroup(request: DeleteFirewallRuleGroupRequest): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.DeleteFirewallRuleGroupResponse.ReadOnly
  ] = ZIO.accessM(_.get.deleteFirewallRuleGroup(request))
  def listFirewallDomainLists(request: ListFirewallDomainListsRequest): ZStream[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.FirewallDomainListMetadata.ReadOnly
  ] = ZStream.accessStream(_.get.listFirewallDomainLists(request))
  def deleteResolverQueryLogConfig(
      request: DeleteResolverQueryLogConfigRequest
  ): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.DeleteResolverQueryLogConfigResponse.ReadOnly
  ] = ZIO.accessM(_.get.deleteResolverQueryLogConfig(request))
  def getResolverQueryLogConfig(request: GetResolverQueryLogConfigRequest): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.GetResolverQueryLogConfigResponse.ReadOnly
  ] = ZIO.accessM(_.get.getResolverQueryLogConfig(request))
  def createFirewallRule(request: CreateFirewallRuleRequest): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.CreateFirewallRuleResponse.ReadOnly
  ] = ZIO.accessM(_.get.createFirewallRule(request))
  def updateResolverConfig(request: UpdateResolverConfigRequest): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.UpdateResolverConfigResponse.ReadOnly
  ] = ZIO.accessM(_.get.updateResolverConfig(request))
  def listResolverEndpointIpAddresses(
      request: ListResolverEndpointIpAddressesRequest
  ): ZIO[Route53Resolver, AwsError, StreamingOutputResult[
    Any,
    io.github.vigoo.zioaws.route53resolver.model.ListResolverEndpointIpAddressesResponse.ReadOnly,
    io.github.vigoo.zioaws.route53resolver.model.IpAddressResponse.ReadOnly
  ]] = ZIO.accessM(_.get.listResolverEndpointIpAddresses(request))
  def listResolverEndpoints(
      request: ListResolverEndpointsRequest
  ): ZIO[Route53Resolver, AwsError, StreamingOutputResult[
    Any,
    io.github.vigoo.zioaws.route53resolver.model.ListResolverEndpointsResponse.ReadOnly,
    io.github.vigoo.zioaws.route53resolver.model.ResolverEndpoint.ReadOnly
  ]] = ZIO.accessM(_.get.listResolverEndpoints(request))
  def listResolverRules(
      request: ListResolverRulesRequest
  ): ZIO[Route53Resolver, AwsError, StreamingOutputResult[
    Any,
    io.github.vigoo.zioaws.route53resolver.model.ListResolverRulesResponse.ReadOnly,
    io.github.vigoo.zioaws.route53resolver.model.ResolverRule.ReadOnly
  ]] = ZIO.accessM(_.get.listResolverRules(request))
  def deleteFirewallRule(request: DeleteFirewallRuleRequest): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.DeleteFirewallRuleResponse.ReadOnly
  ] = ZIO.accessM(_.get.deleteFirewallRule(request))
  def associateResolverQueryLogConfig(
      request: AssociateResolverQueryLogConfigRequest
  ): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.AssociateResolverQueryLogConfigResponse.ReadOnly
  ] = ZIO.accessM(_.get.associateResolverQueryLogConfig(request))
  def listFirewallDomains(
      request: ListFirewallDomainsRequest
  ): ZStream[Route53Resolver, AwsError, FirewallDomainName] =
    ZStream.accessStream(_.get.listFirewallDomains(request))
  def getFirewallDomainList(request: GetFirewallDomainListRequest): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.GetFirewallDomainListResponse.ReadOnly
  ] = ZIO.accessM(_.get.getFirewallDomainList(request))
  def createFirewallRuleGroup(request: CreateFirewallRuleGroupRequest): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.CreateFirewallRuleGroupResponse.ReadOnly
  ] = ZIO.accessM(_.get.createFirewallRuleGroup(request))
  def disassociateResolverEndpointIpAddress(
      request: DisassociateResolverEndpointIpAddressRequest
  ): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.DisassociateResolverEndpointIpAddressResponse.ReadOnly
  ] = ZIO.accessM(_.get.disassociateResolverEndpointIpAddress(request))
  def updateResolverRule(request: UpdateResolverRuleRequest): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.UpdateResolverRuleResponse.ReadOnly
  ] = ZIO.accessM(_.get.updateResolverRule(request))
  def createResolverEndpoint(request: CreateResolverEndpointRequest): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.CreateResolverEndpointResponse.ReadOnly
  ] = ZIO.accessM(_.get.createResolverEndpoint(request))
  def listResolverRuleAssociations(
      request: ListResolverRuleAssociationsRequest
  ): ZIO[Route53Resolver, AwsError, StreamingOutputResult[
    Any,
    io.github.vigoo.zioaws.route53resolver.model.ListResolverRuleAssociationsResponse.ReadOnly,
    io.github.vigoo.zioaws.route53resolver.model.ResolverRuleAssociation.ReadOnly
  ]] = ZIO.accessM(_.get.listResolverRuleAssociations(request))
  def updateResolverEndpoint(request: UpdateResolverEndpointRequest): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.UpdateResolverEndpointResponse.ReadOnly
  ] = ZIO.accessM(_.get.updateResolverEndpoint(request))
  def putResolverRulePolicy(request: PutResolverRulePolicyRequest): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.PutResolverRulePolicyResponse.ReadOnly
  ] = ZIO.accessM(_.get.putResolverRulePolicy(request))
  def getFirewallRuleGroupPolicy(
      request: GetFirewallRuleGroupPolicyRequest
  ): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.GetFirewallRuleGroupPolicyResponse.ReadOnly
  ] = ZIO.accessM(_.get.getFirewallRuleGroupPolicy(request))
  def getResolverRuleAssociation(
      request: GetResolverRuleAssociationRequest
  ): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.GetResolverRuleAssociationResponse.ReadOnly
  ] = ZIO.accessM(_.get.getResolverRuleAssociation(request))
  def disassociateFirewallRuleGroup(
      request: DisassociateFirewallRuleGroupRequest
  ): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.DisassociateFirewallRuleGroupResponse.ReadOnly
  ] = ZIO.accessM(_.get.disassociateFirewallRuleGroup(request))
  def associateFirewallRuleGroup(
      request: AssociateFirewallRuleGroupRequest
  ): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.AssociateFirewallRuleGroupResponse.ReadOnly
  ] = ZIO.accessM(_.get.associateFirewallRuleGroup(request))
  def disassociateResolverRule(request: DisassociateResolverRuleRequest): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.DisassociateResolverRuleResponse.ReadOnly
  ] = ZIO.accessM(_.get.disassociateResolverRule(request))
  def getResolverDnssecConfig(request: GetResolverDnssecConfigRequest): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.GetResolverDnssecConfigResponse.ReadOnly
  ] = ZIO.accessM(_.get.getResolverDnssecConfig(request))
  def listResolverDnssecConfigs(
      request: ListResolverDnssecConfigsRequest
  ): ZStream[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.ResolverDnssecConfig.ReadOnly
  ] = ZStream.accessStream(_.get.listResolverDnssecConfigs(request))
  def getResolverRule(request: GetResolverRuleRequest): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.GetResolverRuleResponse.ReadOnly
  ] = ZIO.accessM(_.get.getResolverRule(request))
  def disassociateResolverQueryLogConfig(
      request: DisassociateResolverQueryLogConfigRequest
  ): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.DisassociateResolverQueryLogConfigResponse.ReadOnly
  ] = ZIO.accessM(_.get.disassociateResolverQueryLogConfig(request))
  def listFirewallConfigs(request: ListFirewallConfigsRequest): ZStream[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.FirewallConfig.ReadOnly
  ] = ZStream.accessStream(_.get.listFirewallConfigs(request))
  def updateFirewallRuleGroupAssociation(
      request: UpdateFirewallRuleGroupAssociationRequest
  ): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.UpdateFirewallRuleGroupAssociationResponse.ReadOnly
  ] = ZIO.accessM(_.get.updateFirewallRuleGroupAssociation(request))
  def updateFirewallDomains(request: UpdateFirewallDomainsRequest): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.UpdateFirewallDomainsResponse.ReadOnly
  ] = ZIO.accessM(_.get.updateFirewallDomains(request))
  def getResolverRulePolicy(request: GetResolverRulePolicyRequest): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.GetResolverRulePolicyResponse.ReadOnly
  ] = ZIO.accessM(_.get.getResolverRulePolicy(request))
  def createResolverQueryLogConfig(
      request: CreateResolverQueryLogConfigRequest
  ): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.CreateResolverQueryLogConfigResponse.ReadOnly
  ] = ZIO.accessM(_.get.createResolverQueryLogConfig(request))
  def deleteFirewallDomainList(request: DeleteFirewallDomainListRequest): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.DeleteFirewallDomainListResponse.ReadOnly
  ] = ZIO.accessM(_.get.deleteFirewallDomainList(request))
  def getResolverEndpoint(request: GetResolverEndpointRequest): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.GetResolverEndpointResponse.ReadOnly
  ] = ZIO.accessM(_.get.getResolverEndpoint(request))
  def untagResource(request: UntagResourceRequest): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.UntagResourceResponse.ReadOnly
  ] = ZIO.accessM(_.get.untagResource(request))
  def getResolverQueryLogConfigAssociation(
      request: GetResolverQueryLogConfigAssociationRequest
  ): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.GetResolverQueryLogConfigAssociationResponse.ReadOnly
  ] = ZIO.accessM(_.get.getResolverQueryLogConfigAssociation(request))
  def listResolverConfigs(request: ListResolverConfigsRequest): ZStream[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.ResolverConfig.ReadOnly
  ] = ZStream.accessStream(_.get.listResolverConfigs(request))
  def listResolverQueryLogConfigs(
      request: ListResolverQueryLogConfigsRequest
  ): ZIO[Route53Resolver, AwsError, StreamingOutputResult[
    Any,
    io.github.vigoo.zioaws.route53resolver.model.ListResolverQueryLogConfigsResponse.ReadOnly,
    io.github.vigoo.zioaws.route53resolver.model.ResolverQueryLogConfig.ReadOnly
  ]] = ZIO.accessM(_.get.listResolverQueryLogConfigs(request))
  def listResolverQueryLogConfigAssociations(
      request: ListResolverQueryLogConfigAssociationsRequest
  ): ZIO[Route53Resolver, AwsError, StreamingOutputResult[
    Any,
    io.github.vigoo.zioaws.route53resolver.model.ListResolverQueryLogConfigAssociationsResponse.ReadOnly,
    io.github.vigoo.zioaws.route53resolver.model.ResolverQueryLogConfigAssociation.ReadOnly
  ]] = ZIO.accessM(_.get.listResolverQueryLogConfigAssociations(request))
  def putFirewallRuleGroupPolicy(
      request: PutFirewallRuleGroupPolicyRequest
  ): ZIO[Route53Resolver, AwsError, ReadOnly] =
    ZIO.accessM(_.get.putFirewallRuleGroupPolicy(request))
  def listTagsForResource(request: ListTagsForResourceRequest): ZStream[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.Tag.ReadOnly
  ] = ZStream.accessStream(_.get.listTagsForResource(request))
  def getFirewallRuleGroupAssociation(
      request: GetFirewallRuleGroupAssociationRequest
  ): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.GetFirewallRuleGroupAssociationResponse.ReadOnly
  ] = ZIO.accessM(_.get.getFirewallRuleGroupAssociation(request))
  def associateResolverEndpointIpAddress(
      request: AssociateResolverEndpointIpAddressRequest
  ): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.AssociateResolverEndpointIpAddressResponse.ReadOnly
  ] = ZIO.accessM(_.get.associateResolverEndpointIpAddress(request))
  def tagResource(request: TagResourceRequest): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.TagResourceResponse.ReadOnly
  ] = ZIO.accessM(_.get.tagResource(request))
  def importFirewallDomains(request: ImportFirewallDomainsRequest): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.ImportFirewallDomainsResponse.ReadOnly
  ] = ZIO.accessM(_.get.importFirewallDomains(request))
  def deleteResolverEndpoint(request: DeleteResolverEndpointRequest): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.DeleteResolverEndpointResponse.ReadOnly
  ] = ZIO.accessM(_.get.deleteResolverEndpoint(request))
  def listFirewallRuleGroupAssociations(
      request: ListFirewallRuleGroupAssociationsRequest
  ): ZStream[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.FirewallRuleGroupAssociation.ReadOnly
  ] = ZStream.accessStream(_.get.listFirewallRuleGroupAssociations(request))
  def listFirewallRules(request: ListFirewallRulesRequest): ZStream[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.FirewallRule.ReadOnly
  ] = ZStream.accessStream(_.get.listFirewallRules(request))
  def listFirewallRuleGroups(request: ListFirewallRuleGroupsRequest): ZStream[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.FirewallRuleGroupMetadata.ReadOnly
  ] = ZStream.accessStream(_.get.listFirewallRuleGroups(request))
  def deleteResolverRule(request: DeleteResolverRuleRequest): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.DeleteResolverRuleResponse.ReadOnly
  ] = ZIO.accessM(_.get.deleteResolverRule(request))
  def getResolverConfig(request: GetResolverConfigRequest): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.GetResolverConfigResponse.ReadOnly
  ] = ZIO.accessM(_.get.getResolverConfig(request))
  def updateFirewallRule(request: UpdateFirewallRuleRequest): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.UpdateFirewallRuleResponse.ReadOnly
  ] = ZIO.accessM(_.get.updateFirewallRule(request))
  def getResolverQueryLogConfigPolicy(
      request: GetResolverQueryLogConfigPolicyRequest
  ): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.GetResolverQueryLogConfigPolicyResponse.ReadOnly
  ] = ZIO.accessM(_.get.getResolverQueryLogConfigPolicy(request))
  def createFirewallDomainList(request: CreateFirewallDomainListRequest): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.CreateFirewallDomainListResponse.ReadOnly
  ] = ZIO.accessM(_.get.createFirewallDomainList(request))
  def getFirewallConfig(request: GetFirewallConfigRequest): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.GetFirewallConfigResponse.ReadOnly
  ] = ZIO.accessM(_.get.getFirewallConfig(request))
  def updateResolverDnssecConfig(
      request: UpdateResolverDnssecConfigRequest
  ): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.UpdateResolverDnssecConfigResponse.ReadOnly
  ] = ZIO.accessM(_.get.updateResolverDnssecConfig(request))
  def associateResolverRule(request: AssociateResolverRuleRequest): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.AssociateResolverRuleResponse.ReadOnly
  ] = ZIO.accessM(_.get.associateResolverRule(request))
  def createResolverRule(request: CreateResolverRuleRequest): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.CreateResolverRuleResponse.ReadOnly
  ] = ZIO.accessM(_.get.createResolverRule(request))
  def putResolverQueryLogConfigPolicy(
      request: PutResolverQueryLogConfigPolicyRequest
  ): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.PutResolverQueryLogConfigPolicyResponse.ReadOnly
  ] = ZIO.accessM(_.get.putResolverQueryLogConfigPolicy(request))
  def getFirewallRuleGroup(request: GetFirewallRuleGroupRequest): ZIO[
    Route53Resolver,
    AwsError,
    io.github.vigoo.zioaws.route53resolver.model.GetFirewallRuleGroupResponse.ReadOnly
  ] = ZIO.accessM(_.get.getFirewallRuleGroup(request))
}