• Home
• io.github.vigoo
• zio-aws-lightsail_2.12
• 3.16.61.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.lightsail.package.scala Maven / Gradle / Ivy

package io.github.vigoo.zioaws
import io.github.vigoo.zioaws.core._
import io.github.vigoo.zioaws.core.aspects._
import io.github.vigoo.zioaws.core.config.AwsConfig
import io.github.vigoo.zioaws.core.httpclient.ServiceHttpCapabilities
import software.amazon.awssdk.services.lightsail.{ LightsailAsyncClient, LightsailAsyncClientBuilder }
import zio.{ Chunk, Has, IO, ZIO, ZLayer, ZManaged }
import zio.stream.ZStream
import org.reactivestreams.Publisher
import scala.jdk.CollectionConverters._
package object lightsail {
  import model._
  type Lightsail = Has[Lightsail.Service]
  object Lightsail {
    trait Service extends AspectSupport[Service] {
      val api: LightsailAsyncClient
      def putInstancePublicPorts(request: PutInstancePublicPortsRequest): IO[AwsError, PutInstancePublicPortsResponse.ReadOnly]
      def resetDistributionCache(request: ResetDistributionCacheRequest): IO[AwsError, ResetDistributionCacheResponse.ReadOnly]
      def getRelationalDatabaseSnapshot(request: GetRelationalDatabaseSnapshotRequest): IO[AwsError, GetRelationalDatabaseSnapshotResponse.ReadOnly]
      def getKeyPair(request: GetKeyPairRequest): IO[AwsError, GetKeyPairResponse.ReadOnly]
      def getInstanceAccessDetails(request: GetInstanceAccessDetailsRequest): IO[AwsError, GetInstanceAccessDetailsResponse.ReadOnly]
      def deleteLoadBalancerTlsCertificate(request: DeleteLoadBalancerTlsCertificateRequest): IO[AwsError, DeleteLoadBalancerTlsCertificateResponse.ReadOnly]
      def createDiskSnapshot(request: CreateDiskSnapshotRequest): IO[AwsError, CreateDiskSnapshotResponse.ReadOnly]
      def deleteRelationalDatabase(request: DeleteRelationalDatabaseRequest): IO[AwsError, DeleteRelationalDatabaseResponse.ReadOnly]
      def releaseStaticIp(request: ReleaseStaticIpRequest): IO[AwsError, ReleaseStaticIpResponse.ReadOnly]
      def updateLoadBalancerAttribute(request: UpdateLoadBalancerAttributeRequest): IO[AwsError, UpdateLoadBalancerAttributeResponse.ReadOnly]
      def testAlarm(request: TestAlarmRequest): IO[AwsError, TestAlarmResponse.ReadOnly]
      def closeInstancePublicPorts(request: CloseInstancePublicPortsRequest): IO[AwsError, CloseInstancePublicPortsResponse.ReadOnly]
      def deleteContactMethod(request: DeleteContactMethodRequest): IO[AwsError, DeleteContactMethodResponse.ReadOnly]
      def deleteDiskSnapshot(request: DeleteDiskSnapshotRequest): IO[AwsError, DeleteDiskSnapshotResponse.ReadOnly]
      def putAlarm(request: PutAlarmRequest): IO[AwsError, PutAlarmResponse.ReadOnly]
      def getInstances(request: GetInstancesRequest): IO[AwsError, GetInstancesResponse.ReadOnly]
      def createCertificate(request: CreateCertificateRequest): IO[AwsError, CreateCertificateResponse.ReadOnly]
      def getRelationalDatabaseLogEvents(request: GetRelationalDatabaseLogEventsRequest): IO[AwsError, GetRelationalDatabaseLogEventsResponse.ReadOnly]
      def deleteKnownHostKeys(request: DeleteKnownHostKeysRequest): IO[AwsError, DeleteKnownHostKeysResponse.ReadOnly]
      def rebootRelationalDatabase(request: RebootRelationalDatabaseRequest): IO[AwsError, RebootRelationalDatabaseResponse.ReadOnly]
      def createCloudFormationStack(request: CreateCloudFormationStackRequest): IO[AwsError, CreateCloudFormationStackResponse.ReadOnly]
      def detachDisk(request: DetachDiskRequest): IO[AwsError, DetachDiskResponse.ReadOnly]
      def allocateStaticIp(request: AllocateStaticIpRequest): IO[AwsError, AllocateStaticIpResponse.ReadOnly]
      def getRelationalDatabaseEvents(request: GetRelationalDatabaseEventsRequest): IO[AwsError, GetRelationalDatabaseEventsResponse.ReadOnly]
      def getOperations(request: GetOperationsRequest): IO[AwsError, GetOperationsResponse.ReadOnly]
      def getInstanceState(request: GetInstanceStateRequest): IO[AwsError, GetInstanceStateResponse.ReadOnly]
      def getDomains(request: GetDomainsRequest): IO[AwsError, GetDomainsResponse.ReadOnly]
      def getLoadBalancers(request: GetLoadBalancersRequest): IO[AwsError, GetLoadBalancersResponse.ReadOnly]
      def getContainerServices(request: GetContainerServicesRequest): IO[AwsError, GetContainerServicesResponse.ReadOnly]
      def getLoadBalancerTlsCertificates(request: GetLoadBalancerTlsCertificatesRequest): IO[AwsError, GetLoadBalancerTlsCertificatesResponse.ReadOnly]
      def createRelationalDatabaseFromSnapshot(request: CreateRelationalDatabaseFromSnapshotRequest): IO[AwsError, CreateRelationalDatabaseFromSnapshotResponse.ReadOnly]
      def getInstanceSnapshot(request: GetInstanceSnapshotRequest): IO[AwsError, GetInstanceSnapshotResponse.ReadOnly]
      def deleteContainerService(request: DeleteContainerServiceRequest): IO[AwsError, DeleteContainerServiceResponse.ReadOnly]
      def getContainerAPIMetadata(request: GetContainerApiMetadataRequest): IO[AwsError, GetContainerApiMetadataResponse.ReadOnly]
      def getDiskSnapshot(request: GetDiskSnapshotRequest): IO[AwsError, GetDiskSnapshotResponse.ReadOnly]
      def detachStaticIp(request: DetachStaticIpRequest): IO[AwsError, DetachStaticIpResponse.ReadOnly]
      def createDisk(request: CreateDiskRequest): IO[AwsError, CreateDiskResponse.ReadOnly]
      def getContainerImages(request: GetContainerImagesRequest): IO[AwsError, GetContainerImagesResponse.ReadOnly]
      def createDomainEntry(request: CreateDomainEntryRequest): IO[AwsError, CreateDomainEntryResponse.ReadOnly]
      def sendContactMethodVerification(request: SendContactMethodVerificationRequest): IO[AwsError, SendContactMethodVerificationResponse.ReadOnly]
      def getDomain(request: GetDomainRequest): IO[AwsError, GetDomainResponse.ReadOnly]
      def deleteInstance(request: DeleteInstanceRequest): IO[AwsError, DeleteInstanceResponse.ReadOnly]
      def copySnapshot(request: CopySnapshotRequest): IO[AwsError, CopySnapshotResponse.ReadOnly]
      def getContactMethods(request: GetContactMethodsRequest): IO[AwsError, GetContactMethodsResponse.ReadOnly]
      def getRelationalDatabaseBundles(request: GetRelationalDatabaseBundlesRequest): IO[AwsError, GetRelationalDatabaseBundlesResponse.ReadOnly]
      def detachInstancesFromLoadBalancer(request: DetachInstancesFromLoadBalancerRequest): IO[AwsError, DetachInstancesFromLoadBalancerResponse.ReadOnly]
      def openInstancePublicPorts(request: OpenInstancePublicPortsRequest): IO[AwsError, OpenInstancePublicPortsResponse.ReadOnly]
      def getInstanceMetricData(request: GetInstanceMetricDataRequest): IO[AwsError, GetInstanceMetricDataResponse.ReadOnly]
      def deleteRelationalDatabaseSnapshot(request: DeleteRelationalDatabaseSnapshotRequest): IO[AwsError, DeleteRelationalDatabaseSnapshotResponse.ReadOnly]
      def attachInstancesToLoadBalancer(request: AttachInstancesToLoadBalancerRequest): IO[AwsError, AttachInstancesToLoadBalancerResponse.ReadOnly]
      def getDistributionBundles(request: GetDistributionBundlesRequest): IO[AwsError, GetDistributionBundlesResponse.ReadOnly]
      def getRelationalDatabaseParameters(request: GetRelationalDatabaseParametersRequest): IO[AwsError, GetRelationalDatabaseParametersResponse.ReadOnly]
      def getAlarms(request: GetAlarmsRequest): IO[AwsError, GetAlarmsResponse.ReadOnly]
      def deleteLoadBalancer(request: DeleteLoadBalancerRequest): IO[AwsError, DeleteLoadBalancerResponse.ReadOnly]
      def getInstanceSnapshots(request: GetInstanceSnapshotsRequest): IO[AwsError, GetInstanceSnapshotsResponse.ReadOnly]
      def stopRelationalDatabase(request: StopRelationalDatabaseRequest): IO[AwsError, StopRelationalDatabaseResponse.ReadOnly]
      def getLoadBalancerMetricData(request: GetLoadBalancerMetricDataRequest): IO[AwsError, GetLoadBalancerMetricDataResponse.ReadOnly]
      def attachCertificateToDistribution(request: AttachCertificateToDistributionRequest): IO[AwsError, AttachCertificateToDistributionResponse.ReadOnly]
      def deleteCertificate(request: DeleteCertificateRequest): IO[AwsError, DeleteCertificateResponse.ReadOnly]
      def getInstance(request: GetInstanceRequest): IO[AwsError, GetInstanceResponse.ReadOnly]
      def getDistributions(request: GetDistributionsRequest): IO[AwsError, GetDistributionsResponse.ReadOnly]
      def getRelationalDatabases(request: GetRelationalDatabasesRequest): IO[AwsError, GetRelationalDatabasesResponse.ReadOnly]
      def attachLoadBalancerTlsCertificate(request: AttachLoadBalancerTlsCertificateRequest): IO[AwsError, AttachLoadBalancerTlsCertificateResponse.ReadOnly]
      def getOperationsForResource(request: GetOperationsForResourceRequest): IO[AwsError, GetOperationsForResourceResponse.ReadOnly]
      def createDiskFromSnapshot(request: CreateDiskFromSnapshotRequest): IO[AwsError, CreateDiskFromSnapshotResponse.ReadOnly]
      def getLoadBalancer(request: GetLoadBalancerRequest): IO[AwsError, GetLoadBalancerResponse.ReadOnly]
      def deleteInstanceSnapshot(request: DeleteInstanceSnapshotRequest): IO[AwsError, DeleteInstanceSnapshotResponse.ReadOnly]
      def deleteDomainEntry(request: DeleteDomainEntryRequest): IO[AwsError, DeleteDomainEntryResponse.ReadOnly]
      def updateRelationalDatabase(request: UpdateRelationalDatabaseRequest): IO[AwsError, UpdateRelationalDatabaseResponse.ReadOnly]
      def peerVpc(request: PeerVpcRequest): IO[AwsError, PeerVpcResponse.ReadOnly]
      def unpeerVpc(request: UnpeerVpcRequest): IO[AwsError, UnpeerVpcResponse.ReadOnly]
      def getActiveNames(request: GetActiveNamesRequest): IO[AwsError, GetActiveNamesResponse.ReadOnly]
      def getAutoSnapshots(request: GetAutoSnapshotsRequest): IO[AwsError, GetAutoSnapshotsResponse.ReadOnly]
      def startRelationalDatabase(request: StartRelationalDatabaseRequest): IO[AwsError, StartRelationalDatabaseResponse.ReadOnly]
      def createInstanceSnapshot(request: CreateInstanceSnapshotRequest): IO[AwsError, CreateInstanceSnapshotResponse.ReadOnly]
      def updateDomainEntry(request: UpdateDomainEntryRequest): IO[AwsError, UpdateDomainEntryResponse.ReadOnly]
      def rebootInstance(request: RebootInstanceRequest): IO[AwsError, RebootInstanceResponse.ReadOnly]
      def createContactMethod(request: CreateContactMethodRequest): IO[AwsError, CreateContactMethodResponse.ReadOnly]
      def getDiskSnapshots(request: GetDiskSnapshotsRequest): IO[AwsError, GetDiskSnapshotsResponse.ReadOnly]
      def getContainerLog(request: GetContainerLogRequest): IO[AwsError, GetContainerLogResponse.ReadOnly]
      def getContainerServiceDeployments(request: GetContainerServiceDeploymentsRequest): IO[AwsError, GetContainerServiceDeploymentsResponse.ReadOnly]
      def createDomain(request: CreateDomainRequest): IO[AwsError, CreateDomainResponse.ReadOnly]
      def createContainerService(request: CreateContainerServiceRequest): IO[AwsError, CreateContainerServiceResponse.ReadOnly]
      def isVpcPeered(request: IsVpcPeeredRequest): IO[AwsError, IsVpcPeeredResponse.ReadOnly]
      def deleteAutoSnapshot(request: DeleteAutoSnapshotRequest): IO[AwsError, DeleteAutoSnapshotResponse.ReadOnly]
      def createContainerServiceRegistryLogin(request: CreateContainerServiceRegistryLoginRequest): IO[AwsError, CreateContainerServiceRegistryLoginResponse.ReadOnly]
      def getDisk(request: GetDiskRequest): IO[AwsError, GetDiskResponse.ReadOnly]
      def enableAddOn(request: EnableAddOnRequest): IO[AwsError, EnableAddOnResponse.ReadOnly]
      def untagResource(request: UntagResourceRequest): IO[AwsError, UntagResourceResponse.ReadOnly]
      def createLoadBalancerTlsCertificate(request: CreateLoadBalancerTlsCertificateRequest): IO[AwsError, CreateLoadBalancerTlsCertificateResponse.ReadOnly]
      def getStaticIp(request: GetStaticIpRequest): IO[AwsError, GetStaticIpResponse.ReadOnly]
      def attachStaticIp(request: AttachStaticIpRequest): IO[AwsError, AttachStaticIpResponse.ReadOnly]
      def importKeyPair(request: ImportKeyPairRequest): IO[AwsError, ImportKeyPairResponse.ReadOnly]
      def getDisks(request: GetDisksRequest): IO[AwsError, GetDisksResponse.ReadOnly]
      def downloadDefaultKeyPair(request: DownloadDefaultKeyPairRequest): IO[AwsError, DownloadDefaultKeyPairResponse.ReadOnly]
      def getExportSnapshotRecords(request: GetExportSnapshotRecordsRequest): IO[AwsError, GetExportSnapshotRecordsResponse.ReadOnly]
      def createKeyPair(request: CreateKeyPairRequest): IO[AwsError, CreateKeyPairResponse.ReadOnly]
      def getBundles(request: GetBundlesRequest): IO[AwsError, GetBundlesResponse.ReadOnly]
      def registerContainerImage(request: RegisterContainerImageRequest): IO[AwsError, RegisterContainerImageResponse.ReadOnly]
      def startInstance(request: StartInstanceRequest): IO[AwsError, StartInstanceResponse.ReadOnly]
      def getInstancePortStates(request: GetInstancePortStatesRequest): IO[AwsError, GetInstancePortStatesResponse.ReadOnly]
      def deleteDisk(request: DeleteDiskRequest): IO[AwsError, DeleteDiskResponse.ReadOnly]
      def getBlueprints(request: GetBlueprintsRequest): IO[AwsError, GetBlueprintsResponse.ReadOnly]
      def deleteAlarm(request: DeleteAlarmRequest): IO[AwsError, DeleteAlarmResponse.ReadOnly]
      def createRelationalDatabaseSnapshot(request: CreateRelationalDatabaseSnapshotRequest): IO[AwsError, CreateRelationalDatabaseSnapshotResponse.ReadOnly]
      def getContainerServiceMetricData(request: GetContainerServiceMetricDataRequest): IO[AwsError, GetContainerServiceMetricDataResponse.ReadOnly]
      def getRelationalDatabaseLogStreams(request: GetRelationalDatabaseLogStreamsRequest): IO[AwsError, GetRelationalDatabaseLogStreamsResponse.ReadOnly]
      def updateRelationalDatabaseParameters(request: UpdateRelationalDatabaseParametersRequest): IO[AwsError, UpdateRelationalDatabaseParametersResponse.ReadOnly]
      def createContainerServiceDeployment(request: CreateContainerServiceDeploymentRequest): IO[AwsError, CreateContainerServiceDeploymentResponse.ReadOnly]
      def getDistributionLatestCacheReset(request: GetDistributionLatestCacheResetRequest): IO[AwsError, GetDistributionLatestCacheResetResponse.ReadOnly]
      def updateDistributionBundle(request: UpdateDistributionBundleRequest): IO[AwsError, UpdateDistributionBundleResponse.ReadOnly]
      def deleteKeyPair(request: DeleteKeyPairRequest): IO[AwsError, DeleteKeyPairResponse.ReadOnly]
      def getStaticIps(request: GetStaticIpsRequest): IO[AwsError, GetStaticIpsResponse.ReadOnly]
      def createRelationalDatabase(request: CreateRelationalDatabaseRequest): IO[AwsError, CreateRelationalDatabaseResponse.ReadOnly]
      def getCertificates(request: GetCertificatesRequest): IO[AwsError, GetCertificatesResponse.ReadOnly]
      def tagResource(request: TagResourceRequest): IO[AwsError, TagResourceResponse.ReadOnly]
      def deleteDomain(request: DeleteDomainRequest): IO[AwsError, DeleteDomainResponse.ReadOnly]
      def getRelationalDatabaseSnapshots(request: GetRelationalDatabaseSnapshotsRequest): IO[AwsError, GetRelationalDatabaseSnapshotsResponse.ReadOnly]
      def createInstancesFromSnapshot(request: CreateInstancesFromSnapshotRequest): IO[AwsError, CreateInstancesFromSnapshotResponse.ReadOnly]
      def exportSnapshot(request: ExportSnapshotRequest): IO[AwsError, ExportSnapshotResponse.ReadOnly]
      def attachDisk(request: AttachDiskRequest): IO[AwsError, AttachDiskResponse.ReadOnly]
      def setIpAddressType(request: SetIpAddressTypeRequest): IO[AwsError, SetIpAddressTypeResponse.ReadOnly]
      def getRegions(request: GetRegionsRequest): IO[AwsError, GetRegionsResponse.ReadOnly]
      def getRelationalDatabaseMetricData(request: GetRelationalDatabaseMetricDataRequest): IO[AwsError, GetRelationalDatabaseMetricDataResponse.ReadOnly]
      def getOperation(request: GetOperationRequest): IO[AwsError, GetOperationResponse.ReadOnly]
      def stopInstance(request: StopInstanceRequest): IO[AwsError, StopInstanceResponse.ReadOnly]
      def getDistributionMetricData(request: GetDistributionMetricDataRequest): IO[AwsError, GetDistributionMetricDataResponse.ReadOnly]
      def getKeyPairs(request: GetKeyPairsRequest): IO[AwsError, GetKeyPairsResponse.ReadOnly]
      def disableAddOn(request: DisableAddOnRequest): IO[AwsError, DisableAddOnResponse.ReadOnly]
      def createInstances(request: CreateInstancesRequest): IO[AwsError, CreateInstancesResponse.ReadOnly]
      def createLoadBalancer(request: CreateLoadBalancerRequest): IO[AwsError, CreateLoadBalancerResponse.ReadOnly]
      def getRelationalDatabaseBlueprints(request: GetRelationalDatabaseBlueprintsRequest): IO[AwsError, GetRelationalDatabaseBlueprintsResponse.ReadOnly]
      def detachCertificateFromDistribution(request: DetachCertificateFromDistributionRequest): IO[AwsError, DetachCertificateFromDistributionResponse.ReadOnly]
      def getRelationalDatabaseMasterUserPassword(request: GetRelationalDatabaseMasterUserPasswordRequest): IO[AwsError, GetRelationalDatabaseMasterUserPasswordResponse.ReadOnly]
      def updateContainerService(request: UpdateContainerServiceRequest): IO[AwsError, UpdateContainerServiceResponse.ReadOnly]
      def getContainerServicePowers(request: GetContainerServicePowersRequest): IO[AwsError, GetContainerServicePowersResponse.ReadOnly]
      def getRelationalDatabase(request: GetRelationalDatabaseRequest): IO[AwsError, GetRelationalDatabaseResponse.ReadOnly]
      def getCloudFormationStackRecords(request: GetCloudFormationStackRecordsRequest): IO[AwsError, GetCloudFormationStackRecordsResponse.ReadOnly]
      def updateDistribution(request: UpdateDistributionRequest): IO[AwsError, UpdateDistributionResponse.ReadOnly]
      def deleteDistribution(request: DeleteDistributionRequest): IO[AwsError, DeleteDistributionResponse.ReadOnly]
      def deleteContainerImage(request: DeleteContainerImageRequest): IO[AwsError, DeleteContainerImageResponse.ReadOnly]
      def createDistribution(request: CreateDistributionRequest): IO[AwsError, CreateDistributionResponse.ReadOnly]
    }
  }
  val live: ZLayer[AwsConfig, Throwable, Lightsail] = customized(identity)
  def customized(customization: LightsailAsyncClientBuilder => LightsailAsyncClientBuilder): ZLayer[AwsConfig, Throwable, Lightsail] = managed(customization).toLayer
  def managed(customization: LightsailAsyncClientBuilder => LightsailAsyncClientBuilder): ZManaged[AwsConfig, Throwable, Lightsail.Service] = for (awsConfig <- ZManaged.service[AwsConfig.Service]; b0 <- awsConfig.configure[LightsailAsyncClient, LightsailAsyncClientBuilder](LightsailAsyncClient.builder()).toManaged_; b1 <- awsConfig.configureHttpClient[LightsailAsyncClient, LightsailAsyncClientBuilder](b0, ServiceHttpCapabilities(supportsHttp2 = false)).toManaged_; client <- ZIO(customization(b1).build()).toManaged_) yield new LightsailImpl(client, AwsCallAspect.identity, ().asInstanceOf[Any])
  private class LightsailImpl[R](override val api: LightsailAsyncClient, override val aspect: AwsCallAspect[R], r: R) extends Lightsail.Service with AwsServiceBase[R, LightsailImpl] {
    override val serviceName: String = "Lightsail"
    override def withAspect[R1](newAspect: AwsCallAspect[R1], r: R1): LightsailImpl[R1] = new LightsailImpl(api, newAspect, r)
    def putInstancePublicPorts(request: PutInstancePublicPortsRequest): IO[AwsError, PutInstancePublicPortsResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.PutInstancePublicPortsRequest, software.amazon.awssdk.services.lightsail.model.PutInstancePublicPortsResponse]("putInstancePublicPorts", api.putInstancePublicPorts)(request.buildAwsValue()).map(PutInstancePublicPortsResponse.wrap).provide(r)
    def resetDistributionCache(request: ResetDistributionCacheRequest): IO[AwsError, ResetDistributionCacheResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.ResetDistributionCacheRequest, software.amazon.awssdk.services.lightsail.model.ResetDistributionCacheResponse]("resetDistributionCache", api.resetDistributionCache)(request.buildAwsValue()).map(ResetDistributionCacheResponse.wrap).provide(r)
    def getRelationalDatabaseSnapshot(request: GetRelationalDatabaseSnapshotRequest): IO[AwsError, GetRelationalDatabaseSnapshotResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetRelationalDatabaseSnapshotRequest, software.amazon.awssdk.services.lightsail.model.GetRelationalDatabaseSnapshotResponse]("getRelationalDatabaseSnapshot", api.getRelationalDatabaseSnapshot)(request.buildAwsValue()).map(GetRelationalDatabaseSnapshotResponse.wrap).provide(r)
    def getKeyPair(request: GetKeyPairRequest): IO[AwsError, GetKeyPairResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetKeyPairRequest, software.amazon.awssdk.services.lightsail.model.GetKeyPairResponse]("getKeyPair", api.getKeyPair)(request.buildAwsValue()).map(GetKeyPairResponse.wrap).provide(r)
    def getInstanceAccessDetails(request: GetInstanceAccessDetailsRequest): IO[AwsError, GetInstanceAccessDetailsResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetInstanceAccessDetailsRequest, software.amazon.awssdk.services.lightsail.model.GetInstanceAccessDetailsResponse]("getInstanceAccessDetails", api.getInstanceAccessDetails)(request.buildAwsValue()).map(GetInstanceAccessDetailsResponse.wrap).provide(r)
    def deleteLoadBalancerTlsCertificate(request: DeleteLoadBalancerTlsCertificateRequest): IO[AwsError, DeleteLoadBalancerTlsCertificateResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.DeleteLoadBalancerTlsCertificateRequest, software.amazon.awssdk.services.lightsail.model.DeleteLoadBalancerTlsCertificateResponse]("deleteLoadBalancerTlsCertificate", api.deleteLoadBalancerTlsCertificate)(request.buildAwsValue()).map(DeleteLoadBalancerTlsCertificateResponse.wrap).provide(r)
    def createDiskSnapshot(request: CreateDiskSnapshotRequest): IO[AwsError, CreateDiskSnapshotResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.CreateDiskSnapshotRequest, software.amazon.awssdk.services.lightsail.model.CreateDiskSnapshotResponse]("createDiskSnapshot", api.createDiskSnapshot)(request.buildAwsValue()).map(CreateDiskSnapshotResponse.wrap).provide(r)
    def deleteRelationalDatabase(request: DeleteRelationalDatabaseRequest): IO[AwsError, DeleteRelationalDatabaseResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.DeleteRelationalDatabaseRequest, software.amazon.awssdk.services.lightsail.model.DeleteRelationalDatabaseResponse]("deleteRelationalDatabase", api.deleteRelationalDatabase)(request.buildAwsValue()).map(DeleteRelationalDatabaseResponse.wrap).provide(r)
    def releaseStaticIp(request: ReleaseStaticIpRequest): IO[AwsError, ReleaseStaticIpResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.ReleaseStaticIpRequest, software.amazon.awssdk.services.lightsail.model.ReleaseStaticIpResponse]("releaseStaticIp", api.releaseStaticIp)(request.buildAwsValue()).map(ReleaseStaticIpResponse.wrap).provide(r)
    def updateLoadBalancerAttribute(request: UpdateLoadBalancerAttributeRequest): IO[AwsError, UpdateLoadBalancerAttributeResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.UpdateLoadBalancerAttributeRequest, software.amazon.awssdk.services.lightsail.model.UpdateLoadBalancerAttributeResponse]("updateLoadBalancerAttribute", api.updateLoadBalancerAttribute)(request.buildAwsValue()).map(UpdateLoadBalancerAttributeResponse.wrap).provide(r)
    def testAlarm(request: TestAlarmRequest): IO[AwsError, TestAlarmResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.TestAlarmRequest, software.amazon.awssdk.services.lightsail.model.TestAlarmResponse]("testAlarm", api.testAlarm)(request.buildAwsValue()).map(TestAlarmResponse.wrap).provide(r)
    def closeInstancePublicPorts(request: CloseInstancePublicPortsRequest): IO[AwsError, CloseInstancePublicPortsResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.CloseInstancePublicPortsRequest, software.amazon.awssdk.services.lightsail.model.CloseInstancePublicPortsResponse]("closeInstancePublicPorts", api.closeInstancePublicPorts)(request.buildAwsValue()).map(CloseInstancePublicPortsResponse.wrap).provide(r)
    def deleteContactMethod(request: DeleteContactMethodRequest): IO[AwsError, DeleteContactMethodResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.DeleteContactMethodRequest, software.amazon.awssdk.services.lightsail.model.DeleteContactMethodResponse]("deleteContactMethod", api.deleteContactMethod)(request.buildAwsValue()).map(DeleteContactMethodResponse.wrap).provide(r)
    def deleteDiskSnapshot(request: DeleteDiskSnapshotRequest): IO[AwsError, DeleteDiskSnapshotResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.DeleteDiskSnapshotRequest, software.amazon.awssdk.services.lightsail.model.DeleteDiskSnapshotResponse]("deleteDiskSnapshot", api.deleteDiskSnapshot)(request.buildAwsValue()).map(DeleteDiskSnapshotResponse.wrap).provide(r)
    def putAlarm(request: PutAlarmRequest): IO[AwsError, PutAlarmResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.PutAlarmRequest, software.amazon.awssdk.services.lightsail.model.PutAlarmResponse]("putAlarm", api.putAlarm)(request.buildAwsValue()).map(PutAlarmResponse.wrap).provide(r)
    def getInstances(request: GetInstancesRequest): IO[AwsError, GetInstancesResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetInstancesRequest, software.amazon.awssdk.services.lightsail.model.GetInstancesResponse]("getInstances", api.getInstances)(request.buildAwsValue()).map(GetInstancesResponse.wrap).provide(r)
    def createCertificate(request: CreateCertificateRequest): IO[AwsError, CreateCertificateResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.CreateCertificateRequest, software.amazon.awssdk.services.lightsail.model.CreateCertificateResponse]("createCertificate", api.createCertificate)(request.buildAwsValue()).map(CreateCertificateResponse.wrap).provide(r)
    def getRelationalDatabaseLogEvents(request: GetRelationalDatabaseLogEventsRequest): IO[AwsError, GetRelationalDatabaseLogEventsResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetRelationalDatabaseLogEventsRequest, software.amazon.awssdk.services.lightsail.model.GetRelationalDatabaseLogEventsResponse]("getRelationalDatabaseLogEvents", api.getRelationalDatabaseLogEvents)(request.buildAwsValue()).map(GetRelationalDatabaseLogEventsResponse.wrap).provide(r)
    def deleteKnownHostKeys(request: DeleteKnownHostKeysRequest): IO[AwsError, DeleteKnownHostKeysResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.DeleteKnownHostKeysRequest, software.amazon.awssdk.services.lightsail.model.DeleteKnownHostKeysResponse]("deleteKnownHostKeys", api.deleteKnownHostKeys)(request.buildAwsValue()).map(DeleteKnownHostKeysResponse.wrap).provide(r)
    def rebootRelationalDatabase(request: RebootRelationalDatabaseRequest): IO[AwsError, RebootRelationalDatabaseResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.RebootRelationalDatabaseRequest, software.amazon.awssdk.services.lightsail.model.RebootRelationalDatabaseResponse]("rebootRelationalDatabase", api.rebootRelationalDatabase)(request.buildAwsValue()).map(RebootRelationalDatabaseResponse.wrap).provide(r)
    def createCloudFormationStack(request: CreateCloudFormationStackRequest): IO[AwsError, CreateCloudFormationStackResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.CreateCloudFormationStackRequest, software.amazon.awssdk.services.lightsail.model.CreateCloudFormationStackResponse]("createCloudFormationStack", api.createCloudFormationStack)(request.buildAwsValue()).map(CreateCloudFormationStackResponse.wrap).provide(r)
    def detachDisk(request: DetachDiskRequest): IO[AwsError, DetachDiskResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.DetachDiskRequest, software.amazon.awssdk.services.lightsail.model.DetachDiskResponse]("detachDisk", api.detachDisk)(request.buildAwsValue()).map(DetachDiskResponse.wrap).provide(r)
    def allocateStaticIp(request: AllocateStaticIpRequest): IO[AwsError, AllocateStaticIpResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.AllocateStaticIpRequest, software.amazon.awssdk.services.lightsail.model.AllocateStaticIpResponse]("allocateStaticIp", api.allocateStaticIp)(request.buildAwsValue()).map(AllocateStaticIpResponse.wrap).provide(r)
    def getRelationalDatabaseEvents(request: GetRelationalDatabaseEventsRequest): IO[AwsError, GetRelationalDatabaseEventsResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetRelationalDatabaseEventsRequest, software.amazon.awssdk.services.lightsail.model.GetRelationalDatabaseEventsResponse]("getRelationalDatabaseEvents", api.getRelationalDatabaseEvents)(request.buildAwsValue()).map(GetRelationalDatabaseEventsResponse.wrap).provide(r)
    def getOperations(request: GetOperationsRequest): IO[AwsError, GetOperationsResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetOperationsRequest, software.amazon.awssdk.services.lightsail.model.GetOperationsResponse]("getOperations", api.getOperations)(request.buildAwsValue()).map(GetOperationsResponse.wrap).provide(r)
    def getInstanceState(request: GetInstanceStateRequest): IO[AwsError, GetInstanceStateResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetInstanceStateRequest, software.amazon.awssdk.services.lightsail.model.GetInstanceStateResponse]("getInstanceState", api.getInstanceState)(request.buildAwsValue()).map(GetInstanceStateResponse.wrap).provide(r)
    def getDomains(request: GetDomainsRequest): IO[AwsError, GetDomainsResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetDomainsRequest, software.amazon.awssdk.services.lightsail.model.GetDomainsResponse]("getDomains", api.getDomains)(request.buildAwsValue()).map(GetDomainsResponse.wrap).provide(r)
    def getLoadBalancers(request: GetLoadBalancersRequest): IO[AwsError, GetLoadBalancersResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetLoadBalancersRequest, software.amazon.awssdk.services.lightsail.model.GetLoadBalancersResponse]("getLoadBalancers", api.getLoadBalancers)(request.buildAwsValue()).map(GetLoadBalancersResponse.wrap).provide(r)
    def getContainerServices(request: GetContainerServicesRequest): IO[AwsError, GetContainerServicesResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetContainerServicesRequest, software.amazon.awssdk.services.lightsail.model.GetContainerServicesResponse]("getContainerServices", api.getContainerServices)(request.buildAwsValue()).map(GetContainerServicesResponse.wrap).provide(r)
    def getLoadBalancerTlsCertificates(request: GetLoadBalancerTlsCertificatesRequest): IO[AwsError, GetLoadBalancerTlsCertificatesResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetLoadBalancerTlsCertificatesRequest, software.amazon.awssdk.services.lightsail.model.GetLoadBalancerTlsCertificatesResponse]("getLoadBalancerTlsCertificates", api.getLoadBalancerTlsCertificates)(request.buildAwsValue()).map(GetLoadBalancerTlsCertificatesResponse.wrap).provide(r)
    def createRelationalDatabaseFromSnapshot(request: CreateRelationalDatabaseFromSnapshotRequest): IO[AwsError, CreateRelationalDatabaseFromSnapshotResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.CreateRelationalDatabaseFromSnapshotRequest, software.amazon.awssdk.services.lightsail.model.CreateRelationalDatabaseFromSnapshotResponse]("createRelationalDatabaseFromSnapshot", api.createRelationalDatabaseFromSnapshot)(request.buildAwsValue()).map(CreateRelationalDatabaseFromSnapshotResponse.wrap).provide(r)
    def getInstanceSnapshot(request: GetInstanceSnapshotRequest): IO[AwsError, GetInstanceSnapshotResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetInstanceSnapshotRequest, software.amazon.awssdk.services.lightsail.model.GetInstanceSnapshotResponse]("getInstanceSnapshot", api.getInstanceSnapshot)(request.buildAwsValue()).map(GetInstanceSnapshotResponse.wrap).provide(r)
    def deleteContainerService(request: DeleteContainerServiceRequest): IO[AwsError, DeleteContainerServiceResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.DeleteContainerServiceRequest, software.amazon.awssdk.services.lightsail.model.DeleteContainerServiceResponse]("deleteContainerService", api.deleteContainerService)(request.buildAwsValue()).map(DeleteContainerServiceResponse.wrap).provide(r)
    def getContainerAPIMetadata(request: GetContainerApiMetadataRequest): IO[AwsError, GetContainerApiMetadataResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetContainerApiMetadataRequest, software.amazon.awssdk.services.lightsail.model.GetContainerApiMetadataResponse]("getContainerAPIMetadata", api.getContainerAPIMetadata)(request.buildAwsValue()).map(GetContainerApiMetadataResponse.wrap).provide(r)
    def getDiskSnapshot(request: GetDiskSnapshotRequest): IO[AwsError, GetDiskSnapshotResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetDiskSnapshotRequest, software.amazon.awssdk.services.lightsail.model.GetDiskSnapshotResponse]("getDiskSnapshot", api.getDiskSnapshot)(request.buildAwsValue()).map(GetDiskSnapshotResponse.wrap).provide(r)
    def detachStaticIp(request: DetachStaticIpRequest): IO[AwsError, DetachStaticIpResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.DetachStaticIpRequest, software.amazon.awssdk.services.lightsail.model.DetachStaticIpResponse]("detachStaticIp", api.detachStaticIp)(request.buildAwsValue()).map(DetachStaticIpResponse.wrap).provide(r)
    def createDisk(request: CreateDiskRequest): IO[AwsError, CreateDiskResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.CreateDiskRequest, software.amazon.awssdk.services.lightsail.model.CreateDiskResponse]("createDisk", api.createDisk)(request.buildAwsValue()).map(CreateDiskResponse.wrap).provide(r)
    def getContainerImages(request: GetContainerImagesRequest): IO[AwsError, GetContainerImagesResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetContainerImagesRequest, software.amazon.awssdk.services.lightsail.model.GetContainerImagesResponse]("getContainerImages", api.getContainerImages)(request.buildAwsValue()).map(GetContainerImagesResponse.wrap).provide(r)
    def createDomainEntry(request: CreateDomainEntryRequest): IO[AwsError, CreateDomainEntryResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.CreateDomainEntryRequest, software.amazon.awssdk.services.lightsail.model.CreateDomainEntryResponse]("createDomainEntry", api.createDomainEntry)(request.buildAwsValue()).map(CreateDomainEntryResponse.wrap).provide(r)
    def sendContactMethodVerification(request: SendContactMethodVerificationRequest): IO[AwsError, SendContactMethodVerificationResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.SendContactMethodVerificationRequest, software.amazon.awssdk.services.lightsail.model.SendContactMethodVerificationResponse]("sendContactMethodVerification", api.sendContactMethodVerification)(request.buildAwsValue()).map(SendContactMethodVerificationResponse.wrap).provide(r)
    def getDomain(request: GetDomainRequest): IO[AwsError, GetDomainResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetDomainRequest, software.amazon.awssdk.services.lightsail.model.GetDomainResponse]("getDomain", api.getDomain)(request.buildAwsValue()).map(GetDomainResponse.wrap).provide(r)
    def deleteInstance(request: DeleteInstanceRequest): IO[AwsError, DeleteInstanceResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.DeleteInstanceRequest, software.amazon.awssdk.services.lightsail.model.DeleteInstanceResponse]("deleteInstance", api.deleteInstance)(request.buildAwsValue()).map(DeleteInstanceResponse.wrap).provide(r)
    def copySnapshot(request: CopySnapshotRequest): IO[AwsError, CopySnapshotResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.CopySnapshotRequest, software.amazon.awssdk.services.lightsail.model.CopySnapshotResponse]("copySnapshot", api.copySnapshot)(request.buildAwsValue()).map(CopySnapshotResponse.wrap).provide(r)
    def getContactMethods(request: GetContactMethodsRequest): IO[AwsError, GetContactMethodsResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetContactMethodsRequest, software.amazon.awssdk.services.lightsail.model.GetContactMethodsResponse]("getContactMethods", api.getContactMethods)(request.buildAwsValue()).map(GetContactMethodsResponse.wrap).provide(r)
    def getRelationalDatabaseBundles(request: GetRelationalDatabaseBundlesRequest): IO[AwsError, GetRelationalDatabaseBundlesResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetRelationalDatabaseBundlesRequest, software.amazon.awssdk.services.lightsail.model.GetRelationalDatabaseBundlesResponse]("getRelationalDatabaseBundles", api.getRelationalDatabaseBundles)(request.buildAwsValue()).map(GetRelationalDatabaseBundlesResponse.wrap).provide(r)
    def detachInstancesFromLoadBalancer(request: DetachInstancesFromLoadBalancerRequest): IO[AwsError, DetachInstancesFromLoadBalancerResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.DetachInstancesFromLoadBalancerRequest, software.amazon.awssdk.services.lightsail.model.DetachInstancesFromLoadBalancerResponse]("detachInstancesFromLoadBalancer", api.detachInstancesFromLoadBalancer)(request.buildAwsValue()).map(DetachInstancesFromLoadBalancerResponse.wrap).provide(r)
    def openInstancePublicPorts(request: OpenInstancePublicPortsRequest): IO[AwsError, OpenInstancePublicPortsResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.OpenInstancePublicPortsRequest, software.amazon.awssdk.services.lightsail.model.OpenInstancePublicPortsResponse]("openInstancePublicPorts", api.openInstancePublicPorts)(request.buildAwsValue()).map(OpenInstancePublicPortsResponse.wrap).provide(r)
    def getInstanceMetricData(request: GetInstanceMetricDataRequest): IO[AwsError, GetInstanceMetricDataResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetInstanceMetricDataRequest, software.amazon.awssdk.services.lightsail.model.GetInstanceMetricDataResponse]("getInstanceMetricData", api.getInstanceMetricData)(request.buildAwsValue()).map(GetInstanceMetricDataResponse.wrap).provide(r)
    def deleteRelationalDatabaseSnapshot(request: DeleteRelationalDatabaseSnapshotRequest): IO[AwsError, DeleteRelationalDatabaseSnapshotResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.DeleteRelationalDatabaseSnapshotRequest, software.amazon.awssdk.services.lightsail.model.DeleteRelationalDatabaseSnapshotResponse]("deleteRelationalDatabaseSnapshot", api.deleteRelationalDatabaseSnapshot)(request.buildAwsValue()).map(DeleteRelationalDatabaseSnapshotResponse.wrap).provide(r)
    def attachInstancesToLoadBalancer(request: AttachInstancesToLoadBalancerRequest): IO[AwsError, AttachInstancesToLoadBalancerResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.AttachInstancesToLoadBalancerRequest, software.amazon.awssdk.services.lightsail.model.AttachInstancesToLoadBalancerResponse]("attachInstancesToLoadBalancer", api.attachInstancesToLoadBalancer)(request.buildAwsValue()).map(AttachInstancesToLoadBalancerResponse.wrap).provide(r)
    def getDistributionBundles(request: GetDistributionBundlesRequest): IO[AwsError, GetDistributionBundlesResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetDistributionBundlesRequest, software.amazon.awssdk.services.lightsail.model.GetDistributionBundlesResponse]("getDistributionBundles", api.getDistributionBundles)(request.buildAwsValue()).map(GetDistributionBundlesResponse.wrap).provide(r)
    def getRelationalDatabaseParameters(request: GetRelationalDatabaseParametersRequest): IO[AwsError, GetRelationalDatabaseParametersResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetRelationalDatabaseParametersRequest, software.amazon.awssdk.services.lightsail.model.GetRelationalDatabaseParametersResponse]("getRelationalDatabaseParameters", api.getRelationalDatabaseParameters)(request.buildAwsValue()).map(GetRelationalDatabaseParametersResponse.wrap).provide(r)
    def getAlarms(request: GetAlarmsRequest): IO[AwsError, GetAlarmsResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetAlarmsRequest, software.amazon.awssdk.services.lightsail.model.GetAlarmsResponse]("getAlarms", api.getAlarms)(request.buildAwsValue()).map(GetAlarmsResponse.wrap).provide(r)
    def deleteLoadBalancer(request: DeleteLoadBalancerRequest): IO[AwsError, DeleteLoadBalancerResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.DeleteLoadBalancerRequest, software.amazon.awssdk.services.lightsail.model.DeleteLoadBalancerResponse]("deleteLoadBalancer", api.deleteLoadBalancer)(request.buildAwsValue()).map(DeleteLoadBalancerResponse.wrap).provide(r)
    def getInstanceSnapshots(request: GetInstanceSnapshotsRequest): IO[AwsError, GetInstanceSnapshotsResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetInstanceSnapshotsRequest, software.amazon.awssdk.services.lightsail.model.GetInstanceSnapshotsResponse]("getInstanceSnapshots", api.getInstanceSnapshots)(request.buildAwsValue()).map(GetInstanceSnapshotsResponse.wrap).provide(r)
    def stopRelationalDatabase(request: StopRelationalDatabaseRequest): IO[AwsError, StopRelationalDatabaseResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.StopRelationalDatabaseRequest, software.amazon.awssdk.services.lightsail.model.StopRelationalDatabaseResponse]("stopRelationalDatabase", api.stopRelationalDatabase)(request.buildAwsValue()).map(StopRelationalDatabaseResponse.wrap).provide(r)
    def getLoadBalancerMetricData(request: GetLoadBalancerMetricDataRequest): IO[AwsError, GetLoadBalancerMetricDataResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetLoadBalancerMetricDataRequest, software.amazon.awssdk.services.lightsail.model.GetLoadBalancerMetricDataResponse]("getLoadBalancerMetricData", api.getLoadBalancerMetricData)(request.buildAwsValue()).map(GetLoadBalancerMetricDataResponse.wrap).provide(r)
    def attachCertificateToDistribution(request: AttachCertificateToDistributionRequest): IO[AwsError, AttachCertificateToDistributionResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.AttachCertificateToDistributionRequest, software.amazon.awssdk.services.lightsail.model.AttachCertificateToDistributionResponse]("attachCertificateToDistribution", api.attachCertificateToDistribution)(request.buildAwsValue()).map(AttachCertificateToDistributionResponse.wrap).provide(r)
    def deleteCertificate(request: DeleteCertificateRequest): IO[AwsError, DeleteCertificateResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.DeleteCertificateRequest, software.amazon.awssdk.services.lightsail.model.DeleteCertificateResponse]("deleteCertificate", api.deleteCertificate)(request.buildAwsValue()).map(DeleteCertificateResponse.wrap).provide(r)
    def getInstance(request: GetInstanceRequest): IO[AwsError, GetInstanceResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetInstanceRequest, software.amazon.awssdk.services.lightsail.model.GetInstanceResponse]("getInstance", api.getInstance)(request.buildAwsValue()).map(GetInstanceResponse.wrap).provide(r)
    def getDistributions(request: GetDistributionsRequest): IO[AwsError, GetDistributionsResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetDistributionsRequest, software.amazon.awssdk.services.lightsail.model.GetDistributionsResponse]("getDistributions", api.getDistributions)(request.buildAwsValue()).map(GetDistributionsResponse.wrap).provide(r)
    def getRelationalDatabases(request: GetRelationalDatabasesRequest): IO[AwsError, GetRelationalDatabasesResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetRelationalDatabasesRequest, software.amazon.awssdk.services.lightsail.model.GetRelationalDatabasesResponse]("getRelationalDatabases", api.getRelationalDatabases)(request.buildAwsValue()).map(GetRelationalDatabasesResponse.wrap).provide(r)
    def attachLoadBalancerTlsCertificate(request: AttachLoadBalancerTlsCertificateRequest): IO[AwsError, AttachLoadBalancerTlsCertificateResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.AttachLoadBalancerTlsCertificateRequest, software.amazon.awssdk.services.lightsail.model.AttachLoadBalancerTlsCertificateResponse]("attachLoadBalancerTlsCertificate", api.attachLoadBalancerTlsCertificate)(request.buildAwsValue()).map(AttachLoadBalancerTlsCertificateResponse.wrap).provide(r)
    def getOperationsForResource(request: GetOperationsForResourceRequest): IO[AwsError, GetOperationsForResourceResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetOperationsForResourceRequest, software.amazon.awssdk.services.lightsail.model.GetOperationsForResourceResponse]("getOperationsForResource", api.getOperationsForResource)(request.buildAwsValue()).map(GetOperationsForResourceResponse.wrap).provide(r)
    def createDiskFromSnapshot(request: CreateDiskFromSnapshotRequest): IO[AwsError, CreateDiskFromSnapshotResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.CreateDiskFromSnapshotRequest, software.amazon.awssdk.services.lightsail.model.CreateDiskFromSnapshotResponse]("createDiskFromSnapshot", api.createDiskFromSnapshot)(request.buildAwsValue()).map(CreateDiskFromSnapshotResponse.wrap).provide(r)
    def getLoadBalancer(request: GetLoadBalancerRequest): IO[AwsError, GetLoadBalancerResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetLoadBalancerRequest, software.amazon.awssdk.services.lightsail.model.GetLoadBalancerResponse]("getLoadBalancer", api.getLoadBalancer)(request.buildAwsValue()).map(GetLoadBalancerResponse.wrap).provide(r)
    def deleteInstanceSnapshot(request: DeleteInstanceSnapshotRequest): IO[AwsError, DeleteInstanceSnapshotResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.DeleteInstanceSnapshotRequest, software.amazon.awssdk.services.lightsail.model.DeleteInstanceSnapshotResponse]("deleteInstanceSnapshot", api.deleteInstanceSnapshot)(request.buildAwsValue()).map(DeleteInstanceSnapshotResponse.wrap).provide(r)
    def deleteDomainEntry(request: DeleteDomainEntryRequest): IO[AwsError, DeleteDomainEntryResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.DeleteDomainEntryRequest, software.amazon.awssdk.services.lightsail.model.DeleteDomainEntryResponse]("deleteDomainEntry", api.deleteDomainEntry)(request.buildAwsValue()).map(DeleteDomainEntryResponse.wrap).provide(r)
    def updateRelationalDatabase(request: UpdateRelationalDatabaseRequest): IO[AwsError, UpdateRelationalDatabaseResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.UpdateRelationalDatabaseRequest, software.amazon.awssdk.services.lightsail.model.UpdateRelationalDatabaseResponse]("updateRelationalDatabase", api.updateRelationalDatabase)(request.buildAwsValue()).map(UpdateRelationalDatabaseResponse.wrap).provide(r)
    def peerVpc(request: PeerVpcRequest): IO[AwsError, PeerVpcResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.PeerVpcRequest, software.amazon.awssdk.services.lightsail.model.PeerVpcResponse]("peerVpc", api.peerVpc)(request.buildAwsValue()).map(PeerVpcResponse.wrap).provide(r)
    def unpeerVpc(request: UnpeerVpcRequest): IO[AwsError, UnpeerVpcResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.UnpeerVpcRequest, software.amazon.awssdk.services.lightsail.model.UnpeerVpcResponse]("unpeerVpc", api.unpeerVpc)(request.buildAwsValue()).map(UnpeerVpcResponse.wrap).provide(r)
    def getActiveNames(request: GetActiveNamesRequest): IO[AwsError, GetActiveNamesResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetActiveNamesRequest, software.amazon.awssdk.services.lightsail.model.GetActiveNamesResponse]("getActiveNames", api.getActiveNames)(request.buildAwsValue()).map(GetActiveNamesResponse.wrap).provide(r)
    def getAutoSnapshots(request: GetAutoSnapshotsRequest): IO[AwsError, GetAutoSnapshotsResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetAutoSnapshotsRequest, software.amazon.awssdk.services.lightsail.model.GetAutoSnapshotsResponse]("getAutoSnapshots", api.getAutoSnapshots)(request.buildAwsValue()).map(GetAutoSnapshotsResponse.wrap).provide(r)
    def startRelationalDatabase(request: StartRelationalDatabaseRequest): IO[AwsError, StartRelationalDatabaseResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.StartRelationalDatabaseRequest, software.amazon.awssdk.services.lightsail.model.StartRelationalDatabaseResponse]("startRelationalDatabase", api.startRelationalDatabase)(request.buildAwsValue()).map(StartRelationalDatabaseResponse.wrap).provide(r)
    def createInstanceSnapshot(request: CreateInstanceSnapshotRequest): IO[AwsError, CreateInstanceSnapshotResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.CreateInstanceSnapshotRequest, software.amazon.awssdk.services.lightsail.model.CreateInstanceSnapshotResponse]("createInstanceSnapshot", api.createInstanceSnapshot)(request.buildAwsValue()).map(CreateInstanceSnapshotResponse.wrap).provide(r)
    def updateDomainEntry(request: UpdateDomainEntryRequest): IO[AwsError, UpdateDomainEntryResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.UpdateDomainEntryRequest, software.amazon.awssdk.services.lightsail.model.UpdateDomainEntryResponse]("updateDomainEntry", api.updateDomainEntry)(request.buildAwsValue()).map(UpdateDomainEntryResponse.wrap).provide(r)
    def rebootInstance(request: RebootInstanceRequest): IO[AwsError, RebootInstanceResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.RebootInstanceRequest, software.amazon.awssdk.services.lightsail.model.RebootInstanceResponse]("rebootInstance", api.rebootInstance)(request.buildAwsValue()).map(RebootInstanceResponse.wrap).provide(r)
    def createContactMethod(request: CreateContactMethodRequest): IO[AwsError, CreateContactMethodResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.CreateContactMethodRequest, software.amazon.awssdk.services.lightsail.model.CreateContactMethodResponse]("createContactMethod", api.createContactMethod)(request.buildAwsValue()).map(CreateContactMethodResponse.wrap).provide(r)
    def getDiskSnapshots(request: GetDiskSnapshotsRequest): IO[AwsError, GetDiskSnapshotsResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetDiskSnapshotsRequest, software.amazon.awssdk.services.lightsail.model.GetDiskSnapshotsResponse]("getDiskSnapshots", api.getDiskSnapshots)(request.buildAwsValue()).map(GetDiskSnapshotsResponse.wrap).provide(r)
    def getContainerLog(request: GetContainerLogRequest): IO[AwsError, GetContainerLogResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetContainerLogRequest, software.amazon.awssdk.services.lightsail.model.GetContainerLogResponse]("getContainerLog", api.getContainerLog)(request.buildAwsValue()).map(GetContainerLogResponse.wrap).provide(r)
    def getContainerServiceDeployments(request: GetContainerServiceDeploymentsRequest): IO[AwsError, GetContainerServiceDeploymentsResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetContainerServiceDeploymentsRequest, software.amazon.awssdk.services.lightsail.model.GetContainerServiceDeploymentsResponse]("getContainerServiceDeployments", api.getContainerServiceDeployments)(request.buildAwsValue()).map(GetContainerServiceDeploymentsResponse.wrap).provide(r)
    def createDomain(request: CreateDomainRequest): IO[AwsError, CreateDomainResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.CreateDomainRequest, software.amazon.awssdk.services.lightsail.model.CreateDomainResponse]("createDomain", api.createDomain)(request.buildAwsValue()).map(CreateDomainResponse.wrap).provide(r)
    def createContainerService(request: CreateContainerServiceRequest): IO[AwsError, CreateContainerServiceResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.CreateContainerServiceRequest, software.amazon.awssdk.services.lightsail.model.CreateContainerServiceResponse]("createContainerService", api.createContainerService)(request.buildAwsValue()).map(CreateContainerServiceResponse.wrap).provide(r)
    def isVpcPeered(request: IsVpcPeeredRequest): IO[AwsError, IsVpcPeeredResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.IsVpcPeeredRequest, software.amazon.awssdk.services.lightsail.model.IsVpcPeeredResponse]("isVpcPeered", api.isVpcPeered)(request.buildAwsValue()).map(IsVpcPeeredResponse.wrap).provide(r)
    def deleteAutoSnapshot(request: DeleteAutoSnapshotRequest): IO[AwsError, DeleteAutoSnapshotResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.DeleteAutoSnapshotRequest, software.amazon.awssdk.services.lightsail.model.DeleteAutoSnapshotResponse]("deleteAutoSnapshot", api.deleteAutoSnapshot)(request.buildAwsValue()).map(DeleteAutoSnapshotResponse.wrap).provide(r)
    def createContainerServiceRegistryLogin(request: CreateContainerServiceRegistryLoginRequest): IO[AwsError, CreateContainerServiceRegistryLoginResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.CreateContainerServiceRegistryLoginRequest, software.amazon.awssdk.services.lightsail.model.CreateContainerServiceRegistryLoginResponse]("createContainerServiceRegistryLogin", api.createContainerServiceRegistryLogin)(request.buildAwsValue()).map(CreateContainerServiceRegistryLoginResponse.wrap).provide(r)
    def getDisk(request: GetDiskRequest): IO[AwsError, GetDiskResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetDiskRequest, software.amazon.awssdk.services.lightsail.model.GetDiskResponse]("getDisk", api.getDisk)(request.buildAwsValue()).map(GetDiskResponse.wrap).provide(r)
    def enableAddOn(request: EnableAddOnRequest): IO[AwsError, EnableAddOnResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.EnableAddOnRequest, software.amazon.awssdk.services.lightsail.model.EnableAddOnResponse]("enableAddOn", api.enableAddOn)(request.buildAwsValue()).map(EnableAddOnResponse.wrap).provide(r)
    def untagResource(request: UntagResourceRequest): IO[AwsError, UntagResourceResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.UntagResourceRequest, software.amazon.awssdk.services.lightsail.model.UntagResourceResponse]("untagResource", api.untagResource)(request.buildAwsValue()).map(UntagResourceResponse.wrap).provide(r)
    def createLoadBalancerTlsCertificate(request: CreateLoadBalancerTlsCertificateRequest): IO[AwsError, CreateLoadBalancerTlsCertificateResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.CreateLoadBalancerTlsCertificateRequest, software.amazon.awssdk.services.lightsail.model.CreateLoadBalancerTlsCertificateResponse]("createLoadBalancerTlsCertificate", api.createLoadBalancerTlsCertificate)(request.buildAwsValue()).map(CreateLoadBalancerTlsCertificateResponse.wrap).provide(r)
    def getStaticIp(request: GetStaticIpRequest): IO[AwsError, GetStaticIpResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetStaticIpRequest, software.amazon.awssdk.services.lightsail.model.GetStaticIpResponse]("getStaticIp", api.getStaticIp)(request.buildAwsValue()).map(GetStaticIpResponse.wrap).provide(r)
    def attachStaticIp(request: AttachStaticIpRequest): IO[AwsError, AttachStaticIpResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.AttachStaticIpRequest, software.amazon.awssdk.services.lightsail.model.AttachStaticIpResponse]("attachStaticIp", api.attachStaticIp)(request.buildAwsValue()).map(AttachStaticIpResponse.wrap).provide(r)
    def importKeyPair(request: ImportKeyPairRequest): IO[AwsError, ImportKeyPairResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.ImportKeyPairRequest, software.amazon.awssdk.services.lightsail.model.ImportKeyPairResponse]("importKeyPair", api.importKeyPair)(request.buildAwsValue()).map(ImportKeyPairResponse.wrap).provide(r)
    def getDisks(request: GetDisksRequest): IO[AwsError, GetDisksResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetDisksRequest, software.amazon.awssdk.services.lightsail.model.GetDisksResponse]("getDisks", api.getDisks)(request.buildAwsValue()).map(GetDisksResponse.wrap).provide(r)
    def downloadDefaultKeyPair(request: DownloadDefaultKeyPairRequest): IO[AwsError, DownloadDefaultKeyPairResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.DownloadDefaultKeyPairRequest, software.amazon.awssdk.services.lightsail.model.DownloadDefaultKeyPairResponse]("downloadDefaultKeyPair", api.downloadDefaultKeyPair)(request.buildAwsValue()).map(DownloadDefaultKeyPairResponse.wrap).provide(r)
    def getExportSnapshotRecords(request: GetExportSnapshotRecordsRequest): IO[AwsError, GetExportSnapshotRecordsResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetExportSnapshotRecordsRequest, software.amazon.awssdk.services.lightsail.model.GetExportSnapshotRecordsResponse]("getExportSnapshotRecords", api.getExportSnapshotRecords)(request.buildAwsValue()).map(GetExportSnapshotRecordsResponse.wrap).provide(r)
    def createKeyPair(request: CreateKeyPairRequest): IO[AwsError, CreateKeyPairResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.CreateKeyPairRequest, software.amazon.awssdk.services.lightsail.model.CreateKeyPairResponse]("createKeyPair", api.createKeyPair)(request.buildAwsValue()).map(CreateKeyPairResponse.wrap).provide(r)
    def getBundles(request: GetBundlesRequest): IO[AwsError, GetBundlesResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetBundlesRequest, software.amazon.awssdk.services.lightsail.model.GetBundlesResponse]("getBundles", api.getBundles)(request.buildAwsValue()).map(GetBundlesResponse.wrap).provide(r)
    def registerContainerImage(request: RegisterContainerImageRequest): IO[AwsError, RegisterContainerImageResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.RegisterContainerImageRequest, software.amazon.awssdk.services.lightsail.model.RegisterContainerImageResponse]("registerContainerImage", api.registerContainerImage)(request.buildAwsValue()).map(RegisterContainerImageResponse.wrap).provide(r)
    def startInstance(request: StartInstanceRequest): IO[AwsError, StartInstanceResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.StartInstanceRequest, software.amazon.awssdk.services.lightsail.model.StartInstanceResponse]("startInstance", api.startInstance)(request.buildAwsValue()).map(StartInstanceResponse.wrap).provide(r)
    def getInstancePortStates(request: GetInstancePortStatesRequest): IO[AwsError, GetInstancePortStatesResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetInstancePortStatesRequest, software.amazon.awssdk.services.lightsail.model.GetInstancePortStatesResponse]("getInstancePortStates", api.getInstancePortStates)(request.buildAwsValue()).map(GetInstancePortStatesResponse.wrap).provide(r)
    def deleteDisk(request: DeleteDiskRequest): IO[AwsError, DeleteDiskResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.DeleteDiskRequest, software.amazon.awssdk.services.lightsail.model.DeleteDiskResponse]("deleteDisk", api.deleteDisk)(request.buildAwsValue()).map(DeleteDiskResponse.wrap).provide(r)
    def getBlueprints(request: GetBlueprintsRequest): IO[AwsError, GetBlueprintsResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetBlueprintsRequest, software.amazon.awssdk.services.lightsail.model.GetBlueprintsResponse]("getBlueprints", api.getBlueprints)(request.buildAwsValue()).map(GetBlueprintsResponse.wrap).provide(r)
    def deleteAlarm(request: DeleteAlarmRequest): IO[AwsError, DeleteAlarmResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.DeleteAlarmRequest, software.amazon.awssdk.services.lightsail.model.DeleteAlarmResponse]("deleteAlarm", api.deleteAlarm)(request.buildAwsValue()).map(DeleteAlarmResponse.wrap).provide(r)
    def createRelationalDatabaseSnapshot(request: CreateRelationalDatabaseSnapshotRequest): IO[AwsError, CreateRelationalDatabaseSnapshotResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.CreateRelationalDatabaseSnapshotRequest, software.amazon.awssdk.services.lightsail.model.CreateRelationalDatabaseSnapshotResponse]("createRelationalDatabaseSnapshot", api.createRelationalDatabaseSnapshot)(request.buildAwsValue()).map(CreateRelationalDatabaseSnapshotResponse.wrap).provide(r)
    def getContainerServiceMetricData(request: GetContainerServiceMetricDataRequest): IO[AwsError, GetContainerServiceMetricDataResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetContainerServiceMetricDataRequest, software.amazon.awssdk.services.lightsail.model.GetContainerServiceMetricDataResponse]("getContainerServiceMetricData", api.getContainerServiceMetricData)(request.buildAwsValue()).map(GetContainerServiceMetricDataResponse.wrap).provide(r)
    def getRelationalDatabaseLogStreams(request: GetRelationalDatabaseLogStreamsRequest): IO[AwsError, GetRelationalDatabaseLogStreamsResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetRelationalDatabaseLogStreamsRequest, software.amazon.awssdk.services.lightsail.model.GetRelationalDatabaseLogStreamsResponse]("getRelationalDatabaseLogStreams", api.getRelationalDatabaseLogStreams)(request.buildAwsValue()).map(GetRelationalDatabaseLogStreamsResponse.wrap).provide(r)
    def updateRelationalDatabaseParameters(request: UpdateRelationalDatabaseParametersRequest): IO[AwsError, UpdateRelationalDatabaseParametersResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.UpdateRelationalDatabaseParametersRequest, software.amazon.awssdk.services.lightsail.model.UpdateRelationalDatabaseParametersResponse]("updateRelationalDatabaseParameters", api.updateRelationalDatabaseParameters)(request.buildAwsValue()).map(UpdateRelationalDatabaseParametersResponse.wrap).provide(r)
    def createContainerServiceDeployment(request: CreateContainerServiceDeploymentRequest): IO[AwsError, CreateContainerServiceDeploymentResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.CreateContainerServiceDeploymentRequest, software.amazon.awssdk.services.lightsail.model.CreateContainerServiceDeploymentResponse]("createContainerServiceDeployment", api.createContainerServiceDeployment)(request.buildAwsValue()).map(CreateContainerServiceDeploymentResponse.wrap).provide(r)
    def getDistributionLatestCacheReset(request: GetDistributionLatestCacheResetRequest): IO[AwsError, GetDistributionLatestCacheResetResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetDistributionLatestCacheResetRequest, software.amazon.awssdk.services.lightsail.model.GetDistributionLatestCacheResetResponse]("getDistributionLatestCacheReset", api.getDistributionLatestCacheReset)(request.buildAwsValue()).map(GetDistributionLatestCacheResetResponse.wrap).provide(r)
    def updateDistributionBundle(request: UpdateDistributionBundleRequest): IO[AwsError, UpdateDistributionBundleResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.UpdateDistributionBundleRequest, software.amazon.awssdk.services.lightsail.model.UpdateDistributionBundleResponse]("updateDistributionBundle", api.updateDistributionBundle)(request.buildAwsValue()).map(UpdateDistributionBundleResponse.wrap).provide(r)
    def deleteKeyPair(request: DeleteKeyPairRequest): IO[AwsError, DeleteKeyPairResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.DeleteKeyPairRequest, software.amazon.awssdk.services.lightsail.model.DeleteKeyPairResponse]("deleteKeyPair", api.deleteKeyPair)(request.buildAwsValue()).map(DeleteKeyPairResponse.wrap).provide(r)
    def getStaticIps(request: GetStaticIpsRequest): IO[AwsError, GetStaticIpsResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetStaticIpsRequest, software.amazon.awssdk.services.lightsail.model.GetStaticIpsResponse]("getStaticIps", api.getStaticIps)(request.buildAwsValue()).map(GetStaticIpsResponse.wrap).provide(r)
    def createRelationalDatabase(request: CreateRelationalDatabaseRequest): IO[AwsError, CreateRelationalDatabaseResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.CreateRelationalDatabaseRequest, software.amazon.awssdk.services.lightsail.model.CreateRelationalDatabaseResponse]("createRelationalDatabase", api.createRelationalDatabase)(request.buildAwsValue()).map(CreateRelationalDatabaseResponse.wrap).provide(r)
    def getCertificates(request: GetCertificatesRequest): IO[AwsError, GetCertificatesResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetCertificatesRequest, software.amazon.awssdk.services.lightsail.model.GetCertificatesResponse]("getCertificates", api.getCertificates)(request.buildAwsValue()).map(GetCertificatesResponse.wrap).provide(r)
    def tagResource(request: TagResourceRequest): IO[AwsError, TagResourceResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.TagResourceRequest, software.amazon.awssdk.services.lightsail.model.TagResourceResponse]("tagResource", api.tagResource)(request.buildAwsValue()).map(TagResourceResponse.wrap).provide(r)
    def deleteDomain(request: DeleteDomainRequest): IO[AwsError, DeleteDomainResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.DeleteDomainRequest, software.amazon.awssdk.services.lightsail.model.DeleteDomainResponse]("deleteDomain", api.deleteDomain)(request.buildAwsValue()).map(DeleteDomainResponse.wrap).provide(r)
    def getRelationalDatabaseSnapshots(request: GetRelationalDatabaseSnapshotsRequest): IO[AwsError, GetRelationalDatabaseSnapshotsResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetRelationalDatabaseSnapshotsRequest, software.amazon.awssdk.services.lightsail.model.GetRelationalDatabaseSnapshotsResponse]("getRelationalDatabaseSnapshots", api.getRelationalDatabaseSnapshots)(request.buildAwsValue()).map(GetRelationalDatabaseSnapshotsResponse.wrap).provide(r)
    def createInstancesFromSnapshot(request: CreateInstancesFromSnapshotRequest): IO[AwsError, CreateInstancesFromSnapshotResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.CreateInstancesFromSnapshotRequest, software.amazon.awssdk.services.lightsail.model.CreateInstancesFromSnapshotResponse]("createInstancesFromSnapshot", api.createInstancesFromSnapshot)(request.buildAwsValue()).map(CreateInstancesFromSnapshotResponse.wrap).provide(r)
    def exportSnapshot(request: ExportSnapshotRequest): IO[AwsError, ExportSnapshotResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.ExportSnapshotRequest, software.amazon.awssdk.services.lightsail.model.ExportSnapshotResponse]("exportSnapshot", api.exportSnapshot)(request.buildAwsValue()).map(ExportSnapshotResponse.wrap).provide(r)
    def attachDisk(request: AttachDiskRequest): IO[AwsError, AttachDiskResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.AttachDiskRequest, software.amazon.awssdk.services.lightsail.model.AttachDiskResponse]("attachDisk", api.attachDisk)(request.buildAwsValue()).map(AttachDiskResponse.wrap).provide(r)
    def setIpAddressType(request: SetIpAddressTypeRequest): IO[AwsError, SetIpAddressTypeResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.SetIpAddressTypeRequest, software.amazon.awssdk.services.lightsail.model.SetIpAddressTypeResponse]("setIpAddressType", api.setIpAddressType)(request.buildAwsValue()).map(SetIpAddressTypeResponse.wrap).provide(r)
    def getRegions(request: GetRegionsRequest): IO[AwsError, GetRegionsResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetRegionsRequest, software.amazon.awssdk.services.lightsail.model.GetRegionsResponse]("getRegions", api.getRegions)(request.buildAwsValue()).map(GetRegionsResponse.wrap).provide(r)
    def getRelationalDatabaseMetricData(request: GetRelationalDatabaseMetricDataRequest): IO[AwsError, GetRelationalDatabaseMetricDataResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetRelationalDatabaseMetricDataRequest, software.amazon.awssdk.services.lightsail.model.GetRelationalDatabaseMetricDataResponse]("getRelationalDatabaseMetricData", api.getRelationalDatabaseMetricData)(request.buildAwsValue()).map(GetRelationalDatabaseMetricDataResponse.wrap).provide(r)
    def getOperation(request: GetOperationRequest): IO[AwsError, GetOperationResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetOperationRequest, software.amazon.awssdk.services.lightsail.model.GetOperationResponse]("getOperation", api.getOperation)(request.buildAwsValue()).map(GetOperationResponse.wrap).provide(r)
    def stopInstance(request: StopInstanceRequest): IO[AwsError, StopInstanceResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.StopInstanceRequest, software.amazon.awssdk.services.lightsail.model.StopInstanceResponse]("stopInstance", api.stopInstance)(request.buildAwsValue()).map(StopInstanceResponse.wrap).provide(r)
    def getDistributionMetricData(request: GetDistributionMetricDataRequest): IO[AwsError, GetDistributionMetricDataResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetDistributionMetricDataRequest, software.amazon.awssdk.services.lightsail.model.GetDistributionMetricDataResponse]("getDistributionMetricData", api.getDistributionMetricData)(request.buildAwsValue()).map(GetDistributionMetricDataResponse.wrap).provide(r)
    def getKeyPairs(request: GetKeyPairsRequest): IO[AwsError, GetKeyPairsResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetKeyPairsRequest, software.amazon.awssdk.services.lightsail.model.GetKeyPairsResponse]("getKeyPairs", api.getKeyPairs)(request.buildAwsValue()).map(GetKeyPairsResponse.wrap).provide(r)
    def disableAddOn(request: DisableAddOnRequest): IO[AwsError, DisableAddOnResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.DisableAddOnRequest, software.amazon.awssdk.services.lightsail.model.DisableAddOnResponse]("disableAddOn", api.disableAddOn)(request.buildAwsValue()).map(DisableAddOnResponse.wrap).provide(r)
    def createInstances(request: CreateInstancesRequest): IO[AwsError, CreateInstancesResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.CreateInstancesRequest, software.amazon.awssdk.services.lightsail.model.CreateInstancesResponse]("createInstances", api.createInstances)(request.buildAwsValue()).map(CreateInstancesResponse.wrap).provide(r)
    def createLoadBalancer(request: CreateLoadBalancerRequest): IO[AwsError, CreateLoadBalancerResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.CreateLoadBalancerRequest, software.amazon.awssdk.services.lightsail.model.CreateLoadBalancerResponse]("createLoadBalancer", api.createLoadBalancer)(request.buildAwsValue()).map(CreateLoadBalancerResponse.wrap).provide(r)
    def getRelationalDatabaseBlueprints(request: GetRelationalDatabaseBlueprintsRequest): IO[AwsError, GetRelationalDatabaseBlueprintsResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetRelationalDatabaseBlueprintsRequest, software.amazon.awssdk.services.lightsail.model.GetRelationalDatabaseBlueprintsResponse]("getRelationalDatabaseBlueprints", api.getRelationalDatabaseBlueprints)(request.buildAwsValue()).map(GetRelationalDatabaseBlueprintsResponse.wrap).provide(r)
    def detachCertificateFromDistribution(request: DetachCertificateFromDistributionRequest): IO[AwsError, DetachCertificateFromDistributionResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.DetachCertificateFromDistributionRequest, software.amazon.awssdk.services.lightsail.model.DetachCertificateFromDistributionResponse]("detachCertificateFromDistribution", api.detachCertificateFromDistribution)(request.buildAwsValue()).map(DetachCertificateFromDistributionResponse.wrap).provide(r)
    def getRelationalDatabaseMasterUserPassword(request: GetRelationalDatabaseMasterUserPasswordRequest): IO[AwsError, GetRelationalDatabaseMasterUserPasswordResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetRelationalDatabaseMasterUserPasswordRequest, software.amazon.awssdk.services.lightsail.model.GetRelationalDatabaseMasterUserPasswordResponse]("getRelationalDatabaseMasterUserPassword", api.getRelationalDatabaseMasterUserPassword)(request.buildAwsValue()).map(GetRelationalDatabaseMasterUserPasswordResponse.wrap).provide(r)
    def updateContainerService(request: UpdateContainerServiceRequest): IO[AwsError, UpdateContainerServiceResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.UpdateContainerServiceRequest, software.amazon.awssdk.services.lightsail.model.UpdateContainerServiceResponse]("updateContainerService", api.updateContainerService)(request.buildAwsValue()).map(UpdateContainerServiceResponse.wrap).provide(r)
    def getContainerServicePowers(request: GetContainerServicePowersRequest): IO[AwsError, GetContainerServicePowersResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetContainerServicePowersRequest, software.amazon.awssdk.services.lightsail.model.GetContainerServicePowersResponse]("getContainerServicePowers", api.getContainerServicePowers)(request.buildAwsValue()).map(GetContainerServicePowersResponse.wrap).provide(r)
    def getRelationalDatabase(request: GetRelationalDatabaseRequest): IO[AwsError, GetRelationalDatabaseResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetRelationalDatabaseRequest, software.amazon.awssdk.services.lightsail.model.GetRelationalDatabaseResponse]("getRelationalDatabase", api.getRelationalDatabase)(request.buildAwsValue()).map(GetRelationalDatabaseResponse.wrap).provide(r)
    def getCloudFormationStackRecords(request: GetCloudFormationStackRecordsRequest): IO[AwsError, GetCloudFormationStackRecordsResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.GetCloudFormationStackRecordsRequest, software.amazon.awssdk.services.lightsail.model.GetCloudFormationStackRecordsResponse]("getCloudFormationStackRecords", api.getCloudFormationStackRecords)(request.buildAwsValue()).map(GetCloudFormationStackRecordsResponse.wrap).provide(r)
    def updateDistribution(request: UpdateDistributionRequest): IO[AwsError, UpdateDistributionResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.UpdateDistributionRequest, software.amazon.awssdk.services.lightsail.model.UpdateDistributionResponse]("updateDistribution", api.updateDistribution)(request.buildAwsValue()).map(UpdateDistributionResponse.wrap).provide(r)
    def deleteDistribution(request: DeleteDistributionRequest): IO[AwsError, DeleteDistributionResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.DeleteDistributionRequest, software.amazon.awssdk.services.lightsail.model.DeleteDistributionResponse]("deleteDistribution", api.deleteDistribution)(request.buildAwsValue()).map(DeleteDistributionResponse.wrap).provide(r)
    def deleteContainerImage(request: DeleteContainerImageRequest): IO[AwsError, DeleteContainerImageResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.DeleteContainerImageRequest, software.amazon.awssdk.services.lightsail.model.DeleteContainerImageResponse]("deleteContainerImage", api.deleteContainerImage)(request.buildAwsValue()).map(DeleteContainerImageResponse.wrap).provide(r)
    def createDistribution(request: CreateDistributionRequest): IO[AwsError, CreateDistributionResponse.ReadOnly] = asyncRequestResponse[software.amazon.awssdk.services.lightsail.model.CreateDistributionRequest, software.amazon.awssdk.services.lightsail.model.CreateDistributionResponse]("createDistribution", api.createDistribution)(request.buildAwsValue()).map(CreateDistributionResponse.wrap).provide(r)
  }
  def putInstancePublicPorts(request: PutInstancePublicPortsRequest): ZIO[Lightsail, AwsError, PutInstancePublicPortsResponse.ReadOnly] = ZIO.accessM(_.get.putInstancePublicPorts(request))
  def resetDistributionCache(request: ResetDistributionCacheRequest): ZIO[Lightsail, AwsError, ResetDistributionCacheResponse.ReadOnly] = ZIO.accessM(_.get.resetDistributionCache(request))
  def getRelationalDatabaseSnapshot(request: GetRelationalDatabaseSnapshotRequest): ZIO[Lightsail, AwsError, GetRelationalDatabaseSnapshotResponse.ReadOnly] = ZIO.accessM(_.get.getRelationalDatabaseSnapshot(request))
  def getKeyPair(request: GetKeyPairRequest): ZIO[Lightsail, AwsError, GetKeyPairResponse.ReadOnly] = ZIO.accessM(_.get.getKeyPair(request))
  def getInstanceAccessDetails(request: GetInstanceAccessDetailsRequest): ZIO[Lightsail, AwsError, GetInstanceAccessDetailsResponse.ReadOnly] = ZIO.accessM(_.get.getInstanceAccessDetails(request))
  def deleteLoadBalancerTlsCertificate(request: DeleteLoadBalancerTlsCertificateRequest): ZIO[Lightsail, AwsError, DeleteLoadBalancerTlsCertificateResponse.ReadOnly] = ZIO.accessM(_.get.deleteLoadBalancerTlsCertificate(request))
  def createDiskSnapshot(request: CreateDiskSnapshotRequest): ZIO[Lightsail, AwsError, CreateDiskSnapshotResponse.ReadOnly] = ZIO.accessM(_.get.createDiskSnapshot(request))
  def deleteRelationalDatabase(request: DeleteRelationalDatabaseRequest): ZIO[Lightsail, AwsError, DeleteRelationalDatabaseResponse.ReadOnly] = ZIO.accessM(_.get.deleteRelationalDatabase(request))
  def releaseStaticIp(request: ReleaseStaticIpRequest): ZIO[Lightsail, AwsError, ReleaseStaticIpResponse.ReadOnly] = ZIO.accessM(_.get.releaseStaticIp(request))
  def updateLoadBalancerAttribute(request: UpdateLoadBalancerAttributeRequest): ZIO[Lightsail, AwsError, UpdateLoadBalancerAttributeResponse.ReadOnly] = ZIO.accessM(_.get.updateLoadBalancerAttribute(request))
  def testAlarm(request: TestAlarmRequest): ZIO[Lightsail, AwsError, TestAlarmResponse.ReadOnly] = ZIO.accessM(_.get.testAlarm(request))
  def closeInstancePublicPorts(request: CloseInstancePublicPortsRequest): ZIO[Lightsail, AwsError, CloseInstancePublicPortsResponse.ReadOnly] = ZIO.accessM(_.get.closeInstancePublicPorts(request))
  def deleteContactMethod(request: DeleteContactMethodRequest): ZIO[Lightsail, AwsError, DeleteContactMethodResponse.ReadOnly] = ZIO.accessM(_.get.deleteContactMethod(request))
  def deleteDiskSnapshot(request: DeleteDiskSnapshotRequest): ZIO[Lightsail, AwsError, DeleteDiskSnapshotResponse.ReadOnly] = ZIO.accessM(_.get.deleteDiskSnapshot(request))
  def putAlarm(request: PutAlarmRequest): ZIO[Lightsail, AwsError, PutAlarmResponse.ReadOnly] = ZIO.accessM(_.get.putAlarm(request))
  def getInstances(request: GetInstancesRequest): ZIO[Lightsail, AwsError, GetInstancesResponse.ReadOnly] = ZIO.accessM(_.get.getInstances(request))
  def createCertificate(request: CreateCertificateRequest): ZIO[Lightsail, AwsError, CreateCertificateResponse.ReadOnly] = ZIO.accessM(_.get.createCertificate(request))
  def getRelationalDatabaseLogEvents(request: GetRelationalDatabaseLogEventsRequest): ZIO[Lightsail, AwsError, GetRelationalDatabaseLogEventsResponse.ReadOnly] = ZIO.accessM(_.get.getRelationalDatabaseLogEvents(request))
  def deleteKnownHostKeys(request: DeleteKnownHostKeysRequest): ZIO[Lightsail, AwsError, DeleteKnownHostKeysResponse.ReadOnly] = ZIO.accessM(_.get.deleteKnownHostKeys(request))
  def rebootRelationalDatabase(request: RebootRelationalDatabaseRequest): ZIO[Lightsail, AwsError, RebootRelationalDatabaseResponse.ReadOnly] = ZIO.accessM(_.get.rebootRelationalDatabase(request))
  def createCloudFormationStack(request: CreateCloudFormationStackRequest): ZIO[Lightsail, AwsError, CreateCloudFormationStackResponse.ReadOnly] = ZIO.accessM(_.get.createCloudFormationStack(request))
  def detachDisk(request: DetachDiskRequest): ZIO[Lightsail, AwsError, DetachDiskResponse.ReadOnly] = ZIO.accessM(_.get.detachDisk(request))
  def allocateStaticIp(request: AllocateStaticIpRequest): ZIO[Lightsail, AwsError, AllocateStaticIpResponse.ReadOnly] = ZIO.accessM(_.get.allocateStaticIp(request))
  def getRelationalDatabaseEvents(request: GetRelationalDatabaseEventsRequest): ZIO[Lightsail, AwsError, GetRelationalDatabaseEventsResponse.ReadOnly] = ZIO.accessM(_.get.getRelationalDatabaseEvents(request))
  def getOperations(request: GetOperationsRequest): ZIO[Lightsail, AwsError, GetOperationsResponse.ReadOnly] = ZIO.accessM(_.get.getOperations(request))
  def getInstanceState(request: GetInstanceStateRequest): ZIO[Lightsail, AwsError, GetInstanceStateResponse.ReadOnly] = ZIO.accessM(_.get.getInstanceState(request))
  def getDomains(request: GetDomainsRequest): ZIO[Lightsail, AwsError, GetDomainsResponse.ReadOnly] = ZIO.accessM(_.get.getDomains(request))
  def getLoadBalancers(request: GetLoadBalancersRequest): ZIO[Lightsail, AwsError, GetLoadBalancersResponse.ReadOnly] = ZIO.accessM(_.get.getLoadBalancers(request))
  def getContainerServices(request: GetContainerServicesRequest): ZIO[Lightsail, AwsError, GetContainerServicesResponse.ReadOnly] = ZIO.accessM(_.get.getContainerServices(request))
  def getLoadBalancerTlsCertificates(request: GetLoadBalancerTlsCertificatesRequest): ZIO[Lightsail, AwsError, GetLoadBalancerTlsCertificatesResponse.ReadOnly] = ZIO.accessM(_.get.getLoadBalancerTlsCertificates(request))
  def createRelationalDatabaseFromSnapshot(request: CreateRelationalDatabaseFromSnapshotRequest): ZIO[Lightsail, AwsError, CreateRelationalDatabaseFromSnapshotResponse.ReadOnly] = ZIO.accessM(_.get.createRelationalDatabaseFromSnapshot(request))
  def getInstanceSnapshot(request: GetInstanceSnapshotRequest): ZIO[Lightsail, AwsError, GetInstanceSnapshotResponse.ReadOnly] = ZIO.accessM(_.get.getInstanceSnapshot(request))
  def deleteContainerService(request: DeleteContainerServiceRequest): ZIO[Lightsail, AwsError, DeleteContainerServiceResponse.ReadOnly] = ZIO.accessM(_.get.deleteContainerService(request))
  def getContainerAPIMetadata(request: GetContainerApiMetadataRequest): ZIO[Lightsail, AwsError, GetContainerApiMetadataResponse.ReadOnly] = ZIO.accessM(_.get.getContainerAPIMetadata(request))
  def getDiskSnapshot(request: GetDiskSnapshotRequest): ZIO[Lightsail, AwsError, GetDiskSnapshotResponse.ReadOnly] = ZIO.accessM(_.get.getDiskSnapshot(request))
  def detachStaticIp(request: DetachStaticIpRequest): ZIO[Lightsail, AwsError, DetachStaticIpResponse.ReadOnly] = ZIO.accessM(_.get.detachStaticIp(request))
  def createDisk(request: CreateDiskRequest): ZIO[Lightsail, AwsError, CreateDiskResponse.ReadOnly] = ZIO.accessM(_.get.createDisk(request))
  def getContainerImages(request: GetContainerImagesRequest): ZIO[Lightsail, AwsError, GetContainerImagesResponse.ReadOnly] = ZIO.accessM(_.get.getContainerImages(request))
  def createDomainEntry(request: CreateDomainEntryRequest): ZIO[Lightsail, AwsError, CreateDomainEntryResponse.ReadOnly] = ZIO.accessM(_.get.createDomainEntry(request))
  def sendContactMethodVerification(request: SendContactMethodVerificationRequest): ZIO[Lightsail, AwsError, SendContactMethodVerificationResponse.ReadOnly] = ZIO.accessM(_.get.sendContactMethodVerification(request))
  def getDomain(request: GetDomainRequest): ZIO[Lightsail, AwsError, GetDomainResponse.ReadOnly] = ZIO.accessM(_.get.getDomain(request))
  def deleteInstance(request: DeleteInstanceRequest): ZIO[Lightsail, AwsError, DeleteInstanceResponse.ReadOnly] = ZIO.accessM(_.get.deleteInstance(request))
  def copySnapshot(request: CopySnapshotRequest): ZIO[Lightsail, AwsError, CopySnapshotResponse.ReadOnly] = ZIO.accessM(_.get.copySnapshot(request))
  def getContactMethods(request: GetContactMethodsRequest): ZIO[Lightsail, AwsError, GetContactMethodsResponse.ReadOnly] = ZIO.accessM(_.get.getContactMethods(request))
  def getRelationalDatabaseBundles(request: GetRelationalDatabaseBundlesRequest): ZIO[Lightsail, AwsError, GetRelationalDatabaseBundlesResponse.ReadOnly] = ZIO.accessM(_.get.getRelationalDatabaseBundles(request))
  def detachInstancesFromLoadBalancer(request: DetachInstancesFromLoadBalancerRequest): ZIO[Lightsail, AwsError, DetachInstancesFromLoadBalancerResponse.ReadOnly] = ZIO.accessM(_.get.detachInstancesFromLoadBalancer(request))
  def openInstancePublicPorts(request: OpenInstancePublicPortsRequest): ZIO[Lightsail, AwsError, OpenInstancePublicPortsResponse.ReadOnly] = ZIO.accessM(_.get.openInstancePublicPorts(request))
  def getInstanceMetricData(request: GetInstanceMetricDataRequest): ZIO[Lightsail, AwsError, GetInstanceMetricDataResponse.ReadOnly] = ZIO.accessM(_.get.getInstanceMetricData(request))
  def deleteRelationalDatabaseSnapshot(request: DeleteRelationalDatabaseSnapshotRequest): ZIO[Lightsail, AwsError, DeleteRelationalDatabaseSnapshotResponse.ReadOnly] = ZIO.accessM(_.get.deleteRelationalDatabaseSnapshot(request))
  def attachInstancesToLoadBalancer(request: AttachInstancesToLoadBalancerRequest): ZIO[Lightsail, AwsError, AttachInstancesToLoadBalancerResponse.ReadOnly] = ZIO.accessM(_.get.attachInstancesToLoadBalancer(request))
  def getDistributionBundles(request: GetDistributionBundlesRequest): ZIO[Lightsail, AwsError, GetDistributionBundlesResponse.ReadOnly] = ZIO.accessM(_.get.getDistributionBundles(request))
  def getRelationalDatabaseParameters(request: GetRelationalDatabaseParametersRequest): ZIO[Lightsail, AwsError, GetRelationalDatabaseParametersResponse.ReadOnly] = ZIO.accessM(_.get.getRelationalDatabaseParameters(request))
  def getAlarms(request: GetAlarmsRequest): ZIO[Lightsail, AwsError, GetAlarmsResponse.ReadOnly] = ZIO.accessM(_.get.getAlarms(request))
  def deleteLoadBalancer(request: DeleteLoadBalancerRequest): ZIO[Lightsail, AwsError, DeleteLoadBalancerResponse.ReadOnly] = ZIO.accessM(_.get.deleteLoadBalancer(request))
  def getInstanceSnapshots(request: GetInstanceSnapshotsRequest): ZIO[Lightsail, AwsError, GetInstanceSnapshotsResponse.ReadOnly] = ZIO.accessM(_.get.getInstanceSnapshots(request))
  def stopRelationalDatabase(request: StopRelationalDatabaseRequest): ZIO[Lightsail, AwsError, StopRelationalDatabaseResponse.ReadOnly] = ZIO.accessM(_.get.stopRelationalDatabase(request))
  def getLoadBalancerMetricData(request: GetLoadBalancerMetricDataRequest): ZIO[Lightsail, AwsError, GetLoadBalancerMetricDataResponse.ReadOnly] = ZIO.accessM(_.get.getLoadBalancerMetricData(request))
  def attachCertificateToDistribution(request: AttachCertificateToDistributionRequest): ZIO[Lightsail, AwsError, AttachCertificateToDistributionResponse.ReadOnly] = ZIO.accessM(_.get.attachCertificateToDistribution(request))
  def deleteCertificate(request: DeleteCertificateRequest): ZIO[Lightsail, AwsError, DeleteCertificateResponse.ReadOnly] = ZIO.accessM(_.get.deleteCertificate(request))
  def getInstance(request: GetInstanceRequest): ZIO[Lightsail, AwsError, GetInstanceResponse.ReadOnly] = ZIO.accessM(_.get.getInstance(request))
  def getDistributions(request: GetDistributionsRequest): ZIO[Lightsail, AwsError, GetDistributionsResponse.ReadOnly] = ZIO.accessM(_.get.getDistributions(request))
  def getRelationalDatabases(request: GetRelationalDatabasesRequest): ZIO[Lightsail, AwsError, GetRelationalDatabasesResponse.ReadOnly] = ZIO.accessM(_.get.getRelationalDatabases(request))
  def attachLoadBalancerTlsCertificate(request: AttachLoadBalancerTlsCertificateRequest): ZIO[Lightsail, AwsError, AttachLoadBalancerTlsCertificateResponse.ReadOnly] = ZIO.accessM(_.get.attachLoadBalancerTlsCertificate(request))
  def getOperationsForResource(request: GetOperationsForResourceRequest): ZIO[Lightsail, AwsError, GetOperationsForResourceResponse.ReadOnly] = ZIO.accessM(_.get.getOperationsForResource(request))
  def createDiskFromSnapshot(request: CreateDiskFromSnapshotRequest): ZIO[Lightsail, AwsError, CreateDiskFromSnapshotResponse.ReadOnly] = ZIO.accessM(_.get.createDiskFromSnapshot(request))
  def getLoadBalancer(request: GetLoadBalancerRequest): ZIO[Lightsail, AwsError, GetLoadBalancerResponse.ReadOnly] = ZIO.accessM(_.get.getLoadBalancer(request))
  def deleteInstanceSnapshot(request: DeleteInstanceSnapshotRequest): ZIO[Lightsail, AwsError, DeleteInstanceSnapshotResponse.ReadOnly] = ZIO.accessM(_.get.deleteInstanceSnapshot(request))
  def deleteDomainEntry(request: DeleteDomainEntryRequest): ZIO[Lightsail, AwsError, DeleteDomainEntryResponse.ReadOnly] = ZIO.accessM(_.get.deleteDomainEntry(request))
  def updateRelationalDatabase(request: UpdateRelationalDatabaseRequest): ZIO[Lightsail, AwsError, UpdateRelationalDatabaseResponse.ReadOnly] = ZIO.accessM(_.get.updateRelationalDatabase(request))
  def peerVpc(request: PeerVpcRequest): ZIO[Lightsail, AwsError, PeerVpcResponse.ReadOnly] = ZIO.accessM(_.get.peerVpc(request))
  def unpeerVpc(request: UnpeerVpcRequest): ZIO[Lightsail, AwsError, UnpeerVpcResponse.ReadOnly] = ZIO.accessM(_.get.unpeerVpc(request))
  def getActiveNames(request: GetActiveNamesRequest): ZIO[Lightsail, AwsError, GetActiveNamesResponse.ReadOnly] = ZIO.accessM(_.get.getActiveNames(request))
  def getAutoSnapshots(request: GetAutoSnapshotsRequest): ZIO[Lightsail, AwsError, GetAutoSnapshotsResponse.ReadOnly] = ZIO.accessM(_.get.getAutoSnapshots(request))
  def startRelationalDatabase(request: StartRelationalDatabaseRequest): ZIO[Lightsail, AwsError, StartRelationalDatabaseResponse.ReadOnly] = ZIO.accessM(_.get.startRelationalDatabase(request))
  def createInstanceSnapshot(request: CreateInstanceSnapshotRequest): ZIO[Lightsail, AwsError, CreateInstanceSnapshotResponse.ReadOnly] = ZIO.accessM(_.get.createInstanceSnapshot(request))
  def updateDomainEntry(request: UpdateDomainEntryRequest): ZIO[Lightsail, AwsError, UpdateDomainEntryResponse.ReadOnly] = ZIO.accessM(_.get.updateDomainEntry(request))
  def rebootInstance(request: RebootInstanceRequest): ZIO[Lightsail, AwsError, RebootInstanceResponse.ReadOnly] = ZIO.accessM(_.get.rebootInstance(request))
  def createContactMethod(request: CreateContactMethodRequest): ZIO[Lightsail, AwsError, CreateContactMethodResponse.ReadOnly] = ZIO.accessM(_.get.createContactMethod(request))
  def getDiskSnapshots(request: GetDiskSnapshotsRequest): ZIO[Lightsail, AwsError, GetDiskSnapshotsResponse.ReadOnly] = ZIO.accessM(_.get.getDiskSnapshots(request))
  def getContainerLog(request: GetContainerLogRequest): ZIO[Lightsail, AwsError, GetContainerLogResponse.ReadOnly] = ZIO.accessM(_.get.getContainerLog(request))
  def getContainerServiceDeployments(request: GetContainerServiceDeploymentsRequest): ZIO[Lightsail, AwsError, GetContainerServiceDeploymentsResponse.ReadOnly] = ZIO.accessM(_.get.getContainerServiceDeployments(request))
  def createDomain(request: CreateDomainRequest): ZIO[Lightsail, AwsError, CreateDomainResponse.ReadOnly] = ZIO.accessM(_.get.createDomain(request))
  def createContainerService(request: CreateContainerServiceRequest): ZIO[Lightsail, AwsError, CreateContainerServiceResponse.ReadOnly] = ZIO.accessM(_.get.createContainerService(request))
  def isVpcPeered(request: IsVpcPeeredRequest): ZIO[Lightsail, AwsError, IsVpcPeeredResponse.ReadOnly] = ZIO.accessM(_.get.isVpcPeered(request))
  def deleteAutoSnapshot(request: DeleteAutoSnapshotRequest): ZIO[Lightsail, AwsError, DeleteAutoSnapshotResponse.ReadOnly] = ZIO.accessM(_.get.deleteAutoSnapshot(request))
  def createContainerServiceRegistryLogin(request: CreateContainerServiceRegistryLoginRequest): ZIO[Lightsail, AwsError, CreateContainerServiceRegistryLoginResponse.ReadOnly] = ZIO.accessM(_.get.createContainerServiceRegistryLogin(request))
  def getDisk(request: GetDiskRequest): ZIO[Lightsail, AwsError, GetDiskResponse.ReadOnly] = ZIO.accessM(_.get.getDisk(request))
  def enableAddOn(request: EnableAddOnRequest): ZIO[Lightsail, AwsError, EnableAddOnResponse.ReadOnly] = ZIO.accessM(_.get.enableAddOn(request))
  def untagResource(request: UntagResourceRequest): ZIO[Lightsail, AwsError, UntagResourceResponse.ReadOnly] = ZIO.accessM(_.get.untagResource(request))
  def createLoadBalancerTlsCertificate(request: CreateLoadBalancerTlsCertificateRequest): ZIO[Lightsail, AwsError, CreateLoadBalancerTlsCertificateResponse.ReadOnly] = ZIO.accessM(_.get.createLoadBalancerTlsCertificate(request))
  def getStaticIp(request: GetStaticIpRequest): ZIO[Lightsail, AwsError, GetStaticIpResponse.ReadOnly] = ZIO.accessM(_.get.getStaticIp(request))
  def attachStaticIp(request: AttachStaticIpRequest): ZIO[Lightsail, AwsError, AttachStaticIpResponse.ReadOnly] = ZIO.accessM(_.get.attachStaticIp(request))
  def importKeyPair(request: ImportKeyPairRequest): ZIO[Lightsail, AwsError, ImportKeyPairResponse.ReadOnly] = ZIO.accessM(_.get.importKeyPair(request))
  def getDisks(request: GetDisksRequest): ZIO[Lightsail, AwsError, GetDisksResponse.ReadOnly] = ZIO.accessM(_.get.getDisks(request))
  def downloadDefaultKeyPair(request: DownloadDefaultKeyPairRequest): ZIO[Lightsail, AwsError, DownloadDefaultKeyPairResponse.ReadOnly] = ZIO.accessM(_.get.downloadDefaultKeyPair(request))
  def getExportSnapshotRecords(request: GetExportSnapshotRecordsRequest): ZIO[Lightsail, AwsError, GetExportSnapshotRecordsResponse.ReadOnly] = ZIO.accessM(_.get.getExportSnapshotRecords(request))
  def createKeyPair(request: CreateKeyPairRequest): ZIO[Lightsail, AwsError, CreateKeyPairResponse.ReadOnly] = ZIO.accessM(_.get.createKeyPair(request))
  def getBundles(request: GetBundlesRequest): ZIO[Lightsail, AwsError, GetBundlesResponse.ReadOnly] = ZIO.accessM(_.get.getBundles(request))
  def registerContainerImage(request: RegisterContainerImageRequest): ZIO[Lightsail, AwsError, RegisterContainerImageResponse.ReadOnly] = ZIO.accessM(_.get.registerContainerImage(request))
  def startInstance(request: StartInstanceRequest): ZIO[Lightsail, AwsError, StartInstanceResponse.ReadOnly] = ZIO.accessM(_.get.startInstance(request))
  def getInstancePortStates(request: GetInstancePortStatesRequest): ZIO[Lightsail, AwsError, GetInstancePortStatesResponse.ReadOnly] = ZIO.accessM(_.get.getInstancePortStates(request))
  def deleteDisk(request: DeleteDiskRequest): ZIO[Lightsail, AwsError, DeleteDiskResponse.ReadOnly] = ZIO.accessM(_.get.deleteDisk(request))
  def getBlueprints(request: GetBlueprintsRequest): ZIO[Lightsail, AwsError, GetBlueprintsResponse.ReadOnly] = ZIO.accessM(_.get.getBlueprints(request))
  def deleteAlarm(request: DeleteAlarmRequest): ZIO[Lightsail, AwsError, DeleteAlarmResponse.ReadOnly] = ZIO.accessM(_.get.deleteAlarm(request))
  def createRelationalDatabaseSnapshot(request: CreateRelationalDatabaseSnapshotRequest): ZIO[Lightsail, AwsError, CreateRelationalDatabaseSnapshotResponse.ReadOnly] = ZIO.accessM(_.get.createRelationalDatabaseSnapshot(request))
  def getContainerServiceMetricData(request: GetContainerServiceMetricDataRequest): ZIO[Lightsail, AwsError, GetContainerServiceMetricDataResponse.ReadOnly] = ZIO.accessM(_.get.getContainerServiceMetricData(request))
  def getRelationalDatabaseLogStreams(request: GetRelationalDatabaseLogStreamsRequest): ZIO[Lightsail, AwsError, GetRelationalDatabaseLogStreamsResponse.ReadOnly] = ZIO.accessM(_.get.getRelationalDatabaseLogStreams(request))
  def updateRelationalDatabaseParameters(request: UpdateRelationalDatabaseParametersRequest): ZIO[Lightsail, AwsError, UpdateRelationalDatabaseParametersResponse.ReadOnly] = ZIO.accessM(_.get.updateRelationalDatabaseParameters(request))
  def createContainerServiceDeployment(request: CreateContainerServiceDeploymentRequest): ZIO[Lightsail, AwsError, CreateContainerServiceDeploymentResponse.ReadOnly] = ZIO.accessM(_.get.createContainerServiceDeployment(request))
  def getDistributionLatestCacheReset(request: GetDistributionLatestCacheResetRequest): ZIO[Lightsail, AwsError, GetDistributionLatestCacheResetResponse.ReadOnly] = ZIO.accessM(_.get.getDistributionLatestCacheReset(request))
  def updateDistributionBundle(request: UpdateDistributionBundleRequest): ZIO[Lightsail, AwsError, UpdateDistributionBundleResponse.ReadOnly] = ZIO.accessM(_.get.updateDistributionBundle(request))
  def deleteKeyPair(request: DeleteKeyPairRequest): ZIO[Lightsail, AwsError, DeleteKeyPairResponse.ReadOnly] = ZIO.accessM(_.get.deleteKeyPair(request))
  def getStaticIps(request: GetStaticIpsRequest): ZIO[Lightsail, AwsError, GetStaticIpsResponse.ReadOnly] = ZIO.accessM(_.get.getStaticIps(request))
  def createRelationalDatabase(request: CreateRelationalDatabaseRequest): ZIO[Lightsail, AwsError, CreateRelationalDatabaseResponse.ReadOnly] = ZIO.accessM(_.get.createRelationalDatabase(request))
  def getCertificates(request: GetCertificatesRequest): ZIO[Lightsail, AwsError, GetCertificatesResponse.ReadOnly] = ZIO.accessM(_.get.getCertificates(request))
  def tagResource(request: TagResourceRequest): ZIO[Lightsail, AwsError, TagResourceResponse.ReadOnly] = ZIO.accessM(_.get.tagResource(request))
  def deleteDomain(request: DeleteDomainRequest): ZIO[Lightsail, AwsError, DeleteDomainResponse.ReadOnly] = ZIO.accessM(_.get.deleteDomain(request))
  def getRelationalDatabaseSnapshots(request: GetRelationalDatabaseSnapshotsRequest): ZIO[Lightsail, AwsError, GetRelationalDatabaseSnapshotsResponse.ReadOnly] = ZIO.accessM(_.get.getRelationalDatabaseSnapshots(request))
  def createInstancesFromSnapshot(request: CreateInstancesFromSnapshotRequest): ZIO[Lightsail, AwsError, CreateInstancesFromSnapshotResponse.ReadOnly] = ZIO.accessM(_.get.createInstancesFromSnapshot(request))
  def exportSnapshot(request: ExportSnapshotRequest): ZIO[Lightsail, AwsError, ExportSnapshotResponse.ReadOnly] = ZIO.accessM(_.get.exportSnapshot(request))
  def attachDisk(request: AttachDiskRequest): ZIO[Lightsail, AwsError, AttachDiskResponse.ReadOnly] = ZIO.accessM(_.get.attachDisk(request))
  def setIpAddressType(request: SetIpAddressTypeRequest): ZIO[Lightsail, AwsError, SetIpAddressTypeResponse.ReadOnly] = ZIO.accessM(_.get.setIpAddressType(request))
  def getRegions(request: GetRegionsRequest): ZIO[Lightsail, AwsError, GetRegionsResponse.ReadOnly] = ZIO.accessM(_.get.getRegions(request))
  def getRelationalDatabaseMetricData(request: GetRelationalDatabaseMetricDataRequest): ZIO[Lightsail, AwsError, GetRelationalDatabaseMetricDataResponse.ReadOnly] = ZIO.accessM(_.get.getRelationalDatabaseMetricData(request))
  def getOperation(request: GetOperationRequest): ZIO[Lightsail, AwsError, GetOperationResponse.ReadOnly] = ZIO.accessM(_.get.getOperation(request))
  def stopInstance(request: StopInstanceRequest): ZIO[Lightsail, AwsError, StopInstanceResponse.ReadOnly] = ZIO.accessM(_.get.stopInstance(request))
  def getDistributionMetricData(request: GetDistributionMetricDataRequest): ZIO[Lightsail, AwsError, GetDistributionMetricDataResponse.ReadOnly] = ZIO.accessM(_.get.getDistributionMetricData(request))
  def getKeyPairs(request: GetKeyPairsRequest): ZIO[Lightsail, AwsError, GetKeyPairsResponse.ReadOnly] = ZIO.accessM(_.get.getKeyPairs(request))
  def disableAddOn(request: DisableAddOnRequest): ZIO[Lightsail, AwsError, DisableAddOnResponse.ReadOnly] = ZIO.accessM(_.get.disableAddOn(request))
  def createInstances(request: CreateInstancesRequest): ZIO[Lightsail, AwsError, CreateInstancesResponse.ReadOnly] = ZIO.accessM(_.get.createInstances(request))
  def createLoadBalancer(request: CreateLoadBalancerRequest): ZIO[Lightsail, AwsError, CreateLoadBalancerResponse.ReadOnly] = ZIO.accessM(_.get.createLoadBalancer(request))
  def getRelationalDatabaseBlueprints(request: GetRelationalDatabaseBlueprintsRequest): ZIO[Lightsail, AwsError, GetRelationalDatabaseBlueprintsResponse.ReadOnly] = ZIO.accessM(_.get.getRelationalDatabaseBlueprints(request))
  def detachCertificateFromDistribution(request: DetachCertificateFromDistributionRequest): ZIO[Lightsail, AwsError, DetachCertificateFromDistributionResponse.ReadOnly] = ZIO.accessM(_.get.detachCertificateFromDistribution(request))
  def getRelationalDatabaseMasterUserPassword(request: GetRelationalDatabaseMasterUserPasswordRequest): ZIO[Lightsail, AwsError, GetRelationalDatabaseMasterUserPasswordResponse.ReadOnly] = ZIO.accessM(_.get.getRelationalDatabaseMasterUserPassword(request))
  def updateContainerService(request: UpdateContainerServiceRequest): ZIO[Lightsail, AwsError, UpdateContainerServiceResponse.ReadOnly] = ZIO.accessM(_.get.updateContainerService(request))
  def getContainerServicePowers(request: GetContainerServicePowersRequest): ZIO[Lightsail, AwsError, GetContainerServicePowersResponse.ReadOnly] = ZIO.accessM(_.get.getContainerServicePowers(request))
  def getRelationalDatabase(request: GetRelationalDatabaseRequest): ZIO[Lightsail, AwsError, GetRelationalDatabaseResponse.ReadOnly] = ZIO.accessM(_.get.getRelationalDatabase(request))
  def getCloudFormationStackRecords(request: GetCloudFormationStackRecordsRequest): ZIO[Lightsail, AwsError, GetCloudFormationStackRecordsResponse.ReadOnly] = ZIO.accessM(_.get.getCloudFormationStackRecords(request))
  def updateDistribution(request: UpdateDistributionRequest): ZIO[Lightsail, AwsError, UpdateDistributionResponse.ReadOnly] = ZIO.accessM(_.get.updateDistribution(request))
  def deleteDistribution(request: DeleteDistributionRequest): ZIO[Lightsail, AwsError, DeleteDistributionResponse.ReadOnly] = ZIO.accessM(_.get.deleteDistribution(request))
  def deleteContainerImage(request: DeleteContainerImageRequest): ZIO[Lightsail, AwsError, DeleteContainerImageResponse.ReadOnly] = ZIO.accessM(_.get.deleteContainerImage(request))
  def createDistribution(request: CreateDistributionRequest): ZIO[Lightsail, AwsError, CreateDistributionResponse.ReadOnly] = ZIO.accessM(_.get.createDistribution(request))
}