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

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

__all__ = [
    'ProviderAssumeRoleArgs',
    'ProviderAssumeRoleWithWebIdentityArgs',
    'ProviderDefaultTagsArgs',
    'ProviderEndpointArgs',
    'ProviderIgnoreTagsArgs',
    'GetAmiFilterArgs',
    'GetAmiIdsFilterArgs',
    'GetAutoscalingGroupsFilterArgs',
    'GetAvailabilityZoneFilterArgs',
    'GetAvailabilityZonesFilterArgs',
    'GetElasticIpFilterArgs',
    'GetPrefixListFilterArgs',
    'GetRegionsFilterArgs',
]

@pulumi.input_type
class ProviderAssumeRoleArgs:
    def __init__(__self__, *,
                 duration: Optional[pulumi.Input[str]] = None,
                 duration_seconds: Optional[pulumi.Input[int]] = None,
                 external_id: Optional[pulumi.Input[str]] = None,
                 policy: Optional[pulumi.Input[str]] = None,
                 policy_arns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 role_arn: Optional[pulumi.Input[str]] = None,
                 session_name: Optional[pulumi.Input[str]] = None,
                 source_identity: Optional[pulumi.Input[str]] = None,
                 tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                 transitive_tag_keys: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        if duration is not None:
            pulumi.set(__self__, "duration", duration)
        if duration_seconds is not None:
            warnings.warn("""Use assume_role.duration instead""", DeprecationWarning)
            pulumi.log.warn("""duration_seconds is deprecated: Use assume_role.duration instead""")
        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 source_identity is not None:
            pulumi.set(__self__, "source_identity", source_identity)
        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
    def duration(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "duration")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class ProviderAssumeRoleWithWebIdentityArgs:
    def __init__(__self__, *,
                 duration: Optional[pulumi.Input[str]] = None,
                 policy: Optional[pulumi.Input[str]] = None,
                 policy_arns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 role_arn: Optional[pulumi.Input[str]] = None,
                 session_name: Optional[pulumi.Input[str]] = None,
                 web_identity_token: Optional[pulumi.Input[str]] = None,
                 web_identity_token_file: Optional[pulumi.Input[str]] = None):
        if duration is not None:
            pulumi.set(__self__, "duration", duration)
        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 web_identity_token is not None:
            pulumi.set(__self__, "web_identity_token", web_identity_token)
        if web_identity_token_file is not None:
            pulumi.set(__self__, "web_identity_token_file", web_identity_token_file)

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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


@pulumi.input_type
class ProviderEndpointArgs:
    def __init__(__self__, *,
                 accessanalyzer: Optional[pulumi.Input[str]] = None,
                 account: Optional[pulumi.Input[str]] = None,
                 acm: Optional[pulumi.Input[str]] = None,
                 acmpca: Optional[pulumi.Input[str]] = None,
                 alexaforbusiness: Optional[pulumi.Input[str]] = None,
                 amg: Optional[pulumi.Input[str]] = None,
                 amp: Optional[pulumi.Input[str]] = None,
                 amplify: Optional[pulumi.Input[str]] = None,
                 amplifybackend: Optional[pulumi.Input[str]] = None,
                 amplifyuibuilder: Optional[pulumi.Input[str]] = None,
                 apigateway: Optional[pulumi.Input[str]] = None,
                 apigatewaymanagementapi: Optional[pulumi.Input[str]] = None,
                 apigatewayv2: Optional[pulumi.Input[str]] = None,
                 appautoscaling: Optional[pulumi.Input[str]] = None,
                 appconfig: Optional[pulumi.Input[str]] = None,
                 appconfigdata: Optional[pulumi.Input[str]] = None,
                 appflow: Optional[pulumi.Input[str]] = None,
                 appintegrations: Optional[pulumi.Input[str]] = None,
                 appintegrationsservice: Optional[pulumi.Input[str]] = None,
                 applicationautoscaling: Optional[pulumi.Input[str]] = None,
                 applicationcostprofiler: Optional[pulumi.Input[str]] = None,
                 applicationdiscovery: Optional[pulumi.Input[str]] = None,
                 applicationdiscoveryservice: Optional[pulumi.Input[str]] = None,
                 applicationinsights: Optional[pulumi.Input[str]] = None,
                 appmesh: Optional[pulumi.Input[str]] = None,
                 appregistry: Optional[pulumi.Input[str]] = None,
                 apprunner: Optional[pulumi.Input[str]] = None,
                 appstream: Optional[pulumi.Input[str]] = None,
                 appsync: Optional[pulumi.Input[str]] = None,
                 athena: Optional[pulumi.Input[str]] = None,
                 auditmanager: Optional[pulumi.Input[str]] = None,
                 augmentedairuntime: Optional[pulumi.Input[str]] = None,
                 autoscaling: Optional[pulumi.Input[str]] = None,
                 autoscalingplans: Optional[pulumi.Input[str]] = None,
                 backup: Optional[pulumi.Input[str]] = None,
                 backupgateway: Optional[pulumi.Input[str]] = None,
                 batch: Optional[pulumi.Input[str]] = None,
                 beanstalk: Optional[pulumi.Input[str]] = None,
                 billingconductor: Optional[pulumi.Input[str]] = None,
                 braket: Optional[pulumi.Input[str]] = None,
                 budgets: Optional[pulumi.Input[str]] = None,
                 ce: Optional[pulumi.Input[str]] = None,
                 chime: Optional[pulumi.Input[str]] = None,
                 chimesdkidentity: Optional[pulumi.Input[str]] = None,
                 chimesdkmeetings: Optional[pulumi.Input[str]] = None,
                 chimesdkmessaging: Optional[pulumi.Input[str]] = None,
                 cloud9: Optional[pulumi.Input[str]] = None,
                 cloudcontrol: Optional[pulumi.Input[str]] = None,
                 cloudcontrolapi: Optional[pulumi.Input[str]] = None,
                 clouddirectory: Optional[pulumi.Input[str]] = None,
                 cloudformation: Optional[pulumi.Input[str]] = None,
                 cloudfront: Optional[pulumi.Input[str]] = None,
                 cloudhsm: Optional[pulumi.Input[str]] = None,
                 cloudhsmv2: Optional[pulumi.Input[str]] = None,
                 cloudsearch: Optional[pulumi.Input[str]] = None,
                 cloudsearchdomain: Optional[pulumi.Input[str]] = None,
                 cloudtrail: Optional[pulumi.Input[str]] = None,
                 cloudwatch: Optional[pulumi.Input[str]] = None,
                 cloudwatchevents: Optional[pulumi.Input[str]] = None,
                 cloudwatchevidently: Optional[pulumi.Input[str]] = None,
                 cloudwatchlog: Optional[pulumi.Input[str]] = None,
                 cloudwatchlogs: Optional[pulumi.Input[str]] = None,
                 cloudwatchobservabilityaccessmanager: Optional[pulumi.Input[str]] = None,
                 cloudwatchrum: Optional[pulumi.Input[str]] = None,
                 codeartifact: Optional[pulumi.Input[str]] = None,
                 codebuild: Optional[pulumi.Input[str]] = None,
                 codecommit: Optional[pulumi.Input[str]] = None,
                 codedeploy: Optional[pulumi.Input[str]] = None,
                 codeguruprofiler: Optional[pulumi.Input[str]] = None,
                 codegurureviewer: Optional[pulumi.Input[str]] = None,
                 codepipeline: Optional[pulumi.Input[str]] = None,
                 codestar: Optional[pulumi.Input[str]] = None,
                 codestarconnections: Optional[pulumi.Input[str]] = None,
                 codestarnotifications: Optional[pulumi.Input[str]] = None,
                 cognitoidentity: Optional[pulumi.Input[str]] = None,
                 cognitoidentityprovider: Optional[pulumi.Input[str]] = None,
                 cognitoidp: Optional[pulumi.Input[str]] = None,
                 cognitosync: Optional[pulumi.Input[str]] = None,
                 comprehend: Optional[pulumi.Input[str]] = None,
                 comprehendmedical: Optional[pulumi.Input[str]] = None,
                 computeoptimizer: Optional[pulumi.Input[str]] = None,
                 config: Optional[pulumi.Input[str]] = None,
                 configservice: Optional[pulumi.Input[str]] = None,
                 connect: Optional[pulumi.Input[str]] = None,
                 connectcontactlens: Optional[pulumi.Input[str]] = None,
                 connectparticipant: Optional[pulumi.Input[str]] = None,
                 connectwisdomservice: Optional[pulumi.Input[str]] = None,
                 controltower: Optional[pulumi.Input[str]] = None,
                 costandusagereportservice: Optional[pulumi.Input[str]] = None,
                 costexplorer: Optional[pulumi.Input[str]] = None,
                 cur: Optional[pulumi.Input[str]] = None,
                 customerprofiles: Optional[pulumi.Input[str]] = None,
                 databasemigration: Optional[pulumi.Input[str]] = None,
                 databasemigrationservice: Optional[pulumi.Input[str]] = None,
                 databrew: Optional[pulumi.Input[str]] = None,
                 dataexchange: Optional[pulumi.Input[str]] = None,
                 datapipeline: Optional[pulumi.Input[str]] = None,
                 datasync: Optional[pulumi.Input[str]] = None,
                 dax: Optional[pulumi.Input[str]] = None,
                 deploy: Optional[pulumi.Input[str]] = None,
                 detective: Optional[pulumi.Input[str]] = None,
                 devicefarm: Optional[pulumi.Input[str]] = None,
                 devopsguru: Optional[pulumi.Input[str]] = None,
                 directconnect: Optional[pulumi.Input[str]] = None,
                 directoryservice: Optional[pulumi.Input[str]] = None,
                 discovery: Optional[pulumi.Input[str]] = None,
                 dlm: Optional[pulumi.Input[str]] = None,
                 dms: Optional[pulumi.Input[str]] = None,
                 docdb: Optional[pulumi.Input[str]] = None,
                 drs: Optional[pulumi.Input[str]] = None,
                 ds: Optional[pulumi.Input[str]] = None,
                 dynamodb: Optional[pulumi.Input[str]] = None,
                 dynamodbstreams: Optional[pulumi.Input[str]] = None,
                 ebs: Optional[pulumi.Input[str]] = None,
                 ec2: Optional[pulumi.Input[str]] = None,
                 ec2instanceconnect: Optional[pulumi.Input[str]] = None,
                 ecr: Optional[pulumi.Input[str]] = None,
                 ecrpublic: Optional[pulumi.Input[str]] = None,
                 ecs: Optional[pulumi.Input[str]] = None,
                 efs: Optional[pulumi.Input[str]] = None,
                 eks: Optional[pulumi.Input[str]] = None,
                 elasticache: Optional[pulumi.Input[str]] = None,
                 elasticbeanstalk: Optional[pulumi.Input[str]] = None,
                 elasticinference: Optional[pulumi.Input[str]] = None,
                 elasticloadbalancing: Optional[pulumi.Input[str]] = None,
                 elasticloadbalancingv2: Optional[pulumi.Input[str]] = None,
                 elasticsearch: Optional[pulumi.Input[str]] = None,
                 elasticsearchservice: Optional[pulumi.Input[str]] = None,
                 elastictranscoder: Optional[pulumi.Input[str]] = None,
                 elb: Optional[pulumi.Input[str]] = None,
                 elbv2: Optional[pulumi.Input[str]] = None,
                 emr: Optional[pulumi.Input[str]] = None,
                 emrcontainers: Optional[pulumi.Input[str]] = None,
                 emrserverless: Optional[pulumi.Input[str]] = None,
                 es: Optional[pulumi.Input[str]] = None,
                 eventbridge: Optional[pulumi.Input[str]] = None,
                 events: Optional[pulumi.Input[str]] = None,
                 evidently: Optional[pulumi.Input[str]] = None,
                 finspace: Optional[pulumi.Input[str]] = None,
                 finspacedata: Optional[pulumi.Input[str]] = None,
                 firehose: Optional[pulumi.Input[str]] = None,
                 fis: Optional[pulumi.Input[str]] = None,
                 fms: Optional[pulumi.Input[str]] = None,
                 forecast: Optional[pulumi.Input[str]] = None,
                 forecastquery: Optional[pulumi.Input[str]] = None,
                 forecastqueryservice: Optional[pulumi.Input[str]] = None,
                 forecastservice: Optional[pulumi.Input[str]] = None,
                 frauddetector: Optional[pulumi.Input[str]] = None,
                 fsx: Optional[pulumi.Input[str]] = None,
                 gamelift: Optional[pulumi.Input[str]] = None,
                 glacier: Optional[pulumi.Input[str]] = None,
                 globalaccelerator: Optional[pulumi.Input[str]] = None,
                 glue: Optional[pulumi.Input[str]] = None,
                 gluedatabrew: Optional[pulumi.Input[str]] = None,
                 grafana: Optional[pulumi.Input[str]] = None,
                 greengrass: Optional[pulumi.Input[str]] = None,
                 greengrassv2: Optional[pulumi.Input[str]] = None,
                 groundstation: Optional[pulumi.Input[str]] = None,
                 guardduty: Optional[pulumi.Input[str]] = None,
                 health: Optional[pulumi.Input[str]] = None,
                 healthlake: Optional[pulumi.Input[str]] = None,
                 honeycode: Optional[pulumi.Input[str]] = None,
                 iam: Optional[pulumi.Input[str]] = None,
                 identitystore: Optional[pulumi.Input[str]] = None,
                 imagebuilder: Optional[pulumi.Input[str]] = None,
                 inspector: Optional[pulumi.Input[str]] = None,
                 inspector2: Optional[pulumi.Input[str]] = None,
                 inspectorv2: Optional[pulumi.Input[str]] = None,
                 iot: Optional[pulumi.Input[str]] = None,
                 iot1clickdevices: Optional[pulumi.Input[str]] = None,
                 iot1clickdevicesservice: Optional[pulumi.Input[str]] = None,
                 iot1clickprojects: Optional[pulumi.Input[str]] = None,
                 iotanalytics: Optional[pulumi.Input[str]] = None,
                 iotdata: Optional[pulumi.Input[str]] = None,
                 iotdataplane: Optional[pulumi.Input[str]] = None,
                 iotdeviceadvisor: Optional[pulumi.Input[str]] = None,
                 iotevents: Optional[pulumi.Input[str]] = None,
                 ioteventsdata: Optional[pulumi.Input[str]] = None,
                 iotfleethub: Optional[pulumi.Input[str]] = None,
                 iotjobsdata: Optional[pulumi.Input[str]] = None,
                 iotjobsdataplane: Optional[pulumi.Input[str]] = None,
                 iotsecuretunneling: Optional[pulumi.Input[str]] = None,
                 iotsitewise: Optional[pulumi.Input[str]] = None,
                 iotthingsgraph: Optional[pulumi.Input[str]] = None,
                 iottwinmaker: Optional[pulumi.Input[str]] = None,
                 iotwireless: Optional[pulumi.Input[str]] = None,
                 ivs: Optional[pulumi.Input[str]] = None,
                 ivschat: Optional[pulumi.Input[str]] = None,
                 kafka: Optional[pulumi.Input[str]] = None,
                 kafkaconnect: Optional[pulumi.Input[str]] = None,
                 kendra: Optional[pulumi.Input[str]] = None,
                 keyspaces: Optional[pulumi.Input[str]] = None,
                 kinesis: Optional[pulumi.Input[str]] = None,
                 kinesisanalytics: Optional[pulumi.Input[str]] = None,
                 kinesisanalyticsv2: Optional[pulumi.Input[str]] = None,
                 kinesisvideo: Optional[pulumi.Input[str]] = None,
                 kinesisvideoarchivedmedia: Optional[pulumi.Input[str]] = None,
                 kinesisvideomedia: Optional[pulumi.Input[str]] = None,
                 kinesisvideosignaling: Optional[pulumi.Input[str]] = None,
                 kinesisvideosignalingchannels: Optional[pulumi.Input[str]] = None,
                 kms: Optional[pulumi.Input[str]] = None,
                 lakeformation: Optional[pulumi.Input[str]] = None,
                 lambda_: Optional[pulumi.Input[str]] = None,
                 lex: Optional[pulumi.Input[str]] = None,
                 lexmodelbuilding: Optional[pulumi.Input[str]] = None,
                 lexmodelbuildingservice: Optional[pulumi.Input[str]] = None,
                 lexmodels: Optional[pulumi.Input[str]] = None,
                 lexmodelsv2: Optional[pulumi.Input[str]] = None,
                 lexruntime: Optional[pulumi.Input[str]] = None,
                 lexruntimeservice: Optional[pulumi.Input[str]] = None,
                 lexruntimev2: Optional[pulumi.Input[str]] = None,
                 lexv2models: Optional[pulumi.Input[str]] = None,
                 lexv2runtime: Optional[pulumi.Input[str]] = None,
                 licensemanager: Optional[pulumi.Input[str]] = None,
                 lightsail: Optional[pulumi.Input[str]] = None,
                 location: Optional[pulumi.Input[str]] = None,
                 locationservice: Optional[pulumi.Input[str]] = None,
                 logs: Optional[pulumi.Input[str]] = None,
                 lookoutequipment: Optional[pulumi.Input[str]] = None,
                 lookoutforvision: Optional[pulumi.Input[str]] = None,
                 lookoutmetrics: Optional[pulumi.Input[str]] = None,
                 lookoutvision: Optional[pulumi.Input[str]] = None,
                 machinelearning: Optional[pulumi.Input[str]] = None,
                 macie: Optional[pulumi.Input[str]] = None,
                 macie2: Optional[pulumi.Input[str]] = None,
                 managedblockchain: Optional[pulumi.Input[str]] = None,
                 managedgrafana: Optional[pulumi.Input[str]] = None,
                 marketplacecatalog: Optional[pulumi.Input[str]] = None,
                 marketplacecommerceanalytics: Optional[pulumi.Input[str]] = None,
                 marketplaceentitlement: Optional[pulumi.Input[str]] = None,
                 marketplaceentitlementservice: Optional[pulumi.Input[str]] = None,
                 marketplacemetering: Optional[pulumi.Input[str]] = None,
                 mediaconnect: Optional[pulumi.Input[str]] = None,
                 mediaconvert: Optional[pulumi.Input[str]] = None,
                 medialive: Optional[pulumi.Input[str]] = None,
                 mediapackage: Optional[pulumi.Input[str]] = None,
                 mediapackagevod: Optional[pulumi.Input[str]] = None,
                 mediastore: Optional[pulumi.Input[str]] = None,
                 mediastoredata: Optional[pulumi.Input[str]] = None,
                 mediatailor: Optional[pulumi.Input[str]] = None,
                 memorydb: Optional[pulumi.Input[str]] = None,
                 meteringmarketplace: Optional[pulumi.Input[str]] = None,
                 mgh: Optional[pulumi.Input[str]] = None,
                 mgn: Optional[pulumi.Input[str]] = None,
                 migrationhub: Optional[pulumi.Input[str]] = None,
                 migrationhubconfig: Optional[pulumi.Input[str]] = None,
                 migrationhubrefactorspaces: Optional[pulumi.Input[str]] = None,
                 migrationhubstrategy: Optional[pulumi.Input[str]] = None,
                 migrationhubstrategyrecommendations: Optional[pulumi.Input[str]] = None,
                 mobile: Optional[pulumi.Input[str]] = None,
                 mq: Optional[pulumi.Input[str]] = None,
                 msk: Optional[pulumi.Input[str]] = None,
                 mturk: Optional[pulumi.Input[str]] = None,
                 mwaa: Optional[pulumi.Input[str]] = None,
                 neptune: Optional[pulumi.Input[str]] = None,
                 networkfirewall: Optional[pulumi.Input[str]] = None,
                 networkmanager: Optional[pulumi.Input[str]] = None,
                 nimble: Optional[pulumi.Input[str]] = None,
                 nimblestudio: Optional[pulumi.Input[str]] = None,
                 oam: Optional[pulumi.Input[str]] = None,
                 opensearch: Optional[pulumi.Input[str]] = None,
                 opensearchserverless: Optional[pulumi.Input[str]] = None,
                 opensearchservice: Optional[pulumi.Input[str]] = None,
                 opsworks: Optional[pulumi.Input[str]] = None,
                 opsworkscm: Optional[pulumi.Input[str]] = None,
                 organizations: Optional[pulumi.Input[str]] = None,
                 outposts: Optional[pulumi.Input[str]] = None,
                 panorama: Optional[pulumi.Input[str]] = None,
                 personalize: Optional[pulumi.Input[str]] = None,
                 personalizeevents: Optional[pulumi.Input[str]] = None,
                 personalizeruntime: Optional[pulumi.Input[str]] = None,
                 pi: Optional[pulumi.Input[str]] = None,
                 pinpoint: Optional[pulumi.Input[str]] = None,
                 pinpointemail: Optional[pulumi.Input[str]] = None,
                 pinpointsmsvoice: Optional[pulumi.Input[str]] = None,
                 pipes: Optional[pulumi.Input[str]] = None,
                 polly: Optional[pulumi.Input[str]] = None,
                 pricing: Optional[pulumi.Input[str]] = None,
                 prometheus: Optional[pulumi.Input[str]] = None,
                 prometheusservice: Optional[pulumi.Input[str]] = None,
                 proton: Optional[pulumi.Input[str]] = None,
                 qldb: Optional[pulumi.Input[str]] = None,
                 qldbsession: Optional[pulumi.Input[str]] = None,
                 quicksight: Optional[pulumi.Input[str]] = None,
                 ram: Optional[pulumi.Input[str]] = None,
                 rbin: Optional[pulumi.Input[str]] = None,
                 rds: Optional[pulumi.Input[str]] = None,
                 rdsdata: Optional[pulumi.Input[str]] = None,
                 rdsdataservice: Optional[pulumi.Input[str]] = None,
                 recyclebin: Optional[pulumi.Input[str]] = None,
                 redshift: Optional[pulumi.Input[str]] = None,
                 redshiftdata: Optional[pulumi.Input[str]] = None,
                 redshiftdataapiservice: Optional[pulumi.Input[str]] = None,
                 redshiftserverless: Optional[pulumi.Input[str]] = None,
                 rekognition: Optional[pulumi.Input[str]] = None,
                 resiliencehub: Optional[pulumi.Input[str]] = None,
                 resourceexplorer2: Optional[pulumi.Input[str]] = None,
                 resourcegroups: Optional[pulumi.Input[str]] = None,
                 resourcegroupstagging: Optional[pulumi.Input[str]] = None,
                 resourcegroupstaggingapi: Optional[pulumi.Input[str]] = None,
                 robomaker: Optional[pulumi.Input[str]] = None,
                 rolesanywhere: Optional[pulumi.Input[str]] = None,
                 route53: Optional[pulumi.Input[str]] = None,
                 route53domains: Optional[pulumi.Input[str]] = None,
                 route53recoverycluster: Optional[pulumi.Input[str]] = None,
                 route53recoverycontrolconfig: Optional[pulumi.Input[str]] = None,
                 route53recoveryreadiness: Optional[pulumi.Input[str]] = None,
                 route53resolver: Optional[pulumi.Input[str]] = None,
                 rum: Optional[pulumi.Input[str]] = None,
                 s3: Optional[pulumi.Input[str]] = None,
                 s3api: Optional[pulumi.Input[str]] = None,
                 s3control: Optional[pulumi.Input[str]] = None,
                 s3outposts: Optional[pulumi.Input[str]] = None,
                 sagemaker: Optional[pulumi.Input[str]] = None,
                 sagemakera2iruntime: Optional[pulumi.Input[str]] = None,
                 sagemakeredge: Optional[pulumi.Input[str]] = None,
                 sagemakeredgemanager: Optional[pulumi.Input[str]] = None,
                 sagemakerfeaturestoreruntime: Optional[pulumi.Input[str]] = None,
                 sagemakerruntime: Optional[pulumi.Input[str]] = None,
                 savingsplans: Optional[pulumi.Input[str]] = None,
                 scheduler: Optional[pulumi.Input[str]] = None,
                 schemas: Optional[pulumi.Input[str]] = None,
                 sdb: Optional[pulumi.Input[str]] = None,
                 secretsmanager: Optional[pulumi.Input[str]] = None,
                 securityhub: Optional[pulumi.Input[str]] = None,
                 serverlessapplicationrepository: Optional[pulumi.Input[str]] = None,
                 serverlessapprepo: Optional[pulumi.Input[str]] = None,
                 serverlessrepo: Optional[pulumi.Input[str]] = None,
                 servicecatalog: Optional[pulumi.Input[str]] = None,
                 servicecatalogappregistry: Optional[pulumi.Input[str]] = None,
                 servicediscovery: Optional[pulumi.Input[str]] = None,
                 servicequotas: Optional[pulumi.Input[str]] = None,
                 ses: Optional[pulumi.Input[str]] = None,
                 sesv2: Optional[pulumi.Input[str]] = None,
                 sfn: Optional[pulumi.Input[str]] = None,
                 shield: Optional[pulumi.Input[str]] = None,
                 signer: Optional[pulumi.Input[str]] = None,
                 simpledb: Optional[pulumi.Input[str]] = None,
                 sms: Optional[pulumi.Input[str]] = None,
                 snowball: Optional[pulumi.Input[str]] = None,
                 snowdevicemanagement: Optional[pulumi.Input[str]] = None,
                 sns: Optional[pulumi.Input[str]] = None,
                 sqs: Optional[pulumi.Input[str]] = None,
                 ssm: Optional[pulumi.Input[str]] = None,
                 ssmcontacts: Optional[pulumi.Input[str]] = None,
                 ssmincidents: Optional[pulumi.Input[str]] = None,
                 sso: Optional[pulumi.Input[str]] = None,
                 ssoadmin: Optional[pulumi.Input[str]] = None,
                 ssooidc: Optional[pulumi.Input[str]] = None,
                 stepfunctions: Optional[pulumi.Input[str]] = None,
                 storagegateway: Optional[pulumi.Input[str]] = None,
                 sts: Optional[pulumi.Input[str]] = None,
                 support: Optional[pulumi.Input[str]] = None,
                 swf: Optional[pulumi.Input[str]] = None,
                 synthetics: Optional[pulumi.Input[str]] = None,
                 textract: Optional[pulumi.Input[str]] = None,
                 timestreamquery: Optional[pulumi.Input[str]] = None,
                 timestreamwrite: Optional[pulumi.Input[str]] = None,
                 transcribe: Optional[pulumi.Input[str]] = None,
                 transcribeservice: Optional[pulumi.Input[str]] = None,
                 transcribestreaming: Optional[pulumi.Input[str]] = None,
                 transcribestreamingservice: Optional[pulumi.Input[str]] = None,
                 transfer: Optional[pulumi.Input[str]] = None,
                 translate: Optional[pulumi.Input[str]] = None,
                 voiceid: Optional[pulumi.Input[str]] = None,
                 waf: Optional[pulumi.Input[str]] = None,
                 wafregional: Optional[pulumi.Input[str]] = None,
                 wafv2: Optional[pulumi.Input[str]] = None,
                 wellarchitected: Optional[pulumi.Input[str]] = None,
                 wisdom: Optional[pulumi.Input[str]] = None,
                 workdocs: Optional[pulumi.Input[str]] = None,
                 worklink: Optional[pulumi.Input[str]] = None,
                 workmail: Optional[pulumi.Input[str]] = None,
                 workmailmessageflow: Optional[pulumi.Input[str]] = None,
                 workspaces: Optional[pulumi.Input[str]] = None,
                 workspacesweb: Optional[pulumi.Input[str]] = None,
                 xray: Optional[pulumi.Input[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 amg is not None:
            pulumi.set(__self__, "amg", amg)
        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 amplifyuibuilder is not None:
            pulumi.set(__self__, "amplifyuibuilder", amplifyuibuilder)
        if apigateway is not None:
            pulumi.set(__self__, "apigateway", apigateway)
        if apigatewaymanagementapi is not None:
            pulumi.set(__self__, "apigatewaymanagementapi", apigatewaymanagementapi)
        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 appconfigdata is not None:
            pulumi.set(__self__, "appconfigdata", appconfigdata)
        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 backupgateway is not None:
            pulumi.set(__self__, "backupgateway", backupgateway)
        if batch is not None:
            pulumi.set(__self__, "batch", batch)
        if beanstalk is not None:
            pulumi.set(__self__, "beanstalk", beanstalk)
        if billingconductor is not None:
            pulumi.set(__self__, "billingconductor", billingconductor)
        if braket is not None:
            pulumi.set(__self__, "braket", braket)
        if budgets is not None:
            pulumi.set(__self__, "budgets", budgets)
        if ce is not None:
            pulumi.set(__self__, "ce", ce)
        if chime is not None:
            pulumi.set(__self__, "chime", chime)
        if chimesdkidentity is not None:
            pulumi.set(__self__, "chimesdkidentity", chimesdkidentity)
        if chimesdkmeetings is not None:
            pulumi.set(__self__, "chimesdkmeetings", chimesdkmeetings)
        if chimesdkmessaging is not None:
            pulumi.set(__self__, "chimesdkmessaging", chimesdkmessaging)
        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 cloudwatchevidently is not None:
            pulumi.set(__self__, "cloudwatchevidently", cloudwatchevidently)
        if cloudwatchlog is not None:
            pulumi.set(__self__, "cloudwatchlog", cloudwatchlog)
        if cloudwatchlogs is not None:
            pulumi.set(__self__, "cloudwatchlogs", cloudwatchlogs)
        if cloudwatchobservabilityaccessmanager is not None:
            pulumi.set(__self__, "cloudwatchobservabilityaccessmanager", cloudwatchobservabilityaccessmanager)
        if cloudwatchrum is not None:
            pulumi.set(__self__, "cloudwatchrum", cloudwatchrum)
        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 computeoptimizer is not None:
            pulumi.set(__self__, "computeoptimizer", computeoptimizer)
        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 connectwisdomservice is not None:
            pulumi.set(__self__, "connectwisdomservice", connectwisdomservice)
        if controltower is not None:
            pulumi.set(__self__, "controltower", controltower)
        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 customerprofiles is not None:
            pulumi.set(__self__, "customerprofiles", customerprofiles)
        if databasemigration is not None:
            pulumi.set(__self__, "databasemigration", databasemigration)
        if databasemigrationservice is not None:
            pulumi.set(__self__, "databasemigrationservice", databasemigrationservice)
        if databrew is not None:
            pulumi.set(__self__, "databrew", databrew)
        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 deploy is not None:
            pulumi.set(__self__, "deploy", deploy)
        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 directoryservice is not None:
            pulumi.set(__self__, "directoryservice", directoryservice)
        if discovery is not None:
            pulumi.set(__self__, "discovery", discovery)
        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 drs is not None:
            pulumi.set(__self__, "drs", drs)
        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 ebs is not None:
            pulumi.set(__self__, "ebs", ebs)
        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 elasticloadbalancing is not None:
            pulumi.set(__self__, "elasticloadbalancing", elasticloadbalancing)
        if elasticloadbalancingv2 is not None:
            pulumi.set(__self__, "elasticloadbalancingv2", elasticloadbalancingv2)
        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 emrserverless is not None:
            pulumi.set(__self__, "emrserverless", emrserverless)
        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 evidently is not None:
            pulumi.set(__self__, "evidently", evidently)
        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 grafana is not None:
            pulumi.set(__self__, "grafana", grafana)
        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 inspector2 is not None:
            pulumi.set(__self__, "inspector2", inspector2)
        if inspectorv2 is not None:
            pulumi.set(__self__, "inspectorv2", inspectorv2)
        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 iotdata is not None:
            pulumi.set(__self__, "iotdata", iotdata)
        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 iotjobsdata is not None:
            pulumi.set(__self__, "iotjobsdata", iotjobsdata)
        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 iottwinmaker is not None:
            pulumi.set(__self__, "iottwinmaker", iottwinmaker)
        if iotwireless is not None:
            pulumi.set(__self__, "iotwireless", iotwireless)
        if ivs is not None:
            pulumi.set(__self__, "ivs", ivs)
        if ivschat is not None:
            pulumi.set(__self__, "ivschat", ivschat)
        if kafka is not None:
            pulumi.set(__self__, "kafka", kafka)
        if kafkaconnect is not None:
            pulumi.set(__self__, "kafkaconnect", kafkaconnect)
        if kendra is not None:
            pulumi.set(__self__, "kendra", kendra)
        if keyspaces is not None:
            pulumi.set(__self__, "keyspaces", keyspaces)
        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 kinesisvideosignaling is not None:
            pulumi.set(__self__, "kinesisvideosignaling", kinesisvideosignaling)
        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 lex is not None:
            pulumi.set(__self__, "lex", lex)
        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 lexv2models is not None:
            pulumi.set(__self__, "lexv2models", lexv2models)
        if lexv2runtime is not None:
            pulumi.set(__self__, "lexv2runtime", lexv2runtime)
        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 locationservice is not None:
            pulumi.set(__self__, "locationservice", locationservice)
        if logs is not None:
            pulumi.set(__self__, "logs", logs)
        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 lookoutvision is not None:
            pulumi.set(__self__, "lookoutvision", lookoutvision)
        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 managedgrafana is not None:
            pulumi.set(__self__, "managedgrafana", managedgrafana)
        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 meteringmarketplace is not None:
            pulumi.set(__self__, "meteringmarketplace", meteringmarketplace)
        if mgh is not None:
            pulumi.set(__self__, "mgh", mgh)
        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 migrationhubrefactorspaces is not None:
            pulumi.set(__self__, "migrationhubrefactorspaces", migrationhubrefactorspaces)
        if migrationhubstrategy is not None:
            pulumi.set(__self__, "migrationhubstrategy", migrationhubstrategy)
        if migrationhubstrategyrecommendations is not None:
            pulumi.set(__self__, "migrationhubstrategyrecommendations", migrationhubstrategyrecommendations)
        if mobile is not None:
            pulumi.set(__self__, "mobile", mobile)
        if mq is not None:
            pulumi.set(__self__, "mq", mq)
        if msk is not None:
            pulumi.set(__self__, "msk", msk)
        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 nimble is not None:
            pulumi.set(__self__, "nimble", nimble)
        if nimblestudio is not None:
            pulumi.set(__self__, "nimblestudio", nimblestudio)
        if oam is not None:
            pulumi.set(__self__, "oam", oam)
        if opensearch is not None:
            pulumi.set(__self__, "opensearch", opensearch)
        if opensearchserverless is not None:
            pulumi.set(__self__, "opensearchserverless", opensearchserverless)
        if opensearchservice is not None:
            pulumi.set(__self__, "opensearchservice", opensearchservice)
        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 panorama is not None:
            pulumi.set(__self__, "panorama", panorama)
        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 pipes is not None:
            pulumi.set(__self__, "pipes", pipes)
        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 rbin is not None:
            pulumi.set(__self__, "rbin", rbin)
        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 recyclebin is not None:
            pulumi.set(__self__, "recyclebin", recyclebin)
        if redshift is not None:
            pulumi.set(__self__, "redshift", redshift)
        if redshiftdata is not None:
            pulumi.set(__self__, "redshiftdata", redshiftdata)
        if redshiftdataapiservice is not None:
            pulumi.set(__self__, "redshiftdataapiservice", redshiftdataapiservice)
        if redshiftserverless is not None:
            pulumi.set(__self__, "redshiftserverless", redshiftserverless)
        if rekognition is not None:
            pulumi.set(__self__, "rekognition", rekognition)
        if resiliencehub is not None:
            pulumi.set(__self__, "resiliencehub", resiliencehub)
        if resourceexplorer2 is not None:
            pulumi.set(__self__, "resourceexplorer2", resourceexplorer2)
        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 rolesanywhere is not None:
            pulumi.set(__self__, "rolesanywhere", rolesanywhere)
        if route53 is not None:
            pulumi.set(__self__, "route53", route53)
        if route53domains is not None:
            pulumi.set(__self__, "route53domains", route53domains)
        if route53recoverycluster is not None:
            pulumi.set(__self__, "route53recoverycluster", route53recoverycluster)
        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 rum is not None:
            pulumi.set(__self__, "rum", rum)
        if s3 is not None:
            pulumi.set(__self__, "s3", s3)
        if s3api is not None:
            pulumi.set(__self__, "s3api", s3api)
        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 sagemakera2iruntime is not None:
            pulumi.set(__self__, "sagemakera2iruntime", sagemakera2iruntime)
        if sagemakeredge is not None:
            pulumi.set(__self__, "sagemakeredge", sagemakeredge)
        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 scheduler is not None:
            pulumi.set(__self__, "scheduler", scheduler)
        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 servicecatalogappregistry is not None:
            pulumi.set(__self__, "servicecatalogappregistry", servicecatalogappregistry)
        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 snowdevicemanagement is not None:
            pulumi.set(__self__, "snowdevicemanagement", snowdevicemanagement)
        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 voiceid is not None:
            pulumi.set(__self__, "voiceid", voiceid)
        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 wisdom is not None:
            pulumi.set(__self__, "wisdom", wisdom)
        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 workspacesweb is not None:
            pulumi.set(__self__, "workspacesweb", workspacesweb)
        if xray is not None:
            pulumi.set(__self__, "xray", xray)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class ProviderIgnoreTagsArgs:
    def __init__(__self__, *,
                 key_prefixes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 keys: Optional[pulumi.Input[Sequence[pulumi.Input[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[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "key_prefixes")

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

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

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


@pulumi.input_type
class GetAmiFilterArgs:
    def __init__(__self__, *,
                 name: str,
                 values: Sequence[str]):
        """
        :param str name: Name of the AMI that was provided during image creation.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Name of the AMI that was provided during image creation.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: str):
        pulumi.set(self, "name", value)

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

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


@pulumi.input_type
class GetAmiIdsFilterArgs:
    def __init__(__self__, *,
                 name: str,
                 values: Sequence[str]):
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def name(self) -> str:
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: str):
        pulumi.set(self, "name", value)

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

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


@pulumi.input_type
class GetAutoscalingGroupsFilterArgs:
    def __init__(__self__, *,
                 name: str,
                 values: Sequence[str]):
        """
        :param str name: Name of the DescribeAutoScalingGroup filter. The recommended values are: `tag-key`, `tag-value`, and `tag:<tag name>`
        :param Sequence[str] values: Value of the filter.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Name of the DescribeAutoScalingGroup filter. The recommended values are: `tag-key`, `tag-value`, and `tag:<tag name>`
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: str):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        Value of the filter.
        """
        return pulumi.get(self, "values")

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


@pulumi.input_type
class GetAvailabilityZoneFilterArgs:
    def __init__(__self__, *,
                 name: str,
                 values: Sequence[str]):
        """
        :param str name: Name of the filter field. Valid values can be found in the [EC2 DescribeAvailabilityZones API Reference](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeAvailabilityZones.html).
        :param Sequence[str] values: Set of values that are accepted for the given filter field. Results will be selected if any given value matches.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Name of the filter field. Valid values can be found in the [EC2 DescribeAvailabilityZones API Reference](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeAvailabilityZones.html).
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: str):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        Set of values that are accepted for the given filter field. Results will be selected if any given value matches.
        """
        return pulumi.get(self, "values")

    @values.setter
    def values(self, value: Sequence[str]):
        pulumi.set(self, "values", value)


@pulumi.input_type
class GetAvailabilityZonesFilterArgs:
    def __init__(__self__, *,
                 name: str,
                 values: Sequence[str]):
        """
        :param str name: Name of the filter field. Valid values can be found in the [EC2 DescribeAvailabilityZones API Reference](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeAvailabilityZones.html).
        :param Sequence[str] values: Set of values that are accepted for the given filter field. Results will be selected if any given value matches.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Name of the filter field. Valid values can be found in the [EC2 DescribeAvailabilityZones API Reference](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeAvailabilityZones.html).
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: str):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        Set of values that are accepted for the given filter field. Results will be selected if any given value matches.
        """
        return pulumi.get(self, "values")

    @values.setter
    def values(self, value: Sequence[str]):
        pulumi.set(self, "values", value)


@pulumi.input_type
class GetElasticIpFilterArgs:
    def __init__(__self__, *,
                 name: str,
                 values: Sequence[str]):
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def name(self) -> str:
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: str):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        return pulumi.get(self, "values")

    @values.setter
    def values(self, value: Sequence[str]):
        pulumi.set(self, "values", value)


@pulumi.input_type
class GetPrefixListFilterArgs:
    def __init__(__self__, *,
                 name: str,
                 values: Sequence[str]):
        """
        :param str name: Name of the filter field. Valid values can be found in the [EC2 DescribePrefixLists API Reference](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribePrefixLists.html).
        :param Sequence[str] values: Set of values that are accepted for the given filter field. Results will be selected if any given value matches.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Name of the filter field. Valid values can be found in the [EC2 DescribePrefixLists API Reference](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribePrefixLists.html).
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: str):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        Set of values that are accepted for the given filter field. Results will be selected if any given value matches.
        """
        return pulumi.get(self, "values")

    @values.setter
    def values(self, value: Sequence[str]):
        pulumi.set(self, "values", value)


@pulumi.input_type
class GetRegionsFilterArgs:
    def __init__(__self__, *,
                 name: str,
                 values: Sequence[str]):
        """
        :param str name: Name of the filter field. Valid values can be found in the [describe-regions AWS CLI Reference][1].
        :param Sequence[str] values: Set of values that are accepted for the given filter field. Results will be selected if any given value matches.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Name of the filter field. Valid values can be found in the [describe-regions AWS CLI Reference][1].
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: str):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        Set of values that are accepted for the given filter field. Results will be selected if any given value matches.
        """
        return pulumi.get(self, "values")

    @values.setter
    def values(self, value: Sequence[str]):
        pulumi.set(self, "values", value)


