# 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 warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities

__all__ = [
    'AssumeRole',
    'DefaultTags',
    'Endpoints',
    'IgnoreTags',
]

@pulumi.output_type
class AssumeRole(dict):
    def __init__(__self__, *,
                 duration_seconds: Optional[int] = None,
                 external_id: Optional[str] = None,
                 policy: Optional[str] = None,
                 policy_arns: Optional[Sequence[str]] = None,
                 role_arn: Optional[str] = None,
                 session_name: Optional[str] = None,
                 tags: Optional[Mapping[str, str]] = None,
                 transitive_tag_keys: Optional[Sequence[str]] = None):
        if duration_seconds is not None:
            pulumi.set(__self__, "duration_seconds", duration_seconds)
        if external_id is not None:
            pulumi.set(__self__, "external_id", external_id)
        if policy is not None:
            pulumi.set(__self__, "policy", policy)
        if policy_arns is not None:
            pulumi.set(__self__, "policy_arns", policy_arns)
        if role_arn is not None:
            pulumi.set(__self__, "role_arn", role_arn)
        if session_name is not None:
            pulumi.set(__self__, "session_name", session_name)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if transitive_tag_keys is not None:
            pulumi.set(__self__, "transitive_tag_keys", transitive_tag_keys)

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

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

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

    @property
    @pulumi.getter(name="policyArns")
    def policy_arns(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "policy_arns")

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

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

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

    @property
    @pulumi.getter(name="transitiveTagKeys")
    def transitive_tag_keys(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "transitive_tag_keys")


@pulumi.output_type
class DefaultTags(dict):
    def __init__(__self__, *,
                 tags: Optional[Mapping[str, str]] = None):
        if tags is not None:
            pulumi.set(__self__, "tags", tags)

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


