# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import copy
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from . import _utilities

__all__ = [
    'ProviderAssumeRoleArgs',
    'ProviderEndpointArgs',
]

@pulumi.input_type
class ProviderAssumeRoleArgs:
    def __init__(__self__, *,
                 role_arn: pulumi.Input[str],
                 policy: Optional[pulumi.Input[str]] = None,
                 session_expiration: Optional[pulumi.Input[int]] = None,
                 session_name: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "role_arn", role_arn)
        if policy is not None:
            pulumi.set(__self__, "policy", policy)
        if session_expiration is not None:
            pulumi.set(__self__, "session_expiration", session_expiration)
        if session_name is not None:
            pulumi.set(__self__, "session_name", session_name)

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> pulumi.Input[str]:
        return pulumi.get(self, "role_arn")

    @role_arn.setter
    def role_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "role_arn", value)

    @property
    @pulumi.getter
    def policy(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "policy")

    @policy.setter
    def policy(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "policy", value)

    @property
    @pulumi.getter(name="sessionExpiration")
    def session_expiration(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "session_expiration")

    @session_expiration.setter
    def session_expiration(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "session_expiration", value)

    @property
    @pulumi.getter(name="sessionName")
    def session_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "session_name")

    @session_name.setter
    def session_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "session_name", value)


