text: # 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, _tables
  
  __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")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @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")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class Endpoints(dict):
      def __init__(__self__, *,
                   accessanalyzer: Optional[str] = None,
                   acm: Optional[str] = None,
                   acmpca: Optional[str] = None,
                   amplify: Optional[str] = None,
                   apigateway: Optional[str] = None,
                   applicationautoscaling: Optional[str] = None,
                   applicationinsights: Optional[str] = None,
                   appmesh: Optional[str] = None,
                   appstream: Optional[str] = None,
                   appsync: Optional[str] = None,
                   athena: Optional[str] = None,
                   auditmanager: Optional[str] = None,
                   autoscaling: Optional[str] = None,
                   autoscalingplans: Optional[str] = None,
                   backup: Optional[str] = None,
                   batch: Optional[str] = None,
                   budgets: Optional[str] = None,
                   cloud9: Optional[str] = None,
                   cloudformation: Optional[str] = None,
                   cloudfront: Optional[str] = None,
                   cloudhsm: Optional[str] = None,
                   cloudsearch: 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,
                   codepipeline: Optional[str] = None,
                   codestarconnections: Optional[str] = None,
                   cognitoidentity: Optional[str] = None,
                   cognitoidp: Optional[str] = None,
                   configservice: Optional[str] = None,
                   connect: Optional[str] = None,
                   cur: Optional[str] = None,
                   dataexchange: Optional[str] = None,
                   datapipeline: Optional[str] = None,
                   datasync: Optional[str] = None,
                   dax: Optional[str] = None,
                   devicefarm: 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,
                   ec2: 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,
                   elastictranscoder: Optional[str] = None,
                   elb: Optional[str] = None,
                   emr: Optional[str] = None,
                   emrcontainers: Optional[str] = None,
                   es: Optional[str] = None,
                   firehose: Optional[str] = None,
                   fms: Optional[str] = None,
                   forecast: Optional[str] = None,
                   fsx: Optional[str] = None,
                   gamelift: Optional[str] = None,
                   glacier: Optional[str] = None,
                   globalaccelerator: Optional[str] = None,
                   glue: Optional[str] = None,
                   greengrass: Optional[str] = None,
                   guardduty: Optional[str] = None,
                   iam: Optional[str] = None,
                   identitystore: Optional[str] = None,
                   imagebuilder: Optional[str] = None,
                   inspector: Optional[str] = None,
                   iot: Optional[str] = None,
                   iotanalytics: Optional[str] = None,
                   iotevents: Optional[str] = None,
                   kafka: Optional[str] = None,
                   kinesis: Optional[str] = None,
                   kinesisanalytics: Optional[str] = None,
                   kinesisanalyticsv2: Optional[str] = None,
                   kinesisvideo: Optional[str] = None,
                   kms: Optional[str] = None,
                   lakeformation: Optional[str] = None,
                   lambda_: Optional[str] = None,
                   lexmodels: Optional[str] = None,
                   licensemanager: Optional[str] = None,
                   lightsail: Optional[str] = None,
                   macie: Optional[str] = None,
                   macie2: Optional[str] = None,
                   managedblockchain: Optional[str] = None,
                   marketplacecatalog: Optional[str] = None,
                   mediaconnect: Optional[str] = None,
                   mediaconvert: Optional[str] = None,
                   medialive: Optional[str] = None,
                   mediapackage: Optional[str] = None,
                   mediastore: Optional[str] = None,
                   mediastoredata: Optional[str] = None,
                   mq: Optional[str] = None,
                   mwaa: Optional[str] = None,
                   neptune: Optional[str] = None,
                   networkfirewall: Optional[str] = None,
                   networkmanager: Optional[str] = None,
                   opsworks: Optional[str] = None,
                   organizations: Optional[str] = None,
                   outposts: Optional[str] = None,
                   personalize: Optional[str] = None,
                   pinpoint: Optional[str] = None,
                   pricing: Optional[str] = None,
                   qldb: Optional[str] = None,
                   quicksight: Optional[str] = None,
                   ram: Optional[str] = None,
                   rds: Optional[str] = None,
                   redshift: Optional[str] = None,
                   resourcegroups: Optional[str] = None,
                   resourcegroupstaggingapi: Optional[str] = None,
                   route53: Optional[str] = None,
                   route53domains: Optional[str] = None,
                   route53resolver: Optional[str] = None,
                   s3: Optional[str] = None,
                   s3control: Optional[str] = None,
                   s3outposts: Optional[str] = None,
                   sagemaker: Optional[str] = None,
                   sdb: Optional[str] = None,
                   secretsmanager: Optional[str] = None,
                   securityhub: Optional[str] = None,
                   serverlessrepo: Optional[str] = None,
                   servicecatalog: Optional[str] = None,
                   servicediscovery: Optional[str] = None,
                   servicequotas: Optional[str] = None,
                   ses: Optional[str] = None,
                   shield: Optional[str] = None,
                   signer: Optional[str] = None,
                   sns: Optional[str] = None,
                   sqs: Optional[str] = None,
                   ssm: Optional[str] = None,
                   ssoadmin: Optional[str] = None,
                   stepfunctions: Optional[str] = None,
                   storagegateway: Optional[str] = None,
                   sts: Optional[str] = None,
                   swf: Optional[str] = None,
                   synthetics: Optional[str] = None,
                   timestreamwrite: Optional[str] = None,
                   transfer: Optional[str] = None,
                   waf: Optional[str] = None,
                   wafregional: Optional[str] = None,
                   wafv2: Optional[str] = None,
                   worklink: Optional[str] = None,
                   workmail: Optional[str] = None,
                   workspaces: Optional[str] = None,
                   xray: Optional[str] = None):
          if accessanalyzer is not None:
              pulumi.set(__self__, "accessanalyzer", accessanalyzer)
          if acm is not None:
              pulumi.set(__self__, "acm", acm)
          if acmpca is not None:
              pulumi.set(__self__, "acmpca", acmpca)
          if amplify is not None:
              pulumi.set(__self__, "amplify", amplify)
          if apigateway is not None:
              pulumi.set(__self__, "apigateway", apigateway)
          if applicationautoscaling is not None:
              pulumi.set(__self__, "applicationautoscaling", applicationautoscaling)
          if applicationinsights is not None:
              pulumi.set(__self__, "applicationinsights", applicationinsights)
          if appmesh is not None:
              pulumi.set(__self__, "appmesh", appmesh)
          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 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 budgets is not None:
              pulumi.set(__self__, "budgets", budgets)
          if cloud9 is not None:
              pulumi.set(__self__, "cloud9", cloud9)
          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 cloudsearch is not None:
              pulumi.set(__self__, "cloudsearch", cloudsearch)
          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 codepipeline is not None:
              pulumi.set(__self__, "codepipeline", codepipeline)
          if codestarconnections is not None:
              pulumi.set(__self__, "codestarconnections", codestarconnections)
          if cognitoidentity is not None:
              pulumi.set(__self__, "cognitoidentity", cognitoidentity)
          if cognitoidp is not None:
              pulumi.set(__self__, "cognitoidp", cognitoidp)
          if configservice is not None:
              pulumi.set(__self__, "configservice", configservice)
          if connect is not None:
              pulumi.set(__self__, "connect", connect)
          if cur is not None:
              pulumi.set(__self__, "cur", cur)
          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 devicefarm is not None:
              pulumi.set(__self__, "devicefarm", devicefarm)
          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 ec2 is not None:
              pulumi.set(__self__, "ec2", ec2)
          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 elastictranscoder is not None:
              pulumi.set(__self__, "elastictranscoder", elastictranscoder)
          if elb is not None:
              pulumi.set(__self__, "elb", elb)
          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 firehose is not None:
              pulumi.set(__self__, "firehose", firehose)
          if fms is not None:
              pulumi.set(__self__, "fms", fms)
          if forecast is not None:
              pulumi.set(__self__, "forecast", forecast)
          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 greengrass is not None:
              pulumi.set(__self__, "greengrass", greengrass)
          if guardduty is not None:
              pulumi.set(__self__, "guardduty", guardduty)
          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 iotanalytics is not None:
              pulumi.set(__self__, "iotanalytics", iotanalytics)
          if iotevents is not None:
              pulumi.set(__self__, "iotevents", iotevents)
          if kafka is not None:
              pulumi.set(__self__, "kafka", kafka)
          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 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 lexmodels is not None:
              pulumi.set(__self__, "lexmodels", lexmodels)
          if licensemanager is not None:
              pulumi.set(__self__, "licensemanager", licensemanager)
          if lightsail is not None:
              pulumi.set(__self__, "lightsail", lightsail)
          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 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 mediastore is not None:
              pulumi.set(__self__, "mediastore", mediastore)
          if mediastoredata is not None:
              pulumi.set(__self__, "mediastoredata", mediastoredata)
          if mq is not None:
              pulumi.set(__self__, "mq", mq)
          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 opsworks is not None:
              pulumi.set(__self__, "opsworks", opsworks)
          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 pinpoint is not None:
              pulumi.set(__self__, "pinpoint", pinpoint)
          if pricing is not None:
              pulumi.set(__self__, "pricing", pricing)
          if qldb is not None:
              pulumi.set(__self__, "qldb", qldb)
          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 redshift is not None:
              pulumi.set(__self__, "redshift", redshift)
          if resourcegroups is not None:
              pulumi.set(__self__, "resourcegroups", resourcegroups)
          if resourcegroupstaggingapi is not None:
              pulumi.set(__self__, "resourcegroupstaggingapi", resourcegroupstaggingapi)
          if route53 is not None:
              pulumi.set(__self__, "route53", route53)
          if route53domains is not None:
              pulumi.set(__self__, "route53domains", route53domains)
          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 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 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 shield is not None:
              pulumi.set(__self__, "shield", shield)
          if signer is not None:
              pulumi.set(__self__, "signer", signer)
          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 ssoadmin is not None:
              pulumi.set(__self__, "ssoadmin", ssoadmin)
          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 swf is not None:
              pulumi.set(__self__, "swf", swf)
          if synthetics is not None:
              pulumi.set(__self__, "synthetics", synthetics)
          if timestreamwrite is not None:
              pulumi.set(__self__, "timestreamwrite", timestreamwrite)
          if transfer is not None:
              pulumi.set(__self__, "transfer", transfer)
          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 worklink is not None:
              pulumi.set(__self__, "worklink", worklink)
          if workmail is not None:
              pulumi.set(__self__, "workmail", workmail)
          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 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 amplify(self) -> Optional[str]:
          return pulumi.get(self, "amplify")
  
      @property
      @pulumi.getter
      def apigateway(self) -> Optional[str]:
          return pulumi.get(self, "apigateway")
  
      @property
      @pulumi.getter
      def applicationautoscaling(self) -> Optional[str]:
          return pulumi.get(self, "applicationautoscaling")
  
      @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 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 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 budgets(self) -> Optional[str]:
          return pulumi.get(self, "budgets")
  
      @property
      @pulumi.getter
      def cloud9(self) -> Optional[str]:
          return pulumi.get(self, "cloud9")
  
      @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 cloudsearch(self) -> Optional[str]:
          return pulumi.get(self, "cloudsearch")
  
      @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 codepipeline(self) -> Optional[str]:
          return pulumi.get(self, "codepipeline")
  
      @property
      @pulumi.getter
      def codestarconnections(self) -> Optional[str]:
          return pulumi.get(self, "codestarconnections")
  
      @property
      @pulumi.getter
      def cognitoidentity(self) -> Optional[str]:
          return pulumi.get(self, "cognitoidentity")
  
      @property
      @pulumi.getter
      def cognitoidp(self) -> Optional[str]:
          return pulumi.get(self, "cognitoidp")
  
      @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 cur(self) -> Optional[str]:
          return pulumi.get(self, "cur")
  
      @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 devicefarm(self) -> Optional[str]:
          return pulumi.get(self, "devicefarm")
  
      @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 ec2(self) -> Optional[str]:
          return pulumi.get(self, "ec2")
  
      @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 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 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 firehose(self) -> Optional[str]:
          return pulumi.get(self, "firehose")
  
      @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 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 greengrass(self) -> Optional[str]:
          return pulumi.get(self, "greengrass")
  
      @property
      @pulumi.getter
      def guardduty(self) -> Optional[str]:
          return pulumi.get(self, "guardduty")
  
      @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 iotanalytics(self) -> Optional[str]:
          return pulumi.get(self, "iotanalytics")
  
      @property
      @pulumi.getter
      def iotevents(self) -> Optional[str]:
          return pulumi.get(self, "iotevents")
  
      @property
      @pulumi.getter
      def kafka(self) -> Optional[str]:
          return pulumi.get(self, "kafka")
  
      @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 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 lexmodels(self) -> Optional[str]:
          return pulumi.get(self, "lexmodels")
  
      @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 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 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 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 mq(self) -> Optional[str]:
          return pulumi.get(self, "mq")
  
      @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 opsworks(self) -> Optional[str]:
          return pulumi.get(self, "opsworks")
  
      @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 pinpoint(self) -> Optional[str]:
          return pulumi.get(self, "pinpoint")
  
      @property
      @pulumi.getter
      def pricing(self) -> Optional[str]:
          return pulumi.get(self, "pricing")
  
      @property
      @pulumi.getter
      def qldb(self) -> Optional[str]:
          return pulumi.get(self, "qldb")
  
      @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 redshift(self) -> Optional[str]:
          return pulumi.get(self, "redshift")
  
      @property
      @pulumi.getter
      def resourcegroups(self) -> Optional[str]:
          return pulumi.get(self, "resourcegroups")
  
      @property
      @pulumi.getter
      def resourcegroupstaggingapi(self) -> Optional[str]:
          return pulumi.get(self, "resourcegroupstaggingapi")
  
      @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 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 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 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 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 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 ssoadmin(self) -> Optional[str]:
          return pulumi.get(self, "ssoadmin")
  
      @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 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 timestreamwrite(self) -> Optional[str]:
          return pulumi.get(self, "timestreamwrite")
  
      @property
      @pulumi.getter
      def transfer(self) -> Optional[str]:
          return pulumi.get(self, "transfer")
  
      @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 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 workspaces(self) -> Optional[str]:
          return pulumi.get(self, "workspaces")
  
      @property
      @pulumi.getter
      def xray(self) -> Optional[str]:
          return pulumi.get(self, "xray")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @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")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  