@pulumi.output_type
class Endpoints(dict):
    def __init__(__self__, *,
                 accessanalyzer: Optional[str] = None,
                 account: Optional[str] = None,
                 acm: Optional[str] = None,
                 acmpca: Optional[str] = None,
                 alexaforbusiness: Optional[str] = None,
                 amp: Optional[str] = None,
                 amplify: Optional[str] = None,
                 amplifybackend: Optional[str] = None,
                 apigateway: Optional[str] = None,
                 apigatewayv2: Optional[str] = None,
                 appautoscaling: Optional[str] = None,
                 appconfig: Optional[str] = None,
                 appflow: Optional[str] = None,
                 appintegrations: Optional[str] = None,
                 appintegrationsservice: Optional[str] = None,
                 applicationautoscaling: Optional[str] = None,
                 applicationcostprofiler: Optional[str] = None,
                 applicationdiscovery: Optional[str] = None,
                 applicationdiscoveryservice: Optional[str] = None,
                 applicationinsights: Optional[str] = None,
                 appmesh: Optional[str] = None,
                 appregistry: Optional[str] = None,
                 apprunner: Optional[str] = None,
                 appstream: Optional[str] = None,
                 appsync: Optional[str] = None,
                 athena: Optional[str] = None,
                 auditmanager: Optional[str] = None,
                 augmentedairuntime: Optional[str] = None,
                 autoscaling: Optional[str] = None,
                 autoscalingplans: Optional[str] = None,
                 backup: Optional[str] = None,
                 batch: Optional[str] = None,
                 braket: Optional[str] = None,
                 budgets: Optional[str] = None,
                 chime: Optional[str] = None,
                 cloud9: Optional[str] = None,
                 cloudcontrol: Optional[str] = None,
                 cloudcontrolapi: Optional[str] = None,
                 clouddirectory: Optional[str] = None,
                 cloudformation: Optional[str] = None,
                 cloudfront: Optional[str] = None,
                 cloudhsm: Optional[str] = None,
                 cloudhsmv2: Optional[str] = None,
                 cloudsearch: Optional[str] = None,
                 cloudsearchdomain: Optional[str] = None,
                 cloudtrail: Optional[str] = None,
                 cloudwatch: Optional[str] = None,
                 cloudwatchevents: Optional[str] = None,
                 cloudwatchlogs: Optional[str] = None,
                 codeartifact: Optional[str] = None,
                 codebuild: Optional[str] = None,
                 codecommit: Optional[str] = None,
                 codedeploy: Optional[str] = None,
                 codeguruprofiler: Optional[str] = None,
                 codegurureviewer: Optional[str] = None,
                 codepipeline: Optional[str] = None,
                 codestar: Optional[str] = None,
                 codestarconnections: Optional[str] = None,
                 codestarnotifications: Optional[str] = None,
                 cognitoidentity: Optional[str] = None,
                 cognitoidentityprovider: Optional[str] = None,
                 cognitoidp: Optional[str] = None,
                 cognitosync: Optional[str] = None,
                 comprehend: Optional[str] = None,
                 comprehendmedical: Optional[str] = None,
                 config: Optional[str] = None,
                 configservice: Optional[str] = None,
                 connect: Optional[str] = None,
                 connectcontactlens: Optional[str] = None,
                 connectparticipant: Optional[str] = None,
                 costandusagereportservice: Optional[str] = None,
                 costexplorer: Optional[str] = None,
                 cur: Optional[str] = None,
                 databasemigration: Optional[str] = None,
                 databasemigrationservice: Optional[str] = None,
                 dataexchange: Optional[str] = None,
                 datapipeline: Optional[str] = None,
                 datasync: Optional[str] = None,
                 dax: Optional[str] = None,
                 detective: Optional[str] = None,
                 devicefarm: Optional[str] = None,
                 devopsguru: Optional[str] = None,
                 directconnect: Optional[str] = None,
                 dlm: Optional[str] = None,
                 dms: Optional[str] = None,
                 docdb: Optional[str] = None,
                 ds: Optional[str] = None,
                 dynamodb: Optional[str] = None,
                 dynamodbstreams: Optional[str] = None,
                 ec2: Optional[str] = None,
                 ec2instanceconnect: Optional[str] = None,
                 ecr: Optional[str] = None,
                 ecrpublic: Optional[str] = None,
                 ecs: Optional[str] = None,
                 efs: Optional[str] = None,
                 eks: Optional[str] = None,
                 elasticache: Optional[str] = None,
                 elasticbeanstalk: Optional[str] = None,
                 elasticinference: Optional[str] = None,
                 elasticsearch: Optional[str] = None,
                 elasticsearchservice: Optional[str] = None,
                 elastictranscoder: Optional[str] = None,
                 elb: Optional[str] = None,
                 elbv2: Optional[str] = None,
                 emr: Optional[str] = None,
                 emrcontainers: Optional[str] = None,
                 es: Optional[str] = None,
                 eventbridge: Optional[str] = None,
                 events: Optional[str] = None,
                 finspace: Optional[str] = None,
                 finspacedata: Optional[str] = None,
                 firehose: Optional[str] = None,
                 fis: Optional[str] = None,
                 fms: Optional[str] = None,
                 forecast: Optional[str] = None,
                 forecastquery: Optional[str] = None,
                 forecastqueryservice: Optional[str] = None,
                 forecastservice: Optional[str] = None,
                 frauddetector: Optional[str] = None,
                 fsx: Optional[str] = None,
                 gamelift: Optional[str] = None,
                 glacier: Optional[str] = None,
                 globalaccelerator: Optional[str] = None,
                 glue: Optional[str] = None,
                 gluedatabrew: Optional[str] = None,
                 greengrass: Optional[str] = None,
                 greengrassv2: Optional[str] = None,
                 groundstation: Optional[str] = None,
                 guardduty: Optional[str] = None,
                 health: Optional[str] = None,
                 healthlake: Optional[str] = None,
                 honeycode: Optional[str] = None,
                 iam: Optional[str] = None,
                 identitystore: Optional[str] = None,
                 imagebuilder: Optional[str] = None,
                 inspector: Optional[str] = None,
                 iot: Optional[str] = None,
                 iot1clickdevices: Optional[str] = None,
                 iot1clickdevicesservice: Optional[str] = None,
                 iot1clickprojects: Optional[str] = None,
                 iotanalytics: Optional[str] = None,
                 iotdataplane: Optional[str] = None,
                 iotdeviceadvisor: Optional[str] = None,
                 iotevents: Optional[str] = None,
                 ioteventsdata: Optional[str] = None,
                 iotfleethub: Optional[str] = None,
                 iotjobsdataplane: Optional[str] = None,
                 iotsecuretunneling: Optional[str] = None,
                 iotsitewise: Optional[str] = None,
                 iotthingsgraph: Optional[str] = None,
                 iotwireless: Optional[str] = None,
                 kafka: Optional[str] = None,
                 kendra: Optional[str] = None,
                 kinesis: Optional[str] = None,
                 kinesisanalytics: Optional[str] = None,
                 kinesisanalyticsv2: Optional[str] = None,
                 kinesisvideo: Optional[str] = None,
                 kinesisvideoarchivedmedia: Optional[str] = None,
                 kinesisvideomedia: Optional[str] = None,
                 kinesisvideosignalingchannels: Optional[str] = None,
                 kms: Optional[str] = None,
                 lakeformation: Optional[str] = None,
                 lambda_: Optional[str] = None,
                 lexmodelbuilding: Optional[str] = None,
                 lexmodelbuildingservice: Optional[str] = None,
                 lexmodels: Optional[str] = None,
                 lexmodelsv2: Optional[str] = None,
                 lexruntime: Optional[str] = None,
                 lexruntimeservice: Optional[str] = None,
                 lexruntimev2: Optional[str] = None,
                 licensemanager: Optional[str] = None,
                 lightsail: Optional[str] = None,
                 location: Optional[str] = None,
                 lookoutequipment: Optional[str] = None,
                 lookoutforvision: Optional[str] = None,
                 lookoutmetrics: Optional[str] = None,
                 machinelearning: Optional[str] = None,
                 macie: Optional[str] = None,
                 macie2: Optional[str] = None,
                 managedblockchain: Optional[str] = None,
                 marketplacecatalog: Optional[str] = None,
                 marketplacecommerceanalytics: Optional[str] = None,
                 marketplaceentitlement: Optional[str] = None,
                 marketplaceentitlementservice: Optional[str] = None,
                 marketplacemetering: Optional[str] = None,
                 mediaconnect: Optional[str] = None,
                 mediaconvert: Optional[str] = None,
                 medialive: Optional[str] = None,
                 mediapackage: Optional[str] = None,
                 mediapackagevod: Optional[str] = None,
                 mediastore: Optional[str] = None,
                 mediastoredata: Optional[str] = None,
                 mediatailor: Optional[str] = None,
                 memorydb: Optional[str] = None,
                 mgn: Optional[str] = None,
                 migrationhub: Optional[str] = None,
                 migrationhubconfig: Optional[str] = None,
                 mobile: Optional[str] = None,
                 mobileanalytics: Optional[str] = None,
                 mq: Optional[str] = None,
                 mturk: Optional[str] = None,
                 mwaa: Optional[str] = None,
                 neptune: Optional[str] = None,
                 networkfirewall: Optional[str] = None,
                 networkmanager: Optional[str] = None,
                 nimblestudio: Optional[str] = None,
                 opsworks: Optional[str] = None,
                 opsworkscm: Optional[str] = None,
                 organizations: Optional[str] = None,
                 outposts: Optional[str] = None,
                 personalize: Optional[str] = None,
                 personalizeevents: Optional[str] = None,
                 personalizeruntime: Optional[str] = None,
                 pi: Optional[str] = None,
                 pinpoint: Optional[str] = None,
                 pinpointemail: Optional[str] = None,
                 pinpointsmsvoice: Optional[str] = None,
                 polly: Optional[str] = None,
                 pricing: Optional[str] = None,
                 prometheus: Optional[str] = None,
                 prometheusservice: Optional[str] = None,
                 proton: Optional[str] = None,
                 qldb: Optional[str] = None,
                 qldbsession: Optional[str] = None,
                 quicksight: Optional[str] = None,
                 ram: Optional[str] = None,
                 rds: Optional[str] = None,
                 rdsdata: Optional[str] = None,
                 rdsdataservice: Optional[str] = None,
                 redshift: Optional[str] = None,
                 redshiftdata: Optional[str] = None,
                 rekognition: Optional[str] = None,
                 resourcegroups: Optional[str] = None,
                 resourcegroupstagging: Optional[str] = None,
                 resourcegroupstaggingapi: Optional[str] = None,
                 robomaker: Optional[str] = None,
                 route53: Optional[str] = None,
                 route53domains: Optional[str] = None,
                 route53recoverycontrolconfig: Optional[str] = None,
                 route53recoveryreadiness: Optional[str] = None,
                 route53resolver: Optional[str] = None,
                 s3: Optional[str] = None,
                 s3control: Optional[str] = None,
                 s3outposts: Optional[str] = None,
                 sagemaker: Optional[str] = None,
                 sagemakeredgemanager: Optional[str] = None,
                 sagemakerfeaturestoreruntime: Optional[str] = None,
                 sagemakerruntime: Optional[str] = None,
                 savingsplans: Optional[str] = None,
                 schemas: Optional[str] = None,
                 sdb: Optional[str] = None,
                 secretsmanager: Optional[str] = None,
                 securityhub: Optional[str] = None,
                 serverlessapplicationrepository: Optional[str] = None,
                 serverlessapprepo: Optional[str] = None,
                 serverlessrepo: Optional[str] = None,
                 servicecatalog: Optional[str] = None,
                 servicediscovery: Optional[str] = None,
                 servicequotas: Optional[str] = None,
                 ses: Optional[str] = None,
                 sesv2: Optional[str] = None,
                 sfn: Optional[str] = None,
                 shield: Optional[str] = None,
                 signer: Optional[str] = None,
                 simpledb: Optional[str] = None,
                 sms: Optional[str] = None,
                 snowball: Optional[str] = None,
                 sns: Optional[str] = None,
                 sqs: Optional[str] = None,
                 ssm: Optional[str] = None,
                 ssmcontacts: Optional[str] = None,
                 ssmincidents: Optional[str] = None,
                 sso: Optional[str] = None,
                 ssoadmin: Optional[str] = None,
                 ssooidc: Optional[str] = None,
                 stepfunctions: Optional[str] = None,
                 storagegateway: Optional[str] = None,
                 sts: Optional[str] = None,
                 support: Optional[str] = None,
                 swf: Optional[str] = None,
                 synthetics: Optional[str] = None,
                 textract: Optional[str] = None,
                 timestreamquery: Optional[str] = None,
                 timestreamwrite: Optional[str] = None,
                 transcribe: Optional[str] = None,
                 transcribeservice: Optional[str] = None,
                 transcribestreaming: Optional[str] = None,
                 transcribestreamingservice: Optional[str] = None,
                 transfer: Optional[str] = None,
                 translate: Optional[str] = None,
                 waf: Optional[str] = None,
                 wafregional: Optional[str] = None,
                 wafv2: Optional[str] = None,
                 wellarchitected: Optional[str] = None,
                 workdocs: Optional[str] = None,
                 worklink: Optional[str] = None,
                 workmail: Optional[str] = None,
                 workmailmessageflow: Optional[str] = None,
                 workspaces: Optional[str] = None,
                 xray: Optional[str] = None):
        if accessanalyzer is not None:
            pulumi.set(__self__, "accessanalyzer", accessanalyzer)
        if account is not None:
            pulumi.set(__self__, "account", account)
        if acm is not None:
            pulumi.set(__self__, "acm", acm)
        if acmpca is not None:
            pulumi.set(__self__, "acmpca", acmpca)
        if alexaforbusiness is not None:
            pulumi.set(__self__, "alexaforbusiness", alexaforbusiness)
        if amp is not None:
            pulumi.set(__self__, "amp", amp)
        if amplify is not None:
            pulumi.set(__self__, "amplify", amplify)
        if amplifybackend is not None:
            pulumi.set(__self__, "amplifybackend", amplifybackend)
        if apigateway is not None:
            pulumi.set(__self__, "apigateway", apigateway)
        if apigatewayv2 is not None:
            pulumi.set(__self__, "apigatewayv2", apigatewayv2)
        if appautoscaling is not None:
            pulumi.set(__self__, "appautoscaling", appautoscaling)
        if appconfig is not None:
            pulumi.set(__self__, "appconfig", appconfig)
        if appflow is not None:
            pulumi.set(__self__, "appflow", appflow)
        if appintegrations is not None:
            pulumi.set(__self__, "appintegrations", appintegrations)
        if appintegrationsservice is not None:
            pulumi.set(__self__, "appintegrationsservice", appintegrationsservice)
        if applicationautoscaling is not None:
            pulumi.set(__self__, "applicationautoscaling", applicationautoscaling)
        if applicationcostprofiler is not None:
            pulumi.set(__self__, "applicationcostprofiler", applicationcostprofiler)
        if applicationdiscovery is not None:
            pulumi.set(__self__, "applicationdiscovery", applicationdiscovery)
        if applicationdiscoveryservice is not None:
            pulumi.set(__self__, "applicationdiscoveryservice", applicationdiscoveryservice)
        if applicationinsights is not None:
            pulumi.set(__self__, "applicationinsights", applicationinsights)
        if appmesh is not None:
            pulumi.set(__self__, "appmesh", appmesh)
        if appregistry is not None:
            pulumi.set(__self__, "appregistry", appregistry)
        if apprunner is not None:
            pulumi.set(__self__, "apprunner", apprunner)
        if appstream is not None:
            pulumi.set(__self__, "appstream", appstream)
        if appsync is not None:
            pulumi.set(__self__, "appsync", appsync)
        if athena is not None:
            pulumi.set(__self__, "athena", athena)
        if auditmanager is not None:
            pulumi.set(__self__, "auditmanager", auditmanager)
        if augmentedairuntime is not None:
            pulumi.set(__self__, "augmentedairuntime", augmentedairuntime)
        if autoscaling is not None:
            pulumi.set(__self__, "autoscaling", autoscaling)
        if autoscalingplans is not None:
            pulumi.set(__self__, "autoscalingplans", autoscalingplans)
        if backup is not None:
            pulumi.set(__self__, "backup", backup)
        if batch is not None:
            pulumi.set(__self__, "batch", batch)
        if braket is not None:
            pulumi.set(__self__, "braket", braket)
        if budgets is not None:
            pulumi.set(__self__, "budgets", budgets)
        if chime is not None:
            pulumi.set(__self__, "chime", chime)
        if cloud9 is not None:
            pulumi.set(__self__, "cloud9", cloud9)
        if cloudcontrol is not None:
            pulumi.set(__self__, "cloudcontrol", cloudcontrol)
        if cloudcontrolapi is not None:
            pulumi.set(__self__, "cloudcontrolapi", cloudcontrolapi)
        if clouddirectory is not None:
            pulumi.set(__self__, "clouddirectory", clouddirectory)
        if cloudformation is not None:
            pulumi.set(__self__, "cloudformation", cloudformation)
        if cloudfront is not None:
            pulumi.set(__self__, "cloudfront", cloudfront)
        if cloudhsm is not None:
            pulumi.set(__self__, "cloudhsm", cloudhsm)
        if cloudhsmv2 is not None:
            pulumi.set(__self__, "cloudhsmv2", cloudhsmv2)
        if cloudsearch is not None:
            pulumi.set(__self__, "cloudsearch", cloudsearch)
        if cloudsearchdomain is not None:
            pulumi.set(__self__, "cloudsearchdomain", cloudsearchdomain)
        if cloudtrail is not None:
            pulumi.set(__self__, "cloudtrail", cloudtrail)
        if cloudwatch is not None:
            pulumi.set(__self__, "cloudwatch", cloudwatch)
        if cloudwatchevents is not None:
            pulumi.set(__self__, "cloudwatchevents", cloudwatchevents)
        if cloudwatchlogs is not None:
            pulumi.set(__self__, "cloudwatchlogs", cloudwatchlogs)
        if codeartifact is not None:
            pulumi.set(__self__, "codeartifact", codeartifact)
        if codebuild is not None:
            pulumi.set(__self__, "codebuild", codebuild)
        if codecommit is not None:
            pulumi.set(__self__, "codecommit", codecommit)
        if codedeploy is not None:
            pulumi.set(__self__, "codedeploy", codedeploy)
        if codeguruprofiler is not None:
            pulumi.set(__self__, "codeguruprofiler", codeguruprofiler)
        if codegurureviewer is not None:
            pulumi.set(__self__, "codegurureviewer", codegurureviewer)
        if codepipeline is not None:
            pulumi.set(__self__, "codepipeline", codepipeline)
        if codestar is not None:
            pulumi.set(__self__, "codestar", codestar)
        if codestarconnections is not None:
            pulumi.set(__self__, "codestarconnections", codestarconnections)
        if codestarnotifications is not None:
            pulumi.set(__self__, "codestarnotifications", codestarnotifications)
        if cognitoidentity is not None:
            pulumi.set(__self__, "cognitoidentity", cognitoidentity)
        if cognitoidentityprovider is not None:
            pulumi.set(__self__, "cognitoidentityprovider", cognitoidentityprovider)
        if cognitoidp is not None:
            pulumi.set(__self__, "cognitoidp", cognitoidp)
        if cognitosync is not None:
            pulumi.set(__self__, "cognitosync", cognitosync)
        if comprehend is not None:
            pulumi.set(__self__, "comprehend", comprehend)
        if comprehendmedical is not None:
            pulumi.set(__self__, "comprehendmedical", comprehendmedical)
        if config is not None:
            pulumi.set(__self__, "config", config)
        if configservice is not None:
            pulumi.set(__self__, "configservice", configservice)
        if connect is not None:
            pulumi.set(__self__, "connect", connect)
        if connectcontactlens is not None:
            pulumi.set(__self__, "connectcontactlens", connectcontactlens)
        if connectparticipant is not None:
            pulumi.set(__self__, "connectparticipant", connectparticipant)
        if costandusagereportservice is not None:
            pulumi.set(__self__, "costandusagereportservice", costandusagereportservice)
        if costexplorer is not None:
            pulumi.set(__self__, "costexplorer", costexplorer)
        if cur is not None:
            pulumi.set(__self__, "cur", cur)
        if databasemigration is not None:
            pulumi.set(__self__, "databasemigration", databasemigration)
        if databasemigrationservice is not None:
            pulumi.set(__self__, "databasemigrationservice", databasemigrationservice)
        if dataexchange is not None:
            pulumi.set(__self__, "dataexchange", dataexchange)
        if datapipeline is not None:
            pulumi.set(__self__, "datapipeline", datapipeline)
        if datasync is not None:
            pulumi.set(__self__, "datasync", datasync)
        if dax is not None:
            pulumi.set(__self__, "dax", dax)
        if detective is not None:
            pulumi.set(__self__, "detective", detective)
        if devicefarm is not None:
            pulumi.set(__self__, "devicefarm", devicefarm)
        if devopsguru is not None:
            pulumi.set(__self__, "devopsguru", devopsguru)
        if directconnect is not None:
            pulumi.set(__self__, "directconnect", directconnect)
        if dlm is not None:
            pulumi.set(__self__, "dlm", dlm)
        if dms is not None:
            pulumi.set(__self__, "dms", dms)
        if docdb is not None:
            pulumi.set(__self__, "docdb", docdb)
        if ds is not None:
            pulumi.set(__self__, "ds", ds)
        if dynamodb is not None:
            pulumi.set(__self__, "dynamodb", dynamodb)
        if dynamodbstreams is not None:
            pulumi.set(__self__, "dynamodbstreams", dynamodbstreams)
        if ec2 is not None:
            pulumi.set(__self__, "ec2", ec2)
        if ec2instanceconnect is not None:
            pulumi.set(__self__, "ec2instanceconnect", ec2instanceconnect)
        if ecr is not None:
            pulumi.set(__self__, "ecr", ecr)
        if ecrpublic is not None:
            pulumi.set(__self__, "ecrpublic", ecrpublic)
        if ecs is not None:
            pulumi.set(__self__, "ecs", ecs)
        if efs is not None:
            pulumi.set(__self__, "efs", efs)
        if eks is not None:
            pulumi.set(__self__, "eks", eks)
        if elasticache is not None:
            pulumi.set(__self__, "elasticache", elasticache)
        if elasticbeanstalk is not None:
            pulumi.set(__self__, "elasticbeanstalk", elasticbeanstalk)
        if elasticinference is not None:
            pulumi.set(__self__, "elasticinference", elasticinference)
        if elasticsearch is not None:
            pulumi.set(__self__, "elasticsearch", elasticsearch)
        if elasticsearchservice is not None:
            pulumi.set(__self__, "elasticsearchservice", elasticsearchservice)
        if elastictranscoder is not None:
            pulumi.set(__self__, "elastictranscoder", elastictranscoder)
        if elb is not None:
            pulumi.set(__self__, "elb", elb)
        if elbv2 is not None:
            pulumi.set(__self__, "elbv2", elbv2)
        if emr is not None:
            pulumi.set(__self__, "emr", emr)
        if emrcontainers is not None:
            pulumi.set(__self__, "emrcontainers", emrcontainers)
        if es is not None:
            pulumi.set(__self__, "es", es)
        if eventbridge is not None:
            pulumi.set(__self__, "eventbridge", eventbridge)
        if events is not None:
            pulumi.set(__self__, "events", events)
        if finspace is not None:
            pulumi.set(__self__, "finspace", finspace)
        if finspacedata is not None:
            pulumi.set(__self__, "finspacedata", finspacedata)
        if firehose is not None:
            pulumi.set(__self__, "firehose", firehose)
        if fis is not None:
            pulumi.set(__self__, "fis", fis)
        if fms is not None:
            pulumi.set(__self__, "fms", fms)
        if forecast is not None:
            pulumi.set(__self__, "forecast", forecast)
        if forecastquery is not None:
            pulumi.set(__self__, "forecastquery", forecastquery)
        if forecastqueryservice is not None:
            pulumi.set(__self__, "forecastqueryservice", forecastqueryservice)
        if forecastservice is not None:
            pulumi.set(__self__, "forecastservice", forecastservice)
        if frauddetector is not None:
            pulumi.set(__self__, "frauddetector", frauddetector)
        if fsx is not None:
            pulumi.set(__self__, "fsx", fsx)
        if gamelift is not None:
            pulumi.set(__self__, "gamelift", gamelift)
        if glacier is not None:
            pulumi.set(__self__, "glacier", glacier)
        if globalaccelerator is not None:
            pulumi.set(__self__, "globalaccelerator", globalaccelerator)
        if glue is not None:
            pulumi.set(__self__, "glue", glue)
        if gluedatabrew is not None:
            pulumi.set(__self__, "gluedatabrew", gluedatabrew)
        if greengrass is not None:
            pulumi.set(__self__, "greengrass", greengrass)
        if greengrassv2 is not None:
            pulumi.set(__self__, "greengrassv2", greengrassv2)
        if groundstation is not None:
            pulumi.set(__self__, "groundstation", groundstation)
        if guardduty is not None:
            pulumi.set(__self__, "guardduty", guardduty)
        if health is not None:
            pulumi.set(__self__, "health", health)
        if healthlake is not None:
            pulumi.set(__self__, "healthlake", healthlake)
        if honeycode is not None:
            pulumi.set(__self__, "honeycode", honeycode)
        if iam is not None:
            pulumi.set(__self__, "iam", iam)
        if identitystore is not None:
            pulumi.set(__self__, "identitystore", identitystore)
        if imagebuilder is not None:
            pulumi.set(__self__, "imagebuilder", imagebuilder)
        if inspector is not None:
            pulumi.set(__self__, "inspector", inspector)
        if iot is not None:
            pulumi.set(__self__, "iot", iot)
        if iot1clickdevices is not None:
            pulumi.set(__self__, "iot1clickdevices", iot1clickdevices)
        if iot1clickdevicesservice is not None:
            pulumi.set(__self__, "iot1clickdevicesservice", iot1clickdevicesservice)
        if iot1clickprojects is not None:
            pulumi.set(__self__, "iot1clickprojects", iot1clickprojects)
        if iotanalytics is not None:
            pulumi.set(__self__, "iotanalytics", iotanalytics)
        if iotdataplane is not None:
            pulumi.set(__self__, "iotdataplane", iotdataplane)
        if iotdeviceadvisor is not None:
            pulumi.set(__self__, "iotdeviceadvisor", iotdeviceadvisor)
        if iotevents is not None:
            pulumi.set(__self__, "iotevents", iotevents)
        if ioteventsdata is not None:
            pulumi.set(__self__, "ioteventsdata", ioteventsdata)
        if iotfleethub is not None:
            pulumi.set(__self__, "iotfleethub", iotfleethub)
        if iotjobsdataplane is not None:
            pulumi.set(__self__, "iotjobsdataplane", iotjobsdataplane)
        if iotsecuretunneling is not None:
            pulumi.set(__self__, "iotsecuretunneling", iotsecuretunneling)
        if iotsitewise is not None:
            pulumi.set(__self__, "iotsitewise", iotsitewise)
        if iotthingsgraph is not None:
            pulumi.set(__self__, "iotthingsgraph", iotthingsgraph)
        if iotwireless is not None:
            pulumi.set(__self__, "iotwireless", iotwireless)
        if kafka is not None:
            pulumi.set(__self__, "kafka", kafka)
        if kendra is not None:
            pulumi.set(__self__, "kendra", kendra)
        if kinesis is not None:
            pulumi.set(__self__, "kinesis", kinesis)
        if kinesisanalytics is not None:
            pulumi.set(__self__, "kinesisanalytics", kinesisanalytics)
        if kinesisanalyticsv2 is not None:
            pulumi.set(__self__, "kinesisanalyticsv2", kinesisanalyticsv2)
        if kinesisvideo is not None:
            pulumi.set(__self__, "kinesisvideo", kinesisvideo)
        if kinesisvideoarchivedmedia is not None:
            pulumi.set(__self__, "kinesisvideoarchivedmedia", kinesisvideoarchivedmedia)
        if kinesisvideomedia is not None:
            pulumi.set(__self__, "kinesisvideomedia", kinesisvideomedia)
        if kinesisvideosignalingchannels is not None:
            pulumi.set(__self__, "kinesisvideosignalingchannels", kinesisvideosignalingchannels)
        if kms is not None:
            pulumi.set(__self__, "kms", kms)
        if lakeformation is not None:
            pulumi.set(__self__, "lakeformation", lakeformation)
        if lambda_ is not None:
            pulumi.set(__self__, "lambda_", lambda_)
        if lexmodelbuilding is not None:
            pulumi.set(__self__, "lexmodelbuilding", lexmodelbuilding)
        if lexmodelbuildingservice is not None:
            pulumi.set(__self__, "lexmodelbuildingservice", lexmodelbuildingservice)
        if lexmodels is not None:
            pulumi.set(__self__, "lexmodels", lexmodels)
        if lexmodelsv2 is not None:
            pulumi.set(__self__, "lexmodelsv2", lexmodelsv2)
        if lexruntime is not None:
            pulumi.set(__self__, "lexruntime", lexruntime)
        if lexruntimeservice is not None:
            pulumi.set(__self__, "lexruntimeservice", lexruntimeservice)
        if lexruntimev2 is not None:
            pulumi.set(__self__, "lexruntimev2", lexruntimev2)
        if licensemanager is not None:
            pulumi.set(__self__, "licensemanager", licensemanager)
        if lightsail is not None:
            pulumi.set(__self__, "lightsail", lightsail)
        if location is not None:
            pulumi.set(__self__, "location", location)
        if lookoutequipment is not None:
            pulumi.set(__self__, "lookoutequipment", lookoutequipment)
        if lookoutforvision is not None:
            pulumi.set(__self__, "lookoutforvision", lookoutforvision)
        if lookoutmetrics is not None:
            pulumi.set(__self__, "lookoutmetrics", lookoutmetrics)
        if machinelearning is not None:
            pulumi.set(__self__, "machinelearning", machinelearning)
        if macie is not None:
            pulumi.set(__self__, "macie", macie)
        if macie2 is not None:
            pulumi.set(__self__, "macie2", macie2)
        if managedblockchain is not None:
            pulumi.set(__self__, "managedblockchain", managedblockchain)
        if marketplacecatalog is not None:
            pulumi.set(__self__, "marketplacecatalog", marketplacecatalog)
        if marketplacecommerceanalytics is not None:
            pulumi.set(__self__, "marketplacecommerceanalytics", marketplacecommerceanalytics)
        if marketplaceentitlement is not None:
            pulumi.set(__self__, "marketplaceentitlement", marketplaceentitlement)
        if marketplaceentitlementservice is not None:
            pulumi.set(__self__, "marketplaceentitlementservice", marketplaceentitlementservice)
        if marketplacemetering is not None:
            pulumi.set(__self__, "marketplacemetering", marketplacemetering)
        if mediaconnect is not None:
            pulumi.set(__self__, "mediaconnect", mediaconnect)
        if mediaconvert is not None:
            pulumi.set(__self__, "mediaconvert", mediaconvert)
        if medialive is not None:
            pulumi.set(__self__, "medialive", medialive)
        if mediapackage is not None:
            pulumi.set(__self__, "mediapackage", mediapackage)
        if mediapackagevod is not None:
            pulumi.set(__self__, "mediapackagevod", mediapackagevod)
        if mediastore is not None:
            pulumi.set(__self__, "mediastore", mediastore)
        if mediastoredata is not None:
            pulumi.set(__self__, "mediastoredata", mediastoredata)
        if mediatailor is not None:
            pulumi.set(__self__, "mediatailor", mediatailor)
        if memorydb is not None:
            pulumi.set(__self__, "memorydb", memorydb)
        if mgn is not None:
            pulumi.set(__self__, "mgn", mgn)
        if migrationhub is not None:
            pulumi.set(__self__, "migrationhub", migrationhub)
        if migrationhubconfig is not None:
            pulumi.set(__self__, "migrationhubconfig", migrationhubconfig)
        if mobile is not None:
            pulumi.set(__self__, "mobile", mobile)
        if mobileanalytics is not None:
            pulumi.set(__self__, "mobileanalytics", mobileanalytics)
        if mq is not None:
            pulumi.set(__self__, "mq", mq)
        if mturk is not None:
            pulumi.set(__self__, "mturk", mturk)
        if mwaa is not None:
            pulumi.set(__self__, "mwaa", mwaa)
        if neptune is not None:
            pulumi.set(__self__, "neptune", neptune)
        if networkfirewall is not None:
            pulumi.set(__self__, "networkfirewall", networkfirewall)
        if networkmanager is not None:
            pulumi.set(__self__, "networkmanager", networkmanager)
        if nimblestudio is not None:
            pulumi.set(__self__, "nimblestudio", nimblestudio)
        if opsworks is not None:
            pulumi.set(__self__, "opsworks", opsworks)
        if opsworkscm is not None:
            pulumi.set(__self__, "opsworkscm", opsworkscm)
        if organizations is not None:
            pulumi.set(__self__, "organizations", organizations)
        if outposts is not None:
            pulumi.set(__self__, "outposts", outposts)
        if personalize is not None:
            pulumi.set(__self__, "personalize", personalize)
        if personalizeevents is not None:
            pulumi.set(__self__, "personalizeevents", personalizeevents)
        if personalizeruntime is not None:
            pulumi.set(__self__, "personalizeruntime", personalizeruntime)
        if pi is not None:
            pulumi.set(__self__, "pi", pi)
        if pinpoint is not None:
            pulumi.set(__self__, "pinpoint", pinpoint)
        if pinpointemail is not None:
            pulumi.set(__self__, "pinpointemail", pinpointemail)
        if pinpointsmsvoice is not None:
            pulumi.set(__self__, "pinpointsmsvoice", pinpointsmsvoice)
        if polly is not None:
            pulumi.set(__self__, "polly", polly)
        if pricing is not None:
            pulumi.set(__self__, "pricing", pricing)
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)
        if prometheusservice is not None:
            pulumi.set(__self__, "prometheusservice", prometheusservice)
        if proton is not None:
            pulumi.set(__self__, "proton", proton)
        if qldb is not None:
            pulumi.set(__self__, "qldb", qldb)
        if qldbsession is not None:
            pulumi.set(__self__, "qldbsession", qldbsession)
        if quicksight is not None:
            pulumi.set(__self__, "quicksight", quicksight)
        if ram is not None:
            pulumi.set(__self__, "ram", ram)
        if rds is not None:
            pulumi.set(__self__, "rds", rds)
        if rdsdata is not None:
            pulumi.set(__self__, "rdsdata", rdsdata)
        if rdsdataservice is not None:
            pulumi.set(__self__, "rdsdataservice", rdsdataservice)
        if redshift is not None:
            pulumi.set(__self__, "redshift", redshift)
        if redshiftdata is not None:
            pulumi.set(__self__, "redshiftdata", redshiftdata)
        if rekognition is not None:
            pulumi.set(__self__, "rekognition", rekognition)
        if resourcegroups is not None:
            pulumi.set(__self__, "resourcegroups", resourcegroups)
        if resourcegroupstagging is not None:
            pulumi.set(__self__, "resourcegroupstagging", resourcegroupstagging)
        if resourcegroupstaggingapi is not None:
            pulumi.set(__self__, "resourcegroupstaggingapi", resourcegroupstaggingapi)
        if robomaker is not None:
            pulumi.set(__self__, "robomaker", robomaker)
        if route53 is not None:
            pulumi.set(__self__, "route53", route53)
        if route53domains is not None:
            pulumi.set(__self__, "route53domains", route53domains)
        if route53recoverycontrolconfig is not None:
            pulumi.set(__self__, "route53recoverycontrolconfig", route53recoverycontrolconfig)
        if route53recoveryreadiness is not None:
            pulumi.set(__self__, "route53recoveryreadiness", route53recoveryreadiness)
        if route53resolver is not None:
            pulumi.set(__self__, "route53resolver", route53resolver)
        if s3 is not None:
            pulumi.set(__self__, "s3", s3)
        if s3control is not None:
            pulumi.set(__self__, "s3control", s3control)
        if s3outposts is not None:
            pulumi.set(__self__, "s3outposts", s3outposts)
        if sagemaker is not None:
            pulumi.set(__self__, "sagemaker", sagemaker)
        if sagemakeredgemanager is not None:
            pulumi.set(__self__, "sagemakeredgemanager", sagemakeredgemanager)
        if sagemakerfeaturestoreruntime is not None:
            pulumi.set(__self__, "sagemakerfeaturestoreruntime", sagemakerfeaturestoreruntime)
        if sagemakerruntime is not None:
            pulumi.set(__self__, "sagemakerruntime", sagemakerruntime)
        if savingsplans is not None:
            pulumi.set(__self__, "savingsplans", savingsplans)
        if schemas is not None:
            pulumi.set(__self__, "schemas", schemas)
        if sdb is not None:
            pulumi.set(__self__, "sdb", sdb)
        if secretsmanager is not None:
            pulumi.set(__self__, "secretsmanager", secretsmanager)
        if securityhub is not None:
            pulumi.set(__self__, "securityhub", securityhub)
        if serverlessapplicationrepository is not None:
            pulumi.set(__self__, "serverlessapplicationrepository", serverlessapplicationrepository)
        if serverlessapprepo is not None:
            pulumi.set(__self__, "serverlessapprepo", serverlessapprepo)
        if serverlessrepo is not None:
            pulumi.set(__self__, "serverlessrepo", serverlessrepo)
        if servicecatalog is not None:
            pulumi.set(__self__, "servicecatalog", servicecatalog)
        if servicediscovery is not None:
            pulumi.set(__self__, "servicediscovery", servicediscovery)
        if servicequotas is not None:
            pulumi.set(__self__, "servicequotas", servicequotas)
        if ses is not None:
            pulumi.set(__self__, "ses", ses)
        if sesv2 is not None:
            pulumi.set(__self__, "sesv2", sesv2)
        if sfn is not None:
            pulumi.set(__self__, "sfn", sfn)
        if shield is not None:
            pulumi.set(__self__, "shield", shield)
        if signer is not None:
            pulumi.set(__self__, "signer", signer)
        if simpledb is not None:
            pulumi.set(__self__, "simpledb", simpledb)
        if sms is not None:
            pulumi.set(__self__, "sms", sms)
        if snowball is not None:
            pulumi.set(__self__, "snowball", snowball)
        if sns is not None:
            pulumi.set(__self__, "sns", sns)
        if sqs is not None:
            pulumi.set(__self__, "sqs", sqs)
        if ssm is not None:
            pulumi.set(__self__, "ssm", ssm)
        if ssmcontacts is not None:
            pulumi.set(__self__, "ssmcontacts", ssmcontacts)
        if ssmincidents is not None:
            pulumi.set(__self__, "ssmincidents", ssmincidents)
        if sso is not None:
            pulumi.set(__self__, "sso", sso)
        if ssoadmin is not None:
            pulumi.set(__self__, "ssoadmin", ssoadmin)
        if ssooidc is not None:
            pulumi.set(__self__, "ssooidc", ssooidc)
        if stepfunctions is not None:
            pulumi.set(__self__, "stepfunctions", stepfunctions)
        if storagegateway is not None:
            pulumi.set(__self__, "storagegateway", storagegateway)
        if sts is not None:
            pulumi.set(__self__, "sts", sts)
        if support is not None:
            pulumi.set(__self__, "support", support)
        if swf is not None:
            pulumi.set(__self__, "swf", swf)
        if synthetics is not None:
            pulumi.set(__self__, "synthetics", synthetics)
        if textract is not None:
            pulumi.set(__self__, "textract", textract)
        if timestreamquery is not None:
            pulumi.set(__self__, "timestreamquery", timestreamquery)
        if timestreamwrite is not None:
            pulumi.set(__self__, "timestreamwrite", timestreamwrite)
        if transcribe is not None:
            pulumi.set(__self__, "transcribe", transcribe)
        if transcribeservice is not None:
            pulumi.set(__self__, "transcribeservice", transcribeservice)
        if transcribestreaming is not None:
            pulumi.set(__self__, "transcribestreaming", transcribestreaming)
        if transcribestreamingservice is not None:
            pulumi.set(__self__, "transcribestreamingservice", transcribestreamingservice)
        if transfer is not None:
            pulumi.set(__self__, "transfer", transfer)
        if translate is not None:
            pulumi.set(__self__, "translate", translate)
        if waf is not None:
            pulumi.set(__self__, "waf", waf)
        if wafregional is not None:
            pulumi.set(__self__, "wafregional", wafregional)
        if wafv2 is not None:
            pulumi.set(__self__, "wafv2", wafv2)
        if wellarchitected is not None:
            pulumi.set(__self__, "wellarchitected", wellarchitected)
        if workdocs is not None:
            pulumi.set(__self__, "workdocs", workdocs)
        if worklink is not None:
            pulumi.set(__self__, "worklink", worklink)
        if workmail is not None:
            pulumi.set(__self__, "workmail", workmail)
        if workmailmessageflow is not None:
            pulumi.set(__self__, "workmailmessageflow", workmailmessageflow)
        if workspaces is not None:
            pulumi.set(__self__, "workspaces", workspaces)
        if xray is not None:
            pulumi.set(__self__, "xray", xray)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.output_type
class IgnoreTags(dict):
    def __init__(__self__, *,
                 key_prefixes: Optional[Sequence[str]] = None,
                 keys: Optional[Sequence[str]] = None):
        if key_prefixes is not None:
            pulumi.set(__self__, "key_prefixes", key_prefixes)
        if keys is not None:
            pulumi.set(__self__, "keys", keys)

    @property
    @pulumi.getter(name="keyPrefixes")
    def key_prefixes(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "key_prefixes")

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