@pulumi.input_type
class ProviderEndpointArgs:
    def __init__(__self__, *,
                 acr: Optional[pulumi.Input[str]] = None,
                 actiontrail: Optional[pulumi.Input[str]] = None,
                 adb: Optional[pulumi.Input[str]] = None,
                 alb: Optional[pulumi.Input[str]] = None,
                 alidfs: Optional[pulumi.Input[str]] = None,
                 alidns: Optional[pulumi.Input[str]] = None,
                 alikafka: Optional[pulumi.Input[str]] = None,
                 apigateway: Optional[pulumi.Input[str]] = None,
                 arms: Optional[pulumi.Input[str]] = None,
                 bastionhost: Optional[pulumi.Input[str]] = None,
                 beebot: Optional[pulumi.Input[str]] = None,
                 bpstudio: Optional[pulumi.Input[str]] = None,
                 brain_industrial: Optional[pulumi.Input[str]] = None,
                 bssopenapi: Optional[pulumi.Input[str]] = None,
                 cas: Optional[pulumi.Input[str]] = None,
                 cassandra: Optional[pulumi.Input[str]] = None,
                 cbn: Optional[pulumi.Input[str]] = None,
                 cbs: Optional[pulumi.Input[str]] = None,
                 cddc: Optional[pulumi.Input[str]] = None,
                 cdn: Optional[pulumi.Input[str]] = None,
                 cds: Optional[pulumi.Input[str]] = None,
                 clickhouse: Optional[pulumi.Input[str]] = None,
                 cloudauth: Optional[pulumi.Input[str]] = None,
                 cloudfirewall: Optional[pulumi.Input[str]] = None,
                 cloudfw: Optional[pulumi.Input[str]] = None,
                 cloudphone: Optional[pulumi.Input[str]] = None,
                 cloudsso: Optional[pulumi.Input[str]] = None,
                 cms: Optional[pulumi.Input[str]] = None,
                 computenest: Optional[pulumi.Input[str]] = None,
                 config: Optional[pulumi.Input[str]] = None,
                 cr: Optional[pulumi.Input[str]] = None,
                 cs: Optional[pulumi.Input[str]] = None,
                 das: Optional[pulumi.Input[str]] = None,
                 datahub: Optional[pulumi.Input[str]] = None,
                 dataworkspublic: Optional[pulumi.Input[str]] = None,
                 dbfs: Optional[pulumi.Input[str]] = None,
                 dcdn: Optional[pulumi.Input[str]] = None,
                 ddosbasic: Optional[pulumi.Input[str]] = None,
                 ddosbgp: Optional[pulumi.Input[str]] = None,
                 ddoscoo: Optional[pulumi.Input[str]] = None,
                 dds: Optional[pulumi.Input[str]] = None,
                 devopsrdc: Optional[pulumi.Input[str]] = None,
                 dg: Optional[pulumi.Input[str]] = None,
                 dm: Optional[pulumi.Input[str]] = None,
                 dms_enterprise: Optional[pulumi.Input[str]] = None,
                 dmsenterprise: Optional[pulumi.Input[str]] = None,
                 dns: Optional[pulumi.Input[str]] = None,
                 drds: Optional[pulumi.Input[str]] = None,
                 dts: Optional[pulumi.Input[str]] = None,
                 dysms: Optional[pulumi.Input[str]] = None,
                 eais: Optional[pulumi.Input[str]] = None,
                 ebs: Optional[pulumi.Input[str]] = None,
                 eci: Optional[pulumi.Input[str]] = None,
                 ecs: Optional[pulumi.Input[str]] = None,
                 edas: Optional[pulumi.Input[str]] = None,
                 edasschedulerx: Optional[pulumi.Input[str]] = None,
                 edsuser: Optional[pulumi.Input[str]] = None,
                 eflo: Optional[pulumi.Input[str]] = None,
                 ehpc: Optional[pulumi.Input[str]] = None,
                 ehs: Optional[pulumi.Input[str]] = None,
                 eipanycast: Optional[pulumi.Input[str]] = None,
                 elasticsearch: Optional[pulumi.Input[str]] = None,
                 emr: Optional[pulumi.Input[str]] = None,
                 ens: Optional[pulumi.Input[str]] = None,
                 ess: Optional[pulumi.Input[str]] = None,
                 eventbridge: Optional[pulumi.Input[str]] = None,
                 fc: Optional[pulumi.Input[str]] = None,
                 fnf: Optional[pulumi.Input[str]] = None,
                 ga: Optional[pulumi.Input[str]] = None,
                 gaplus: Optional[pulumi.Input[str]] = None,
                 gds: Optional[pulumi.Input[str]] = None,
                 gpdb: Optional[pulumi.Input[str]] = None,
                 gwsecd: Optional[pulumi.Input[str]] = None,
                 hbr: Optional[pulumi.Input[str]] = None,
                 hcs_sgw: Optional[pulumi.Input[str]] = None,
                 hitsdb: Optional[pulumi.Input[str]] = None,
                 imm: Optional[pulumi.Input[str]] = None,
                 imp: Optional[pulumi.Input[str]] = None,
                 ims: Optional[pulumi.Input[str]] = None,
                 iot: Optional[pulumi.Input[str]] = None,
                 kms: Optional[pulumi.Input[str]] = None,
                 kvstore: Optional[pulumi.Input[str]] = None,
                 location: Optional[pulumi.Input[str]] = None,
                 log: Optional[pulumi.Input[str]] = None,
                 market: Optional[pulumi.Input[str]] = None,
                 maxcompute: Optional[pulumi.Input[str]] = None,
                 mhub: Optional[pulumi.Input[str]] = None,
                 mns: Optional[pulumi.Input[str]] = None,
                 mscopensubscription: Optional[pulumi.Input[str]] = None,
                 mse: Optional[pulumi.Input[str]] = None,
                 nas: Optional[pulumi.Input[str]] = None,
                 nlb: Optional[pulumi.Input[str]] = None,
                 oceanbase: Optional[pulumi.Input[str]] = None,
                 ons: Optional[pulumi.Input[str]] = None,
                 onsproxy: Optional[pulumi.Input[str]] = None,
                 oos: Optional[pulumi.Input[str]] = None,
                 opensearch: Optional[pulumi.Input[str]] = None,
                 oss: Optional[pulumi.Input[str]] = None,
                 ots: Optional[pulumi.Input[str]] = None,
                 polardb: Optional[pulumi.Input[str]] = None,
                 privatelink: Optional[pulumi.Input[str]] = None,
                 pvtz: Optional[pulumi.Input[str]] = None,
                 quickbi: Optional[pulumi.Input[str]] = None,
                 quotas: Optional[pulumi.Input[str]] = None,
                 r_kvstore: Optional[pulumi.Input[str]] = None,
                 ram: Optional[pulumi.Input[str]] = None,
                 rds: Optional[pulumi.Input[str]] = None,
                 redisa: Optional[pulumi.Input[str]] = None,
                 resourcemanager: Optional[pulumi.Input[str]] = None,
                 resourcesharing: Optional[pulumi.Input[str]] = None,
                 ros: Optional[pulumi.Input[str]] = None,
                 sas: Optional[pulumi.Input[str]] = None,
                 scdn: Optional[pulumi.Input[str]] = None,
                 sddp: Optional[pulumi.Input[str]] = None,
                 serverless: Optional[pulumi.Input[str]] = None,
                 servicemesh: Optional[pulumi.Input[str]] = None,
                 sgw: Optional[pulumi.Input[str]] = None,
                 slb: Optional[pulumi.Input[str]] = None,
                 smartag: Optional[pulumi.Input[str]] = None,
                 srvcatalog: Optional[pulumi.Input[str]] = None,
                 sts: Optional[pulumi.Input[str]] = None,
                 swas: Optional[pulumi.Input[str]] = None,
                 tag: Optional[pulumi.Input[str]] = None,
                 vod: Optional[pulumi.Input[str]] = None,
                 vpc: Optional[pulumi.Input[str]] = None,
                 vpcpeer: Optional[pulumi.Input[str]] = None,
                 vs: Optional[pulumi.Input[str]] = None,
                 waf: Optional[pulumi.Input[str]] = None,
                 waf_openapi: Optional[pulumi.Input[str]] = None):
        if acr is not None:
            pulumi.set(__self__, "acr", acr)
        if actiontrail is not None:
            pulumi.set(__self__, "actiontrail", actiontrail)
        if adb is not None:
            pulumi.set(__self__, "adb", adb)
        if alb is not None:
            pulumi.set(__self__, "alb", alb)
        if alidfs is not None:
            pulumi.set(__self__, "alidfs", alidfs)
        if alidns is not None:
            pulumi.set(__self__, "alidns", alidns)
        if alikafka is not None:
            pulumi.set(__self__, "alikafka", alikafka)
        if apigateway is not None:
            pulumi.set(__self__, "apigateway", apigateway)
        if arms is not None:
            pulumi.set(__self__, "arms", arms)
        if bastionhost is not None:
            pulumi.set(__self__, "bastionhost", bastionhost)
        if beebot is not None:
            pulumi.set(__self__, "beebot", beebot)
        if bpstudio is not None:
            pulumi.set(__self__, "bpstudio", bpstudio)
        if brain_industrial is not None:
            pulumi.set(__self__, "brain_industrial", brain_industrial)
        if bssopenapi is not None:
            pulumi.set(__self__, "bssopenapi", bssopenapi)
        if cas is not None:
            pulumi.set(__self__, "cas", cas)
        if cassandra is not None:
            pulumi.set(__self__, "cassandra", cassandra)
        if cbn is not None:
            pulumi.set(__self__, "cbn", cbn)
        if cbs is not None:
            pulumi.set(__self__, "cbs", cbs)
        if cddc is not None:
            pulumi.set(__self__, "cddc", cddc)
        if cdn is not None:
            pulumi.set(__self__, "cdn", cdn)
        if cds is not None:
            pulumi.set(__self__, "cds", cds)
        if clickhouse is not None:
            pulumi.set(__self__, "clickhouse", clickhouse)
        if cloudauth is not None:
            pulumi.set(__self__, "cloudauth", cloudauth)
        if cloudfirewall is not None:
            pulumi.set(__self__, "cloudfirewall", cloudfirewall)
        if cloudfw is not None:
            pulumi.set(__self__, "cloudfw", cloudfw)
        if cloudphone is not None:
            pulumi.set(__self__, "cloudphone", cloudphone)
        if cloudsso is not None:
            pulumi.set(__self__, "cloudsso", cloudsso)
        if cms is not None:
            pulumi.set(__self__, "cms", cms)
        if computenest is not None:
            pulumi.set(__self__, "computenest", computenest)
        if config is not None:
            pulumi.set(__self__, "config", config)
        if cr is not None:
            pulumi.set(__self__, "cr", cr)
        if cs is not None:
            pulumi.set(__self__, "cs", cs)
        if das is not None:
            pulumi.set(__self__, "das", das)
        if datahub is not None:
            pulumi.set(__self__, "datahub", datahub)
        if dataworkspublic is not None:
            pulumi.set(__self__, "dataworkspublic", dataworkspublic)
        if dbfs is not None:
            pulumi.set(__self__, "dbfs", dbfs)
        if dcdn is not None:
            pulumi.set(__self__, "dcdn", dcdn)
        if ddosbasic is not None:
            pulumi.set(__self__, "ddosbasic", ddosbasic)
        if ddosbgp is not None:
            pulumi.set(__self__, "ddosbgp", ddosbgp)
        if ddoscoo is not None:
            pulumi.set(__self__, "ddoscoo", ddoscoo)
        if dds is not None:
            pulumi.set(__self__, "dds", dds)
        if devopsrdc is not None:
            pulumi.set(__self__, "devopsrdc", devopsrdc)
        if dg is not None:
            pulumi.set(__self__, "dg", dg)
        if dm is not None:
            pulumi.set(__self__, "dm", dm)
        if dms_enterprise is not None:
            pulumi.set(__self__, "dms_enterprise", dms_enterprise)
        if dmsenterprise is not None:
            pulumi.set(__self__, "dmsenterprise", dmsenterprise)
        if dns is not None:
            pulumi.set(__self__, "dns", dns)
        if drds is not None:
            pulumi.set(__self__, "drds", drds)
        if dts is not None:
            pulumi.set(__self__, "dts", dts)
        if dysms is not None:
            pulumi.set(__self__, "dysms", dysms)
        if eais is not None:
            pulumi.set(__self__, "eais", eais)
        if ebs is not None:
            pulumi.set(__self__, "ebs", ebs)
        if eci is not None:
            pulumi.set(__self__, "eci", eci)
        if ecs is not None:
            pulumi.set(__self__, "ecs", ecs)
        if edas is not None:
            pulumi.set(__self__, "edas", edas)
        if edasschedulerx is not None:
            pulumi.set(__self__, "edasschedulerx", edasschedulerx)
        if edsuser is not None:
            pulumi.set(__self__, "edsuser", edsuser)
        if eflo is not None:
            pulumi.set(__self__, "eflo", eflo)
        if ehpc is not None:
            pulumi.set(__self__, "ehpc", ehpc)
        if ehs is not None:
            pulumi.set(__self__, "ehs", ehs)
        if eipanycast is not None:
            pulumi.set(__self__, "eipanycast", eipanycast)
        if elasticsearch is not None:
            pulumi.set(__self__, "elasticsearch", elasticsearch)
        if emr is not None:
            pulumi.set(__self__, "emr", emr)
        if ens is not None:
            pulumi.set(__self__, "ens", ens)
        if ess is not None:
            pulumi.set(__self__, "ess", ess)
        if eventbridge is not None:
            pulumi.set(__self__, "eventbridge", eventbridge)
        if fc is not None:
            pulumi.set(__self__, "fc", fc)
        if fnf is not None:
            pulumi.set(__self__, "fnf", fnf)
        if ga is not None:
            pulumi.set(__self__, "ga", ga)
        if gaplus is not None:
            pulumi.set(__self__, "gaplus", gaplus)
        if gds is not None:
            pulumi.set(__self__, "gds", gds)
        if gpdb is not None:
            pulumi.set(__self__, "gpdb", gpdb)
        if gwsecd is not None:
            pulumi.set(__self__, "gwsecd", gwsecd)
        if hbr is not None:
            pulumi.set(__self__, "hbr", hbr)
        if hcs_sgw is not None:
            pulumi.set(__self__, "hcs_sgw", hcs_sgw)
        if hitsdb is not None:
            pulumi.set(__self__, "hitsdb", hitsdb)
        if imm is not None:
            pulumi.set(__self__, "imm", imm)
        if imp is not None:
            pulumi.set(__self__, "imp", imp)
        if ims is not None:
            pulumi.set(__self__, "ims", ims)
        if iot is not None:
            pulumi.set(__self__, "iot", iot)
        if kms is not None:
            pulumi.set(__self__, "kms", kms)
        if kvstore is not None:
            pulumi.set(__self__, "kvstore", kvstore)
        if location is not None:
            pulumi.set(__self__, "location", location)
        if log is not None:
            pulumi.set(__self__, "log", log)
        if market is not None:
            pulumi.set(__self__, "market", market)
        if maxcompute is not None:
            pulumi.set(__self__, "maxcompute", maxcompute)
        if mhub is not None:
            pulumi.set(__self__, "mhub", mhub)
        if mns is not None:
            pulumi.set(__self__, "mns", mns)
        if mscopensubscription is not None:
            pulumi.set(__self__, "mscopensubscription", mscopensubscription)
        if mse is not None:
            pulumi.set(__self__, "mse", mse)
        if nas is not None:
            pulumi.set(__self__, "nas", nas)
        if nlb is not None:
            pulumi.set(__self__, "nlb", nlb)
        if oceanbase is not None:
            pulumi.set(__self__, "oceanbase", oceanbase)
        if ons is not None:
            pulumi.set(__self__, "ons", ons)
        if onsproxy is not None:
            pulumi.set(__self__, "onsproxy", onsproxy)
        if oos is not None:
            pulumi.set(__self__, "oos", oos)
        if opensearch is not None:
            pulumi.set(__self__, "opensearch", opensearch)
        if oss is not None:
            pulumi.set(__self__, "oss", oss)
        if ots is not None:
            pulumi.set(__self__, "ots", ots)
        if polardb is not None:
            pulumi.set(__self__, "polardb", polardb)
        if privatelink is not None:
            pulumi.set(__self__, "privatelink", privatelink)
        if pvtz is not None:
            pulumi.set(__self__, "pvtz", pvtz)
        if quickbi is not None:
            pulumi.set(__self__, "quickbi", quickbi)
        if quotas is not None:
            pulumi.set(__self__, "quotas", quotas)
        if r_kvstore is not None:
            pulumi.set(__self__, "r_kvstore", r_kvstore)
        if ram is not None:
            pulumi.set(__self__, "ram", ram)
        if rds is not None:
            pulumi.set(__self__, "rds", rds)
        if redisa is not None:
            pulumi.set(__self__, "redisa", redisa)
        if resourcemanager is not None:
            pulumi.set(__self__, "resourcemanager", resourcemanager)
        if resourcesharing is not None:
            pulumi.set(__self__, "resourcesharing", resourcesharing)
        if ros is not None:
            pulumi.set(__self__, "ros", ros)
        if sas is not None:
            pulumi.set(__self__, "sas", sas)
        if scdn is not None:
            pulumi.set(__self__, "scdn", scdn)
        if sddp is not None:
            pulumi.set(__self__, "sddp", sddp)
        if serverless is not None:
            pulumi.set(__self__, "serverless", serverless)
        if servicemesh is not None:
            pulumi.set(__self__, "servicemesh", servicemesh)
        if sgw is not None:
            pulumi.set(__self__, "sgw", sgw)
        if slb is not None:
            pulumi.set(__self__, "slb", slb)
        if smartag is not None:
            pulumi.set(__self__, "smartag", smartag)
        if srvcatalog is not None:
            pulumi.set(__self__, "srvcatalog", srvcatalog)
        if sts is not None:
            pulumi.set(__self__, "sts", sts)
        if swas is not None:
            pulumi.set(__self__, "swas", swas)
        if tag is not None:
            pulumi.set(__self__, "tag", tag)
        if vod is not None:
            pulumi.set(__self__, "vod", vod)
        if vpc is not None:
            pulumi.set(__self__, "vpc", vpc)
        if vpcpeer is not None:
            pulumi.set(__self__, "vpcpeer", vpcpeer)
        if vs is not None:
            pulumi.set(__self__, "vs", vs)
        if waf is not None:
            pulumi.set(__self__, "waf", waf)
        if waf_openapi is not None:
            pulumi.set(__self__, "waf_openapi", waf_openapi)

    @property
    @pulumi.getter
    def acr(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "acr")

    @acr.setter
    def acr(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "acr", value)

    @property
    @pulumi.getter
    def actiontrail(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "actiontrail")

    @actiontrail.setter
    def actiontrail(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "actiontrail", value)

    @property
    @pulumi.getter
    def adb(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "adb")

    @adb.setter
    def adb(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "adb", value)

    @property
    @pulumi.getter
    def alb(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "alb")

    @alb.setter
    def alb(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "alb", value)

    @property
    @pulumi.getter
    def alidfs(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "alidfs")

    @alidfs.setter
    def alidfs(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "alidfs", value)

    @property
    @pulumi.getter
    def alidns(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "alidns")

    @alidns.setter
    def alidns(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "alidns", value)

    @property
    @pulumi.getter
    def alikafka(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "alikafka")

    @alikafka.setter
    def alikafka(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "alikafka", value)

    @property
    @pulumi.getter
    def apigateway(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "apigateway")

    @apigateway.setter
    def apigateway(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "apigateway", value)

    @property
    @pulumi.getter
    def arms(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "arms")

    @arms.setter
    def arms(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "arms", value)

    @property
    @pulumi.getter
    def bastionhost(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "bastionhost")

    @bastionhost.setter
    def bastionhost(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "bastionhost", value)

    @property
    @pulumi.getter
    def beebot(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "beebot")

    @beebot.setter
    def beebot(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "beebot", value)

    @property
    @pulumi.getter
    def bpstudio(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "bpstudio")

    @bpstudio.setter
    def bpstudio(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "bpstudio", value)

    @property
    @pulumi.getter(name="brainIndustrial")
    def brain_industrial(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "brain_industrial")

    @brain_industrial.setter
    def brain_industrial(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "brain_industrial", value)

    @property
    @pulumi.getter
    def bssopenapi(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "bssopenapi")

    @bssopenapi.setter
    def bssopenapi(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "bssopenapi", value)

    @property
    @pulumi.getter
    def cas(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "cas")

    @cas.setter
    def cas(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cas", value)

    @property
    @pulumi.getter
    def cassandra(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "cassandra")

    @cassandra.setter
    def cassandra(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cassandra", value)

    @property
    @pulumi.getter
    def cbn(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "cbn")

    @cbn.setter
    def cbn(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cbn", value)

    @property
    @pulumi.getter
    def cbs(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "cbs")

    @cbs.setter
    def cbs(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cbs", value)

    @property
    @pulumi.getter
    def cddc(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "cddc")

    @cddc.setter
    def cddc(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cddc", value)

    @property
    @pulumi.getter
    def cdn(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "cdn")

    @cdn.setter
    def cdn(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cdn", value)

    @property
    @pulumi.getter
    def cds(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "cds")

    @cds.setter
    def cds(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cds", value)

    @property
    @pulumi.getter
    def clickhouse(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "clickhouse")

    @clickhouse.setter
    def clickhouse(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "clickhouse", value)

    @property
    @pulumi.getter
    def cloudauth(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "cloudauth")

    @cloudauth.setter
    def cloudauth(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cloudauth", value)

    @property
    @pulumi.getter
    def cloudfirewall(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "cloudfirewall")

    @cloudfirewall.setter
    def cloudfirewall(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cloudfirewall", value)

    @property
    @pulumi.getter
    def cloudfw(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "cloudfw")

    @cloudfw.setter
    def cloudfw(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cloudfw", value)

    @property
    @pulumi.getter
    def cloudphone(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "cloudphone")

    @cloudphone.setter
    def cloudphone(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cloudphone", value)

    @property
    @pulumi.getter
    def cloudsso(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "cloudsso")

    @cloudsso.setter
    def cloudsso(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cloudsso", value)

    @property
    @pulumi.getter
    def cms(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "cms")

    @cms.setter
    def cms(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cms", value)

    @property
    @pulumi.getter
    def computenest(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "computenest")

    @computenest.setter
    def computenest(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "computenest", value)

    @property
    @pulumi.getter
    def config(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "config")

    @config.setter
    def config(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "config", value)

    @property
    @pulumi.getter
    def cr(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "cr")

    @cr.setter
    def cr(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cr", value)

    @property
    @pulumi.getter
    def cs(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "cs")

    @cs.setter
    def cs(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cs", value)

    @property
    @pulumi.getter
    def das(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "das")

    @das.setter
    def das(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "das", value)

    @property
    @pulumi.getter
    def datahub(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "datahub")

    @datahub.setter
    def datahub(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "datahub", value)

    @property
    @pulumi.getter
    def dataworkspublic(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "dataworkspublic")

    @dataworkspublic.setter
    def dataworkspublic(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "dataworkspublic", value)

    @property
    @pulumi.getter
    def dbfs(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "dbfs")

    @dbfs.setter
    def dbfs(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "dbfs", value)

    @property
    @pulumi.getter
    def dcdn(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "dcdn")

    @dcdn.setter
    def dcdn(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "dcdn", value)

    @property
    @pulumi.getter
    def ddosbasic(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "ddosbasic")

    @ddosbasic.setter
    def ddosbasic(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ddosbasic", value)

    @property
    @pulumi.getter
    def ddosbgp(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "ddosbgp")

    @ddosbgp.setter
    def ddosbgp(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ddosbgp", value)

    @property
    @pulumi.getter
    def ddoscoo(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "ddoscoo")

    @ddoscoo.setter
    def ddoscoo(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ddoscoo", value)

    @property
    @pulumi.getter
    def dds(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "dds")

    @dds.setter
    def dds(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "dds", value)

    @property
    @pulumi.getter
    def devopsrdc(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "devopsrdc")

    @devopsrdc.setter
    def devopsrdc(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "devopsrdc", value)

    @property
    @pulumi.getter
    def dg(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "dg")

    @dg.setter
    def dg(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "dg", value)

    @property
    @pulumi.getter
    def dm(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "dm")

    @dm.setter
    def dm(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "dm", value)

    @property
    @pulumi.getter(name="dmsEnterprise")
    def dms_enterprise(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "dms_enterprise")

    @dms_enterprise.setter
    def dms_enterprise(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "dms_enterprise", value)

    @property
    @pulumi.getter
    def dmsenterprise(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "dmsenterprise")

    @dmsenterprise.setter
    def dmsenterprise(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "dmsenterprise", value)

    @property
    @pulumi.getter
    def dns(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "dns")

    @dns.setter
    def dns(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "dns", value)

    @property
    @pulumi.getter
    def drds(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "drds")

    @drds.setter
    def drds(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "drds", value)

    @property
    @pulumi.getter
    def dts(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "dts")

    @dts.setter
    def dts(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "dts", value)

    @property
    @pulumi.getter
    def dysms(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "dysms")

    @dysms.setter
    def dysms(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "dysms", value)

    @property
    @pulumi.getter
    def eais(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "eais")

    @eais.setter
    def eais(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "eais", value)

    @property
    @pulumi.getter
    def ebs(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "ebs")

    @ebs.setter
    def ebs(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ebs", value)

    @property
    @pulumi.getter
    def eci(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "eci")

    @eci.setter
    def eci(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "eci", value)

    @property
    @pulumi.getter
    def ecs(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "ecs")

    @ecs.setter
    def ecs(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ecs", value)

    @property
    @pulumi.getter
    def edas(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "edas")

    @edas.setter
    def edas(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "edas", value)

    @property
    @pulumi.getter
    def edasschedulerx(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "edasschedulerx")

    @edasschedulerx.setter
    def edasschedulerx(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "edasschedulerx", value)

    @property
    @pulumi.getter
    def edsuser(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "edsuser")

    @edsuser.setter
    def edsuser(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "edsuser", value)

    @property
    @pulumi.getter
    def eflo(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "eflo")

    @eflo.setter
    def eflo(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "eflo", value)

    @property
    @pulumi.getter
    def ehpc(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "ehpc")

    @ehpc.setter
    def ehpc(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ehpc", value)

    @property
    @pulumi.getter
    def ehs(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "ehs")

    @ehs.setter
    def ehs(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ehs", value)

    @property
    @pulumi.getter
    def eipanycast(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "eipanycast")

    @eipanycast.setter
    def eipanycast(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "eipanycast", value)

    @property
    @pulumi.getter
    def elasticsearch(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "elasticsearch")

    @elasticsearch.setter
    def elasticsearch(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "elasticsearch", value)

    @property
    @pulumi.getter
    def emr(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "emr")

    @emr.setter
    def emr(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "emr", value)

    @property
    @pulumi.getter
    def ens(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "ens")

    @ens.setter
    def ens(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ens", value)

    @property
    @pulumi.getter
    def ess(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "ess")

    @ess.setter
    def ess(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ess", value)

    @property
    @pulumi.getter
    def eventbridge(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "eventbridge")

    @eventbridge.setter
    def eventbridge(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "eventbridge", value)

    @property
    @pulumi.getter
    def fc(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "fc")

    @fc.setter
    def fc(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "fc", value)

    @property
    @pulumi.getter
    def fnf(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "fnf")

    @fnf.setter
    def fnf(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "fnf", value)

    @property
    @pulumi.getter
    def ga(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "ga")

    @ga.setter
    def ga(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ga", value)

    @property
    @pulumi.getter
    def gaplus(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "gaplus")

    @gaplus.setter
    def gaplus(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "gaplus", value)

    @property
    @pulumi.getter
    def gds(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "gds")

    @gds.setter
    def gds(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "gds", value)

    @property
    @pulumi.getter
    def gpdb(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "gpdb")

    @gpdb.setter
    def gpdb(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "gpdb", value)

    @property
    @pulumi.getter
    def gwsecd(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "gwsecd")

    @gwsecd.setter
    def gwsecd(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "gwsecd", value)

    @property
    @pulumi.getter
    def hbr(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "hbr")

    @hbr.setter
    def hbr(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "hbr", value)

    @property
    @pulumi.getter(name="hcsSgw")
    def hcs_sgw(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "hcs_sgw")

    @hcs_sgw.setter
    def hcs_sgw(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "hcs_sgw", value)

    @property
    @pulumi.getter
    def hitsdb(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "hitsdb")

    @hitsdb.setter
    def hitsdb(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "hitsdb", value)

    @property
    @pulumi.getter
    def imm(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "imm")

    @imm.setter
    def imm(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "imm", value)

    @property
    @pulumi.getter
    def imp(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "imp")

    @imp.setter
    def imp(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "imp", value)

    @property
    @pulumi.getter
    def ims(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "ims")

    @ims.setter
    def ims(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ims", value)

    @property
    @pulumi.getter
    def iot(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "iot")

    @iot.setter
    def iot(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "iot", value)

    @property
    @pulumi.getter
    def kms(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "kms")

    @kms.setter
    def kms(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kms", value)

    @property
    @pulumi.getter
    def kvstore(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "kvstore")

    @kvstore.setter
    def kvstore(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kvstore", value)

    @property
    @pulumi.getter
    def location(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "location")

    @location.setter
    def location(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "location", value)

    @property
    @pulumi.getter
    def log(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "log")

    @log.setter
    def log(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "log", value)

    @property
    @pulumi.getter
    def market(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "market")

    @market.setter
    def market(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "market", value)

    @property
    @pulumi.getter
    def maxcompute(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "maxcompute")

    @maxcompute.setter
    def maxcompute(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "maxcompute", value)

    @property
    @pulumi.getter
    def mhub(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "mhub")

    @mhub.setter
    def mhub(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "mhub", value)

    @property
    @pulumi.getter
    def mns(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "mns")

    @mns.setter
    def mns(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "mns", value)

    @property
    @pulumi.getter
    def mscopensubscription(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "mscopensubscription")

    @mscopensubscription.setter
    def mscopensubscription(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "mscopensubscription", value)

    @property
    @pulumi.getter
    def mse(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "mse")

    @mse.setter
    def mse(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "mse", value)

    @property
    @pulumi.getter
    def nas(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "nas")

    @nas.setter
    def nas(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "nas", value)

    @property
    @pulumi.getter
    def nlb(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "nlb")

    @nlb.setter
    def nlb(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "nlb", value)

    @property
    @pulumi.getter
    def oceanbase(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "oceanbase")

    @oceanbase.setter
    def oceanbase(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "oceanbase", value)

    @property
    @pulumi.getter
    def ons(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "ons")

    @ons.setter
    def ons(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ons", value)

    @property
    @pulumi.getter
    def onsproxy(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "onsproxy")

    @onsproxy.setter
    def onsproxy(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "onsproxy", value)

    @property
    @pulumi.getter
    def oos(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "oos")

    @oos.setter
    def oos(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "oos", value)

    @property
    @pulumi.getter
    def opensearch(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "opensearch")

    @opensearch.setter
    def opensearch(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "opensearch", value)

    @property
    @pulumi.getter
    def oss(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "oss")

    @oss.setter
    def oss(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "oss", value)

    @property
    @pulumi.getter
    def ots(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "ots")

    @ots.setter
    def ots(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ots", value)

    @property
    @pulumi.getter
    def polardb(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "polardb")

    @polardb.setter
    def polardb(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "polardb", value)

    @property
    @pulumi.getter
    def privatelink(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "privatelink")

    @privatelink.setter
    def privatelink(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "privatelink", value)

    @property
    @pulumi.getter
    def pvtz(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "pvtz")

    @pvtz.setter
    def pvtz(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "pvtz", value)

    @property
    @pulumi.getter
    def quickbi(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "quickbi")

    @quickbi.setter
    def quickbi(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "quickbi", value)

    @property
    @pulumi.getter
    def quotas(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "quotas")

    @quotas.setter
    def quotas(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "quotas", value)

    @property
    @pulumi.getter(name="rKvstore")
    def r_kvstore(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "r_kvstore")

    @r_kvstore.setter
    def r_kvstore(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "r_kvstore", value)

    @property
    @pulumi.getter
    def ram(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "ram")

    @ram.setter
    def ram(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ram", value)

    @property
    @pulumi.getter
    def rds(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "rds")

    @rds.setter
    def rds(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "rds", value)

    @property
    @pulumi.getter
    def redisa(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "redisa")

    @redisa.setter
    def redisa(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "redisa", value)

    @property
    @pulumi.getter
    def resourcemanager(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "resourcemanager")

    @resourcemanager.setter
    def resourcemanager(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "resourcemanager", value)

    @property
    @pulumi.getter
    def resourcesharing(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "resourcesharing")

    @resourcesharing.setter
    def resourcesharing(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "resourcesharing", value)

    @property
    @pulumi.getter
    def ros(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "ros")

    @ros.setter
    def ros(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ros", value)

    @property
    @pulumi.getter
    def sas(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "sas")

    @sas.setter
    def sas(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sas", value)

    @property
    @pulumi.getter
    def scdn(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "scdn")

    @scdn.setter
    def scdn(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "scdn", value)

    @property
    @pulumi.getter
    def sddp(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "sddp")

    @sddp.setter
    def sddp(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sddp", value)

    @property
    @pulumi.getter
    def serverless(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "serverless")

    @serverless.setter
    def serverless(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "serverless", value)

    @property
    @pulumi.getter
    def servicemesh(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "servicemesh")

    @servicemesh.setter
    def servicemesh(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "servicemesh", value)

    @property
    @pulumi.getter
    def sgw(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "sgw")

    @sgw.setter
    def sgw(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sgw", value)

    @property
    @pulumi.getter
    def slb(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "slb")

    @slb.setter
    def slb(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "slb", value)

    @property
    @pulumi.getter
    def smartag(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "smartag")

    @smartag.setter
    def smartag(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "smartag", value)

    @property
    @pulumi.getter
    def srvcatalog(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "srvcatalog")

    @srvcatalog.setter
    def srvcatalog(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "srvcatalog", value)

    @property
    @pulumi.getter
    def sts(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "sts")

    @sts.setter
    def sts(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sts", value)

    @property
    @pulumi.getter
    def swas(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "swas")

    @swas.setter
    def swas(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "swas", value)

    @property
    @pulumi.getter
    def tag(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "tag")

    @tag.setter
    def tag(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "tag", value)

    @property
    @pulumi.getter
    def vod(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "vod")

    @vod.setter
    def vod(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "vod", value)

    @property
    @pulumi.getter
    def vpc(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "vpc")

    @vpc.setter
    def vpc(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "vpc", value)

    @property
    @pulumi.getter
    def vpcpeer(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "vpcpeer")

    @vpcpeer.setter
    def vpcpeer(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "vpcpeer", value)

    @property
    @pulumi.getter
    def vs(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "vs")

    @vs.setter
    def vs(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "vs", value)

    @property
    @pulumi.getter
    def waf(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "waf")

    @waf.setter
    def waf(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "waf", value)

    @property
    @pulumi.getter(name="wafOpenapi")
    def waf_openapi(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "waf_openapi")

    @waf_openapi.setter
    def waf_openapi(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "waf_openapi", value)


