troposphere package

Subpackages

• troposphere.helpers package
  • Submodules
  • troposphere.helpers.userdata module
    • from_file()
    • from_file_sub()
  • Module contents
• troposphere.openstack package
  • Submodules
  • troposphere.openstack.heat module
    • Openstack Heat
    • AWSAutoScalingGroup
      • AWSAutoScalingGroup.props
      • AWSAutoScalingGroup.resource_type
  • troposphere.openstack.neutron module
    • AddressPair
      • AddressPair.props
    • Firewall
      • Firewall.props
      • Firewall.resource_type
    • FirewallPolicy
      • FirewallPolicy.props
      • FirewallPolicy.resource_type
    • FirewallRule
      • FirewallRule.props
      • FirewallRule.resource_type
      • FirewallRule.validate()
    • FixedIP
      • FixedIP.props
    • FloatingIP
      • FloatingIP.props
      • FloatingIP.resource_type
    • FloatingIPAssociation
      • FloatingIPAssociation.props
      • FloatingIPAssociation.resource_type
    • HealthMonitor
      • HealthMonitor.props
      • HealthMonitor.resource_type
      • HealthMonitor.validate()
    • LoadBalancer
      • LoadBalancer.props
      • LoadBalancer.resource_type
    • Net
      • Net.props
      • Net.resource_type
    • Pool
      • Pool.props
      • Pool.resource_type
      • Pool.validate()
    • PoolMember
      • PoolMember.props
      • PoolMember.resource_type
    • Port
      • Port.props
      • Port.resource_type
    • SecurityGroup
      • SecurityGroup.props
      • SecurityGroup.resource_type
    • SecurityGroupRule
      • SecurityGroupRule.props
      • SecurityGroupRule.validate()
    • SessionPersistence
      • SessionPersistence.props
      • SessionPersistence.validate()
    • VIP
      • VIP.props
  • troposphere.openstack.nova module
    • BlockDeviceMapping
      • BlockDeviceMapping.props
    • BlockDeviceMappingV2
      • BlockDeviceMappingV2.props
      • BlockDeviceMappingV2.validate()
    • FloatingIP
      • FloatingIP.props
      • FloatingIP.resource_type
    • FloatingIPAssociation
      • FloatingIPAssociation.props
      • FloatingIPAssociation.resource_type
    • KeyPair
      • KeyPair.props
      • KeyPair.resource_type
    • Network
      • Network.props
    • Server
      • Server.props
      • Server.resource_type
      • Server.validate()
  • Module contents
    • OpenStack

Submodules

troposphere.accessanalyzer module

class troposphere.accessanalyzer.AnalysisRule(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

AnalysisRule

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Exclusions': ([<class 'troposphere.accessanalyzer.AnalysisRuleCriteria'>], False)}

class troposphere.accessanalyzer.AnalysisRuleCriteria(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

AnalysisRuleCriteria

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AccountIds': ([<class 'str'>], False), 'ResourceTags': (<class 'dict'>, False)}

class troposphere.accessanalyzer.Analyzer(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Analyzer

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AnalyzerConfiguration': (<class 'troposphere.accessanalyzer.AnalyzerConfiguration'>, False), 'AnalyzerName': (<class 'str'>, False), 'ArchiveRules': ([<class 'troposphere.accessanalyzer.ArchiveRule'>], False), 'Tags': (<class 'troposphere.Tags'>, False), 'Type': (<class 'str'>, True)}

resource_type: str | None = 'AWS::AccessAnalyzer::Analyzer'

class troposphere.accessanalyzer.AnalyzerConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

AnalyzerConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'InternalAccessConfiguration': (<class 'troposphere.accessanalyzer.InternalAccessConfiguration'>, False), 'UnusedAccessConfiguration': (<class 'troposphere.accessanalyzer.UnusedAccessConfiguration'>, False)}

class troposphere.accessanalyzer.ArchiveRule(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ArchiveRule

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Filter': ([<class 'troposphere.accessanalyzer.Filter'>], True), 'RuleName': (<class 'str'>, True)}

class troposphere.accessanalyzer.Filter(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

Filter

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Contains': ([<class 'str'>], False), 'Eq': ([<class 'str'>], False), 'Exists': (<function boolean>, False), 'Neq': ([<class 'str'>], False), 'Property': (<class 'str'>, True)}

class troposphere.accessanalyzer.InternalAccessAnalysisRule(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

InternalAccessAnalysisRule

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Inclusions': ([<class 'troposphere.accessanalyzer.InternalAccessAnalysisRuleCriteria'>], False)}

class troposphere.accessanalyzer.InternalAccessAnalysisRuleCriteria(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

InternalAccessAnalysisRuleCriteria

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AccountIds': ([<class 'str'>], False), 'ResourceArns': ([<class 'str'>], False), 'ResourceTypes': ([<class 'str'>], False)}

class troposphere.accessanalyzer.InternalAccessConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

InternalAccessConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'InternalAccessAnalysisRule': (<class 'troposphere.accessanalyzer.InternalAccessAnalysisRule'>, False)}

class troposphere.accessanalyzer.UnusedAccessConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

UnusedAccessConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AnalysisRule': (<class 'troposphere.accessanalyzer.AnalysisRule'>, False), 'UnusedAccessAge': (<function integer>, False)}

troposphere.acmpca module

class troposphere.acmpca.AccessDescription(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

AccessDescription

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AccessLocation': (<class 'troposphere.acmpca.GeneralName'>, True), 'AccessMethod': (<class 'troposphere.acmpca.AccessMethod'>, True)}

class troposphere.acmpca.AccessMethod(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

AccessMethod

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AccessMethodType': (<class 'str'>, False), 'CustomObjectIdentifier': (<class 'str'>, False)}

class troposphere.acmpca.ApiPassthrough(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ApiPassthrough

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Extensions': (<class 'troposphere.acmpca.Extensions'>, False), 'Subject': (<class 'troposphere.acmpca.Subject'>, False)}

class troposphere.acmpca.Certificate(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Certificate

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApiPassthrough': (<class 'troposphere.acmpca.ApiPassthrough'>, False), 'CertificateAuthorityArn': (<class 'str'>, True), 'CertificateSigningRequest': (<class 'str'>, True), 'SigningAlgorithm': (<function validate_signing_algorithm>, True), 'TemplateArn': (<class 'str'>, False), 'Validity': (<class 'troposphere.acmpca.Validity'>, True), 'ValidityNotBefore': (<class 'troposphere.acmpca.Validity'>, False)}

resource_type: str | None = 'AWS::ACMPCA::Certificate'

class troposphere.acmpca.CertificateAuthority(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

CertificateAuthority

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CsrExtensions': (<class 'troposphere.acmpca.CsrExtensions'>, False), 'KeyAlgorithm': (<function validate_key_algorithm>, True), 'KeyStorageSecurityStandard': (<class 'str'>, False), 'RevocationConfiguration': (<class 'troposphere.acmpca.RevocationConfiguration'>, False), 'SigningAlgorithm': (<function validate_signing_algorithm>, True), 'Subject': (<class 'troposphere.acmpca.Subject'>, True), 'Tags': (<class 'troposphere.Tags'>, False), 'Type': (<function validate_certificateauthority_type>, True), 'UsageMode': (<class 'str'>, False)}

resource_type: str | None = 'AWS::ACMPCA::CertificateAuthority'

class troposphere.acmpca.CertificateAuthorityActivation(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

CertificateAuthorityActivation

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Certificate': (<class 'str'>, True), 'CertificateAuthorityArn': (<class 'str'>, True), 'CertificateChain': (<class 'str'>, False), 'Status': (<class 'str'>, False)}

resource_type: str | None = 'AWS::ACMPCA::CertificateAuthorityActivation'

class troposphere.acmpca.CrlConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

CrlConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CrlDistributionPointExtensionConfiguration': (<class 'troposphere.acmpca.CrlDistributionPointExtensionConfiguration'>, False), 'CrlType': (<class 'str'>, False), 'CustomCname': (<class 'str'>, False), 'CustomPath': (<class 'str'>, False), 'Enabled': (<function boolean>, True), 'ExpirationInDays': (<function integer>, False), 'S3BucketName': (<class 'str'>, False), 'S3ObjectAcl': (<class 'str'>, False)}

class troposphere.acmpca.CrlDistributionPointExtensionConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

CrlDistributionPointExtensionConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'OmitExtension': (<function boolean>, True)}

class troposphere.acmpca.CsrExtensions(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

CsrExtensions

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'KeyUsage': (<class 'troposphere.acmpca.KeyUsage'>, False), 'SubjectInformationAccess': ([<class 'troposphere.acmpca.AccessDescription'>], False)}

class troposphere.acmpca.CustomAttribute(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

CustomAttribute

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ObjectIdentifier': (<class 'str'>, True), 'Value': (<class 'str'>, True)}

class troposphere.acmpca.CustomExtension(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

CustomExtension

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Critical': (<function boolean>, False), 'ObjectIdentifier': (<class 'str'>, True), 'Value': (<class 'str'>, True)}

class troposphere.acmpca.EdiPartyName(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

EdiPartyName

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'NameAssigner': (<class 'str'>, False), 'PartyName': (<class 'str'>, True)}

class troposphere.acmpca.ExtendedKeyUsage(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ExtendedKeyUsage

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ExtendedKeyUsageObjectIdentifier': (<class 'str'>, False), 'ExtendedKeyUsageType': (<class 'str'>, False)}

class troposphere.acmpca.Extensions(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

Extensions

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CertificatePolicies': ([<class 'troposphere.acmpca.PolicyInformation'>], False), 'CustomExtensions': ([<class 'troposphere.acmpca.CustomExtension'>], False), 'ExtendedKeyUsage': ([<class 'troposphere.acmpca.ExtendedKeyUsage'>], False), 'KeyUsage': (<class 'troposphere.acmpca.KeyUsage'>, False), 'SubjectAlternativeNames': ([<class 'troposphere.acmpca.GeneralName'>], False)}

class troposphere.acmpca.GeneralName(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

GeneralName

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'DirectoryName': (<class 'troposphere.acmpca.Subject'>, False), 'DnsName': (<class 'str'>, False), 'EdiPartyName': (<class 'troposphere.acmpca.EdiPartyName'>, False), 'IpAddress': (<class 'str'>, False), 'OtherName': (<class 'troposphere.acmpca.OtherName'>, False), 'RegisteredId': (<class 'str'>, False), 'Rfc822Name': (<class 'str'>, False), 'UniformResourceIdentifier': (<class 'str'>, False)}

class troposphere.acmpca.KeyUsage(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

KeyUsage

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CRLSign': (<function boolean>, False), 'DataEncipherment': (<function boolean>, False), 'DecipherOnly': (<function boolean>, False), 'DigitalSignature': (<function boolean>, False), 'EncipherOnly': (<function boolean>, False), 'KeyAgreement': (<function boolean>, False), 'KeyCertSign': (<function boolean>, False), 'KeyEncipherment': (<function boolean>, False), 'NonRepudiation': (<function boolean>, False)}

class troposphere.acmpca.OcspConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

OcspConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Enabled': (<function boolean>, True), 'OcspCustomCname': (<class 'str'>, False)}

class troposphere.acmpca.OtherName(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

OtherName

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'TypeId': (<class 'str'>, True), 'Value': (<class 'str'>, True)}

class troposphere.acmpca.Permission(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Permission

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Actions': ([<class 'str'>], True), 'CertificateAuthorityArn': (<class 'str'>, True), 'Principal': (<class 'str'>, True), 'SourceAccount': (<class 'str'>, False)}

resource_type: str | None = 'AWS::ACMPCA::Permission'

class troposphere.acmpca.PolicyInformation(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

PolicyInformation

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CertPolicyId': (<class 'str'>, True), 'PolicyQualifiers': ([<class 'troposphere.acmpca.PolicyQualifierInfo'>], False)}

class troposphere.acmpca.PolicyQualifierInfo(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

PolicyQualifierInfo

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'PolicyQualifierId': (<class 'str'>, True), 'Qualifier': (<class 'troposphere.acmpca.Qualifier'>, True)}

class troposphere.acmpca.Qualifier(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

Qualifier

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CpsUri': (<class 'str'>, True)}

class troposphere.acmpca.RevocationConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

RevocationConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CrlConfiguration': (<class 'troposphere.acmpca.CrlConfiguration'>, False), 'OcspConfiguration': (<class 'troposphere.acmpca.OcspConfiguration'>, False)}

class troposphere.acmpca.Subject(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

Subject

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CommonName': (<class 'str'>, False), 'Country': (<class 'str'>, False), 'CustomAttributes': ([<class 'troposphere.acmpca.CustomAttribute'>], False), 'DistinguishedNameQualifier': (<class 'str'>, False), 'GenerationQualifier': (<class 'str'>, False), 'GivenName': (<class 'str'>, False), 'Initials': (<class 'str'>, False), 'Locality': (<class 'str'>, False), 'Organization': (<class 'str'>, False), 'OrganizationalUnit': (<class 'str'>, False), 'Pseudonym': (<class 'str'>, False), 'SerialNumber': (<class 'str'>, False), 'State': (<class 'str'>, False), 'Surname': (<class 'str'>, False), 'Title': (<class 'str'>, False)}

class troposphere.acmpca.Validity(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

Validity

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Type': (<function validate_validity_type>, True), 'Value': (<function double>, True)}

troposphere.amazonmq module

class troposphere.amazonmq.Broker(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Broker

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AuthenticationStrategy': (<class 'str'>, False), 'AutoMinorVersionUpgrade': (<function boolean>, False), 'BrokerName': (<class 'str'>, True), 'Configuration': (<class 'troposphere.amazonmq.ConfigurationId'>, False), 'DataReplicationMode': (<class 'str'>, False), 'DataReplicationPrimaryBrokerArn': (<class 'str'>, False), 'DeploymentMode': (<class 'str'>, True), 'EncryptionOptions': (<class 'troposphere.amazonmq.EncryptionOptions'>, False), 'EngineType': (<class 'str'>, True), 'EngineVersion': (<class 'str'>, False), 'HostInstanceType': (<class 'str'>, True), 'LdapServerMetadata': (<class 'troposphere.amazonmq.LdapServerMetadata'>, False), 'Logs': (<class 'troposphere.amazonmq.LogsConfiguration'>, False), 'MaintenanceWindowStartTime': (<class 'troposphere.amazonmq.MaintenanceWindow'>, False), 'PubliclyAccessible': (<function boolean>, True), 'ResourceShareArns': ([<class 'str'>], False), 'SecurityGroups': ([<class 'str'>], False), 'StorageType': (<class 'str'>, False), 'SubnetIds': ([<class 'str'>], False), 'Tags': (<function validate_tags_or_list>, False), 'Users': ([<class 'troposphere.amazonmq.User'>], False)}

resource_type: str | None = 'AWS::AmazonMQ::Broker'

class troposphere.amazonmq.Configuration(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Configuration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AuthenticationStrategy': (<class 'str'>, False), 'Data': (<class 'str'>, False), 'Description': (<class 'str'>, False), 'EngineType': (<class 'str'>, True), 'EngineVersion': (<class 'str'>, False), 'Name': (<class 'str'>, True), 'Tags': (<class 'troposphere.Tags'>, False)}

resource_type: str | None = 'AWS::AmazonMQ::Configuration'

class troposphere.amazonmq.ConfigurationAssociation(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

ConfigurationAssociation

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Broker': (<class 'str'>, True), 'Configuration': (<class 'troposphere.amazonmq.ConfigurationId'>, True)}

resource_type: str | None = 'AWS::AmazonMQ::ConfigurationAssociation'

class troposphere.amazonmq.ConfigurationId(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ConfigurationId

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Id': (<class 'str'>, True), 'Revision': (<function integer>, True)}

class troposphere.amazonmq.EncryptionOptions(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

EncryptionOptions

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'KmsKeyId': (<class 'str'>, False), 'UseAwsOwnedKey': (<function boolean>, True)}

class troposphere.amazonmq.LdapServerMetadata(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

LdapServerMetadata

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Hosts': ([<class 'str'>], True), 'RoleBase': (<class 'str'>, True), 'RoleName': (<class 'str'>, False), 'RoleSearchMatching': (<class 'str'>, True), 'RoleSearchSubtree': (<function boolean>, False), 'ServiceAccountPassword': (<class 'str'>, False), 'ServiceAccountUsername': (<class 'str'>, True), 'UserBase': (<class 'str'>, True), 'UserRoleName': (<class 'str'>, False), 'UserSearchMatching': (<class 'str'>, True), 'UserSearchSubtree': (<function boolean>, False)}

class troposphere.amazonmq.LogsConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

LogsConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Audit': (<function boolean>, False), 'General': (<function boolean>, False)}

class troposphere.amazonmq.MaintenanceWindow(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

MaintenanceWindow

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'DayOfWeek': (<class 'str'>, True), 'TimeOfDay': (<class 'str'>, True), 'TimeZone': (<class 'str'>, True)}

class troposphere.amazonmq.User(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

User

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ConsoleAccess': (<function boolean>, False), 'Groups': ([<class 'str'>], False), 'Password': (<class 'str'>, True), 'ReplicationUser': (<function boolean>, False), 'Username': (<class 'str'>, True)}

troposphere.amplify module

class troposphere.amplify.App(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

App

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AccessToken': (<class 'str'>, False), 'AutoBranchCreationConfig': (<class 'troposphere.amplify.AutoBranchCreationConfig'>, False), 'BasicAuthConfig': (<class 'troposphere.amplify.BasicAuthConfig'>, False), 'BuildSpec': (<class 'str'>, False), 'CacheConfig': (<class 'troposphere.amplify.CacheConfig'>, False), 'ComputeRoleArn': (<class 'str'>, False), 'CustomHeaders': (<class 'str'>, False), 'CustomRules': ([<class 'troposphere.amplify.CustomRule'>], False), 'Description': (<class 'str'>, False), 'EnableBranchAutoDeletion': (<function boolean>, False), 'EnvironmentVariables': ([<class 'troposphere.amplify.EnvironmentVariable'>], False), 'IAMServiceRole': (<class 'str'>, False), 'JobConfig': (<class 'troposphere.amplify.JobConfig'>, False), 'Name': (<class 'str'>, True), 'OauthToken': (<class 'str'>, False), 'Platform': (<class 'str'>, False), 'Repository': (<class 'str'>, False), 'Tags': (<class 'troposphere.Tags'>, False)}

resource_type: str | None = 'AWS::Amplify::App'

class troposphere.amplify.AutoBranchCreationConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

AutoBranchCreationConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AutoBranchCreationPatterns': ([<class 'str'>], False), 'BasicAuthConfig': (<class 'troposphere.amplify.BasicAuthConfig'>, False), 'BuildSpec': (<class 'str'>, False), 'EnableAutoBranchCreation': (<function boolean>, False), 'EnableAutoBuild': (<function boolean>, False), 'EnablePerformanceMode': (<function boolean>, False), 'EnablePullRequestPreview': (<function boolean>, False), 'EnvironmentVariables': ([<class 'troposphere.amplify.EnvironmentVariable'>], False), 'Framework': (<class 'str'>, False), 'PullRequestEnvironmentName': (<class 'str'>, False), 'Stage': (<class 'str'>, False)}

class troposphere.amplify.Backend(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

Backend

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'StackArn': (<class 'str'>, False)}

class troposphere.amplify.BasicAuthConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

BasicAuthConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'EnableBasicAuth': (<function boolean>, False), 'Password': (<class 'str'>, True), 'Username': (<class 'str'>, True)}

class troposphere.amplify.Branch(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Branch

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AppId': (<class 'str'>, True), 'Backend': (<class 'troposphere.amplify.Backend'>, False), 'BasicAuthConfig': (<class 'troposphere.amplify.BasicAuthConfig'>, False), 'BranchName': (<class 'str'>, True), 'BuildSpec': (<class 'str'>, False), 'ComputeRoleArn': (<class 'str'>, False), 'Description': (<class 'str'>, False), 'EnableAutoBuild': (<function boolean>, False), 'EnablePerformanceMode': (<function boolean>, False), 'EnablePullRequestPreview': (<function boolean>, False), 'EnableSkewProtection': (<function boolean>, False), 'EnvironmentVariables': ([<class 'troposphere.amplify.EnvironmentVariable'>], False), 'Framework': (<class 'str'>, False), 'PullRequestEnvironmentName': (<class 'str'>, False), 'Stage': (<class 'str'>, False), 'Tags': (<class 'troposphere.Tags'>, False)}

resource_type: str | None = 'AWS::Amplify::Branch'

class troposphere.amplify.CacheConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

CacheConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Type': (<class 'str'>, False)}

class troposphere.amplify.Certificate(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

Certificate

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CertificateArn': (<class 'str'>, False), 'CertificateType': (<class 'str'>, False), 'CertificateVerificationDNSRecord': (<class 'str'>, False)}

class troposphere.amplify.CertificateSettings(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

CertificateSettings

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CertificateType': (<class 'str'>, False), 'CustomCertificateArn': (<class 'str'>, False)}

class troposphere.amplify.CustomRule(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

CustomRule

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Condition': (<class 'str'>, False), 'Source': (<class 'str'>, True), 'Status': (<class 'str'>, False), 'Target': (<class 'str'>, True)}

class troposphere.amplify.Domain(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Domain

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AppId': (<class 'str'>, True), 'AutoSubDomainCreationPatterns': ([<class 'str'>], False), 'AutoSubDomainIAMRole': (<class 'str'>, False), 'CertificateSettings': (<class 'troposphere.amplify.CertificateSettings'>, False), 'DomainName': (<class 'str'>, True), 'EnableAutoSubDomain': (<function boolean>, False), 'SubDomainSettings': ([<class 'troposphere.amplify.SubDomainSetting'>], True)}

resource_type: str | None = 'AWS::Amplify::Domain'

class troposphere.amplify.EnvironmentVariable(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

EnvironmentVariable

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Name': (<class 'str'>, True), 'Value': (<class 'str'>, True)}

class troposphere.amplify.JobConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

JobConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'BuildComputeType': (<class 'str'>, True)}

class troposphere.amplify.SubDomainSetting(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

SubDomainSetting

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'BranchName': (<class 'str'>, True), 'Prefix': (<class 'str'>, True)}

troposphere.analytics module

class troposphere.analytics.Application(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Application

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApplicationCode': (<class 'str'>, False), 'ApplicationDescription': (<class 'str'>, False), 'ApplicationName': (<class 'str'>, False), 'Inputs': ([<class 'troposphere.analytics.Input'>], True)}

resource_type: str | None = 'AWS::KinesisAnalytics::Application'

class troposphere.analytics.ApplicationOutput(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

ApplicationOutput

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApplicationName': (<class 'str'>, True), 'Output': (<class 'troposphere.analytics.Output'>, True)}

resource_type: str | None = 'AWS::KinesisAnalytics::ApplicationOutput'

class troposphere.analytics.ApplicationReferenceDataSource(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

ApplicationReferenceDataSource

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApplicationName': (<class 'str'>, True), 'ReferenceDataSource': (<class 'troposphere.analytics.ReferenceDataSource'>, True)}

resource_type: str | None = 'AWS::KinesisAnalytics::ApplicationReferenceDataSource'

class troposphere.analytics.CSVMappingParameters(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

CSVMappingParameters

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'RecordColumnDelimiter': (<class 'str'>, True), 'RecordRowDelimiter': (<class 'str'>, True)}

class troposphere.analytics.DestinationSchema(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

DestinationSchema

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'RecordFormatType': (<class 'str'>, False)}

class troposphere.analytics.Input(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

Input

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'InputParallelism': (<class 'troposphere.analytics.InputParallelism'>, False), 'InputProcessingConfiguration': (<class 'troposphere.analytics.InputProcessingConfiguration'>, False), 'InputSchema': (<class 'troposphere.analytics.InputSchema'>, True), 'KinesisFirehoseInput': (<class 'troposphere.analytics.KinesisFirehoseInput'>, False), 'KinesisStreamsInput': (<class 'troposphere.analytics.KinesisStreamsInput'>, False), 'NamePrefix': (<class 'str'>, True)}

class troposphere.analytics.InputLambdaProcessor(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

InputLambdaProcessor

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ResourceARN': (<class 'str'>, True), 'RoleARN': (<class 'str'>, True)}

class troposphere.analytics.InputParallelism(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

InputParallelism

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Count': (<function integer>, False)}

class troposphere.analytics.InputProcessingConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

InputProcessingConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'InputLambdaProcessor': (<class 'troposphere.analytics.InputLambdaProcessor'>, False)}

class troposphere.analytics.InputSchema(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

InputSchema

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'RecordColumns': ([<class 'troposphere.analytics.RecordColumn'>], True), 'RecordEncoding': (<class 'str'>, False), 'RecordFormat': (<class 'troposphere.analytics.RecordFormat'>, True)}

class troposphere.analytics.JSONMappingParameters(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

JSONMappingParameters

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'RecordRowPath': (<class 'str'>, True)}

class troposphere.analytics.KinesisFirehoseInput(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

KinesisFirehoseInput

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ResourceARN': (<class 'str'>, True), 'RoleARN': (<class 'str'>, True)}

class troposphere.analytics.KinesisFirehoseOutput(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

KinesisFirehoseOutput

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ResourceARN': (<class 'str'>, True), 'RoleARN': (<class 'str'>, True)}

class troposphere.analytics.KinesisStreamsInput(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

KinesisStreamsInput

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ResourceARN': (<class 'str'>, True), 'RoleARN': (<class 'str'>, True)}

class troposphere.analytics.KinesisStreamsOutput(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

KinesisStreamsOutput

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ResourceARN': (<class 'str'>, True), 'RoleARN': (<class 'str'>, True)}

class troposphere.analytics.LambdaOutput(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

LambdaOutput

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ResourceARN': (<class 'str'>, True), 'RoleARN': (<class 'str'>, True)}

class troposphere.analytics.MappingParameters(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

MappingParameters

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CSVMappingParameters': (<class 'troposphere.analytics.CSVMappingParameters'>, False), 'JSONMappingParameters': (<class 'troposphere.analytics.JSONMappingParameters'>, False)}

class troposphere.analytics.Output(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

Output

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'DestinationSchema': (<class 'troposphere.analytics.DestinationSchema'>, True), 'KinesisFirehoseOutput': (<class 'troposphere.analytics.KinesisFirehoseOutput'>, False), 'KinesisStreamsOutput': (<class 'troposphere.analytics.KinesisStreamsOutput'>, False), 'LambdaOutput': (<class 'troposphere.analytics.LambdaOutput'>, False), 'Name': (<class 'str'>, False)}

class troposphere.analytics.RecordColumn(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

RecordColumn

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Mapping': (<class 'str'>, False), 'Name': (<class 'str'>, True), 'SqlType': (<class 'str'>, True)}

class troposphere.analytics.RecordFormat(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

RecordFormat

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'MappingParameters': (<class 'troposphere.analytics.MappingParameters'>, False), 'RecordFormatType': (<class 'str'>, True)}

class troposphere.analytics.ReferenceDataSource(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ReferenceDataSource

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ReferenceSchema': (<class 'troposphere.analytics.ReferenceSchema'>, True), 'S3ReferenceDataSource': (<class 'troposphere.analytics.S3ReferenceDataSource'>, False), 'TableName': (<class 'str'>, False)}

class troposphere.analytics.ReferenceSchema(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ReferenceSchema

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'RecordColumns': ([<class 'troposphere.analytics.RecordColumn'>], True), 'RecordEncoding': (<class 'str'>, False), 'RecordFormat': (<class 'troposphere.analytics.RecordFormat'>, True)}

class troposphere.analytics.S3ReferenceDataSource(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

S3ReferenceDataSource

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'BucketARN': (<class 'str'>, True), 'FileKey': (<class 'str'>, True), 'ReferenceRoleARN': (<class 'str'>, True)}

troposphere.apigateway module

class troposphere.apigateway.AccessLogSetting(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

AccessLogSetting

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'DestinationArn': (<class 'str'>, False), 'Format': (<class 'str'>, False)}

class troposphere.apigateway.Account(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Account

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CloudWatchRoleArn': (<class 'str'>, False)}

resource_type: str | None = 'AWS::ApiGateway::Account'

class troposphere.apigateway.ApiKey(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

ApiKey

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CustomerId': (<class 'str'>, False), 'Description': (<class 'str'>, False), 'Enabled': (<function boolean>, False), 'GenerateDistinctId': (<function boolean>, False), 'Name': (<class 'str'>, False), 'StageKeys': ([<class 'troposphere.apigateway.StageKey'>], False), 'Tags': (<class 'troposphere.Tags'>, False), 'Value': (<class 'str'>, False)}

resource_type: str | None = 'AWS::ApiGateway::ApiKey'

class troposphere.apigateway.ApiStage(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ApiStage

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApiId': (<class 'str'>, False), 'Stage': (<class 'str'>, False), 'Throttle': (<class 'dict'>, False)}

class troposphere.apigateway.Authorizer(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Authorizer

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AuthType': (<class 'str'>, False), 'AuthorizerCredentials': (<class 'str'>, False), 'AuthorizerResultTtlInSeconds': (<function validate_authorizer_ttl>, False), 'AuthorizerUri': (<class 'str'>, False), 'IdentitySource': (<class 'str'>, False), 'IdentityValidationExpression': (<class 'str'>, False), 'Name': (<class 'str'>, True), 'ProviderARNs': ([<class 'str'>], False), 'RestApiId': (<class 'str'>, True), 'Type': (<class 'str'>, True)}

resource_type: str | None = 'AWS::ApiGateway::Authorizer'

class troposphere.apigateway.BasePathMapping(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

BasePathMapping

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'BasePath': (<class 'str'>, False), 'DomainName': (<class 'str'>, True), 'Id': (<class 'str'>, False), 'RestApiId': (<class 'str'>, False), 'Stage': (<class 'str'>, False)}

resource_type: str | None = 'AWS::ApiGateway::BasePathMapping'

class troposphere.apigateway.BasePathMappingV2(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

BasePathMappingV2

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'BasePath': (<class 'str'>, False), 'DomainNameArn': (<class 'str'>, True), 'RestApiId': (<class 'str'>, True), 'Stage': (<class 'str'>, False)}

resource_type: str | None = 'AWS::ApiGateway::BasePathMappingV2'

class troposphere.apigateway.CanarySetting(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

CanarySetting

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'PercentTraffic': (<function double>, False), 'StageVariableOverrides': (<class 'dict'>, False), 'UseStageCache': (<function boolean>, False)}

class troposphere.apigateway.ClientCertificate(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

ClientCertificate

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Description': (<class 'str'>, False), 'Tags': (<class 'troposphere.Tags'>, False)}

resource_type: str | None = 'AWS::ApiGateway::ClientCertificate'

class troposphere.apigateway.Deployment(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Deployment

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'DeploymentCanarySettings': (<class 'troposphere.apigateway.DeploymentCanarySettings'>, False), 'Description': (<class 'str'>, False), 'RestApiId': (<class 'str'>, True), 'StageDescription': (<class 'troposphere.apigateway.StageDescription'>, False), 'StageName': (<class 'str'>, False)}

resource_type: str | None = 'AWS::ApiGateway::Deployment'

class troposphere.apigateway.DeploymentCanarySettings(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

DeploymentCanarySettings

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'PercentTraffic': (<function double>, False), 'StageVariableOverrides': (<class 'dict'>, False), 'UseStageCache': (<function boolean>, False)}

class troposphere.apigateway.DocumentationPart(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

DocumentationPart

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Location': (<class 'troposphere.apigateway.Location'>, True), 'Properties': (<class 'str'>, True), 'RestApiId': (<class 'str'>, True)}

resource_type: str | None = 'AWS::ApiGateway::DocumentationPart'

class troposphere.apigateway.DocumentationVersion(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

DocumentationVersion

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Description': (<class 'str'>, False), 'DocumentationVersion': (<class 'str'>, True), 'RestApiId': (<class 'str'>, True)}

resource_type: str | None = 'AWS::ApiGateway::DocumentationVersion'

class troposphere.apigateway.DomainName(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

DomainName

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CertificateArn': (<class 'str'>, False), 'DomainName': (<class 'str'>, False), 'EndpointAccessMode': (<class 'str'>, False), 'EndpointConfiguration': (<class 'troposphere.apigateway.EndpointConfiguration'>, False), 'MutualTlsAuthentication': (<class 'troposphere.apigateway.MutualTlsAuthentication'>, False), 'OwnershipVerificationCertificateArn': (<class 'str'>, False), 'RegionalCertificateArn': (<class 'str'>, False), 'RoutingMode': (<class 'str'>, False), 'SecurityPolicy': (<class 'str'>, False), 'Tags': (<class 'troposphere.Tags'>, False)}

resource_type: str | None = 'AWS::ApiGateway::DomainName'

class troposphere.apigateway.DomainNameAccessAssociation(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

DomainNameAccessAssociation

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AccessAssociationSource': (<class 'str'>, True), 'AccessAssociationSourceType': (<class 'str'>, True), 'DomainNameArn': (<class 'str'>, True), 'Tags': (<class 'troposphere.Tags'>, False)}

resource_type: str | None = 'AWS::ApiGateway::DomainNameAccessAssociation'

class troposphere.apigateway.DomainNameV2(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

DomainNameV2

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CertificateArn': (<class 'str'>, False), 'DomainName': (<class 'str'>, False), 'EndpointAccessMode': (<class 'str'>, False), 'EndpointConfiguration': (<class 'troposphere.apigateway.EndpointConfiguration'>, False), 'Policy': (<class 'dict'>, False), 'RoutingMode': (<class 'str'>, False), 'SecurityPolicy': (<class 'str'>, False), 'Tags': (<class 'troposphere.Tags'>, False)}

resource_type: str | None = 'AWS::ApiGateway::DomainNameV2'

class troposphere.apigateway.EndpointConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

EndpointConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'IpAddressType': (<class 'str'>, False), 'Types': ([<class 'str'>], False), 'VpcEndpointIds': ([<class 'str'>], False)}

class troposphere.apigateway.GatewayResponse(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

GatewayResponse

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ResponseParameters': (<class 'dict'>, False), 'ResponseTemplates': (<class 'dict'>, False), 'ResponseType': (<function validate_gateway_response_type>, True), 'RestApiId': (<class 'str'>, True), 'StatusCode': (<class 'str'>, False)}

resource_type: str | None = 'AWS::ApiGateway::GatewayResponse'

class troposphere.apigateway.Integration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

Integration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CacheKeyParameters': ([<class 'str'>], False), 'CacheNamespace': (<class 'str'>, False), 'ConnectionId': (<class 'str'>, False), 'ConnectionType': (<class 'str'>, False), 'ContentHandling': (<class 'str'>, False), 'Credentials': (<class 'str'>, False), 'IntegrationHttpMethod': (<class 'str'>, False), 'IntegrationResponses': ([<class 'troposphere.apigateway.IntegrationResponse'>], False), 'IntegrationTarget': (<class 'str'>, False), 'PassthroughBehavior': (<class 'str'>, False), 'RequestParameters': (<class 'dict'>, False), 'RequestTemplates': (<class 'dict'>, False), 'ResponseTransferMode': (<class 'str'>, False), 'TimeoutInMillis': (<function validate_timeout_in_millis>, False), 'Type': (<class 'str'>, True), 'Uri': (<class 'str'>, False)}

class troposphere.apigateway.IntegrationResponse(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

IntegrationResponse

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ContentHandling': (<class 'str'>, False), 'ResponseParameters': (<class 'dict'>, False), 'ResponseTemplates': (<class 'dict'>, False), 'SelectionPattern': (<class 'str'>, False), 'StatusCode': (<class 'str'>, True)}

class troposphere.apigateway.Location(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

Location

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Method': (<class 'str'>, False), 'Name': (<class 'str'>, False), 'Path': (<class 'str'>, False), 'StatusCode': (<class 'str'>, False), 'Type': (<class 'str'>, False)}

class troposphere.apigateway.Method(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Method

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApiKeyRequired': (<function boolean>, False), 'AuthorizationScopes': ([<class 'str'>], False), 'AuthorizationType': (<class 'str'>, False), 'AuthorizerId': (<class 'str'>, False), 'HttpMethod': (<class 'str'>, True), 'Integration': (<class 'troposphere.apigateway.Integration'>, False), 'MethodResponses': ([<class 'troposphere.apigateway.MethodResponse'>], False), 'OperationName': (<class 'str'>, False), 'RequestModels': (<class 'dict'>, False), 'RequestParameters': (<class 'dict'>, False), 'RequestValidatorId': (<class 'str'>, False), 'ResourceId': (<class 'str'>, True), 'RestApiId': (<class 'str'>, True)}

resource_type: str | None = 'AWS::ApiGateway::Method'

class troposphere.apigateway.MethodResponse(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

MethodResponse

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ResponseModels': (<class 'dict'>, False), 'ResponseParameters': (<class 'dict'>, False), 'StatusCode': (<class 'str'>, True)}

class troposphere.apigateway.MethodSetting(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

MethodSetting

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CacheDataEncrypted': (<function boolean>, False), 'CacheTtlInSeconds': (<function integer>, False), 'CachingEnabled': (<function boolean>, False), 'DataTraceEnabled': (<function boolean>, False), 'HttpMethod': (<class 'str'>, False), 'LoggingLevel': (<class 'str'>, False), 'MetricsEnabled': (<function boolean>, False), 'ResourcePath': (<class 'str'>, False), 'ThrottlingBurstLimit': (<function integer>, False), 'ThrottlingRateLimit': (<function double>, False)}

class troposphere.apigateway.Model(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Model

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ContentType': (<class 'str'>, False), 'Description': (<class 'str'>, False), 'Name': (<class 'str'>, False), 'RestApiId': (<class 'str'>, True), 'Schema': (<function dict_or_string>, False)}

resource_type: str | None = 'AWS::ApiGateway::Model'

validate()

class troposphere.apigateway.MutualTlsAuthentication(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

MutualTlsAuthentication

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'TruststoreUri': (<class 'str'>, False), 'TruststoreVersion': (<class 'str'>, False)}

class troposphere.apigateway.QuotaSettings(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

QuotaSettings

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Limit': (<function integer>, False), 'Offset': (<function integer>, False), 'Period': (<class 'str'>, False)}

class troposphere.apigateway.RequestValidator(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

RequestValidator

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Name': (<class 'str'>, False), 'RestApiId': (<class 'str'>, True), 'ValidateRequestBody': (<function boolean>, False), 'ValidateRequestParameters': (<function boolean>, False)}

resource_type: str | None = 'AWS::ApiGateway::RequestValidator'

class troposphere.apigateway.Resource(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Resource

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ParentId': (<class 'str'>, True), 'PathPart': (<class 'str'>, True), 'RestApiId': (<class 'str'>, True)}

resource_type: str | None = 'AWS::ApiGateway::Resource'

class troposphere.apigateway.RestApi(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

RestApi

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApiKeySourceType': (<class 'str'>, False), 'BinaryMediaTypes': ([<class 'str'>], False), 'Body': (<class 'dict'>, False), 'BodyS3Location': (<class 'troposphere.apigateway.S3Location'>, False), 'CloneFrom': (<class 'str'>, False), 'Description': (<class 'str'>, False), 'DisableExecuteApiEndpoint': (<function boolean>, False), 'EndpointAccessMode': (<class 'str'>, False), 'EndpointConfiguration': (<class 'troposphere.apigateway.EndpointConfiguration'>, False), 'FailOnWarnings': (<function boolean>, False), 'MinimumCompressionSize': (<function integer>, False), 'Mode': (<class 'str'>, False), 'Name': (<class 'str'>, False), 'Parameters': (<class 'dict'>, False), 'Policy': (<class 'dict'>, False), 'SecurityPolicy': (<class 'str'>, False), 'Tags': (<class 'troposphere.Tags'>, False)}

resource_type: str | None = 'AWS::ApiGateway::RestApi'

class troposphere.apigateway.S3Location(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

S3Location

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Bucket': (<class 'str'>, False), 'ETag': (<class 'str'>, False), 'Key': (<class 'str'>, False), 'Version': (<class 'str'>, False)}

class troposphere.apigateway.Stage(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Stage

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AccessLogSetting': (<class 'troposphere.apigateway.AccessLogSetting'>, False), 'CacheClusterEnabled': (<function boolean>, False), 'CacheClusterSize': (<class 'str'>, False), 'CanarySetting': (<class 'troposphere.apigateway.StageCanarySetting'>, False), 'ClientCertificateId': (<class 'str'>, False), 'DeploymentId': (<class 'str'>, False), 'Description': (<class 'str'>, False), 'DocumentationVersion': (<class 'str'>, False), 'MethodSettings': ([<class 'troposphere.apigateway.MethodSetting'>], False), 'RestApiId': (<class 'str'>, True), 'StageName': (<class 'str'>, False), 'Tags': (<function validate_tags_or_list>, False), 'TracingEnabled': (<function boolean>, False), 'Variables': (<class 'dict'>, False)}

resource_type: str | None = 'AWS::ApiGateway::Stage'

class troposphere.apigateway.StageCanarySetting(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

StageCanarySetting

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'DeploymentId': (<class 'str'>, False), 'PercentTraffic': (<function double>, False), 'StageVariableOverrides': (<class 'dict'>, False), 'UseStageCache': (<function boolean>, False)}

class troposphere.apigateway.StageDescription(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

StageDescription

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AccessLogSetting': (<class 'troposphere.apigateway.AccessLogSetting'>, False), 'CacheClusterEnabled': (<function boolean>, False), 'CacheClusterSize': (<class 'str'>, False), 'CacheDataEncrypted': (<function boolean>, False), 'CacheTtlInSeconds': (<function integer>, False), 'CachingEnabled': (<function boolean>, False), 'CanarySetting': (<class 'troposphere.apigateway.DeploymentCanarySettings'>, False), 'ClientCertificateId': (<class 'str'>, False), 'DataTraceEnabled': (<function boolean>, False), 'Description': (<class 'str'>, False), 'DocumentationVersion': (<class 'str'>, False), 'LoggingLevel': (<class 'str'>, False), 'MethodSettings': ([<class 'troposphere.apigateway.MethodSetting'>], False), 'MetricsEnabled': (<function boolean>, False), 'Tags': (<function validate_tags_or_list>, False), 'ThrottlingBurstLimit': (<function integer>, False), 'ThrottlingRateLimit': (<function double>, False), 'TracingEnabled': (<function boolean>, False), 'Variables': (<class 'dict'>, False)}

class troposphere.apigateway.StageKey(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

StageKey

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'RestApiId': (<class 'str'>, False), 'StageName': (<class 'str'>, False)}

class troposphere.apigateway.ThrottleSettings(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ThrottleSettings

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'BurstLimit': (<function integer>, False), 'RateLimit': (<function double>, False)}

class troposphere.apigateway.UsagePlan(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

UsagePlan

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApiStages': ([<class 'troposphere.apigateway.ApiStage'>], False), 'Description': (<class 'str'>, False), 'Quota': (<class 'troposphere.apigateway.QuotaSettings'>, False), 'Tags': (<class 'troposphere.Tags'>, False), 'Throttle': (<class 'troposphere.apigateway.ThrottleSettings'>, False), 'UsagePlanName': (<class 'str'>, False)}

resource_type: str | None = 'AWS::ApiGateway::UsagePlan'

class troposphere.apigateway.UsagePlanKey(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

UsagePlanKey

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'KeyId': (<class 'str'>, True), 'KeyType': (<class 'str'>, True), 'UsagePlanId': (<class 'str'>, True)}

resource_type: str | None = 'AWS::ApiGateway::UsagePlanKey'

class troposphere.apigateway.VpcLink(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

VpcLink

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Description': (<class 'str'>, False), 'Name': (<class 'str'>, True), 'Tags': (<class 'troposphere.Tags'>, False), 'TargetArns': ([<class 'str'>], True)}

resource_type: str | None = 'AWS::ApiGateway::VpcLink'

troposphere.apigatewayv2 module

class troposphere.apigatewayv2.AccessLogSettings(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

AccessLogSettings

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'DestinationArn': (<class 'str'>, False), 'Format': (<class 'str'>, False)}

class troposphere.apigatewayv2.Action(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

Action

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'InvokeApi': (<class 'troposphere.apigatewayv2.ActionInvokeApi'>, True)}

class troposphere.apigatewayv2.ActionInvokeApi(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ActionInvokeApi

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApiId': (<class 'str'>, True), 'Stage': (<class 'str'>, True), 'StripBasePath': (<function boolean>, False)}

class troposphere.apigatewayv2.Api(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Api

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApiKeySelectionExpression': (<class 'str'>, False), 'BasePath': (<class 'str'>, False), 'Body': (<class 'dict'>, False), 'BodyS3Location': (<class 'troposphere.apigatewayv2.BodyS3Location'>, False), 'CorsConfiguration': (<class 'troposphere.apigatewayv2.Cors'>, False), 'CredentialsArn': (<class 'str'>, False), 'Description': (<class 'str'>, False), 'DisableExecuteApiEndpoint': (<function boolean>, False), 'DisableSchemaValidation': (<function boolean>, False), 'FailOnWarnings': (<function boolean>, False), 'IpAddressType': (<class 'str'>, False), 'Name': (<class 'str'>, False), 'ProtocolType': (<class 'str'>, False), 'RouteKey': (<class 'str'>, False), 'RouteSelectionExpression': (<class 'str'>, False), 'Tags': (<class 'dict'>, False), 'Target': (<class 'str'>, False), 'Version': (<class 'str'>, False)}

resource_type: str | None = 'AWS::ApiGatewayV2::Api'

class troposphere.apigatewayv2.ApiGatewayManagedOverrides(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

ApiGatewayManagedOverrides

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApiId': (<class 'str'>, True), 'Integration': (<class 'troposphere.apigatewayv2.IntegrationOverrides'>, False), 'Route': (<class 'troposphere.apigatewayv2.RouteOverrides'>, False), 'Stage': (<class 'troposphere.apigatewayv2.StageOverrides'>, False)}

resource_type: str | None = 'AWS::ApiGatewayV2::ApiGatewayManagedOverrides'

class troposphere.apigatewayv2.ApiMapping(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

ApiMapping

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApiId': (<class 'str'>, True), 'ApiMappingKey': (<class 'str'>, False), 'DomainName': (<class 'str'>, True), 'Stage': (<class 'str'>, True)}

resource_type: str | None = 'AWS::ApiGatewayV2::ApiMapping'

class troposphere.apigatewayv2.Authorizer(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Authorizer

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApiId': (<class 'str'>, True), 'AuthorizerCredentialsArn': (<class 'str'>, False), 'AuthorizerPayloadFormatVersion': (<class 'str'>, False), 'AuthorizerResultTtlInSeconds': (<function validate_authorizer_ttl>, False), 'AuthorizerType': (<function validate_authorizer_type>, True), 'AuthorizerUri': (<class 'str'>, False), 'EnableSimpleResponses': (<function boolean>, False), 'IdentitySource': ([<class 'str'>], False), 'IdentityValidationExpression': (<class 'str'>, False), 'JwtConfiguration': (<class 'troposphere.apigatewayv2.JWTConfiguration'>, False), 'Name': (<class 'str'>, True)}

resource_type: str | None = 'AWS::ApiGatewayV2::Authorizer'

class troposphere.apigatewayv2.BodyS3Location(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

BodyS3Location

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Bucket': (<class 'str'>, False), 'Etag': (<class 'str'>, False), 'Key': (<class 'str'>, False), 'Version': (<class 'str'>, False)}

class troposphere.apigatewayv2.Condition(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

Condition

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'MatchBasePaths': (<class 'troposphere.apigatewayv2.MatchBasePaths'>, False), 'MatchHeaders': (<class 'troposphere.apigatewayv2.MatchHeaders'>, False)}

class troposphere.apigatewayv2.Cors(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

Cors

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AllowCredentials': (<function boolean>, False), 'AllowHeaders': ([<class 'str'>], False), 'AllowMethods': ([<class 'str'>], False), 'AllowOrigins': ([<class 'str'>], False), 'ExposeHeaders': ([<class 'str'>], False), 'MaxAge': (<function integer>, False)}

class troposphere.apigatewayv2.Deployment(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Deployment

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApiId': (<class 'str'>, True), 'Description': (<class 'str'>, False), 'StageName': (<class 'str'>, False)}

resource_type: str | None = 'AWS::ApiGatewayV2::Deployment'

class troposphere.apigatewayv2.DomainName(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

DomainName

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'DomainName': (<class 'str'>, True), 'DomainNameConfigurations': ([<class 'troposphere.apigatewayv2.DomainNameConfiguration'>], False), 'MutualTlsAuthentication': (<class 'troposphere.apigatewayv2.MutualTlsAuthentication'>, False), 'RoutingMode': (<class 'str'>, False), 'Tags': (<class 'dict'>, False)}

resource_type: str | None = 'AWS::ApiGatewayV2::DomainName'

class troposphere.apigatewayv2.DomainNameConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

DomainNameConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CertificateArn': (<class 'str'>, False), 'CertificateName': (<class 'str'>, False), 'EndpointType': (<class 'str'>, False), 'IpAddressType': (<class 'str'>, False), 'OwnershipVerificationCertificateArn': (<class 'str'>, False), 'SecurityPolicy': (<class 'str'>, False)}

class troposphere.apigatewayv2.Integration(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Integration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApiId': (<class 'str'>, True), 'ConnectionId': (<class 'str'>, False), 'ConnectionType': (<class 'str'>, False), 'ContentHandlingStrategy': (<function validate_content_handling_strategy>, False), 'CredentialsArn': (<class 'str'>, False), 'Description': (<class 'str'>, False), 'IntegrationMethod': (<class 'str'>, False), 'IntegrationSubtype': (<class 'str'>, False), 'IntegrationType': (<function validate_integration_type>, True), 'IntegrationUri': (<class 'str'>, False), 'PassthroughBehavior': (<function validate_passthrough_behavior>, False), 'PayloadFormatVersion': (<class 'str'>, False), 'RequestParameters': (<class 'dict'>, False), 'RequestTemplates': (<class 'dict'>, False), 'ResponseParameters': (<class 'dict'>, False), 'TemplateSelectionExpression': (<class 'str'>, False), 'TimeoutInMillis': (<function validate_timeout_in_millis>, False), 'TlsConfig': (<class 'troposphere.apigatewayv2.TlsConfig'>, False)}

resource_type: str | None = 'AWS::ApiGatewayV2::Integration'

class troposphere.apigatewayv2.IntegrationOverrides(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

IntegrationOverrides

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Description': (<class 'str'>, False), 'IntegrationMethod': (<class 'str'>, False), 'PayloadFormatVersion': (<class 'str'>, False), 'TimeoutInMillis': (<function integer>, False)}

class troposphere.apigatewayv2.IntegrationResponse(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

IntegrationResponse

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApiId': (<class 'str'>, True), 'ContentHandlingStrategy': (<function validate_content_handling_strategy>, False), 'IntegrationId': (<class 'str'>, True), 'IntegrationResponseKey': (<class 'str'>, True), 'ResponseParameters': (<class 'dict'>, False), 'ResponseTemplates': (<class 'dict'>, False), 'TemplateSelectionExpression': (<class 'str'>, False)}

resource_type: str | None = 'AWS::ApiGatewayV2::IntegrationResponse'

class troposphere.apigatewayv2.JWTConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

JWTConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Audience': ([<class 'str'>], False), 'Issuer': (<class 'str'>, False)}

class troposphere.apigatewayv2.MatchBasePaths(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

MatchBasePaths

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AnyOf': ([<class 'str'>], True)}

class troposphere.apigatewayv2.MatchHeaderValue(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

MatchHeaderValue

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Header': (<class 'str'>, True), 'ValueGlob': (<class 'str'>, True)}

class troposphere.apigatewayv2.MatchHeaders(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

MatchHeaders

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AnyOf': ([<class 'troposphere.apigatewayv2.MatchHeaderValue'>], True)}

class troposphere.apigatewayv2.Model(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Model

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApiId': (<class 'str'>, True), 'ContentType': (<class 'str'>, False), 'Description': (<class 'str'>, False), 'Name': (<class 'str'>, True), 'Schema': (<function dict_or_string>, True)}

resource_type: str | None = 'AWS::ApiGatewayV2::Model'

validate()

class troposphere.apigatewayv2.MutualTlsAuthentication(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

MutualTlsAuthentication

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'TruststoreUri': (<class 'str'>, False), 'TruststoreVersion': (<class 'str'>, False)}

class troposphere.apigatewayv2.ParameterConstraints(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ParameterConstraints

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Required': (<function boolean>, True)}

class troposphere.apigatewayv2.ResponseParameter(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ResponseParameter

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Destination': (<class 'str'>, False), 'Source': (<class 'str'>, False)}

class troposphere.apigatewayv2.ResponseParameterMap(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ResponseParameterMap

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ResponseParameters': ([<class 'troposphere.apigatewayv2.ResponseParameter'>], False)}

class troposphere.apigatewayv2.Route(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Route

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApiId': (<class 'str'>, True), 'ApiKeyRequired': (<function boolean>, False), 'AuthorizationScopes': ([<class 'str'>], False), 'AuthorizationType': (<class 'str'>, False), 'AuthorizerId': (<class 'str'>, False), 'ModelSelectionExpression': (<class 'str'>, False), 'OperationName': (<class 'str'>, False), 'RequestModels': (<class 'dict'>, False), 'RequestParameters': (<class 'dict'>, False), 'RouteKey': (<class 'str'>, True), 'RouteResponseSelectionExpression': (<class 'str'>, False), 'Target': (<class 'str'>, False)}

resource_type: str | None = 'AWS::ApiGatewayV2::Route'

class troposphere.apigatewayv2.RouteOverrides(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

RouteOverrides

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AuthorizationScopes': ([<class 'str'>], False), 'AuthorizationType': (<class 'str'>, False), 'AuthorizerId': (<class 'str'>, False), 'OperationName': (<class 'str'>, False), 'Target': (<class 'str'>, False)}

class troposphere.apigatewayv2.RouteResponse(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

RouteResponse

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApiId': (<class 'str'>, True), 'ModelSelectionExpression': (<class 'str'>, False), 'ResponseModels': (<class 'dict'>, False), 'ResponseParameters': (<class 'dict'>, False), 'RouteId': (<class 'str'>, True), 'RouteResponseKey': (<class 'str'>, True)}

resource_type: str | None = 'AWS::ApiGatewayV2::RouteResponse'

class troposphere.apigatewayv2.RouteSettings(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

RouteSettings

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'DataTraceEnabled': (<function boolean>, False), 'DetailedMetricsEnabled': (<function boolean>, False), 'LoggingLevel': (<function validate_logging_level>, False), 'ThrottlingBurstLimit': (<function integer>, False), 'ThrottlingRateLimit': (<function double>, False)}

class troposphere.apigatewayv2.RoutingRule(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

RoutingRule

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Actions': ([<class 'troposphere.apigatewayv2.Action'>], True), 'Conditions': ([<class 'troposphere.apigatewayv2.Condition'>], True), 'DomainNameArn': (<class 'str'>, True), 'Priority': (<function integer>, True)}

resource_type: str | None = 'AWS::ApiGatewayV2::RoutingRule'

class troposphere.apigatewayv2.Stage(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Stage

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AccessLogSettings': (<class 'troposphere.apigatewayv2.AccessLogSettings'>, False), 'ApiId': (<class 'str'>, True), 'AutoDeploy': (<function boolean>, False), 'ClientCertificateId': (<class 'str'>, False), 'DefaultRouteSettings': (<class 'troposphere.apigatewayv2.RouteSettings'>, False), 'DeploymentId': (<class 'str'>, False), 'Description': (<class 'str'>, False), 'RouteSettings': (<class 'dict'>, False), 'StageName': (<class 'str'>, True), 'StageVariables': (<class 'dict'>, False), 'Tags': (<class 'dict'>, False)}

resource_type: str | None = 'AWS::ApiGatewayV2::Stage'

class troposphere.apigatewayv2.StageOverrides(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

StageOverrides

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AccessLogSettings': (<class 'troposphere.apigatewayv2.AccessLogSettings'>, False), 'AutoDeploy': (<function boolean>, False), 'DefaultRouteSettings': (<class 'troposphere.apigatewayv2.RouteSettings'>, False), 'Description': (<class 'str'>, False), 'RouteSettings': (<class 'dict'>, False), 'StageVariables': (<class 'dict'>, False)}

class troposphere.apigatewayv2.TlsConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

TlsConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ServerNameToVerify': (<class 'str'>, False)}

class troposphere.apigatewayv2.VpcLink(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

VpcLink

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Name': (<class 'str'>, True), 'SecurityGroupIds': ([<class 'str'>], False), 'SubnetIds': ([<class 'str'>], True), 'Tags': (<class 'dict'>, False)}

resource_type: str | None = 'AWS::ApiGatewayV2::VpcLink'

troposphere.appconfig module

class troposphere.appconfig.Application(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Application

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Description': (<class 'str'>, False), 'Name': (<class 'str'>, True), 'Tags': (<class 'troposphere.Tags'>, False)}

resource_type: str | None = 'AWS::AppConfig::Application'

class troposphere.appconfig.ConfigurationProfile(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

ConfigurationProfile

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApplicationId': (<class 'str'>, True), 'DeletionProtectionCheck': (<class 'str'>, False), 'Description': (<class 'str'>, False), 'KmsKeyIdentifier': (<class 'str'>, False), 'LocationUri': (<class 'str'>, True), 'Name': (<class 'str'>, True), 'RetrievalRoleArn': (<class 'str'>, False), 'Tags': (<class 'troposphere.Tags'>, False), 'Type': (<class 'str'>, False), 'Validators': ([<class 'troposphere.appconfig.Validators'>], False)}

resource_type: str | None = 'AWS::AppConfig::ConfigurationProfile'

class troposphere.appconfig.Deployment(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Deployment

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApplicationId': (<class 'str'>, True), 'ConfigurationProfileId': (<class 'str'>, True), 'ConfigurationVersion': (<class 'str'>, True), 'DeploymentStrategyId': (<class 'str'>, True), 'Description': (<class 'str'>, False), 'DynamicExtensionParameters': ([<class 'troposphere.appconfig.DynamicExtensionParameters'>], False), 'EnvironmentId': (<class 'str'>, True), 'KmsKeyIdentifier': (<class 'str'>, False), 'Tags': (<class 'troposphere.Tags'>, False)}

resource_type: str | None = 'AWS::AppConfig::Deployment'

class troposphere.appconfig.DeploymentStrategy(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

DeploymentStrategy

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'DeploymentDurationInMinutes': (<function double>, True), 'Description': (<class 'str'>, False), 'FinalBakeTimeInMinutes': (<function double>, False), 'GrowthFactor': (<function double>, True), 'GrowthType': (<function validate_growth_type>, False), 'Name': (<class 'str'>, True), 'ReplicateTo': (<function validate_replicate_to>, True), 'Tags': (<class 'troposphere.Tags'>, False)}

resource_type: str | None = 'AWS::AppConfig::DeploymentStrategy'

class troposphere.appconfig.DynamicExtensionParameters(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

DynamicExtensionParameters

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ExtensionReference': (<class 'str'>, False), 'ParameterName': (<class 'str'>, False), 'ParameterValue': (<class 'str'>, False)}

class troposphere.appconfig.Environment(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Environment

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApplicationId': (<class 'str'>, True), 'DeletionProtectionCheck': (<class 'str'>, False), 'Description': (<class 'str'>, False), 'Monitors': ([<class 'troposphere.appconfig.Monitor'>], False), 'Name': (<class 'str'>, True), 'Tags': (<class 'troposphere.Tags'>, False)}

resource_type: str | None = 'AWS::AppConfig::Environment'

class troposphere.appconfig.Extension(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Extension

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Actions': (<class 'dict'>, True), 'Description': (<class 'str'>, False), 'LatestVersionNumber': (<function integer>, False), 'Name': (<class 'str'>, True), 'Parameters': (<class 'dict'>, False), 'Tags': (<class 'troposphere.Tags'>, False)}

resource_type: str | None = 'AWS::AppConfig::Extension'

class troposphere.appconfig.ExtensionAssociation(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

ExtensionAssociation

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ExtensionIdentifier': (<class 'str'>, False), 'ExtensionVersionNumber': (<function integer>, False), 'Parameters': (<class 'dict'>, False), 'ResourceIdentifier': (<class 'str'>, False), 'Tags': (<class 'troposphere.Tags'>, False)}

resource_type: str | None = 'AWS::AppConfig::ExtensionAssociation'

class troposphere.appconfig.HostedConfigurationVersion(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

HostedConfigurationVersion

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApplicationId': (<class 'str'>, True), 'ConfigurationProfileId': (<class 'str'>, True), 'Content': (<class 'str'>, True), 'ContentType': (<class 'str'>, True), 'Description': (<class 'str'>, False), 'LatestVersionNumber': (<function integer>, False), 'VersionLabel': (<class 'str'>, False)}

resource_type: str | None = 'AWS::AppConfig::HostedConfigurationVersion'

class troposphere.appconfig.Monitor(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

Monitor

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AlarmArn': (<class 'str'>, True), 'AlarmRoleArn': (<class 'str'>, False)}

class troposphere.appconfig.Parameter(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

Parameter

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Description': (<class 'str'>, False), 'Dynamic': (<function boolean>, False), 'Required': (<function boolean>, True)}

class troposphere.appconfig.Validators(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

Validators

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Content': (<class 'str'>, False), 'Type': (<function validate_validator_type>, False)}

troposphere.appflow module

class troposphere.appflow.AggregationConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

AggregationConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AggregationType': (<class 'str'>, False), 'TargetFileSize': (<function integer>, False)}

class troposphere.appflow.AmplitudeConnectorProfileCredentials(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

AmplitudeConnectorProfileCredentials

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApiKey': (<class 'str'>, True), 'SecretKey': (<class 'str'>, True)}

class troposphere.appflow.AmplitudeSourceProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

AmplitudeSourceProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Object': (<class 'str'>, True)}

class troposphere.appflow.ApiKeyCredentials(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ApiKeyCredentials

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApiKey': (<class 'str'>, True), 'ApiSecretKey': (<class 'str'>, False)}

class troposphere.appflow.BasicAuthCredentials(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

BasicAuthCredentials

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Password': (<class 'str'>, True), 'Username': (<class 'str'>, True)}

class troposphere.appflow.Connector(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Connector

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ConnectorLabel': (<class 'str'>, False), 'ConnectorProvisioningConfig': (<class 'troposphere.appflow.ConnectorProvisioningConfig'>, True), 'ConnectorProvisioningType': (<class 'str'>, True), 'Description': (<class 'str'>, False)}

resource_type: str | None = 'AWS::AppFlow::Connector'

class troposphere.appflow.ConnectorOAuthRequest(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ConnectorOAuthRequest

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AuthCode': (<class 'str'>, False), 'RedirectUri': (<class 'str'>, False)}

class troposphere.appflow.ConnectorOperator(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ConnectorOperator

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Amplitude': (<class 'str'>, False), 'CustomConnector': (<class 'str'>, False), 'Datadog': (<class 'str'>, False), 'Dynatrace': (<class 'str'>, False), 'GoogleAnalytics': (<class 'str'>, False), 'InforNexus': (<class 'str'>, False), 'Marketo': (<class 'str'>, False), 'Pardot': (<class 'str'>, False), 'S3': (<class 'str'>, False), 'SAPOData': (<class 'str'>, False), 'Salesforce': (<class 'str'>, False), 'ServiceNow': (<class 'str'>, False), 'Singular': (<class 'str'>, False), 'Slack': (<class 'str'>, False), 'Trendmicro': (<class 'str'>, False), 'Veeva': (<class 'str'>, False), 'Zendesk': (<class 'str'>, False)}

class troposphere.appflow.ConnectorProfile(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

ConnectorProfile

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ConnectionMode': (<class 'str'>, True), 'ConnectorLabel': (<class 'str'>, False), 'ConnectorProfileConfig': (<class 'troposphere.appflow.ConnectorProfileConfig'>, False), 'ConnectorProfileName': (<class 'str'>, True), 'ConnectorType': (<class 'str'>, True), 'KMSArn': (<class 'str'>, False)}

resource_type: str | None = 'AWS::AppFlow::ConnectorProfile'

class troposphere.appflow.ConnectorProfileConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ConnectorProfileConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ConnectorProfileCredentials': (<class 'troposphere.appflow.ConnectorProfileCredentials'>, False), 'ConnectorProfileProperties': (<class 'troposphere.appflow.ConnectorProfileProperties'>, False)}

class troposphere.appflow.ConnectorProfileCredentials(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ConnectorProfileCredentials

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Amplitude': (<class 'troposphere.appflow.AmplitudeConnectorProfileCredentials'>, False), 'CustomConnector': (<class 'troposphere.appflow.CustomConnectorProfileCredentials'>, False), 'Datadog': (<class 'troposphere.appflow.DatadogConnectorProfileCredentials'>, False), 'Dynatrace': (<class 'troposphere.appflow.DynatraceConnectorProfileCredentials'>, False), 'GoogleAnalytics': (<class 'troposphere.appflow.GoogleAnalyticsConnectorProfileCredentials'>, False), 'InforNexus': (<class 'troposphere.appflow.InforNexusConnectorProfileCredentials'>, False), 'Marketo': (<class 'troposphere.appflow.MarketoConnectorProfileCredentials'>, False), 'Pardot': (<class 'troposphere.appflow.PardotConnectorProfileCredentials'>, False), 'Redshift': (<class 'troposphere.appflow.RedshiftConnectorProfileCredentials'>, False), 'SAPOData': (<class 'troposphere.appflow.SAPODataConnectorProfileCredentials'>, False), 'Salesforce': (<class 'troposphere.appflow.SalesforceConnectorProfileCredentials'>, False), 'ServiceNow': (<class 'troposphere.appflow.ServiceNowConnectorProfileCredentials'>, False), 'Singular': (<class 'troposphere.appflow.SingularConnectorProfileCredentials'>, False), 'Slack': (<class 'troposphere.appflow.SlackConnectorProfileCredentials'>, False), 'Snowflake': (<class 'troposphere.appflow.SnowflakeConnectorProfileCredentials'>, False), 'Trendmicro': (<class 'troposphere.appflow.TrendmicroConnectorProfileCredentials'>, False), 'Veeva': (<class 'troposphere.appflow.VeevaConnectorProfileCredentials'>, False), 'Zendesk': (<class 'troposphere.appflow.ZendeskConnectorProfileCredentials'>, False)}

class troposphere.appflow.ConnectorProfileProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ConnectorProfileProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CustomConnector': (<class 'troposphere.appflow.CustomConnectorProfileProperties'>, False), 'Datadog': (<class 'troposphere.appflow.DatadogConnectorProfileProperties'>, False), 'Dynatrace': (<class 'troposphere.appflow.DynatraceConnectorProfileProperties'>, False), 'InforNexus': (<class 'troposphere.appflow.InforNexusConnectorProfileProperties'>, False), 'Marketo': (<class 'troposphere.appflow.MarketoConnectorProfileProperties'>, False), 'Pardot': (<class 'troposphere.appflow.PardotConnectorProfileProperties'>, False), 'Redshift': (<class 'troposphere.appflow.RedshiftConnectorProfileProperties'>, False), 'SAPOData': (<class 'troposphere.appflow.SAPODataConnectorProfileProperties'>, False), 'Salesforce': (<class 'troposphere.appflow.SalesforceConnectorProfileProperties'>, False), 'ServiceNow': (<class 'troposphere.appflow.ServiceNowConnectorProfileProperties'>, False), 'Slack': (<class 'troposphere.appflow.SlackConnectorProfileProperties'>, False), 'Snowflake': (<class 'troposphere.appflow.SnowflakeConnectorProfileProperties'>, False), 'Veeva': (<class 'troposphere.appflow.VeevaConnectorProfileProperties'>, False), 'Zendesk': (<class 'troposphere.appflow.ZendeskConnectorProfileProperties'>, False)}

class troposphere.appflow.ConnectorProvisioningConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ConnectorProvisioningConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Lambda': (<class 'troposphere.appflow.LambdaConnectorProvisioningConfig'>, False)}

class troposphere.appflow.CustomAuthCredentials(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

CustomAuthCredentials

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CredentialsMap': (<class 'dict'>, False), 'CustomAuthenticationType': (<class 'str'>, True)}

class troposphere.appflow.CustomConnectorDestinationProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

CustomConnectorDestinationProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CustomProperties': (<class 'dict'>, False), 'EntityName': (<class 'str'>, True), 'ErrorHandlingConfig': (<class 'troposphere.appflow.ErrorHandlingConfig'>, False), 'IdFieldNames': ([<class 'str'>], False), 'WriteOperationType': (<class 'str'>, False)}

class troposphere.appflow.CustomConnectorProfileCredentials(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

CustomConnectorProfileCredentials

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApiKey': (<class 'troposphere.appflow.ApiKeyCredentials'>, False), 'AuthenticationType': (<class 'str'>, True), 'Basic': (<class 'troposphere.appflow.BasicAuthCredentials'>, False), 'Custom': (<class 'troposphere.appflow.CustomAuthCredentials'>, False), 'Oauth2': (<class 'troposphere.appflow.OAuth2Credentials'>, False)}

class troposphere.appflow.CustomConnectorProfileProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

CustomConnectorProfileProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'OAuth2Properties': (<class 'troposphere.appflow.OAuth2Properties'>, False), 'ProfileProperties': (<class 'dict'>, False)}

class troposphere.appflow.CustomConnectorSourceProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

CustomConnectorSourceProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CustomProperties': (<class 'dict'>, False), 'DataTransferApi': (<class 'troposphere.appflow.DataTransferApi'>, False), 'EntityName': (<class 'str'>, True)}

class troposphere.appflow.DataTransferApi(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

DataTransferApi

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Name': (<class 'str'>, True), 'Type': (<class 'str'>, True)}

class troposphere.appflow.DatadogConnectorProfileCredentials(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

DatadogConnectorProfileCredentials

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApiKey': (<class 'str'>, True), 'ApplicationKey': (<class 'str'>, True)}

class troposphere.appflow.DatadogConnectorProfileProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

DatadogConnectorProfileProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'InstanceUrl': (<class 'str'>, True)}

class troposphere.appflow.DatadogSourceProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

DatadogSourceProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Object': (<class 'str'>, True)}

class troposphere.appflow.DestinationConnectorProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

DestinationConnectorProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CustomConnector': (<class 'troposphere.appflow.CustomConnectorDestinationProperties'>, False), 'EventBridge': (<class 'troposphere.appflow.EventBridgeDestinationProperties'>, False), 'LookoutMetrics': (<class 'troposphere.appflow.LookoutMetricsDestinationProperties'>, False), 'Marketo': (<class 'troposphere.appflow.MarketoDestinationProperties'>, False), 'Redshift': (<class 'troposphere.appflow.RedshiftDestinationProperties'>, False), 'S3': (<class 'troposphere.appflow.S3DestinationProperties'>, False), 'SAPOData': (<class 'troposphere.appflow.SAPODataDestinationProperties'>, False), 'Salesforce': (<class 'troposphere.appflow.SalesforceDestinationProperties'>, False), 'Snowflake': (<class 'troposphere.appflow.SnowflakeDestinationProperties'>, False), 'Upsolver': (<class 'troposphere.appflow.UpsolverDestinationProperties'>, False), 'Zendesk': (<class 'troposphere.appflow.ZendeskDestinationProperties'>, False)}

class troposphere.appflow.DestinationFlowConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

DestinationFlowConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApiVersion': (<class 'str'>, False), 'ConnectorProfileName': (<class 'str'>, False), 'ConnectorType': (<class 'str'>, True), 'DestinationConnectorProperties': (<class 'troposphere.appflow.DestinationConnectorProperties'>, True)}

class troposphere.appflow.DynatraceConnectorProfileCredentials(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

DynatraceConnectorProfileCredentials

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApiToken': (<class 'str'>, True)}

class troposphere.appflow.DynatraceConnectorProfileProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

DynatraceConnectorProfileProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'InstanceUrl': (<class 'str'>, True)}

class troposphere.appflow.DynatraceSourceProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

DynatraceSourceProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Object': (<class 'str'>, True)}

class troposphere.appflow.ErrorHandlingConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ErrorHandlingConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'BucketName': (<class 'str'>, False), 'BucketPrefix': (<class 'str'>, False), 'FailOnFirstError': (<function boolean>, False)}

class troposphere.appflow.EventBridgeDestinationProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

EventBridgeDestinationProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ErrorHandlingConfig': (<class 'troposphere.appflow.ErrorHandlingConfig'>, False), 'Object': (<class 'str'>, True)}

class troposphere.appflow.Flow(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Flow

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Description': (<class 'str'>, False), 'DestinationFlowConfigList': ([<class 'troposphere.appflow.DestinationFlowConfig'>], True), 'FlowName': (<class 'str'>, True), 'FlowStatus': (<class 'str'>, False), 'KMSArn': (<class 'str'>, False), 'MetadataCatalogConfig': (<class 'troposphere.appflow.MetadataCatalogConfig'>, False), 'SourceFlowConfig': (<class 'troposphere.appflow.SourceFlowConfig'>, True), 'Tags': (<class 'troposphere.Tags'>, False), 'Tasks': ([<class 'troposphere.appflow.Task'>], True), 'TriggerConfig': (<class 'troposphere.appflow.TriggerConfig'>, True)}

resource_type: str | None = 'AWS::AppFlow::Flow'

class troposphere.appflow.GlueDataCatalog(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

GlueDataCatalog

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'DatabaseName': (<class 'str'>, True), 'RoleArn': (<class 'str'>, True), 'TablePrefix': (<class 'str'>, True)}

class troposphere.appflow.GoogleAnalyticsConnectorProfileCredentials(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

GoogleAnalyticsConnectorProfileCredentials

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AccessToken': (<class 'str'>, False), 'ClientId': (<class 'str'>, True), 'ClientSecret': (<class 'str'>, True), 'ConnectorOAuthRequest': (<class 'troposphere.appflow.ConnectorOAuthRequest'>, False), 'RefreshToken': (<class 'str'>, False)}

class troposphere.appflow.GoogleAnalyticsSourceProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

GoogleAnalyticsSourceProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Object': (<class 'str'>, True)}

class troposphere.appflow.IncrementalPullConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

IncrementalPullConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'DatetimeTypeFieldName': (<class 'str'>, False)}

class troposphere.appflow.InforNexusConnectorProfileCredentials(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

InforNexusConnectorProfileCredentials

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AccessKeyId': (<class 'str'>, True), 'Datakey': (<class 'str'>, True), 'SecretAccessKey': (<class 'str'>, True), 'UserId': (<class 'str'>, True)}

class troposphere.appflow.InforNexusConnectorProfileProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

InforNexusConnectorProfileProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'InstanceUrl': (<class 'str'>, True)}

class troposphere.appflow.InforNexusSourceProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

InforNexusSourceProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Object': (<class 'str'>, True)}

class troposphere.appflow.LambdaConnectorProvisioningConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

LambdaConnectorProvisioningConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'LambdaArn': (<class 'str'>, True)}

class troposphere.appflow.LookoutMetricsDestinationProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

LookoutMetricsDestinationProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Object': (<class 'str'>, False)}

class troposphere.appflow.MarketoConnectorProfileCredentials(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

MarketoConnectorProfileCredentials

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AccessToken': (<class 'str'>, False), 'ClientId': (<class 'str'>, True), 'ClientSecret': (<class 'str'>, True), 'ConnectorOAuthRequest': (<class 'troposphere.appflow.ConnectorOAuthRequest'>, False)}

class troposphere.appflow.MarketoConnectorProfileProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

MarketoConnectorProfileProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'InstanceUrl': (<class 'str'>, True)}

class troposphere.appflow.MarketoDestinationProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

MarketoDestinationProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ErrorHandlingConfig': (<class 'troposphere.appflow.ErrorHandlingConfig'>, False), 'Object': (<class 'str'>, True)}

class troposphere.appflow.MarketoSourceProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

MarketoSourceProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Object': (<class 'str'>, True)}

class troposphere.appflow.MetadataCatalogConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

MetadataCatalogConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'GlueDataCatalog': (<class 'troposphere.appflow.GlueDataCatalog'>, False)}

class troposphere.appflow.OAuth2Credentials(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

OAuth2Credentials

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AccessToken': (<class 'str'>, False), 'ClientId': (<class 'str'>, False), 'ClientSecret': (<class 'str'>, False), 'OAuthRequest': (<class 'troposphere.appflow.ConnectorOAuthRequest'>, False), 'RefreshToken': (<class 'str'>, False)}

class troposphere.appflow.OAuth2Properties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

OAuth2Properties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'OAuth2GrantType': (<class 'str'>, False), 'TokenUrl': (<class 'str'>, False), 'TokenUrlCustomProperties': (<class 'dict'>, False)}

class troposphere.appflow.OAuthCredentials(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

OAuthCredentials

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AccessToken': (<class 'str'>, False), 'ClientId': (<class 'str'>, False), 'ClientSecret': (<class 'str'>, False), 'ConnectorOAuthRequest': (<class 'troposphere.appflow.ConnectorOAuthRequest'>, False), 'RefreshToken': (<class 'str'>, False)}

class troposphere.appflow.OAuthProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

OAuthProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AuthCodeUrl': (<class 'str'>, False), 'OAuthScopes': ([<class 'str'>], False), 'TokenUrl': (<class 'str'>, False)}

class troposphere.appflow.PardotConnectorProfileCredentials(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

PardotConnectorProfileCredentials

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AccessToken': (<class 'str'>, False), 'ClientCredentialsArn': (<class 'str'>, False), 'ConnectorOAuthRequest': (<class 'troposphere.appflow.ConnectorOAuthRequest'>, False), 'RefreshToken': (<class 'str'>, False)}

class troposphere.appflow.PardotConnectorProfileProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

PardotConnectorProfileProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'BusinessUnitId': (<class 'str'>, True), 'InstanceUrl': (<class 'str'>, False), 'IsSandboxEnvironment': (<function boolean>, False)}

class troposphere.appflow.PardotSourceProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

PardotSourceProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Object': (<class 'str'>, True)}

class troposphere.appflow.PrefixConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

PrefixConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'PathPrefixHierarchy': ([<class 'str'>], False), 'PrefixFormat': (<class 'str'>, False), 'PrefixType': (<class 'str'>, False)}

class troposphere.appflow.RedshiftConnectorProfileCredentials(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

RedshiftConnectorProfileCredentials

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Password': (<class 'str'>, False), 'Username': (<class 'str'>, False)}

class troposphere.appflow.RedshiftConnectorProfileProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

RedshiftConnectorProfileProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'BucketName': (<class 'str'>, True), 'BucketPrefix': (<class 'str'>, False), 'ClusterIdentifier': (<class 'str'>, False), 'DataApiRoleArn': (<class 'str'>, False), 'DatabaseName': (<class 'str'>, False), 'DatabaseUrl': (<class 'str'>, False), 'IsRedshiftServerless': (<function boolean>, False), 'RoleArn': (<class 'str'>, True), 'WorkgroupName': (<class 'str'>, False)}

class troposphere.appflow.RedshiftDestinationProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

RedshiftDestinationProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'BucketPrefix': (<class 'str'>, False), 'ErrorHandlingConfig': (<class 'troposphere.appflow.ErrorHandlingConfig'>, False), 'IntermediateBucketName': (<class 'str'>, True), 'Object': (<class 'str'>, True)}

class troposphere.appflow.S3DestinationProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

S3DestinationProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'BucketName': (<class 'str'>, True), 'BucketPrefix': (<class 'str'>, False), 'S3OutputFormatConfig': (<class 'troposphere.appflow.S3OutputFormatConfig'>, False)}

class troposphere.appflow.S3InputFormatConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

S3InputFormatConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'S3InputFileType': (<class 'str'>, False)}

class troposphere.appflow.S3OutputFormatConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

S3OutputFormatConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AggregationConfig': (<class 'troposphere.appflow.AggregationConfig'>, False), 'FileType': (<class 'str'>, False), 'PrefixConfig': (<class 'troposphere.appflow.PrefixConfig'>, False), 'PreserveSourceDataTyping': (<function boolean>, False)}

class troposphere.appflow.S3SourceProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

S3SourceProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'BucketName': (<class 'str'>, True), 'BucketPrefix': (<class 'str'>, True), 'S3InputFormatConfig': (<class 'troposphere.appflow.S3InputFormatConfig'>, False)}

class troposphere.appflow.SAPODataConnectorProfileCredentials(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

SAPODataConnectorProfileCredentials

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'BasicAuthCredentials': (<class 'troposphere.appflow.BasicAuthCredentials'>, False), 'OAuthCredentials': (<class 'troposphere.appflow.OAuthCredentials'>, False)}

class troposphere.appflow.SAPODataConnectorProfileProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

SAPODataConnectorProfileProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApplicationHostUrl': (<class 'str'>, False), 'ApplicationServicePath': (<class 'str'>, False), 'ClientNumber': (<class 'str'>, False), 'DisableSSO': (<function boolean>, False), 'LogonLanguage': (<class 'str'>, False), 'OAuthProperties': (<class 'troposphere.appflow.OAuthProperties'>, False), 'PortNumber': (<function integer>, False), 'PrivateLinkServiceName': (<class 'str'>, False)}

class troposphere.appflow.SAPODataDestinationProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

SAPODataDestinationProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ErrorHandlingConfig': (<class 'troposphere.appflow.ErrorHandlingConfig'>, False), 'IdFieldNames': ([<class 'str'>], False), 'ObjectPath': (<class 'str'>, True), 'SuccessResponseHandlingConfig': (<class 'troposphere.appflow.SuccessResponseHandlingConfig'>, False), 'WriteOperationType': (<class 'str'>, False)}

class troposphere.appflow.SAPODataPaginationConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

SAPODataPaginationConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'maxPageSize': (<function integer>, True)}

class troposphere.appflow.SAPODataParallelismConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

SAPODataParallelismConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'maxParallelism': (<function integer>, True)}

class troposphere.appflow.SAPODataSourceProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

SAPODataSourceProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ObjectPath': (<class 'str'>, True), 'paginationConfig': (<class 'troposphere.appflow.SAPODataPaginationConfig'>, False), 'parallelismConfig': (<class 'troposphere.appflow.SAPODataParallelismConfig'>, False)}

class troposphere.appflow.SalesforceConnectorProfileCredentials(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

SalesforceConnectorProfileCredentials

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AccessToken': (<class 'str'>, False), 'ClientCredentialsArn': (<class 'str'>, False), 'ConnectorOAuthRequest': (<class 'troposphere.appflow.ConnectorOAuthRequest'>, False), 'JwtToken': (<class 'str'>, False), 'OAuth2GrantType': (<class 'str'>, False), 'RefreshToken': (<class 'str'>, False)}

class troposphere.appflow.SalesforceConnectorProfileProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

SalesforceConnectorProfileProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'InstanceUrl': (<class 'str'>, False), 'isSandboxEnvironment': (<function boolean>, False), 'usePrivateLinkForMetadataAndAuthorization': (<function boolean>, False)}

class troposphere.appflow.SalesforceDestinationProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

SalesforceDestinationProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'DataTransferApi': (<class 'str'>, False), 'ErrorHandlingConfig': (<class 'troposphere.appflow.ErrorHandlingConfig'>, False), 'IdFieldNames': ([<class 'str'>], False), 'Object': (<class 'str'>, True), 'WriteOperationType': (<class 'str'>, False)}

class troposphere.appflow.SalesforceSourceProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

SalesforceSourceProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'DataTransferApi': (<class 'str'>, False), 'EnableDynamicFieldUpdate': (<function boolean>, False), 'IncludeDeletedRecords': (<function boolean>, False), 'Object': (<class 'str'>, True)}

class troposphere.appflow.ScheduledTriggerProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ScheduledTriggerProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'DataPullMode': (<class 'str'>, False), 'FirstExecutionFrom': (<function double>, False), 'FlowErrorDeactivationThreshold': (<function integer>, False), 'ScheduleEndTime': (<function double>, False), 'ScheduleExpression': (<class 'str'>, True), 'ScheduleOffset': (<function double>, False), 'ScheduleStartTime': (<function double>, False), 'TimeZone': (<class 'str'>, False)}

class troposphere.appflow.ServiceNowConnectorProfileCredentials(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ServiceNowConnectorProfileCredentials

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'OAuth2Credentials': (<class 'troposphere.appflow.OAuth2Credentials'>, False), 'Password': (<class 'str'>, False), 'Username': (<class 'str'>, False)}

class troposphere.appflow.ServiceNowConnectorProfileProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ServiceNowConnectorProfileProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'InstanceUrl': (<class 'str'>, True)}

class troposphere.appflow.ServiceNowSourceProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ServiceNowSourceProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Object': (<class 'str'>, True)}

class troposphere.appflow.SingularConnectorProfileCredentials(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

SingularConnectorProfileCredentials

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApiKey': (<class 'str'>, True)}

class troposphere.appflow.SingularSourceProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

SingularSourceProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Object': (<class 'str'>, True)}

class troposphere.appflow.SlackConnectorProfileCredentials(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

SlackConnectorProfileCredentials

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AccessToken': (<class 'str'>, False), 'ClientId': (<class 'str'>, True), 'ClientSecret': (<class 'str'>, True), 'ConnectorOAuthRequest': (<class 'troposphere.appflow.ConnectorOAuthRequest'>, False)}

class troposphere.appflow.SlackConnectorProfileProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

SlackConnectorProfileProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'InstanceUrl': (<class 'str'>, True)}

class troposphere.appflow.SlackSourceProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

SlackSourceProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Object': (<class 'str'>, True)}

class troposphere.appflow.SnowflakeConnectorProfileCredentials(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

SnowflakeConnectorProfileCredentials

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Password': (<class 'str'>, True), 'Username': (<class 'str'>, True)}

class troposphere.appflow.SnowflakeConnectorProfileProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

SnowflakeConnectorProfileProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AccountName': (<class 'str'>, False), 'BucketName': (<class 'str'>, True), 'BucketPrefix': (<class 'str'>, False), 'PrivateLinkServiceName': (<class 'str'>, False), 'Region': (<class 'str'>, False), 'Stage': (<class 'str'>, True), 'Warehouse': (<class 'str'>, True)}

class troposphere.appflow.SnowflakeDestinationProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

SnowflakeDestinationProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'BucketPrefix': (<class 'str'>, False), 'ErrorHandlingConfig': (<class 'troposphere.appflow.ErrorHandlingConfig'>, False), 'IntermediateBucketName': (<class 'str'>, True), 'Object': (<class 'str'>, True)}

class troposphere.appflow.SourceConnectorProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

SourceConnectorProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Amplitude': (<class 'troposphere.appflow.AmplitudeSourceProperties'>, False), 'CustomConnector': (<class 'troposphere.appflow.CustomConnectorSourceProperties'>, False), 'Datadog': (<class 'troposphere.appflow.DatadogSourceProperties'>, False), 'Dynatrace': (<class 'troposphere.appflow.DynatraceSourceProperties'>, False), 'GoogleAnalytics': (<class 'troposphere.appflow.GoogleAnalyticsSourceProperties'>, False), 'InforNexus': (<class 'troposphere.appflow.InforNexusSourceProperties'>, False), 'Marketo': (<class 'troposphere.appflow.MarketoSourceProperties'>, False), 'Pardot': (<class 'troposphere.appflow.PardotSourceProperties'>, False), 'S3': (<class 'troposphere.appflow.S3SourceProperties'>, False), 'SAPOData': (<class 'troposphere.appflow.SAPODataSourceProperties'>, False), 'Salesforce': (<class 'troposphere.appflow.SalesforceSourceProperties'>, False), 'ServiceNow': (<class 'troposphere.appflow.ServiceNowSourceProperties'>, False), 'Singular': (<class 'troposphere.appflow.SingularSourceProperties'>, False), 'Slack': (<class 'troposphere.appflow.SlackSourceProperties'>, False), 'Trendmicro': (<class 'troposphere.appflow.TrendmicroSourceProperties'>, False), 'Veeva': (<class 'troposphere.appflow.VeevaSourceProperties'>, False), 'Zendesk': (<class 'troposphere.appflow.ZendeskSourceProperties'>, False)}

class troposphere.appflow.SourceFlowConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

SourceFlowConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApiVersion': (<class 'str'>, False), 'ConnectorProfileName': (<class 'str'>, False), 'ConnectorType': (<class 'str'>, True), 'IncrementalPullConfig': (<class 'troposphere.appflow.IncrementalPullConfig'>, False), 'SourceConnectorProperties': (<class 'troposphere.appflow.SourceConnectorProperties'>, True)}

class troposphere.appflow.SuccessResponseHandlingConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

SuccessResponseHandlingConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'BucketName': (<class 'str'>, False), 'BucketPrefix': (<class 'str'>, False)}

class troposphere.appflow.Task(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

Task

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ConnectorOperator': (<class 'troposphere.appflow.ConnectorOperator'>, False), 'DestinationField': (<class 'str'>, False), 'SourceFields': ([<class 'str'>], True), 'TaskProperties': ([<class 'troposphere.appflow.TaskPropertiesObject'>], False), 'TaskType': (<class 'str'>, True)}

class troposphere.appflow.TaskPropertiesObject(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

TaskPropertiesObject

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Key': (<class 'str'>, True), 'Value': (<class 'str'>, True)}

class troposphere.appflow.TrendmicroConnectorProfileCredentials(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

TrendmicroConnectorProfileCredentials

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApiSecretKey': (<class 'str'>, True)}

class troposphere.appflow.TrendmicroSourceProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

TrendmicroSourceProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Object': (<class 'str'>, True)}

class troposphere.appflow.TriggerConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

TriggerConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'TriggerProperties': (<class 'troposphere.appflow.ScheduledTriggerProperties'>, False), 'TriggerType': (<class 'str'>, True)}

class troposphere.appflow.UpsolverDestinationProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

UpsolverDestinationProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'BucketName': (<class 'str'>, True), 'BucketPrefix': (<class 'str'>, False), 'S3OutputFormatConfig': (<class 'troposphere.appflow.UpsolverS3OutputFormatConfig'>, True)}

class troposphere.appflow.UpsolverS3OutputFormatConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

UpsolverS3OutputFormatConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AggregationConfig': (<class 'troposphere.appflow.AggregationConfig'>, False), 'FileType': (<class 'str'>, False), 'PrefixConfig': (<class 'troposphere.appflow.PrefixConfig'>, True)}

class troposphere.appflow.VeevaConnectorProfileCredentials(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VeevaConnectorProfileCredentials

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Password': (<class 'str'>, True), 'Username': (<class 'str'>, True)}

class troposphere.appflow.VeevaConnectorProfileProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VeevaConnectorProfileProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'InstanceUrl': (<class 'str'>, True)}

class troposphere.appflow.VeevaSourceProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VeevaSourceProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'DocumentType': (<class 'str'>, False), 'IncludeAllVersions': (<function boolean>, False), 'IncludeRenditions': (<function boolean>, False), 'IncludeSourceFiles': (<function boolean>, False), 'Object': (<class 'str'>, True)}

class troposphere.appflow.ZendeskConnectorProfileCredentials(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ZendeskConnectorProfileCredentials

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AccessToken': (<class 'str'>, False), 'ClientId': (<class 'str'>, True), 'ClientSecret': (<class 'str'>, True), 'ConnectorOAuthRequest': (<class 'troposphere.appflow.ConnectorOAuthRequest'>, False)}

class troposphere.appflow.ZendeskConnectorProfileProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ZendeskConnectorProfileProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'InstanceUrl': (<class 'str'>, True)}

class troposphere.appflow.ZendeskDestinationProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ZendeskDestinationProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ErrorHandlingConfig': (<class 'troposphere.appflow.ErrorHandlingConfig'>, False), 'IdFieldNames': ([<class 'str'>], False), 'Object': (<class 'str'>, True), 'WriteOperationType': (<class 'str'>, False)}

class troposphere.appflow.ZendeskSourceProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ZendeskSourceProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Object': (<class 'str'>, True)}

troposphere.appintegrations module

class troposphere.appintegrations.Application(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Application

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApplicationConfig': (<class 'troposphere.appintegrations.ApplicationConfig'>, False), 'ApplicationSourceConfig': (<class 'troposphere.appintegrations.ApplicationSourceConfig'>, True), 'ApplicationType': (<class 'str'>, False), 'Description': (<class 'str'>, False), 'IframeConfig': (<class 'troposphere.appintegrations.IframeConfig'>, False), 'InitializationTimeout': (<function integer>, False), 'IsService': (<function boolean>, False), 'Name': (<class 'str'>, True), 'Namespace': (<class 'str'>, True), 'Permissions': ([<class 'str'>], False), 'Tags': (<class 'troposphere.Tags'>, False)}

resource_type: str | None = 'AWS::AppIntegrations::Application'

class troposphere.appintegrations.ApplicationConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ApplicationConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ContactHandling': (<class 'troposphere.appintegrations.ContactHandling'>, False)}

class troposphere.appintegrations.ApplicationSourceConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ApplicationSourceConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ExternalUrlConfig': (<class 'troposphere.appintegrations.ExternalUrlConfig'>, True)}

class troposphere.appintegrations.ContactHandling(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ContactHandling

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Scope': (<class 'str'>, True)}

class troposphere.appintegrations.DataIntegration(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

DataIntegration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Description': (<class 'str'>, False), 'FileConfiguration': (<class 'troposphere.appintegrations.FileConfiguration'>, False), 'KmsKey': (<class 'str'>, True), 'Name': (<class 'str'>, True), 'ObjectConfiguration': (<class 'dict'>, False), 'ScheduleConfig': (<class 'troposphere.appintegrations.ScheduleConfig'>, False), 'SourceURI': (<class 'str'>, True), 'Tags': (<class 'troposphere.Tags'>, False)}

resource_type: str | None = 'AWS::AppIntegrations::DataIntegration'

class troposphere.appintegrations.EventFilter(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

EventFilter

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Source': (<class 'str'>, True)}

class troposphere.appintegrations.EventIntegration(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

EventIntegration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Description': (<class 'str'>, False), 'EventBridgeBus': (<class 'str'>, True), 'EventFilter': (<class 'troposphere.appintegrations.EventFilter'>, True), 'Name': (<class 'str'>, True), 'Tags': (<class 'troposphere.Tags'>, False)}

resource_type: str | None = 'AWS::AppIntegrations::EventIntegration'

class troposphere.appintegrations.ExternalUrlConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ExternalUrlConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AccessUrl': (<class 'str'>, True), 'ApprovedOrigins': ([<class 'str'>], False)}

class troposphere.appintegrations.FileConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

FileConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Filters': (<class 'dict'>, False), 'Folders': ([<class 'str'>], True)}

class troposphere.appintegrations.IframeConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

IframeConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Allow': ([<class 'str'>], False), 'Sandbox': ([<class 'str'>], False)}

class troposphere.appintegrations.ScheduleConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ScheduleConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'FirstExecutionFrom': (<class 'str'>, False), 'Object': (<class 'str'>, False), 'ScheduleExpression': (<class 'str'>, True)}

troposphere.applicationautoscaling module

class troposphere.applicationautoscaling.CustomizedMetricSpecification(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

CustomizedMetricSpecification

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Dimensions': ([<class 'troposphere.applicationautoscaling.MetricDimension'>], False), 'MetricName': (<class 'str'>, False), 'Metrics': ([<class 'troposphere.applicationautoscaling.TargetTrackingMetricDataQuery'>], False), 'Namespace': (<class 'str'>, False), 'Statistic': (<class 'str'>, False), 'Unit': (<class 'str'>, False)}

class troposphere.applicationautoscaling.MetricDimension(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

MetricDimension

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Name': (<class 'str'>, True), 'Value': (<class 'str'>, True)}

class troposphere.applicationautoscaling.PredefinedMetricSpecification(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

PredefinedMetricSpecification

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'PredefinedMetricType': (<class 'str'>, True), 'ResourceLabel': (<class 'str'>, False)}

class troposphere.applicationautoscaling.PredictiveScalingCustomizedCapacityMetric(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

PredictiveScalingCustomizedCapacityMetric

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'MetricDataQueries': ([<class 'troposphere.applicationautoscaling.PredictiveScalingMetricDataQuery'>], True)}

class troposphere.applicationautoscaling.PredictiveScalingCustomizedLoadMetric(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

PredictiveScalingCustomizedLoadMetric

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'MetricDataQueries': ([<class 'troposphere.applicationautoscaling.PredictiveScalingMetricDataQuery'>], True)}

class troposphere.applicationautoscaling.PredictiveScalingCustomizedScalingMetric(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

PredictiveScalingCustomizedScalingMetric

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'MetricDataQueries': ([<class 'troposphere.applicationautoscaling.PredictiveScalingMetricDataQuery'>], True)}

class troposphere.applicationautoscaling.PredictiveScalingMetric(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

PredictiveScalingMetric

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Dimensions': ([<class 'troposphere.applicationautoscaling.PredictiveScalingMetricDimension'>], False), 'MetricName': (<class 'str'>, False), 'Namespace': (<class 'str'>, False)}

class troposphere.applicationautoscaling.PredictiveScalingMetricDataQuery(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

PredictiveScalingMetricDataQuery

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Expression': (<class 'str'>, False), 'Id': (<class 'str'>, False), 'Label': (<class 'str'>, False), 'MetricStat': (<class 'troposphere.applicationautoscaling.PredictiveScalingMetricStat'>, False), 'ReturnData': (<function boolean>, False)}

class troposphere.applicationautoscaling.PredictiveScalingMetricDimension(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

PredictiveScalingMetricDimension

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Name': (<class 'str'>, False), 'Value': (<class 'str'>, False)}

class troposphere.applicationautoscaling.PredictiveScalingMetricSpecification(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

PredictiveScalingMetricSpecification

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CustomizedCapacityMetricSpecification': (<class 'troposphere.applicationautoscaling.PredictiveScalingCustomizedCapacityMetric'>, False), 'CustomizedLoadMetricSpecification': (<class 'troposphere.applicationautoscaling.PredictiveScalingCustomizedLoadMetric'>, False), 'CustomizedScalingMetricSpecification': (<class 'troposphere.applicationautoscaling.PredictiveScalingCustomizedScalingMetric'>, False), 'PredefinedLoadMetricSpecification': (<class 'troposphere.applicationautoscaling.PredictiveScalingPredefinedLoadMetric'>, False), 'PredefinedMetricPairSpecification': (<class 'troposphere.applicationautoscaling.PredictiveScalingPredefinedMetricPair'>, False), 'PredefinedScalingMetricSpecification': (<class 'troposphere.applicationautoscaling.PredictiveScalingPredefinedScalingMetric'>, False), 'TargetValue': (<function double>, True)}

class troposphere.applicationautoscaling.PredictiveScalingMetricStat(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

PredictiveScalingMetricStat

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Metric': (<class 'troposphere.applicationautoscaling.PredictiveScalingMetric'>, False), 'Stat': (<class 'str'>, False), 'Unit': (<class 'str'>, False)}

class troposphere.applicationautoscaling.PredictiveScalingPolicyConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

PredictiveScalingPolicyConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'MaxCapacityBreachBehavior': (<class 'str'>, False), 'MaxCapacityBuffer': (<function integer>, False), 'MetricSpecifications': ([<class 'troposphere.applicationautoscaling.PredictiveScalingMetricSpecification'>], True), 'Mode': (<class 'str'>, False), 'SchedulingBufferTime': (<function integer>, False)}

class troposphere.applicationautoscaling.PredictiveScalingPredefinedLoadMetric(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

PredictiveScalingPredefinedLoadMetric

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'PredefinedMetricType': (<class 'str'>, True), 'ResourceLabel': (<class 'str'>, False)}

class troposphere.applicationautoscaling.PredictiveScalingPredefinedMetricPair(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

PredictiveScalingPredefinedMetricPair

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'PredefinedMetricType': (<class 'str'>, True), 'ResourceLabel': (<class 'str'>, False)}

class troposphere.applicationautoscaling.PredictiveScalingPredefinedScalingMetric(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

PredictiveScalingPredefinedScalingMetric

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'PredefinedMetricType': (<class 'str'>, True), 'ResourceLabel': (<class 'str'>, False)}

class troposphere.applicationautoscaling.ScalableTarget(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

ScalableTarget

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'MaxCapacity': (<function integer>, True), 'MinCapacity': (<function integer>, True), 'ResourceId': (<class 'str'>, True), 'RoleARN': (<class 'str'>, False), 'ScalableDimension': (<class 'str'>, True), 'ScheduledActions': ([<class 'troposphere.applicationautoscaling.ScheduledAction'>], False), 'ServiceNamespace': (<class 'str'>, True), 'SuspendedState': (<class 'troposphere.applicationautoscaling.SuspendedState'>, False)}

resource_type: str | None = 'AWS::ApplicationAutoScaling::ScalableTarget'

class troposphere.applicationautoscaling.ScalableTargetAction(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ScalableTargetAction

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'MaxCapacity': (<function integer>, False), 'MinCapacity': (<function integer>, False)}

class troposphere.applicationautoscaling.ScalingPolicy(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

ScalingPolicy

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'PolicyName': (<class 'str'>, True), 'PolicyType': (<class 'str'>, True), 'PredictiveScalingPolicyConfiguration': (<class 'troposphere.applicationautoscaling.PredictiveScalingPolicyConfiguration'>, False), 'ResourceId': (<class 'str'>, False), 'ScalableDimension': (<class 'str'>, False), 'ScalingTargetId': (<class 'str'>, False), 'ServiceNamespace': (<class 'str'>, False), 'StepScalingPolicyConfiguration': (<class 'troposphere.applicationautoscaling.StepScalingPolicyConfiguration'>, False), 'TargetTrackingScalingPolicyConfiguration': (<class 'troposphere.applicationautoscaling.TargetTrackingScalingPolicyConfiguration'>, False)}

resource_type: str | None = 'AWS::ApplicationAutoScaling::ScalingPolicy'

class troposphere.applicationautoscaling.ScheduledAction(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ScheduledAction

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'EndTime': (<class 'str'>, False), 'ScalableTargetAction': (<class 'troposphere.applicationautoscaling.ScalableTargetAction'>, False), 'Schedule': (<class 'str'>, True), 'ScheduledActionName': (<class 'str'>, True), 'StartTime': (<class 'str'>, False), 'Timezone': (<class 'str'>, False)}

class troposphere.applicationautoscaling.StepAdjustment(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

StepAdjustment

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'MetricIntervalLowerBound': (<function double>, False), 'MetricIntervalUpperBound': (<function double>, False), 'ScalingAdjustment': (<function integer>, True)}

class troposphere.applicationautoscaling.StepScalingPolicyConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

StepScalingPolicyConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AdjustmentType': (<class 'str'>, False), 'Cooldown': (<function integer>, False), 'MetricAggregationType': (<class 'str'>, False), 'MinAdjustmentMagnitude': (<function integer>, False), 'StepAdjustments': ([<class 'troposphere.applicationautoscaling.StepAdjustment'>], False)}

class troposphere.applicationautoscaling.SuspendedState(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

SuspendedState

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'DynamicScalingInSuspended': (<function boolean>, False), 'DynamicScalingOutSuspended': (<function boolean>, False), 'ScheduledScalingSuspended': (<function boolean>, False)}

class troposphere.applicationautoscaling.TargetTrackingMetric(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

TargetTrackingMetric

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Dimensions': ([<class 'troposphere.applicationautoscaling.TargetTrackingMetricDimension'>], False), 'MetricName': (<class 'str'>, False), 'Namespace': (<class 'str'>, False)}

class troposphere.applicationautoscaling.TargetTrackingMetricDataQuery(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

TargetTrackingMetricDataQuery

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Expression': (<class 'str'>, False), 'Id': (<class 'str'>, False), 'Label': (<class 'str'>, False), 'MetricStat': (<class 'troposphere.applicationautoscaling.TargetTrackingMetricStat'>, False), 'ReturnData': (<function boolean>, False)}

class troposphere.applicationautoscaling.TargetTrackingMetricDimension(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

TargetTrackingMetricDimension

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Name': (<class 'str'>, False), 'Value': (<class 'str'>, False)}

class troposphere.applicationautoscaling.TargetTrackingMetricStat(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

TargetTrackingMetricStat

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Metric': (<class 'troposphere.applicationautoscaling.TargetTrackingMetric'>, False), 'Stat': (<class 'str'>, False), 'Unit': (<class 'str'>, False)}

class troposphere.applicationautoscaling.TargetTrackingScalingPolicyConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

TargetTrackingScalingPolicyConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CustomizedMetricSpecification': (<class 'troposphere.applicationautoscaling.CustomizedMetricSpecification'>, False), 'DisableScaleIn': (<function boolean>, False), 'PredefinedMetricSpecification': (<class 'troposphere.applicationautoscaling.PredefinedMetricSpecification'>, False), 'ScaleInCooldown': (<function integer>, False), 'ScaleOutCooldown': (<function integer>, False), 'TargetValue': (<function double>, True)}

troposphere.applicationinsights module

class troposphere.applicationinsights.Alarm(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

Alarm

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AlarmName': (<class 'str'>, True), 'Severity': (<class 'str'>, False)}

class troposphere.applicationinsights.AlarmMetric(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

AlarmMetric

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AlarmMetricName': (<class 'str'>, True)}

class troposphere.applicationinsights.Application(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Application

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AttachMissingPermission': (<function boolean>, False), 'AutoConfigurationEnabled': (<function boolean>, False), 'CWEMonitorEnabled': (<function boolean>, False), 'ComponentMonitoringSettings': ([<class 'troposphere.applicationinsights.ComponentMonitoringSetting'>], False), 'CustomComponents': ([<class 'troposphere.applicationinsights.CustomComponent'>], False), 'GroupingType': (<class 'str'>, False), 'LogPatternSets': ([<class 'troposphere.applicationinsights.LogPatternSet'>], False), 'OpsCenterEnabled': (<function boolean>, False), 'OpsItemSNSTopicArn': (<class 'str'>, False), 'ResourceGroupName': (<class 'str'>, True), 'SNSNotificationArn': (<class 'str'>, False), 'Tags': (<class 'troposphere.Tags'>, False)}

resource_type: str | None = 'AWS::ApplicationInsights::Application'

class troposphere.applicationinsights.ComponentConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ComponentConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ConfigurationDetails': (<class 'troposphere.applicationinsights.ConfigurationDetails'>, False), 'SubComponentTypeConfigurations': ([<class 'troposphere.applicationinsights.SubComponentTypeConfiguration'>], False)}

class troposphere.applicationinsights.ComponentMonitoringSetting(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ComponentMonitoringSetting

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ComponentARN': (<class 'str'>, False), 'ComponentConfigurationMode': (<class 'str'>, True), 'ComponentName': (<class 'str'>, False), 'CustomComponentConfiguration': (<class 'troposphere.applicationinsights.ComponentConfiguration'>, False), 'DefaultOverwriteComponentConfiguration': (<class 'troposphere.applicationinsights.ComponentConfiguration'>, False), 'Tier': (<class 'str'>, True)}

class troposphere.applicationinsights.ConfigurationDetails(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ConfigurationDetails

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AlarmMetrics': ([<class 'troposphere.applicationinsights.AlarmMetric'>], False), 'Alarms': ([<class 'troposphere.applicationinsights.Alarm'>], False), 'HAClusterPrometheusExporter': (<class 'troposphere.applicationinsights.HAClusterPrometheusExporter'>, False), 'HANAPrometheusExporter': (<class 'troposphere.applicationinsights.HANAPrometheusExporter'>, False), 'JMXPrometheusExporter': (<class 'troposphere.applicationinsights.JMXPrometheusExporter'>, False), 'Logs': ([<class 'troposphere.applicationinsights.Log'>], False), 'NetWeaverPrometheusExporter': (<class 'troposphere.applicationinsights.NetWeaverPrometheusExporter'>, False), 'Processes': ([<class 'troposphere.applicationinsights.Process'>], False), 'SQLServerPrometheusExporter': (<class 'troposphere.applicationinsights.SQLServerPrometheusExporter'>, False), 'WindowsEvents': ([<class 'troposphere.applicationinsights.WindowsEvent'>], False)}

class troposphere.applicationinsights.CustomComponent(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

CustomComponent

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ComponentName': (<class 'str'>, True), 'ResourceList': ([<class 'str'>], True)}

class troposphere.applicationinsights.HAClusterPrometheusExporter(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

HAClusterPrometheusExporter

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'PrometheusPort': (<class 'str'>, False)}

class troposphere.applicationinsights.HANAPrometheusExporter(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

HANAPrometheusExporter

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AgreeToInstallHANADBClient': (<function boolean>, True), 'HANAPort': (<class 'str'>, True), 'HANASID': (<class 'str'>, True), 'HANASecretName': (<class 'str'>, True), 'PrometheusPort': (<class 'str'>, False)}

class troposphere.applicationinsights.JMXPrometheusExporter(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

JMXPrometheusExporter

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'HostPort': (<class 'str'>, False), 'JMXURL': (<class 'str'>, False), 'PrometheusPort': (<class 'str'>, False)}

class troposphere.applicationinsights.Log(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

Log

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Encoding': (<class 'str'>, False), 'LogGroupName': (<class 'str'>, False), 'LogPath': (<class 'str'>, False), 'LogType': (<class 'str'>, True), 'PatternSet': (<class 'str'>, False)}

class troposphere.applicationinsights.LogPattern(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

LogPattern

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Pattern': (<class 'str'>, True), 'PatternName': (<class 'str'>, True), 'Rank': (<function integer>, True)}

class troposphere.applicationinsights.LogPatternSet(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

LogPatternSet

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'LogPatterns': ([<class 'troposphere.applicationinsights.LogPattern'>], True), 'PatternSetName': (<class 'str'>, True)}

class troposphere.applicationinsights.NetWeaverPrometheusExporter(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

NetWeaverPrometheusExporter

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'InstanceNumbers': ([<class 'str'>], True), 'PrometheusPort': (<class 'str'>, False), 'SAPSID': (<class 'str'>, True)}

class troposphere.applicationinsights.Process(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

Process

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AlarmMetrics': ([<class 'troposphere.applicationinsights.AlarmMetric'>], True), 'ProcessName': (<class 'str'>, True)}

class troposphere.applicationinsights.SQLServerPrometheusExporter(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

SQLServerPrometheusExporter

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'PrometheusPort': (<class 'str'>, True), 'SQLSecretName': (<class 'str'>, True)}

class troposphere.applicationinsights.SubComponentConfigurationDetails(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

SubComponentConfigurationDetails

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AlarmMetrics': ([<class 'troposphere.applicationinsights.AlarmMetric'>], False), 'Logs': ([<class 'troposphere.applicationinsights.Log'>], False), 'Processes': ([<class 'troposphere.applicationinsights.Process'>], False), 'WindowsEvents': ([<class 'troposphere.applicationinsights.WindowsEvent'>], False)}

class troposphere.applicationinsights.SubComponentTypeConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

SubComponentTypeConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'SubComponentConfigurationDetails': (<class 'troposphere.applicationinsights.SubComponentConfigurationDetails'>, True), 'SubComponentType': (<class 'str'>, True)}

class troposphere.applicationinsights.WindowsEvent(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

WindowsEvent

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'EventLevels': ([<class 'str'>], True), 'EventName': (<class 'str'>, True), 'LogGroupName': (<class 'str'>, True), 'PatternSet': (<class 'str'>, False)}

troposphere.appmesh module

class troposphere.appmesh.AccessLog(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

AccessLog

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'File': (<class 'troposphere.appmesh.FileAccessLog'>, False)}

class troposphere.appmesh.AwsCloudMapInstanceAttribute(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

AwsCloudMapInstanceAttribute

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Key': (<class 'str'>, True), 'Value': (<class 'str'>, True)}

class troposphere.appmesh.AwsCloudMapServiceDiscovery(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

AwsCloudMapServiceDiscovery

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Attributes': ([<class 'troposphere.appmesh.AwsCloudMapInstanceAttribute'>], False), 'IpPreference': (<class 'str'>, False), 'NamespaceName': (<class 'str'>, True), 'ServiceName': (<class 'str'>, True)}

class troposphere.appmesh.Backend(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

Backend

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'VirtualService': (<class 'troposphere.appmesh.VirtualServiceBackend'>, False)}

class troposphere.appmesh.BackendDefaults(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

BackendDefaults

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ClientPolicy': (<class 'troposphere.appmesh.ClientPolicy'>, False)}

class troposphere.appmesh.ClientPolicy(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ClientPolicy

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'TLS': (<class 'troposphere.appmesh.ClientPolicyTls'>, False)}

class troposphere.appmesh.ClientPolicyTls(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ClientPolicyTls

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Certificate': (<class 'troposphere.appmesh.ClientTlsCertificate'>, False), 'Enforce': (<function boolean>, False), 'Ports': ([<function integer>], False), 'Validation': (<class 'troposphere.appmesh.TlsValidationContext'>, True)}

class troposphere.appmesh.ClientTlsCertificate(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ClientTlsCertificate

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'File': (<class 'troposphere.appmesh.ListenerTlsFileCertificate'>, False), 'SDS': (<class 'troposphere.appmesh.ListenerTlsSdsCertificate'>, False)}

class troposphere.appmesh.DnsServiceDiscovery(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

DnsServiceDiscovery

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Hostname': (<class 'str'>, True), 'IpPreference': (<class 'str'>, False), 'ResponseType': (<class 'str'>, False)}

class troposphere.appmesh.Duration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

Duration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Unit': (<class 'str'>, True), 'Value': (<function integer>, True)}

class troposphere.appmesh.EgressFilter(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

EgressFilter

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Type': (<class 'str'>, True)}

class troposphere.appmesh.FileAccessLog(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

FileAccessLog

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Format': (<class 'troposphere.appmesh.LoggingFormat'>, False), 'Path': (<class 'str'>, True)}

class troposphere.appmesh.GatewayRoute(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

GatewayRoute

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'GatewayRouteName': (<class 'str'>, False), 'MeshName': (<class 'str'>, True), 'MeshOwner': (<class 'str'>, False), 'Spec': (<class 'troposphere.appmesh.GatewayRouteSpec'>, True), 'Tags': (<class 'troposphere.Tags'>, False), 'VirtualGatewayName': (<class 'str'>, True)}

resource_type: str | None = 'AWS::AppMesh::GatewayRoute'

class troposphere.appmesh.GatewayRouteHostnameMatch(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

GatewayRouteHostnameMatch

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Exact': (<class 'str'>, False), 'Suffix': (<class 'str'>, False)}

class troposphere.appmesh.GatewayRouteHostnameRewrite(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

GatewayRouteHostnameRewrite

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'DefaultTargetHostname': (<class 'str'>, False)}

class troposphere.appmesh.GatewayRouteMetadataMatch(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

GatewayRouteMetadataMatch

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Exact': (<class 'str'>, False), 'Prefix': (<class 'str'>, False), 'Range': (<class 'troposphere.appmesh.GatewayRouteRangeMatch'>, False), 'Regex': (<class 'str'>, False), 'Suffix': (<class 'str'>, False)}

class troposphere.appmesh.GatewayRouteRangeMatch(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

GatewayRouteRangeMatch

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'End': (<function integer>, True), 'Start': (<function integer>, True)}

class troposphere.appmesh.GatewayRouteSpec(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

GatewayRouteSpec

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'GrpcRoute': (<class 'troposphere.appmesh.GrpcGatewayRoute'>, False), 'Http2Route': (<class 'troposphere.appmesh.HttpGatewayRoute'>, False), 'HttpRoute': (<class 'troposphere.appmesh.HttpGatewayRoute'>, False), 'Priority': (<function integer>, False)}

class troposphere.appmesh.GatewayRouteTarget(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

GatewayRouteTarget

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Port': (<function integer>, False), 'VirtualService': (<class 'troposphere.appmesh.GatewayRouteVirtualService'>, True)}

class troposphere.appmesh.GatewayRouteVirtualService(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

GatewayRouteVirtualService

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'VirtualServiceName': (<class 'str'>, True)}

class troposphere.appmesh.GrpcGatewayRoute(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

GrpcGatewayRoute

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Action': (<class 'troposphere.appmesh.GrpcGatewayRouteAction'>, True), 'Match': (<class 'troposphere.appmesh.GrpcGatewayRouteMatch'>, True)}

class troposphere.appmesh.GrpcGatewayRouteAction(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

GrpcGatewayRouteAction

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Rewrite': (<class 'troposphere.appmesh.GrpcGatewayRouteRewrite'>, False), 'Target': (<class 'troposphere.appmesh.GatewayRouteTarget'>, True)}

class troposphere.appmesh.GrpcGatewayRouteMatch(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

GrpcGatewayRouteMatch

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Hostname': (<class 'troposphere.appmesh.GatewayRouteHostnameMatch'>, False), 'Metadata': ([<class 'troposphere.appmesh.GrpcGatewayRouteMetadata'>], False), 'Port': (<function integer>, False), 'ServiceName': (<class 'str'>, False)}

class troposphere.appmesh.GrpcGatewayRouteMetadata(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

GrpcGatewayRouteMetadata

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Invert': (<function boolean>, False), 'Match': (<class 'troposphere.appmesh.GatewayRouteMetadataMatch'>, False), 'Name': (<class 'str'>, True)}

class troposphere.appmesh.GrpcGatewayRouteRewrite(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

GrpcGatewayRouteRewrite

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Hostname': (<class 'troposphere.appmesh.GatewayRouteHostnameRewrite'>, False)}

class troposphere.appmesh.GrpcRetryPolicy(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

GrpcRetryPolicy

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'GrpcRetryEvents': ([<class 'str'>], False), 'HttpRetryEvents': ([<class 'str'>], False), 'MaxRetries': (<function integer>, True), 'PerRetryTimeout': (<class 'troposphere.appmesh.Duration'>, True), 'TcpRetryEvents': ([<class 'str'>], False)}

class troposphere.appmesh.GrpcRoute(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

GrpcRoute

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Action': (<class 'troposphere.appmesh.GrpcRouteAction'>, True), 'Match': (<class 'troposphere.appmesh.GrpcRouteMatch'>, True), 'RetryPolicy': (<class 'troposphere.appmesh.GrpcRetryPolicy'>, False), 'Timeout': (<class 'troposphere.appmesh.GrpcTimeout'>, False)}

class troposphere.appmesh.GrpcRouteAction(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

GrpcRouteAction

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'WeightedTargets': ([<class 'troposphere.appmesh.WeightedTarget'>], True)}

class troposphere.appmesh.GrpcRouteMatch(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

GrpcRouteMatch

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Metadata': ([<class 'troposphere.appmesh.GrpcRouteMetadata'>], False), 'MethodName': (<class 'str'>, False), 'Port': (<function integer>, False), 'ServiceName': (<class 'str'>, False)}

class troposphere.appmesh.GrpcRouteMetadata(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

GrpcRouteMetadata

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Invert': (<function boolean>, False), 'Match': (<class 'troposphere.appmesh.GrpcRouteMetadataMatchMethod'>, False), 'Name': (<class 'str'>, True)}

class troposphere.appmesh.GrpcRouteMetadataMatchMethod(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

GrpcRouteMetadataMatchMethod

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Exact': (<class 'str'>, False), 'Prefix': (<class 'str'>, False), 'Range': (<class 'troposphere.appmesh.MatchRange'>, False), 'Regex': (<class 'str'>, False), 'Suffix': (<class 'str'>, False)}

class troposphere.appmesh.GrpcTimeout(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

GrpcTimeout

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Idle': (<class 'troposphere.appmesh.Duration'>, False), 'PerRequest': (<class 'troposphere.appmesh.Duration'>, False)}

class troposphere.appmesh.HeaderMatchMethod(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

HeaderMatchMethod

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Exact': (<class 'str'>, False), 'Prefix': (<class 'str'>, False), 'Range': (<class 'troposphere.appmesh.MatchRange'>, False), 'Regex': (<class 'str'>, False), 'Suffix': (<class 'str'>, False)}

class troposphere.appmesh.HealthCheck(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

HealthCheck

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'HealthyThreshold': (<function integer>, True), 'IntervalMillis': (<function integer>, True), 'Path': (<class 'str'>, False), 'Port': (<function integer>, False), 'Protocol': (<class 'str'>, True), 'TimeoutMillis': (<function integer>, True), 'UnhealthyThreshold': (<function integer>, True)}

class troposphere.appmesh.HttpGatewayRoute(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

HttpGatewayRoute

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Action': (<class 'troposphere.appmesh.HttpGatewayRouteAction'>, True), 'Match': (<class 'troposphere.appmesh.HttpGatewayRouteMatch'>, True)}

class troposphere.appmesh.HttpGatewayRouteAction(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

HttpGatewayRouteAction

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Rewrite': (<class 'troposphere.appmesh.HttpGatewayRouteRewrite'>, False), 'Target': (<class 'troposphere.appmesh.GatewayRouteTarget'>, True)}

class troposphere.appmesh.HttpGatewayRouteHeader(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

HttpGatewayRouteHeader

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Invert': (<function boolean>, False), 'Match': (<class 'troposphere.appmesh.HttpGatewayRouteHeaderMatch'>, False), 'Name': (<class 'str'>, True)}

class troposphere.appmesh.HttpGatewayRouteHeaderMatch(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

HttpGatewayRouteHeaderMatch

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Exact': (<class 'str'>, False), 'Prefix': (<class 'str'>, False), 'Range': (<class 'troposphere.appmesh.GatewayRouteRangeMatch'>, False), 'Regex': (<class 'str'>, False), 'Suffix': (<class 'str'>, False)}

class troposphere.appmesh.HttpGatewayRouteMatch(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

HttpGatewayRouteMatch

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Headers': ([<class 'troposphere.appmesh.HttpGatewayRouteHeader'>], False), 'Hostname': (<class 'troposphere.appmesh.GatewayRouteHostnameMatch'>, False), 'Method': (<class 'str'>, False), 'Path': (<class 'troposphere.appmesh.HttpPathMatch'>, False), 'Port': (<function integer>, False), 'Prefix': (<class 'str'>, False), 'QueryParameters': ([<class 'troposphere.appmesh.QueryParameter'>], False)}

class troposphere.appmesh.HttpGatewayRoutePathRewrite(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

HttpGatewayRoutePathRewrite

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Exact': (<class 'str'>, False)}

class troposphere.appmesh.HttpGatewayRoutePrefixRewrite(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

HttpGatewayRoutePrefixRewrite

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'DefaultPrefix': (<class 'str'>, False), 'Value': (<class 'str'>, False)}

class troposphere.appmesh.HttpGatewayRouteRewrite(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

HttpGatewayRouteRewrite

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Hostname': (<class 'troposphere.appmesh.GatewayRouteHostnameRewrite'>, False), 'Path': (<class 'troposphere.appmesh.HttpGatewayRoutePathRewrite'>, False), 'Prefix': (<class 'troposphere.appmesh.HttpGatewayRoutePrefixRewrite'>, False)}

class troposphere.appmesh.HttpPathMatch(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

HttpPathMatch

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Exact': (<class 'str'>, False), 'Regex': (<class 'str'>, False)}

class troposphere.appmesh.HttpQueryParameterMatch(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

HttpQueryParameterMatch

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Exact': (<class 'str'>, False)}

class troposphere.appmesh.HttpRetryPolicy(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

HttpRetryPolicy

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'HttpRetryEvents': ([<class 'str'>], False), 'MaxRetries': (<function integer>, True), 'PerRetryTimeout': (<class 'troposphere.appmesh.Duration'>, True), 'TcpRetryEvents': ([<class 'str'>], False)}

class troposphere.appmesh.HttpRoute(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

HttpRoute

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Action': (<class 'troposphere.appmesh.HttpRouteAction'>, True), 'Match': (<class 'troposphere.appmesh.HttpRouteMatch'>, True), 'RetryPolicy': (<class 'troposphere.appmesh.HttpRetryPolicy'>, False), 'Timeout': (<class 'troposphere.appmesh.HttpTimeout'>, False)}

class troposphere.appmesh.HttpRouteAction(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

HttpRouteAction

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'WeightedTargets': ([<class 'troposphere.appmesh.WeightedTarget'>], True)}

class troposphere.appmesh.HttpRouteHeader(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

HttpRouteHeader

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Invert': (<function boolean>, False), 'Match': (<class 'troposphere.appmesh.HeaderMatchMethod'>, False), 'Name': (<class 'str'>, True)}

class troposphere.appmesh.HttpRouteMatch(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

HttpRouteMatch

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Headers': ([<class 'troposphere.appmesh.HttpRouteHeader'>], False), 'Method': (<class 'str'>, False), 'Path': (<class 'troposphere.appmesh.HttpPathMatch'>, False), 'Port': (<function integer>, False), 'Prefix': (<class 'str'>, False), 'QueryParameters': ([<class 'troposphere.appmesh.QueryParameter'>], False), 'Scheme': (<class 'str'>, False)}

class troposphere.appmesh.HttpTimeout(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

HttpTimeout

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Idle': (<class 'troposphere.appmesh.Duration'>, False), 'PerRequest': (<class 'troposphere.appmesh.Duration'>, False)}

class troposphere.appmesh.JsonFormatRef(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

JsonFormatRef

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Key': (<class 'str'>, True), 'Value': (<class 'str'>, True)}

class troposphere.appmesh.Listener(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

Listener

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ConnectionPool': (<class 'troposphere.appmesh.VirtualNodeConnectionPool'>, False), 'HealthCheck': (<class 'troposphere.appmesh.HealthCheck'>, False), 'OutlierDetection': (<class 'troposphere.appmesh.OutlierDetection'>, False), 'PortMapping': (<class 'troposphere.appmesh.PortMapping'>, True), 'TLS': (<class 'troposphere.appmesh.ListenerTls'>, False), 'Timeout': (<class 'troposphere.appmesh.ListenerTimeout'>, False)}

class troposphere.appmesh.ListenerTimeout(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ListenerTimeout

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'GRPC': (<class 'troposphere.appmesh.GrpcTimeout'>, False), 'HTTP': (<class 'troposphere.appmesh.HttpTimeout'>, False), 'HTTP2': (<class 'troposphere.appmesh.HttpTimeout'>, False), 'TCP': (<class 'troposphere.appmesh.TcpTimeout'>, False)}

class troposphere.appmesh.ListenerTls(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ListenerTls

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Certificate': (<class 'troposphere.appmesh.ListenerTlsCertificate'>, True), 'Mode': (<function validate_listenertls_mode>, True), 'Validation': (<class 'troposphere.appmesh.ListenerTlsValidationContext'>, False)}

class troposphere.appmesh.ListenerTlsAcmCertificate(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ListenerTlsAcmCertificate

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CertificateArn': (<class 'str'>, True)}

class troposphere.appmesh.ListenerTlsCertificate(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ListenerTlsCertificate

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ACM': (<class 'troposphere.appmesh.ListenerTlsAcmCertificate'>, False), 'File': (<class 'troposphere.appmesh.ListenerTlsFileCertificate'>, False), 'SDS': (<class 'troposphere.appmesh.ListenerTlsSdsCertificate'>, False)}

class troposphere.appmesh.ListenerTlsFileCertificate(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ListenerTlsFileCertificate

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CertificateChain': (<class 'str'>, True), 'PrivateKey': (<class 'str'>, True)}

class troposphere.appmesh.ListenerTlsSdsCertificate(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ListenerTlsSdsCertificate

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'SecretName': (<class 'str'>, True)}

class troposphere.appmesh.ListenerTlsValidationContext(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ListenerTlsValidationContext

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'SubjectAlternativeNames': (<class 'troposphere.appmesh.SubjectAlternativeNames'>, False), 'Trust': (<class 'troposphere.appmesh.ListenerTlsValidationContextTrust'>, True)}

class troposphere.appmesh.ListenerTlsValidationContextTrust(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ListenerTlsValidationContextTrust

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'File': (<class 'troposphere.appmesh.TlsValidationContextFileTrust'>, False), 'SDS': (<class 'troposphere.appmesh.TlsValidationContextSdsTrust'>, False)}

class troposphere.appmesh.Logging(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

Logging

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AccessLog': (<class 'troposphere.appmesh.AccessLog'>, False)}

class troposphere.appmesh.LoggingFormat(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

LoggingFormat

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Json': ([<class 'troposphere.appmesh.JsonFormatRef'>], False), 'Text': (<class 'str'>, False)}

class troposphere.appmesh.MatchRange(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

MatchRange

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'End': (<function integer>, True), 'Start': (<function integer>, True)}

class troposphere.appmesh.Mesh(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Mesh

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'MeshName': (<class 'str'>, False), 'Spec': (<class 'troposphere.appmesh.MeshSpec'>, False), 'Tags': (<class 'troposphere.Tags'>, False)}

resource_type: str | None = 'AWS::AppMesh::Mesh'

class troposphere.appmesh.MeshServiceDiscovery(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

MeshServiceDiscovery

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'IpPreference': (<class 'str'>, False)}

class troposphere.appmesh.MeshSpec(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

MeshSpec

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'EgressFilter': (<class 'troposphere.appmesh.EgressFilter'>, False), 'ServiceDiscovery': (<class 'troposphere.appmesh.MeshServiceDiscovery'>, False)}

class troposphere.appmesh.OutlierDetection(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

OutlierDetection

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'BaseEjectionDuration': (<class 'troposphere.appmesh.Duration'>, True), 'Interval': (<class 'troposphere.appmesh.Duration'>, True), 'MaxEjectionPercent': (<function integer>, True), 'MaxServerErrors': (<function integer>, True)}

class troposphere.appmesh.PortMapping(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

PortMapping

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Port': (<function integer>, True), 'Protocol': (<class 'str'>, True)}

class troposphere.appmesh.QueryParameter(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

QueryParameter

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Match': (<class 'troposphere.appmesh.HttpQueryParameterMatch'>, False), 'Name': (<class 'str'>, True)}

class troposphere.appmesh.Route(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Route

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'MeshName': (<class 'str'>, True), 'MeshOwner': (<class 'str'>, False), 'RouteName': (<class 'str'>, False), 'Spec': (<class 'troposphere.appmesh.RouteSpec'>, True), 'Tags': (<class 'troposphere.Tags'>, False), 'VirtualRouterName': (<class 'str'>, True)}

resource_type: str | None = 'AWS::AppMesh::Route'

class troposphere.appmesh.RouteSpec(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

RouteSpec

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'GrpcRoute': (<class 'troposphere.appmesh.GrpcRoute'>, False), 'Http2Route': (<class 'troposphere.appmesh.HttpRoute'>, False), 'HttpRoute': (<class 'troposphere.appmesh.HttpRoute'>, False), 'Priority': (<function integer>, False), 'TcpRoute': (<class 'troposphere.appmesh.TcpRoute'>, False)}

class troposphere.appmesh.ServiceDiscovery(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ServiceDiscovery

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AWSCloudMap': (<class 'troposphere.appmesh.AwsCloudMapServiceDiscovery'>, False), 'DNS': (<class 'troposphere.appmesh.DnsServiceDiscovery'>, False)}

class troposphere.appmesh.SubjectAlternativeNameMatchers(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

SubjectAlternativeNameMatchers

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Exact': ([<class 'str'>], False)}

class troposphere.appmesh.SubjectAlternativeNames(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

SubjectAlternativeNames

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Match': (<class 'troposphere.appmesh.SubjectAlternativeNameMatchers'>, True)}

class troposphere.appmesh.TcpRoute(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

TcpRoute

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Action': (<class 'troposphere.appmesh.TcpRouteAction'>, True), 'Match': (<class 'troposphere.appmesh.TcpRouteMatch'>, False), 'Timeout': (<class 'troposphere.appmesh.TcpTimeout'>, False)}

class troposphere.appmesh.TcpRouteAction(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

TcpRouteAction

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'WeightedTargets': ([<class 'troposphere.appmesh.WeightedTarget'>], True)}

class troposphere.appmesh.TcpRouteMatch(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

TcpRouteMatch

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Port': (<function integer>, False)}

class troposphere.appmesh.TcpTimeout(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

TcpTimeout

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Idle': (<class 'troposphere.appmesh.Duration'>, False)}

class troposphere.appmesh.TlsValidationContext(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

TlsValidationContext

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'SubjectAlternativeNames': (<class 'troposphere.appmesh.SubjectAlternativeNames'>, False), 'Trust': (<class 'troposphere.appmesh.TlsValidationContextTrust'>, True)}

class troposphere.appmesh.TlsValidationContextAcmTrust(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

TlsValidationContextAcmTrust

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CertificateAuthorityArns': ([<class 'str'>], True)}

class troposphere.appmesh.TlsValidationContextFileTrust(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

TlsValidationContextFileTrust

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CertificateChain': (<class 'str'>, True)}

class troposphere.appmesh.TlsValidationContextSdsTrust(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

TlsValidationContextSdsTrust

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'SecretName': (<class 'str'>, True)}

class troposphere.appmesh.TlsValidationContextTrust(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

TlsValidationContextTrust

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ACM': (<class 'troposphere.appmesh.TlsValidationContextAcmTrust'>, False), 'File': (<class 'troposphere.appmesh.TlsValidationContextFileTrust'>, False), 'SDS': (<class 'troposphere.appmesh.TlsValidationContextSdsTrust'>, False)}

class troposphere.appmesh.VirtualGateway(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

VirtualGateway

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'MeshName': (<class 'str'>, True), 'MeshOwner': (<class 'str'>, False), 'Spec': (<class 'troposphere.appmesh.VirtualGatewaySpec'>, True), 'Tags': (<class 'troposphere.Tags'>, False), 'VirtualGatewayName': (<class 'str'>, False)}

resource_type: str | None = 'AWS::AppMesh::VirtualGateway'

class troposphere.appmesh.VirtualGatewayAccessLog(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VirtualGatewayAccessLog

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'File': (<class 'troposphere.appmesh.VirtualGatewayFileAccessLog'>, False)}

class troposphere.appmesh.VirtualGatewayBackendDefaults(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VirtualGatewayBackendDefaults

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ClientPolicy': (<class 'troposphere.appmesh.VirtualGatewayClientPolicy'>, False)}

class troposphere.appmesh.VirtualGatewayClientPolicy(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VirtualGatewayClientPolicy

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'TLS': (<class 'troposphere.appmesh.VirtualGatewayClientPolicyTls'>, False)}

class troposphere.appmesh.VirtualGatewayClientPolicyTls(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VirtualGatewayClientPolicyTls

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Certificate': (<class 'troposphere.appmesh.VirtualGatewayClientTlsCertificate'>, False), 'Enforce': (<function boolean>, False), 'Ports': ([<function integer>], False), 'Validation': (<class 'troposphere.appmesh.VirtualGatewayTlsValidationContext'>, True)}

class troposphere.appmesh.VirtualGatewayClientTlsCertificate(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VirtualGatewayClientTlsCertificate

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'File': (<class 'troposphere.appmesh.VirtualGatewayListenerTlsFileCertificate'>, False), 'SDS': (<class 'troposphere.appmesh.VirtualGatewayListenerTlsSdsCertificate'>, False)}

class troposphere.appmesh.VirtualGatewayConnectionPool(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VirtualGatewayConnectionPool

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'GRPC': (<class 'troposphere.appmesh.VirtualGatewayGrpcConnectionPool'>, False), 'HTTP': (<class 'troposphere.appmesh.VirtualGatewayHttpConnectionPool'>, False), 'HTTP2': (<class 'troposphere.appmesh.VirtualGatewayHttp2ConnectionPool'>, False)}

class troposphere.appmesh.VirtualGatewayFileAccessLog(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VirtualGatewayFileAccessLog

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Format': (<class 'troposphere.appmesh.LoggingFormat'>, False), 'Path': (<class 'str'>, True)}

class troposphere.appmesh.VirtualGatewayGrpcConnectionPool(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VirtualGatewayGrpcConnectionPool

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'MaxRequests': (<function integer>, True)}

class troposphere.appmesh.VirtualGatewayHealthCheckPolicy(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VirtualGatewayHealthCheckPolicy

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'HealthyThreshold': (<function integer>, True), 'IntervalMillis': (<function integer>, True), 'Path': (<class 'str'>, False), 'Port': (<function integer>, False), 'Protocol': (<class 'str'>, True), 'TimeoutMillis': (<function integer>, True), 'UnhealthyThreshold': (<function integer>, True)}

class troposphere.appmesh.VirtualGatewayHttp2ConnectionPool(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VirtualGatewayHttp2ConnectionPool

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'MaxRequests': (<function integer>, True)}

class troposphere.appmesh.VirtualGatewayHttpConnectionPool(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VirtualGatewayHttpConnectionPool

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'MaxConnections': (<function integer>, True), 'MaxPendingRequests': (<function integer>, False)}

class troposphere.appmesh.VirtualGatewayListener(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VirtualGatewayListener

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ConnectionPool': (<class 'troposphere.appmesh.VirtualGatewayConnectionPool'>, False), 'HealthCheck': (<class 'troposphere.appmesh.VirtualGatewayHealthCheckPolicy'>, False), 'PortMapping': (<class 'troposphere.appmesh.VirtualGatewayPortMapping'>, True), 'TLS': (<class 'troposphere.appmesh.VirtualGatewayListenerTls'>, False)}

class troposphere.appmesh.VirtualGatewayListenerTls(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VirtualGatewayListenerTls

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Certificate': (<class 'troposphere.appmesh.VirtualGatewayListenerTlsCertificate'>, True), 'Mode': (<class 'str'>, True), 'Validation': (<class 'troposphere.appmesh.VirtualGatewayListenerTlsValidationContext'>, False)}

class troposphere.appmesh.VirtualGatewayListenerTlsAcmCertificate(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VirtualGatewayListenerTlsAcmCertificate

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CertificateArn': (<class 'str'>, True)}

class troposphere.appmesh.VirtualGatewayListenerTlsCertificate(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VirtualGatewayListenerTlsCertificate

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ACM': (<class 'troposphere.appmesh.VirtualGatewayListenerTlsAcmCertificate'>, False), 'File': (<class 'troposphere.appmesh.VirtualGatewayListenerTlsFileCertificate'>, False), 'SDS': (<class 'troposphere.appmesh.VirtualGatewayListenerTlsSdsCertificate'>, False)}

class troposphere.appmesh.VirtualGatewayListenerTlsFileCertificate(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VirtualGatewayListenerTlsFileCertificate

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CertificateChain': (<class 'str'>, True), 'PrivateKey': (<class 'str'>, True)}

class troposphere.appmesh.VirtualGatewayListenerTlsSdsCertificate(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VirtualGatewayListenerTlsSdsCertificate

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'SecretName': (<class 'str'>, True)}

class troposphere.appmesh.VirtualGatewayListenerTlsValidationContext(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VirtualGatewayListenerTlsValidationContext

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'SubjectAlternativeNames': (<class 'troposphere.appmesh.SubjectAlternativeNames'>, False), 'Trust': (<class 'troposphere.appmesh.VirtualGatewayListenerTlsValidationContextTrust'>, True)}

class troposphere.appmesh.VirtualGatewayListenerTlsValidationContextTrust(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VirtualGatewayListenerTlsValidationContextTrust

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'File': (<class 'troposphere.appmesh.VirtualGatewayTlsValidationContextFileTrust'>, False), 'SDS': (<class 'troposphere.appmesh.VirtualGatewayTlsValidationContextSdsTrust'>, False)}

class troposphere.appmesh.VirtualGatewayLogging(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VirtualGatewayLogging

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AccessLog': (<class 'troposphere.appmesh.VirtualGatewayAccessLog'>, False)}

class troposphere.appmesh.VirtualGatewayPortMapping(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VirtualGatewayPortMapping

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Port': (<function integer>, True), 'Protocol': (<class 'str'>, True)}

class troposphere.appmesh.VirtualGatewaySpec(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VirtualGatewaySpec

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'BackendDefaults': (<class 'troposphere.appmesh.VirtualGatewayBackendDefaults'>, False), 'Listeners': ([<class 'troposphere.appmesh.VirtualGatewayListener'>], True), 'Logging': (<class 'troposphere.appmesh.VirtualGatewayLogging'>, False)}

class troposphere.appmesh.VirtualGatewayTlsValidationContext(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VirtualGatewayTlsValidationContext

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'SubjectAlternativeNames': (<class 'troposphere.appmesh.SubjectAlternativeNames'>, False), 'Trust': (<class 'troposphere.appmesh.VirtualGatewayTlsValidationContextTrust'>, True)}

class troposphere.appmesh.VirtualGatewayTlsValidationContextAcmTrust(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VirtualGatewayTlsValidationContextAcmTrust

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CertificateAuthorityArns': ([<class 'str'>], True)}

class troposphere.appmesh.VirtualGatewayTlsValidationContextFileTrust(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VirtualGatewayTlsValidationContextFileTrust

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CertificateChain': (<class 'str'>, True)}

class troposphere.appmesh.VirtualGatewayTlsValidationContextSdsTrust(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VirtualGatewayTlsValidationContextSdsTrust

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'SecretName': (<class 'str'>, True)}

class troposphere.appmesh.VirtualGatewayTlsValidationContextTrust(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VirtualGatewayTlsValidationContextTrust

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ACM': (<class 'troposphere.appmesh.VirtualGatewayTlsValidationContextAcmTrust'>, False), 'File': (<class 'troposphere.appmesh.VirtualGatewayTlsValidationContextFileTrust'>, False), 'SDS': (<class 'troposphere.appmesh.VirtualGatewayTlsValidationContextSdsTrust'>, False)}

class troposphere.appmesh.VirtualNode(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

VirtualNode

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'MeshName': (<class 'str'>, True), 'MeshOwner': (<class 'str'>, False), 'Spec': (<class 'troposphere.appmesh.VirtualNodeSpec'>, True), 'Tags': (<class 'troposphere.Tags'>, False), 'VirtualNodeName': (<class 'str'>, False)}

resource_type: str | None = 'AWS::AppMesh::VirtualNode'

class troposphere.appmesh.VirtualNodeConnectionPool(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VirtualNodeConnectionPool

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'GRPC': (<class 'troposphere.appmesh.VirtualNodeGrpcConnectionPool'>, False), 'HTTP': (<class 'troposphere.appmesh.VirtualNodeHttpConnectionPool'>, False), 'HTTP2': (<class 'troposphere.appmesh.VirtualNodeHttp2ConnectionPool'>, False), 'TCP': (<class 'troposphere.appmesh.VirtualNodeTcpConnectionPool'>, False)}

class troposphere.appmesh.VirtualNodeGrpcConnectionPool(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VirtualNodeGrpcConnectionPool

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'MaxRequests': (<function integer>, True)}

class troposphere.appmesh.VirtualNodeHttp2ConnectionPool(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VirtualNodeHttp2ConnectionPool

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'MaxRequests': (<function integer>, True)}

class troposphere.appmesh.VirtualNodeHttpConnectionPool(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VirtualNodeHttpConnectionPool

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'MaxConnections': (<function integer>, True), 'MaxPendingRequests': (<function integer>, False)}

class troposphere.appmesh.VirtualNodeServiceProvider(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VirtualNodeServiceProvider

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'VirtualNodeName': (<class 'str'>, True)}

class troposphere.appmesh.VirtualNodeSpec(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VirtualNodeSpec

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'BackendDefaults': (<class 'troposphere.appmesh.BackendDefaults'>, False), 'Backends': ([<class 'troposphere.appmesh.Backend'>], False), 'Listeners': ([<class 'troposphere.appmesh.Listener'>], False), 'Logging': (<class 'troposphere.appmesh.Logging'>, False), 'ServiceDiscovery': (<class 'troposphere.appmesh.ServiceDiscovery'>, False)}

class troposphere.appmesh.VirtualNodeTcpConnectionPool(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VirtualNodeTcpConnectionPool

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'MaxConnections': (<function integer>, True)}

class troposphere.appmesh.VirtualRouter(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

VirtualRouter

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'MeshName': (<class 'str'>, True), 'MeshOwner': (<class 'str'>, False), 'Spec': (<class 'troposphere.appmesh.VirtualRouterSpec'>, True), 'Tags': (<class 'troposphere.Tags'>, False), 'VirtualRouterName': (<class 'str'>, False)}

resource_type: str | None = 'AWS::AppMesh::VirtualRouter'

class troposphere.appmesh.VirtualRouterListener(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VirtualRouterListener

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'PortMapping': (<class 'troposphere.appmesh.PortMapping'>, True)}

class troposphere.appmesh.VirtualRouterServiceProvider(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VirtualRouterServiceProvider

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'VirtualRouterName': (<class 'str'>, True)}

class troposphere.appmesh.VirtualRouterSpec(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VirtualRouterSpec

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Listeners': ([<class 'troposphere.appmesh.VirtualRouterListener'>], True)}

class troposphere.appmesh.VirtualService(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

VirtualService

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'MeshName': (<class 'str'>, True), 'MeshOwner': (<class 'str'>, False), 'Spec': (<class 'troposphere.appmesh.VirtualServiceSpec'>, True), 'Tags': (<class 'troposphere.Tags'>, False), 'VirtualServiceName': (<class 'str'>, True)}

resource_type: str | None = 'AWS::AppMesh::VirtualService'

class troposphere.appmesh.VirtualServiceBackend(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VirtualServiceBackend

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ClientPolicy': (<class 'troposphere.appmesh.ClientPolicy'>, False), 'VirtualServiceName': (<class 'str'>, True)}

class troposphere.appmesh.VirtualServiceProvider(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VirtualServiceProvider

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'VirtualNode': (<class 'troposphere.appmesh.VirtualNodeServiceProvider'>, False), 'VirtualRouter': (<class 'troposphere.appmesh.VirtualRouterServiceProvider'>, False)}

class troposphere.appmesh.VirtualServiceSpec(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VirtualServiceSpec

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Provider': (<class 'troposphere.appmesh.VirtualServiceProvider'>, False)}

class troposphere.appmesh.WeightedTarget(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

WeightedTarget

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Port': (<function integer>, False), 'VirtualNode': (<class 'str'>, True), 'Weight': (<function integer>, True)}

troposphere.apprunner module

class troposphere.apprunner.AuthenticationConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

AuthenticationConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AccessRoleArn': (<class 'str'>, False), 'ConnectionArn': (<class 'str'>, False)}

class troposphere.apprunner.AutoScalingConfiguration(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

AutoScalingConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AutoScalingConfigurationName': (<class 'str'>, False), 'MaxConcurrency': (<function integer>, False), 'MaxSize': (<function integer>, False), 'MinSize': (<function integer>, False), 'Tags': (<class 'troposphere.Tags'>, False)}

resource_type: str | None = 'AWS::AppRunner::AutoScalingConfiguration'

class troposphere.apprunner.CodeConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

CodeConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CodeConfigurationValues': (<class 'troposphere.apprunner.CodeConfigurationValues'>, False), 'ConfigurationSource': (<class 'str'>, True)}

class troposphere.apprunner.CodeConfigurationValues(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

CodeConfigurationValues

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'BuildCommand': (<class 'str'>, False), 'Port': (<class 'str'>, False), 'Runtime': (<class 'str'>, True), 'RuntimeEnvironmentSecrets': ([<class 'troposphere.apprunner.KeyValuePair'>], False), 'RuntimeEnvironmentVariables': ([<class 'troposphere.apprunner.KeyValuePair'>], False), 'StartCommand': (<class 'str'>, False)}

class troposphere.apprunner.CodeRepository(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

CodeRepository

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CodeConfiguration': (<class 'troposphere.apprunner.CodeConfiguration'>, False), 'RepositoryUrl': (<class 'str'>, True), 'SourceCodeVersion': (<class 'troposphere.apprunner.SourceCodeVersion'>, True), 'SourceDirectory': (<class 'str'>, False)}

class troposphere.apprunner.EgressConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

EgressConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'EgressType': (<class 'str'>, True), 'VpcConnectorArn': (<class 'str'>, False)}

class troposphere.apprunner.EncryptionConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

EncryptionConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'KmsKey': (<class 'str'>, True)}

class troposphere.apprunner.HealthCheckConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

HealthCheckConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'HealthyThreshold': (<function integer>, False), 'Interval': (<function integer>, False), 'Path': (<class 'str'>, False), 'Protocol': (<class 'str'>, False), 'Timeout': (<function integer>, False), 'UnhealthyThreshold': (<function integer>, False)}

class troposphere.apprunner.ImageConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ImageConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Port': (<class 'str'>, False), 'RuntimeEnvironmentSecrets': ([<class 'troposphere.apprunner.KeyValuePair'>], False), 'RuntimeEnvironmentVariables': ([<class 'troposphere.apprunner.KeyValuePair'>], False), 'StartCommand': (<class 'str'>, False)}

class troposphere.apprunner.ImageRepository(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ImageRepository

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ImageConfiguration': (<class 'troposphere.apprunner.ImageConfiguration'>, False), 'ImageIdentifier': (<class 'str'>, True), 'ImageRepositoryType': (<class 'str'>, True)}

class troposphere.apprunner.IngressConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

IngressConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'IsPubliclyAccessible': (<function boolean>, True)}

class troposphere.apprunner.IngressVpcConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

IngressVpcConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'VpcEndpointId': (<class 'str'>, True), 'VpcId': (<class 'str'>, True)}

class troposphere.apprunner.InstanceConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

InstanceConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Cpu': (<class 'str'>, False), 'InstanceRoleArn': (<class 'str'>, False), 'Memory': (<class 'str'>, False)}

class troposphere.apprunner.KeyValuePair(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

KeyValuePair

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Name': (<class 'str'>, False), 'Value': (<class 'str'>, False)}

class troposphere.apprunner.NetworkConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

NetworkConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'EgressConfiguration': (<class 'troposphere.apprunner.EgressConfiguration'>, False), 'IngressConfiguration': (<class 'troposphere.apprunner.IngressConfiguration'>, False), 'IpAddressType': (<class 'str'>, False)}

class troposphere.apprunner.ObservabilityConfiguration(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

ObservabilityConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ObservabilityConfigurationName': (<class 'str'>, False), 'Tags': (<class 'troposphere.Tags'>, False), 'TraceConfiguration': (<class 'troposphere.apprunner.TraceConfiguration'>, False)}

resource_type: str | None = 'AWS::AppRunner::ObservabilityConfiguration'

class troposphere.apprunner.Service(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Service

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AutoScalingConfigurationArn': (<class 'str'>, False), 'EncryptionConfiguration': (<class 'troposphere.apprunner.EncryptionConfiguration'>, False), 'HealthCheckConfiguration': (<class 'troposphere.apprunner.HealthCheckConfiguration'>, False), 'InstanceConfiguration': (<class 'troposphere.apprunner.InstanceConfiguration'>, False), 'NetworkConfiguration': (<class 'troposphere.apprunner.NetworkConfiguration'>, False), 'ObservabilityConfiguration': (<class 'troposphere.apprunner.ServiceObservabilityConfiguration'>, False), 'ServiceName': (<class 'str'>, False), 'SourceConfiguration': (<class 'troposphere.apprunner.SourceConfiguration'>, True), 'Tags': (<class 'troposphere.Tags'>, False)}

resource_type: str | None = 'AWS::AppRunner::Service'

class troposphere.apprunner.ServiceObservabilityConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ServiceObservabilityConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ObservabilityConfigurationArn': (<class 'str'>, False), 'ObservabilityEnabled': (<function boolean>, True)}

class troposphere.apprunner.SourceCodeVersion(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

SourceCodeVersion

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Type': (<class 'str'>, True), 'Value': (<class 'str'>, True)}

class troposphere.apprunner.SourceConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

SourceConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AuthenticationConfiguration': (<class 'troposphere.apprunner.AuthenticationConfiguration'>, False), 'AutoDeploymentsEnabled': (<function boolean>, False), 'CodeRepository': (<class 'troposphere.apprunner.CodeRepository'>, False), 'ImageRepository': (<class 'troposphere.apprunner.ImageRepository'>, False)}

class troposphere.apprunner.TraceConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

TraceConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Vendor': (<class 'str'>, True)}

class troposphere.apprunner.VpcConnector(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

VpcConnector

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'SecurityGroups': ([<class 'str'>], False), 'Subnets': ([<class 'str'>], True), 'Tags': (<class 'troposphere.Tags'>, False), 'VpcConnectorName': (<class 'str'>, False)}

resource_type: str | None = 'AWS::AppRunner::VpcConnector'

class troposphere.apprunner.VpcIngressConnection(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

VpcIngressConnection

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'IngressVpcConfiguration': (<class 'troposphere.apprunner.IngressVpcConfiguration'>, True), 'ServiceArn': (<class 'str'>, True), 'Tags': (<class 'troposphere.Tags'>, False), 'VpcIngressConnectionName': (<class 'str'>, False)}

resource_type: str | None = 'AWS::AppRunner::VpcIngressConnection'

troposphere.appstream module

class troposphere.appstream.AccessEndpoint(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

AccessEndpoint

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'EndpointType': (<class 'str'>, True), 'VpceId': (<class 'str'>, True)}

class troposphere.appstream.AppBlock(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

AppBlock

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Description': (<class 'str'>, False), 'DisplayName': (<class 'str'>, False), 'Name': (<class 'str'>, True), 'PackagingType': (<class 'str'>, False), 'PostSetupScriptDetails': (<class 'troposphere.appstream.ScriptDetails'>, False), 'SetupScriptDetails': (<class 'troposphere.appstream.ScriptDetails'>, False), 'SourceS3Location': (<class 'troposphere.appstream.S3Location'>, True), 'Tags': (<function validate_tags_or_list>, False)}

resource_type: str | None = 'AWS::AppStream::AppBlock'

class troposphere.appstream.AppBlockBuilder(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

AppBlockBuilder

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AccessEndpoints': ([<class 'troposphere.appstream.AccessEndpoint'>], False), 'AppBlockArns': ([<class 'str'>], False), 'Description': (<class 'str'>, False), 'DisplayName': (<class 'str'>, False), 'EnableDefaultInternetAccess': (<function boolean>, False), 'IamRoleArn': (<class 'str'>, False), 'InstanceType': (<class 'str'>, True), 'Name': (<class 'str'>, True), 'Platform': (<class 'str'>, True), 'Tags': (<class 'troposphere.Tags'>, False), 'VpcConfig': (<class 'troposphere.appstream.VpcConfig'>, True)}

resource_type: str | None = 'AWS::AppStream::AppBlockBuilder'

class troposphere.appstream.Application(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Application

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AppBlockArn': (<class 'str'>, True), 'AttributesToDelete': ([<class 'str'>], False), 'Description': (<class 'str'>, False), 'DisplayName': (<class 'str'>, False), 'IconS3Location': (<class 'troposphere.appstream.S3Location'>, True), 'InstanceFamilies': ([<class 'str'>], True), 'LaunchParameters': (<class 'str'>, False), 'LaunchPath': (<class 'str'>, True), 'Name': (<class 'str'>, True), 'Platforms': ([<class 'str'>], True), 'Tags': (<function validate_tags_or_list>, False), 'WorkingDirectory': (<class 'str'>, False)}

resource_type: str | None = 'AWS::AppStream::Application'

class troposphere.appstream.ApplicationEntitlementAssociation(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

ApplicationEntitlementAssociation

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApplicationIdentifier': (<class 'str'>, True), 'EntitlementName': (<class 'str'>, True), 'StackName': (<class 'str'>, True)}

resource_type: str | None = 'AWS::AppStream::ApplicationEntitlementAssociation'

class troposphere.appstream.ApplicationFleetAssociation(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

ApplicationFleetAssociation

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApplicationArn': (<class 'str'>, True), 'FleetName': (<class 'str'>, True)}

resource_type: str | None = 'AWS::AppStream::ApplicationFleetAssociation'

class troposphere.appstream.ApplicationSettings(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ApplicationSettings

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Enabled': (<function boolean>, True), 'SettingsGroup': (<class 'str'>, False)}

class troposphere.appstream.Attribute(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

Attribute

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Name': (<class 'str'>, True), 'Value': (<class 'str'>, True)}

class troposphere.appstream.CertificateBasedAuthProperties(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

CertificateBasedAuthProperties

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CertificateAuthorityArn': (<class 'str'>, False), 'Status': (<class 'str'>, False)}

class troposphere.appstream.ComputeCapacity(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ComputeCapacity

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'DesiredInstances': (<function integer>, False), 'DesiredSessions': (<function integer>, False)}

class troposphere.appstream.ContentRedirection(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ContentRedirection

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'HostToClient': (<class 'troposphere.appstream.UrlRedirectionConfig'>, False)}

class troposphere.appstream.DirectoryConfig(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

DirectoryConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CertificateBasedAuthProperties': (<class 'troposphere.appstream.CertificateBasedAuthProperties'>, False), 'DirectoryName': (<class 'str'>, True), 'OrganizationalUnitDistinguishedNames': ([<class 'str'>], True), 'ServiceAccountCredentials': (<class 'troposphere.appstream.ServiceAccountCredentials'>, True)}

resource_type: str | None = 'AWS::AppStream::DirectoryConfig'

class troposphere.appstream.DomainJoinInfo(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

DomainJoinInfo

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'DirectoryName': (<class 'str'>, False), 'OrganizationalUnitDistinguishedName': (<class 'str'>, False)}

class troposphere.appstream.Entitlement(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Entitlement

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AppVisibility': (<class 'str'>, True), 'Attributes': ([<class 'troposphere.appstream.Attribute'>], True), 'Description': (<class 'str'>, False), 'Name': (<class 'str'>, True), 'StackName': (<class 'str'>, True)}

resource_type: str | None = 'AWS::AppStream::Entitlement'

class troposphere.appstream.Fleet(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Fleet

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ComputeCapacity': (<class 'troposphere.appstream.ComputeCapacity'>, False), 'Description': (<class 'str'>, False), 'DisableIMDSV1': (<function boolean>, False), 'DisconnectTimeoutInSeconds': (<function integer>, False), 'DisplayName': (<class 'str'>, False), 'DomainJoinInfo': (<class 'troposphere.appstream.DomainJoinInfo'>, False), 'EnableDefaultInternetAccess': (<function boolean>, False), 'FleetType': (<class 'str'>, False), 'IamRoleArn': (<class 'str'>, False), 'IdleDisconnectTimeoutInSeconds': (<function integer>, False), 'ImageArn': (<class 'str'>, False), 'ImageName': (<class 'str'>, False), 'InstanceType': (<class 'str'>, True), 'MaxConcurrentSessions': (<function integer>, False), 'MaxSessionsPerInstance': (<function integer>, False), 'MaxUserDurationInSeconds': (<function integer>, False), 'Name': (<class 'str'>, True), 'Platform': (<class 'str'>, False), 'RootVolumeConfig': (<class 'troposphere.appstream.VolumeConfig'>, False), 'SessionScriptS3Location': (<class 'troposphere.appstream.S3Location'>, False), 'StreamView': (<class 'str'>, False), 'Tags': (<function validate_tags_or_list>, False), 'UsbDeviceFilterStrings': ([<class 'str'>], False), 'VpcConfig': (<class 'troposphere.appstream.VpcConfig'>, False)}

resource_type: str | None = 'AWS::AppStream::Fleet'

class troposphere.appstream.ImageBuilder(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

ImageBuilder

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AccessEndpoints': ([<class 'troposphere.appstream.AccessEndpoint'>], False), 'AppstreamAgentVersion': (<class 'str'>, False), 'Description': (<class 'str'>, False), 'DisplayName': (<class 'str'>, False), 'DomainJoinInfo': (<class 'troposphere.appstream.DomainJoinInfo'>, False), 'EnableDefaultInternetAccess': (<function boolean>, False), 'IamRoleArn': (<class 'str'>, False), 'ImageArn': (<class 'str'>, False), 'ImageName': (<class 'str'>, False), 'InstanceType': (<class 'str'>, True), 'Name': (<class 'str'>, True), 'RootVolumeConfig': (<class 'troposphere.appstream.VolumeConfig'>, False), 'SoftwaresToInstall': ([<class 'str'>], False), 'SoftwaresToUninstall': ([<class 'str'>], False), 'Tags': (<function validate_tags_or_list>, False), 'VpcConfig': (<class 'troposphere.appstream.VpcConfig'>, False)}

resource_type: str | None = 'AWS::AppStream::ImageBuilder'

class troposphere.appstream.S3Location(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

S3Location

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'S3Bucket': (<class 'str'>, True), 'S3Key': (<class 'str'>, True)}

class troposphere.appstream.ScriptDetails(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ScriptDetails

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ExecutableParameters': (<class 'str'>, False), 'ExecutablePath': (<class 'str'>, True), 'ScriptS3Location': (<class 'troposphere.appstream.S3Location'>, True), 'TimeoutInSeconds': (<function integer>, True)}

class troposphere.appstream.ServiceAccountCredentials(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ServiceAccountCredentials

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AccountName': (<class 'str'>, True), 'AccountPassword': (<class 'str'>, True)}

class troposphere.appstream.Stack(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Stack

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AccessEndpoints': ([<class 'troposphere.appstream.AccessEndpoint'>], False), 'ApplicationSettings': (<class 'troposphere.appstream.ApplicationSettings'>, False), 'AttributesToDelete': ([<class 'str'>], False), 'ContentRedirection': (<class 'troposphere.appstream.ContentRedirection'>, False), 'DeleteStorageConnectors': (<function boolean>, False), 'Description': (<class 'str'>, False), 'DisplayName': (<class 'str'>, False), 'EmbedHostDomains': ([<class 'str'>], False), 'FeedbackURL': (<class 'str'>, False), 'Name': (<class 'str'>, False), 'RedirectURL': (<class 'str'>, False), 'StorageConnectors': ([<class 'troposphere.appstream.StorageConnector'>], False), 'StreamingExperienceSettings': (<class 'troposphere.appstream.StreamingExperienceSettings'>, False), 'Tags': (<function validate_tags_or_list>, False), 'UserSettings': ([<class 'troposphere.appstream.UserSetting'>], False)}

resource_type: str | None = 'AWS::AppStream::Stack'

class troposphere.appstream.StackFleetAssociation(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

StackFleetAssociation

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'FleetName': (<class 'str'>, True), 'StackName': (<class 'str'>, True)}

resource_type: str | None = 'AWS::AppStream::StackFleetAssociation'

class troposphere.appstream.StackUserAssociation(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

StackUserAssociation

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AuthenticationType': (<class 'str'>, True), 'SendEmailNotification': (<function boolean>, False), 'StackName': (<class 'str'>, True), 'UserName': (<class 'str'>, True)}

resource_type: str | None = 'AWS::AppStream::StackUserAssociation'

class troposphere.appstream.StorageConnector(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

StorageConnector

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ConnectorType': (<class 'str'>, True), 'Domains': ([<class 'str'>], False), 'ResourceIdentifier': (<class 'str'>, False)}

class troposphere.appstream.StreamingExperienceSettings(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

StreamingExperienceSettings

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'PreferredProtocol': (<class 'str'>, False)}

class troposphere.appstream.UrlRedirectionConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

UrlRedirectionConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AllowedUrls': ([<class 'str'>], False), 'DeniedUrls': ([<class 'str'>], False), 'Enabled': (<function boolean>, True)}

class troposphere.appstream.User(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

User

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AuthenticationType': (<class 'str'>, True), 'FirstName': (<class 'str'>, False), 'LastName': (<class 'str'>, False), 'MessageAction': (<class 'str'>, False), 'UserName': (<class 'str'>, True)}

resource_type: str | None = 'AWS::AppStream::User'

class troposphere.appstream.UserSetting(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

UserSetting

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Action': (<class 'str'>, True), 'MaximumLength': (<function integer>, False), 'Permission': (<class 'str'>, True)}

class troposphere.appstream.VolumeConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VolumeConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'VolumeSizeInGb': (<function integer>, False)}

class troposphere.appstream.VpcConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VpcConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'SecurityGroupIds': ([<class 'str'>], False), 'SubnetIds': ([<class 'str'>], False)}

troposphere.appsync module

class troposphere.appsync.AdditionalAuthenticationProvider(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

AdditionalAuthenticationProvider

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AuthenticationType': (<class 'str'>, True), 'LambdaAuthorizerConfig': (<class 'troposphere.appsync.LambdaAuthorizerConfig'>, False), 'OpenIDConnectConfig': (<class 'troposphere.appsync.OpenIDConnectConfig'>, False), 'UserPoolConfig': (<class 'troposphere.appsync.CognitoUserPoolConfig'>, False)}

class troposphere.appsync.Api(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Api

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'EventConfig': (<class 'troposphere.appsync.EventConfig'>, False), 'Name': (<class 'str'>, True), 'OwnerContact': (<class 'str'>, False), 'Tags': (<class 'troposphere.Tags'>, False)}

resource_type: str | None = 'AWS::AppSync::Api'

class troposphere.appsync.ApiCache(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

ApiCache

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApiCachingBehavior': (<class 'str'>, True), 'ApiId': (<class 'str'>, True), 'AtRestEncryptionEnabled': (<function boolean>, False), 'HealthMetricsConfig': (<class 'str'>, False), 'TransitEncryptionEnabled': (<function boolean>, False), 'Ttl': (<function double>, True), 'Type': (<class 'str'>, True)}

resource_type: str | None = 'AWS::AppSync::ApiCache'

class troposphere.appsync.ApiKey(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

ApiKey

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApiId': (<class 'str'>, True), 'ApiKeyId': (<class 'str'>, False), 'Description': (<class 'str'>, False), 'Expires': (<function double>, False)}

resource_type: str | None = 'AWS::AppSync::ApiKey'

class troposphere.appsync.AppSyncRuntime(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

AppSyncRuntime

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Name': (<class 'str'>, True), 'RuntimeVersion': (<class 'str'>, True)}

class troposphere.appsync.AuthMode(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

AuthMode

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AuthType': (<class 'str'>, False)}

class troposphere.appsync.AuthProvider(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

AuthProvider

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AuthType': (<class 'str'>, True), 'CognitoConfig': (<class 'troposphere.appsync.CognitoConfig'>, False), 'LambdaAuthorizerConfig': (<class 'troposphere.appsync.LambdaAuthorizerConfig'>, False), 'OpenIDConnectConfig': (<class 'troposphere.appsync.OpenIDConnectConfig'>, False)}

class troposphere.appsync.AuthorizationConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

AuthorizationConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AuthorizationType': (<class 'str'>, True), 'AwsIamConfig': (<class 'troposphere.appsync.AwsIamConfig'>, False)}

class troposphere.appsync.AwsIamConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

AwsIamConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'SigningRegion': (<class 'str'>, False), 'SigningServiceName': (<class 'str'>, False)}

class troposphere.appsync.CachingConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

CachingConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CachingKeys': ([<class 'str'>], False), 'Ttl': (<function double>, True)}

class troposphere.appsync.ChannelNamespace(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

ChannelNamespace

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApiId': (<class 'str'>, True), 'CodeHandlers': (<class 'str'>, False), 'CodeS3Location': (<class 'str'>, False), 'HandlerConfigs': (<class 'troposphere.appsync.HandlerConfigs'>, False), 'Name': (<class 'str'>, True), 'PublishAuthModes': ([<class 'troposphere.appsync.AuthMode'>], False), 'SubscribeAuthModes': ([<class 'troposphere.appsync.AuthMode'>], False), 'Tags': (<class 'troposphere.Tags'>, False)}

resource_type: str | None = 'AWS::AppSync::ChannelNamespace'

class troposphere.appsync.CognitoConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

CognitoConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AppIdClientRegex': (<class 'str'>, False), 'AwsRegion': (<class 'str'>, True), 'UserPoolId': (<class 'str'>, True)}

class troposphere.appsync.CognitoUserPoolConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

CognitoUserPoolConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AppIdClientRegex': (<class 'str'>, False), 'AwsRegion': (<class 'str'>, False), 'UserPoolId': (<class 'str'>, False)}

class troposphere.appsync.DataSource(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

DataSource

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApiId': (<class 'str'>, True), 'Description': (<class 'str'>, False), 'DynamoDBConfig': (<class 'troposphere.appsync.DynamoDBConfig'>, False), 'EventBridgeConfig': (<class 'troposphere.appsync.EventBridgeConfig'>, False), 'HttpConfig': (<class 'troposphere.appsync.HttpConfig'>, False), 'LambdaConfig': (<class 'troposphere.appsync.LambdaConfig'>, False), 'MetricsConfig': (<class 'str'>, False), 'Name': (<class 'str'>, True), 'OpenSearchServiceConfig': (<class 'troposphere.appsync.OpenSearchServiceConfig'>, False), 'RelationalDatabaseConfig': (<class 'troposphere.appsync.RelationalDatabaseConfig'>, False), 'ServiceRoleArn': (<class 'str'>, False), 'Type': (<class 'str'>, True)}

resource_type: str | None = 'AWS::AppSync::DataSource'

class troposphere.appsync.DeltaSyncConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

DeltaSyncConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'BaseTableTTL': (<class 'str'>, True), 'DeltaSyncTableName': (<class 'str'>, True), 'DeltaSyncTableTTL': (<class 'str'>, True)}

class troposphere.appsync.DnsMap(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

DnsMap

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Http': (<class 'str'>, False), 'Realtime': (<class 'str'>, False)}

class troposphere.appsync.DomainName(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

DomainName

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CertificateArn': (<class 'str'>, True), 'Description': (<class 'str'>, False), 'DomainName': (<class 'str'>, True), 'Tags': (<class 'troposphere.Tags'>, False)}

resource_type: str | None = 'AWS::AppSync::DomainName'

class troposphere.appsync.DomainNameApiAssociation(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

DomainNameApiAssociation

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApiId': (<class 'str'>, True), 'DomainName': (<class 'str'>, True)}

resource_type: str | None = 'AWS::AppSync::DomainNameApiAssociation'

class troposphere.appsync.DynamoDBConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

DynamoDBConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AwsRegion': (<class 'str'>, True), 'DeltaSyncConfig': (<class 'troposphere.appsync.DeltaSyncConfig'>, False), 'TableName': (<class 'str'>, True), 'UseCallerCredentials': (<function boolean>, False), 'Versioned': (<function boolean>, False)}

class troposphere.appsync.EnhancedMetricsConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

EnhancedMetricsConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'DataSourceLevelMetricsBehavior': (<class 'str'>, True), 'OperationLevelMetricsConfig': (<class 'str'>, True), 'ResolverLevelMetricsBehavior': (<class 'str'>, True)}

class troposphere.appsync.EventBridgeConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

EventBridgeConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'EventBusArn': (<class 'str'>, True)}

class troposphere.appsync.EventConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

EventConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AuthProviders': ([<class 'troposphere.appsync.AuthProvider'>], True), 'ConnectionAuthModes': ([<class 'troposphere.appsync.AuthMode'>], True), 'DefaultPublishAuthModes': ([<class 'troposphere.appsync.AuthMode'>], True), 'DefaultSubscribeAuthModes': ([<class 'troposphere.appsync.AuthMode'>], True), 'LogConfig': (<class 'troposphere.appsync.EventLogConfig'>, False)}

class troposphere.appsync.EventLogConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

EventLogConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CloudWatchLogsRoleArn': (<class 'str'>, True), 'LogLevel': (<class 'str'>, True)}

class troposphere.appsync.FunctionConfiguration(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

FunctionConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApiId': (<class 'str'>, True), 'Code': (<class 'str'>, False), 'CodeS3Location': (<class 'str'>, False), 'DataSourceName': (<class 'str'>, True), 'Description': (<class 'str'>, False), 'FunctionVersion': (<class 'str'>, False), 'MaxBatchSize': (<function integer>, False), 'Name': (<class 'str'>, True), 'RequestMappingTemplate': (<class 'str'>, False), 'RequestMappingTemplateS3Location': (<class 'str'>, False), 'ResponseMappingTemplate': (<class 'str'>, False), 'ResponseMappingTemplateS3Location': (<class 'str'>, False), 'Runtime': (<class 'troposphere.appsync.AppSyncRuntime'>, False), 'SyncConfig': (<class 'troposphere.appsync.SyncConfig'>, False)}

resource_type: str | None = 'AWS::AppSync::FunctionConfiguration'

class troposphere.appsync.GraphQLApi(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

GraphQLApi

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AdditionalAuthenticationProviders': ([<class 'troposphere.appsync.AdditionalAuthenticationProvider'>], False), 'ApiType': (<class 'str'>, False), 'AuthenticationType': (<class 'str'>, True), 'EnhancedMetricsConfig': (<class 'troposphere.appsync.EnhancedMetricsConfig'>, False), 'EnvironmentVariables': (<class 'dict'>, False), 'IntrospectionConfig': (<class 'str'>, False), 'LambdaAuthorizerConfig': (<class 'troposphere.appsync.LambdaAuthorizerConfig'>, False), 'LogConfig': (<class 'troposphere.appsync.LogConfig'>, False), 'MergedApiExecutionRoleArn': (<class 'str'>, False), 'Name': (<class 'str'>, True), 'OpenIDConnectConfig': (<class 'troposphere.appsync.OpenIDConnectConfig'>, False), 'OwnerContact': (<class 'str'>, False), 'QueryDepthLimit': (<function integer>, False), 'ResolverCountLimit': (<function integer>, False), 'Tags': (<class 'troposphere.Tags'>, False), 'UserPoolConfig': (<class 'troposphere.appsync.UserPoolConfig'>, False), 'Visibility': (<class 'str'>, False), 'XrayEnabled': (<function boolean>, False)}

resource_type: str | None = 'AWS::AppSync::GraphQLApi'

class troposphere.appsync.GraphQLSchema(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

GraphQLSchema

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApiId': (<class 'str'>, True), 'Definition': (<class 'str'>, False), 'DefinitionS3Location': (<class 'str'>, False)}

resource_type: str | None = 'AWS::AppSync::GraphQLSchema'

class troposphere.appsync.HandlerConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

HandlerConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Behavior': (<class 'str'>, True), 'Integration': (<class 'troposphere.appsync.Integration'>, True)}

class troposphere.appsync.HandlerConfigs(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

HandlerConfigs

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'OnPublish': (<class 'troposphere.appsync.HandlerConfig'>, False), 'OnSubscribe': (<class 'troposphere.appsync.HandlerConfig'>, False)}

class troposphere.appsync.HttpConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

HttpConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AuthorizationConfig': (<class 'troposphere.appsync.AuthorizationConfig'>, False), 'Endpoint': (<class 'str'>, True)}

class troposphere.appsync.Integration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

Integration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'DataSourceName': (<class 'str'>, True), 'LambdaConfig': (<class 'troposphere.appsync.LambdaConfig'>, False)}

class troposphere.appsync.LambdaAuthorizerConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

LambdaAuthorizerConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AuthorizerResultTtlInSeconds': (<function double>, False), 'AuthorizerUri': (<class 'str'>, False), 'IdentityValidationExpression': (<class 'str'>, False)}

class troposphere.appsync.LambdaConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

LambdaConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'LambdaFunctionArn': (<class 'str'>, True)}

class troposphere.appsync.LambdaConflictHandlerConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

LambdaConflictHandlerConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'LambdaConflictHandlerArn': (<class 'str'>, False)}

class troposphere.appsync.LogConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

LogConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CloudWatchLogsRoleArn': (<class 'str'>, True), 'ExcludeVerboseContent': (<function boolean>, False), 'FieldLogLevel': (<class 'str'>, True)}

class troposphere.appsync.OpenIDConnectConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

OpenIDConnectConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AuthTTL': (<function double>, False), 'ClientId': (<class 'str'>, False), 'IatTTL': (<function double>, False), 'Issuer': (<class 'str'>, False)}

class troposphere.appsync.OpenSearchServiceConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

OpenSearchServiceConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AwsRegion': (<class 'str'>, True), 'Endpoint': (<class 'str'>, True)}

class troposphere.appsync.PipelineConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

PipelineConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Functions': ([<class 'str'>], False)}

class troposphere.appsync.RdsHttpEndpointConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

RdsHttpEndpointConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AwsRegion': (<class 'str'>, True), 'AwsSecretStoreArn': (<class 'str'>, True), 'DatabaseName': (<class 'str'>, False), 'DbClusterIdentifier': (<class 'str'>, True), 'Schema': (<class 'str'>, False)}

class troposphere.appsync.RelationalDatabaseConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

RelationalDatabaseConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'RdsHttpEndpointConfig': (<class 'troposphere.appsync.RdsHttpEndpointConfig'>, False), 'RelationalDatabaseSourceType': (<class 'str'>, True)}

class troposphere.appsync.Resolver(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Resolver

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApiId': (<class 'str'>, True), 'CachingConfig': (<class 'troposphere.appsync.CachingConfig'>, False), 'Code': (<class 'str'>, False), 'CodeS3Location': (<class 'str'>, False), 'DataSourceName': (<class 'str'>, False), 'FieldName': (<class 'str'>, True), 'Kind': (<function resolver_kind_validator>, False), 'MaxBatchSize': (<function integer>, False), 'MetricsConfig': (<class 'str'>, False), 'PipelineConfig': (<class 'troposphere.appsync.PipelineConfig'>, False), 'RequestMappingTemplate': (<class 'str'>, False), 'RequestMappingTemplateS3Location': (<class 'str'>, False), 'ResponseMappingTemplate': (<class 'str'>, False), 'ResponseMappingTemplateS3Location': (<class 'str'>, False), 'Runtime': (<class 'troposphere.appsync.AppSyncRuntime'>, False), 'SyncConfig': (<class 'troposphere.appsync.SyncConfig'>, False), 'TypeName': (<class 'str'>, True)}

resource_type: str | None = 'AWS::AppSync::Resolver'

class troposphere.appsync.SourceApiAssociation(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

SourceApiAssociation

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Description': (<class 'str'>, False), 'MergedApiIdentifier': (<class 'str'>, False), 'SourceApiAssociationConfig': (<class 'troposphere.appsync.SourceApiAssociationConfig'>, False), 'SourceApiIdentifier': (<class 'str'>, False)}

resource_type: str | None = 'AWS::AppSync::SourceApiAssociation'

class troposphere.appsync.SourceApiAssociationConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

SourceApiAssociationConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'MergeType': (<class 'str'>, False)}

class troposphere.appsync.SyncConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

SyncConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ConflictDetection': (<class 'str'>, True), 'ConflictHandler': (<class 'str'>, False), 'LambdaConflictHandlerConfig': (<class 'troposphere.appsync.LambdaConflictHandlerConfig'>, False)}

class troposphere.appsync.UserPoolConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

UserPoolConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AppIdClientRegex': (<class 'str'>, False), 'AwsRegion': (<class 'str'>, False), 'DefaultAction': (<class 'str'>, False), 'UserPoolId': (<class 'str'>, False)}

troposphere.aps module

class troposphere.aps.AmpConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

AmpConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'WorkspaceArn': (<class 'str'>, True)}

class troposphere.aps.AnomalyDetector(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

AnomalyDetector

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Alias': (<class 'str'>, True), 'Configuration': (<class 'troposphere.aps.AnomalyDetectorConfiguration'>, True), 'EvaluationIntervalInSeconds': (<function integer>, False), 'Labels': ([<class 'troposphere.aps.Label'>], False), 'MissingDataAction': (<class 'troposphere.aps.MissingDataAction'>, False), 'Tags': (<class 'troposphere.Tags'>, False), 'Workspace': (<class 'str'>, True)}

resource_type: str | None = 'AWS::APS::AnomalyDetector'

class troposphere.aps.AnomalyDetectorConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

AnomalyDetectorConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'RandomCutForest': (<class 'troposphere.aps.RandomCutForestConfiguration'>, True)}

class troposphere.aps.CloudWatchLogDestination(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

CloudWatchLogDestination

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'LogGroupArn': (<class 'str'>, True)}

class troposphere.aps.ComponentConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ComponentConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Options': (<class 'dict'>, False)}

class troposphere.aps.Destination(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

Destination

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AmpConfiguration': (<class 'troposphere.aps.AmpConfiguration'>, True)}

class troposphere.aps.EksConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

EksConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ClusterArn': (<class 'str'>, True), 'SecurityGroupIds': ([<class 'str'>], False), 'SubnetIds': ([<class 'str'>], True)}

class troposphere.aps.IgnoreNearExpected(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

IgnoreNearExpected

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Amount': (<function double>, False), 'Ratio': (<function double>, False)}

class troposphere.aps.Label(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

Label

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Name': (<class 'str'>, True), 'Value': (<class 'str'>, True)}

class troposphere.aps.LimitsPerLabelSet(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

LimitsPerLabelSet

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'LabelSet': ([<class 'troposphere.aps.Label'>], True), 'Limits': (<class 'troposphere.aps.LimitsPerLabelSetEntry'>, True)}

class troposphere.aps.LimitsPerLabelSetEntry(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

LimitsPerLabelSetEntry

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'MaxSeries': (<function integer>, False)}

class troposphere.aps.LoggingConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

LoggingConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'LogGroupArn': (<class 'str'>, False)}

class troposphere.aps.LoggingDestination(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

LoggingDestination

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CloudWatchLogs': (<class 'troposphere.aps.CloudWatchLogDestination'>, True), 'Filters': (<class 'troposphere.aps.LoggingFilter'>, True)}

class troposphere.aps.LoggingFilter(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

LoggingFilter

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'QspThreshold': (<function integer>, True)}

class troposphere.aps.MissingDataAction(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

MissingDataAction

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'MarkAsAnomaly': (<function boolean>, False), 'Skip': (<function boolean>, False)}

class troposphere.aps.QueryLoggingConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

QueryLoggingConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Destinations': ([<class 'troposphere.aps.LoggingDestination'>], True)}

class troposphere.aps.RandomCutForestConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

RandomCutForestConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'IgnoreNearExpectedFromAbove': (<class 'troposphere.aps.IgnoreNearExpected'>, False), 'IgnoreNearExpectedFromBelow': (<class 'troposphere.aps.IgnoreNearExpected'>, False), 'Query': (<class 'str'>, True), 'SampleSize': (<function integer>, False), 'ShingleSize': (<function integer>, False)}

class troposphere.aps.ResourcePolicy(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

ResourcePolicy

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'PolicyDocument': (<class 'str'>, True), 'WorkspaceArn': (<class 'str'>, True)}

resource_type: str | None = 'AWS::APS::ResourcePolicy'

class troposphere.aps.RoleConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

RoleConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'SourceRoleArn': (<class 'str'>, False), 'TargetRoleArn': (<class 'str'>, False)}

class troposphere.aps.RuleGroupsNamespace(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

RuleGroupsNamespace

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Data': (<class 'str'>, True), 'Name': (<class 'str'>, True), 'Tags': (<class 'troposphere.Tags'>, False), 'Workspace': (<class 'str'>, True)}

resource_type: str | None = 'AWS::APS::RuleGroupsNamespace'

class troposphere.aps.ScrapeConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ScrapeConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ConfigurationBlob': (<class 'str'>, True)}

class troposphere.aps.Scraper(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Scraper

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Alias': (<class 'str'>, False), 'Destination': (<class 'troposphere.aps.Destination'>, True), 'RoleConfiguration': (<class 'troposphere.aps.RoleConfiguration'>, False), 'ScrapeConfiguration': (<class 'troposphere.aps.ScrapeConfiguration'>, True), 'ScraperLoggingConfiguration': (<class 'troposphere.aps.ScraperLoggingConfiguration'>, False), 'Source': (<class 'troposphere.aps.Source'>, True), 'Tags': (<class 'troposphere.Tags'>, False)}

resource_type: str | None = 'AWS::APS::Scraper'

class troposphere.aps.ScraperComponent(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ScraperComponent

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Config': (<class 'troposphere.aps.ComponentConfig'>, False), 'Type': (<class 'str'>, True)}

class troposphere.aps.ScraperLoggingConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ScraperLoggingConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'LoggingDestination': (<class 'troposphere.aps.ScraperLoggingDestination'>, True), 'ScraperComponents': ([<class 'troposphere.aps.ScraperComponent'>], True)}

class troposphere.aps.ScraperLoggingDestination(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ScraperLoggingDestination

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CloudWatchLogs': (<class 'troposphere.aps.CloudWatchLogDestination'>, False)}

class troposphere.aps.Source(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

Source

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'EksConfiguration': (<class 'troposphere.aps.EksConfiguration'>, False), 'VpcConfiguration': (<class 'troposphere.aps.VpcConfiguration'>, False)}

class troposphere.aps.VpcConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VpcConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'SecurityGroupIds': ([<class 'str'>], True), 'SubnetIds': ([<class 'str'>], True)}

class troposphere.aps.Workspace(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Workspace

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AlertManagerDefinition': (<class 'str'>, False), 'Alias': (<class 'str'>, False), 'KmsKeyArn': (<class 'str'>, False), 'LoggingConfiguration': (<class 'troposphere.aps.LoggingConfiguration'>, False), 'QueryLoggingConfiguration': (<class 'troposphere.aps.QueryLoggingConfiguration'>, False), 'Tags': (<class 'troposphere.Tags'>, False), 'WorkspaceConfiguration': (<class 'troposphere.aps.WorkspaceConfiguration'>, False)}

resource_type: str | None = 'AWS::APS::Workspace'

class troposphere.aps.WorkspaceConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

WorkspaceConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'LimitsPerLabelSets': ([<class 'troposphere.aps.LimitsPerLabelSet'>], False), 'OutOfOrderTimeWindowInSeconds': (<function integer>, False), 'RetentionPeriodInDays': (<function integer>, False), 'RuleQueryOffsetInSeconds': (<function integer>, False)}

troposphere.ask module

class troposphere.ask.AuthenticationConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

AuthenticationConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ClientId': (<class 'str'>, True), 'ClientSecret': (<class 'str'>, True), 'RefreshToken': (<class 'str'>, True)}

class troposphere.ask.Overrides(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

Overrides

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Manifest': (<class 'dict'>, False)}

class troposphere.ask.Skill(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Skill

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AuthenticationConfiguration': (<class 'troposphere.ask.AuthenticationConfiguration'>, True), 'SkillPackage': (<class 'troposphere.ask.SkillPackage'>, True), 'VendorId': (<class 'str'>, True)}

resource_type: str | None = 'Alexa::ASK::Skill'

class troposphere.ask.SkillPackage(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

SkillPackage

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Overrides': (<class 'troposphere.ask.Overrides'>, False), 'S3Bucket': (<class 'str'>, True), 'S3BucketRole': (<class 'str'>, False), 'S3Key': (<class 'str'>, True), 'S3ObjectVersion': (<class 'str'>, False)}

troposphere.athena module

class troposphere.athena.AclConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

AclConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'S3AclOption': (<class 'str'>, True)}

class troposphere.athena.CapacityAssignment(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

CapacityAssignment

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'WorkgroupNames': ([<class 'str'>], True)}

class troposphere.athena.CapacityAssignmentConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

CapacityAssignmentConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CapacityAssignments': ([<class 'troposphere.athena.CapacityAssignment'>], True)}

class troposphere.athena.CapacityReservation(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

CapacityReservation

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CapacityAssignmentConfiguration': (<class 'troposphere.athena.CapacityAssignmentConfiguration'>, False), 'Name': (<class 'str'>, True), 'Tags': (<class 'troposphere.Tags'>, False), 'TargetDpus': (<function integer>, True)}

resource_type: str | None = 'AWS::Athena::CapacityReservation'

class troposphere.athena.Classification(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

Classification

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Name': (<class 'str'>, False), 'Properties': (<class 'dict'>, False)}

class troposphere.athena.CloudWatchLoggingConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

CloudWatchLoggingConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Enabled': (<function boolean>, False), 'LogGroup': (<class 'str'>, False), 'LogStreamNamePrefix': (<class 'str'>, False), 'LogTypes': (<class 'dict'>, False)}

class troposphere.athena.CustomerContentEncryptionConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

CustomerContentEncryptionConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'KmsKey': (<class 'str'>, True)}

class troposphere.athena.DataCatalog(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

DataCatalog

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ConnectionType': (<class 'str'>, False), 'Description': (<class 'str'>, False), 'Error': (<class 'str'>, False), 'Name': (<class 'str'>, True), 'Parameters': (<class 'dict'>, False), 'Status': (<class 'str'>, False), 'Tags': (<class 'troposphere.Tags'>, False), 'Type': (<class 'str'>, True)}

resource_type: str | None = 'AWS::Athena::DataCatalog'

class troposphere.athena.EncryptionConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

EncryptionConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'EncryptionOption': (<function validate_encryptionoption>, True), 'KmsKey': (<class 'str'>, False)}

class troposphere.athena.EngineConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

EngineConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AdditionalConfigs': (<class 'dict'>, False), 'Classifications': ([<class 'troposphere.athena.Classification'>], False), 'CoordinatorDpuSize': (<function integer>, False), 'DefaultExecutorDpuSize': (<function integer>, False), 'MaxConcurrentDpus': (<function integer>, False), 'SparkProperties': (<class 'dict'>, False)}

class troposphere.athena.EngineVersion(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

EngineVersion

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'EffectiveEngineVersion': (<class 'str'>, False), 'SelectedEngineVersion': (<class 'str'>, False)}

class troposphere.athena.ManagedLoggingConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ManagedLoggingConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Enabled': (<function boolean>, False), 'KmsKey': (<class 'str'>, False)}

class troposphere.athena.ManagedQueryResultsConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ManagedQueryResultsConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Enabled': (<function boolean>, False), 'EncryptionConfiguration': (<class 'troposphere.athena.ManagedStorageEncryptionConfiguration'>, False)}

class troposphere.athena.ManagedStorageEncryptionConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ManagedStorageEncryptionConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'KmsKey': (<class 'str'>, False)}

class troposphere.athena.MonitoringConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

MonitoringConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CloudWatchLoggingConfiguration': (<class 'troposphere.athena.CloudWatchLoggingConfiguration'>, False), 'ManagedLoggingConfiguration': (<class 'troposphere.athena.ManagedLoggingConfiguration'>, False), 'S3LoggingConfiguration': (<class 'troposphere.athena.S3LoggingConfiguration'>, False)}

class troposphere.athena.NamedQuery(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

NamedQuery

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Database': (<class 'str'>, True), 'Description': (<class 'str'>, False), 'Name': (<class 'str'>, False), 'QueryString': (<class 'str'>, True), 'WorkGroup': (<class 'str'>, False)}

resource_type: str | None = 'AWS::Athena::NamedQuery'

class troposphere.athena.PreparedStatement(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

PreparedStatement

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Description': (<class 'str'>, False), 'QueryStatement': (<class 'str'>, True), 'StatementName': (<class 'str'>, True), 'WorkGroup': (<class 'str'>, True)}

resource_type: str | None = 'AWS::Athena::PreparedStatement'

class troposphere.athena.ResultConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ResultConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AclConfiguration': (<class 'troposphere.athena.AclConfiguration'>, False), 'EncryptionConfiguration': (<class 'troposphere.athena.EncryptionConfiguration'>, False), 'ExpectedBucketOwner': (<class 'str'>, False), 'OutputLocation': (<class 'str'>, False)}

class troposphere.athena.S3LoggingConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

S3LoggingConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Enabled': (<function boolean>, False), 'KmsKey': (<class 'str'>, False), 'LogLocation': (<class 'str'>, False)}

class troposphere.athena.WorkGroup(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

WorkGroup

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Description': (<class 'str'>, False), 'Name': (<class 'str'>, True), 'RecursiveDeleteOption': (<function boolean>, False), 'State': (<function validate_workgroup_state>, False), 'Tags': (<class 'troposphere.Tags'>, False), 'WorkGroupConfiguration': (<class 'troposphere.athena.WorkGroupConfiguration'>, False)}

resource_type: str | None = 'AWS::Athena::WorkGroup'

class troposphere.athena.WorkGroupConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

WorkGroupConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AdditionalConfiguration': (<class 'str'>, False), 'BytesScannedCutoffPerQuery': (<function integer>, False), 'CustomerContentEncryptionConfiguration': (<class 'troposphere.athena.CustomerContentEncryptionConfiguration'>, False), 'EnforceWorkGroupConfiguration': (<function boolean>, False), 'EngineConfiguration': (<class 'troposphere.athena.EngineConfiguration'>, False), 'EngineVersion': (<class 'troposphere.athena.EngineVersion'>, False), 'ExecutionRole': (<class 'str'>, False), 'ManagedQueryResultsConfiguration': (<class 'troposphere.athena.ManagedQueryResultsConfiguration'>, False), 'MonitoringConfiguration': (<class 'troposphere.athena.MonitoringConfiguration'>, False), 'PublishCloudWatchMetricsEnabled': (<function boolean>, False), 'RequesterPaysEnabled': (<function boolean>, False), 'ResultConfiguration': (<class 'troposphere.athena.ResultConfiguration'>, False)}

troposphere.auditmanager module

class troposphere.auditmanager.AWSAccount(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

AWSAccount

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'EmailAddress': (<class 'str'>, False), 'Id': (<class 'str'>, False), 'Name': (<class 'str'>, False)}

class troposphere.auditmanager.AWSService(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

AWSService

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ServiceName': (<class 'str'>, False)}

class troposphere.auditmanager.Assessment(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Assessment

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AssessmentReportsDestination': (<class 'troposphere.auditmanager.AssessmentReportsDestination'>, False), 'AwsAccount': (<class 'troposphere.auditmanager.AWSAccount'>, False), 'Delegations': ([<class 'troposphere.auditmanager.Delegation'>], False), 'Description': (<class 'str'>, False), 'FrameworkId': (<class 'str'>, False), 'Name': (<class 'str'>, False), 'Roles': ([<class 'troposphere.auditmanager.Role'>], False), 'Scope': (<class 'troposphere.auditmanager.Scope'>, False), 'Status': (<class 'str'>, False), 'Tags': (<class 'troposphere.Tags'>, False)}

resource_type: str | None = 'AWS::AuditManager::Assessment'

class troposphere.auditmanager.AssessmentReportsDestination(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

AssessmentReportsDestination

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Destination': (<class 'str'>, False), 'DestinationType': (<class 'str'>, False)}

class troposphere.auditmanager.Delegation(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

Delegation

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AssessmentId': (<class 'str'>, False), 'AssessmentName': (<class 'str'>, False), 'Comment': (<class 'str'>, False), 'ControlSetId': (<class 'str'>, False), 'CreatedBy': (<class 'str'>, False), 'CreationTime': (<function double>, False), 'Id': (<class 'str'>, False), 'LastUpdated': (<function double>, False), 'RoleArn': (<class 'str'>, False), 'RoleType': (<class 'str'>, False), 'Status': (<class 'str'>, False)}

class troposphere.auditmanager.Role(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

Role

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'RoleArn': (<class 'str'>, False), 'RoleType': (<class 'str'>, False)}

class troposphere.auditmanager.Scope(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

Scope

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AwsAccounts': ([<class 'troposphere.auditmanager.AWSAccount'>], False), 'AwsServices': ([<class 'troposphere.auditmanager.AWSService'>], False)}

troposphere.autoscaling module

class troposphere.autoscaling.AcceleratorCountRequest(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

AcceleratorCountRequest

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Max': (<function integer>, False), 'Min': (<function integer>, False)}

class troposphere.autoscaling.AcceleratorTotalMemoryMiBRequest(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

AcceleratorTotalMemoryMiBRequest

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Max': (<function integer>, False), 'Min': (<function integer>, False)}

class troposphere.autoscaling.AutoScalingGroup(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

AutoScalingGroup

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AutoScalingGroupName': (<class 'str'>, False), 'AvailabilityZoneDistribution': (<class 'troposphere.autoscaling.AvailabilityZoneDistribution'>, False), 'AvailabilityZoneIds': ([<class 'str'>], False), 'AvailabilityZoneImpairmentPolicy': (<class 'troposphere.autoscaling.AvailabilityZoneImpairmentPolicy'>, False), 'AvailabilityZones': ([<class 'str'>], False), 'CapacityRebalance': (<function boolean>, False), 'CapacityReservationSpecification': (<class 'troposphere.autoscaling.CapacityReservationSpecification'>, False), 'Context': (<class 'str'>, False), 'Cooldown': (<class 'str'>, False), 'DefaultInstanceWarmup': (<function integer>, False), 'DeletionProtection': (<class 'str'>, False), 'DesiredCapacity': (<class 'str'>, False), 'DesiredCapacityType': (<class 'str'>, False), 'HealthCheckGracePeriod': (<function integer>, False), 'HealthCheckType': (<class 'str'>, False), 'InstanceId': (<class 'str'>, False), 'InstanceLifecyclePolicy': (<class 'troposphere.autoscaling.InstanceLifecyclePolicy'>, False), 'InstanceMaintenancePolicy': (<class 'troposphere.autoscaling.InstanceMaintenancePolicy'>, False), 'LaunchConfigurationName': (<class 'str'>, False), 'LaunchTemplate': (<class 'troposphere.autoscaling.LaunchTemplateSpecification'>, False), 'LifecycleHookSpecificationList': ([<class 'troposphere.autoscaling.LifecycleHookSpecification'>], False), 'LoadBalancerNames': ([<class 'str'>], False), 'MaxInstanceLifetime': (<function integer>, False), 'MaxSize': (<function validate_int_to_str>, True), 'MetricsCollection': ([<class 'troposphere.autoscaling.MetricsCollection'>], False), 'MinSize': (<function validate_int_to_str>, True), 'MixedInstancesPolicy': (<class 'troposphere.autoscaling.MixedInstancesPolicy'>, False), 'NewInstancesProtectedFromScaleIn': (<function boolean>, False), 'NotificationConfigurations': ([<class 'troposphere.autoscaling.NotificationConfigurations'>], False), 'PlacementGroup': (<class 'str'>, False), 'ServiceLinkedRoleARN': (<class 'str'>, False), 'SkipZonalShiftValidation': (<function boolean>, False), 'Tags': (<function validate_tags_or_list>, False), 'TargetGroupARNs': ([<class 'str'>], False), 'TerminationPolicies': ([<class 'str'>], False), 'TrafficSources': ([<class 'troposphere.autoscaling.TrafficSourceIdentifier'>], False), 'VPCZoneIdentifier': ([<class 'str'>], False)}

resource_type: str | None = 'AWS::AutoScaling::AutoScalingGroup'

validate()

class troposphere.autoscaling.AvailabilityZoneDistribution(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

AvailabilityZoneDistribution

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CapacityDistributionStrategy': (<class 'str'>, False)}

class troposphere.autoscaling.AvailabilityZoneImpairmentPolicy(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

AvailabilityZoneImpairmentPolicy

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ImpairedZoneHealthCheckBehavior': (<class 'str'>, True), 'ZonalShiftEnabled': (<function boolean>, True)}

class troposphere.autoscaling.BaselineEbsBandwidthMbpsRequest(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

BaselineEbsBandwidthMbpsRequest

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Max': (<function integer>, False), 'Min': (<function integer>, False)}

class troposphere.autoscaling.BaselinePerformanceFactorsRequest(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

BaselinePerformanceFactorsRequest

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Cpu': (<class 'troposphere.autoscaling.CpuPerformanceFactorRequest'>, False)}

class troposphere.autoscaling.BlockDeviceMapping(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

BlockDeviceMapping

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'DeviceName': (<class 'str'>, True), 'Ebs': (<class 'troposphere.autoscaling.EBSBlockDevice'>, False), 'NoDevice': (<function boolean>, False), 'VirtualName': (<class 'str'>, False)}

class troposphere.autoscaling.CapacityReservationSpecification(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

CapacityReservationSpecification

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CapacityReservationPreference': (<class 'str'>, True), 'CapacityReservationTarget': (<class 'troposphere.autoscaling.CapacityReservationTarget'>, False)}

class troposphere.autoscaling.CapacityReservationTarget(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

CapacityReservationTarget

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CapacityReservationIds': ([<class 'str'>], False), 'CapacityReservationResourceGroupArns': ([<class 'str'>], False)}

class troposphere.autoscaling.CpuPerformanceFactorRequest(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

CpuPerformanceFactorRequest

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'References': ([<class 'troposphere.autoscaling.PerformanceFactorReferenceRequest'>], False)}

class troposphere.autoscaling.CustomizedMetricSpecification(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

CustomizedMetricSpecification

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Dimensions': ([<class 'troposphere.autoscaling.MetricDimension'>], False), 'MetricName': (<class 'str'>, False), 'Metrics': ([<class 'troposphere.autoscaling.TargetTrackingMetricDataQuery'>], False), 'Namespace': (<class 'str'>, False), 'Period': (<function integer>, False), 'Statistic': (<class 'str'>, False), 'Unit': (<class 'str'>, False)}

class troposphere.autoscaling.EBSBlockDevice(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

EBSBlockDevice

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'DeleteOnTermination': (<function boolean>, False), 'Encrypted': (<function boolean>, False), 'Iops': (<function integer>, False), 'SnapshotId': (<class 'str'>, False), 'Throughput': (<function integer>, False), 'VolumeSize': (<function integer>, False), 'VolumeType': (<class 'str'>, False)}

class troposphere.autoscaling.InstanceLifecyclePolicy(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

InstanceLifecyclePolicy

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'RetentionTriggers': (<class 'troposphere.autoscaling.RetentionTriggers'>, False)}

class troposphere.autoscaling.InstanceMaintenancePolicy(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

InstanceMaintenancePolicy

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'MaxHealthyPercentage': (<function integer>, False), 'MinHealthyPercentage': (<function integer>, False)}

class troposphere.autoscaling.InstanceRequirements(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

InstanceRequirements

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AcceleratorCount': (<class 'troposphere.autoscaling.AcceleratorCountRequest'>, False), 'AcceleratorManufacturers': ([<class 'str'>], False), 'AcceleratorNames': ([<class 'str'>], False), 'AcceleratorTotalMemoryMiB': (<class 'troposphere.autoscaling.AcceleratorTotalMemoryMiBRequest'>, False), 'AcceleratorTypes': ([<class 'str'>], False), 'AllowedInstanceTypes': ([<class 'str'>], False), 'BareMetal': (<class 'str'>, False), 'BaselineEbsBandwidthMbps': (<class 'troposphere.autoscaling.BaselineEbsBandwidthMbpsRequest'>, False), 'BaselinePerformanceFactors': (<class 'troposphere.autoscaling.BaselinePerformanceFactorsRequest'>, False), 'BurstablePerformance': (<class 'str'>, False), 'CpuManufacturers': ([<class 'str'>], False), 'ExcludedInstanceTypes': ([<class 'str'>], False), 'InstanceGenerations': ([<class 'str'>], False), 'LocalStorage': (<class 'str'>, False), 'LocalStorageTypes': ([<class 'str'>], False), 'MaxSpotPriceAsPercentageOfOptimalOnDemandPrice': (<function integer>, False), 'MemoryGiBPerVCpu': (<class 'troposphere.autoscaling.MemoryGiBPerVCpuRequest'>, False), 'MemoryMiB': (<class 'troposphere.autoscaling.MemoryMiBRequest'>, True), 'NetworkBandwidthGbps': (<class 'troposphere.autoscaling.NetworkBandwidthGbpsRequest'>, False), 'NetworkInterfaceCount': (<class 'troposphere.autoscaling.NetworkInterfaceCountRequest'>, False), 'OnDemandMaxPricePercentageOverLowestPrice': (<function integer>, False), 'RequireHibernateSupport': (<function boolean>, False), 'SpotMaxPricePercentageOverLowestPrice': (<function integer>, False), 'TotalLocalStorageGB': (<class 'troposphere.autoscaling.TotalLocalStorageGBRequest'>, False), 'VCpuCount': (<class 'troposphere.autoscaling.VCpuCountRequest'>, True)}

class troposphere.autoscaling.InstanceReusePolicy(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

InstanceReusePolicy

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ReuseOnScaleIn': (<function boolean>, False)}

class troposphere.autoscaling.InstancesDistribution(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

InstancesDistribution

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'OnDemandAllocationStrategy': (<class 'str'>, False), 'OnDemandBaseCapacity': (<function integer>, False), 'OnDemandPercentageAboveBaseCapacity': (<function integer>, False), 'SpotAllocationStrategy': (<class 'str'>, False), 'SpotInstancePools': (<function integer>, False), 'SpotMaxPrice': (<class 'str'>, False)}

class troposphere.autoscaling.LaunchConfiguration(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

LaunchConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AssociatePublicIpAddress': (<function boolean>, False), 'BlockDeviceMappings': ([<class 'troposphere.autoscaling.BlockDeviceMapping'>], False), 'ClassicLinkVPCId': (<class 'str'>, False), 'ClassicLinkVPCSecurityGroups': ([<class 'str'>], False), 'EbsOptimized': (<function boolean>, False), 'IamInstanceProfile': (<class 'str'>, False), 'ImageId': (<class 'str'>, True), 'InstanceId': (<class 'str'>, False), 'InstanceMonitoring': (<function boolean>, False), 'InstanceType': (<class 'str'>, True), 'KernelId': (<class 'str'>, False), 'KeyName': (<class 'str'>, False), 'LaunchConfigurationName': (<class 'str'>, False), 'MetadataOptions': (<class 'troposphere.autoscaling.MetadataOptions'>, False), 'PlacementTenancy': (<class 'str'>, False), 'RamDiskId': (<class 'str'>, False), 'SecurityGroups': ([<class 'str'>], False), 'SpotPrice': (<class 'str'>, False), 'UserData': (<class 'str'>, False)}

resource_type: str | None = 'AWS::AutoScaling::LaunchConfiguration'

class troposphere.autoscaling.LaunchTemplate(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

LaunchTemplate

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'LaunchTemplateSpecification': (<class 'troposphere.autoscaling.LaunchTemplateSpecification'>, True), 'Overrides': ([<class 'troposphere.autoscaling.LaunchTemplateOverrides'>], False)}

class troposphere.autoscaling.LaunchTemplateOverrides(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

LaunchTemplateOverrides

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ImageId': (<class 'str'>, False), 'InstanceRequirements': (<class 'troposphere.autoscaling.InstanceRequirements'>, False), 'InstanceType': (<class 'str'>, False), 'LaunchTemplateSpecification': (<class 'troposphere.autoscaling.LaunchTemplateSpecification'>, False), 'WeightedCapacity': (<class 'str'>, False)}

class troposphere.autoscaling.LaunchTemplateSpecification(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

LaunchTemplateSpecification

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'LaunchTemplateId': (<class 'str'>, False), 'LaunchTemplateName': (<class 'str'>, False), 'Version': (<class 'str'>, True)}

validate()

class troposphere.autoscaling.LifecycleHook(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

LifecycleHook

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AutoScalingGroupName': (<class 'str'>, True), 'DefaultResult': (<class 'str'>, False), 'HeartbeatTimeout': (<function integer>, False), 'LifecycleHookName': (<class 'str'>, False), 'LifecycleTransition': (<class 'str'>, True), 'NotificationMetadata': (<class 'str'>, False), 'NotificationTargetARN': (<class 'str'>, False), 'RoleARN': (<class 'str'>, False)}

resource_type: str | None = 'AWS::AutoScaling::LifecycleHook'

class troposphere.autoscaling.LifecycleHookSpecification(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

LifecycleHookSpecification

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'DefaultResult': (<class 'str'>, False), 'HeartbeatTimeout': (<function integer>, False), 'LifecycleHookName': (<class 'str'>, True), 'LifecycleTransition': (<class 'str'>, True), 'NotificationMetadata': (<class 'str'>, False), 'NotificationTargetARN': (<class 'str'>, False), 'RoleARN': (<class 'str'>, False)}

class troposphere.autoscaling.MemoryGiBPerVCpuRequest(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

MemoryGiBPerVCpuRequest

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Max': (<function double>, False), 'Min': (<function double>, False)}

class troposphere.autoscaling.MemoryMiBRequest(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

MemoryMiBRequest

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Max': (<function integer>, False), 'Min': (<function integer>, False)}

class troposphere.autoscaling.MetadataOptions(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

MetadataOptions

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'HttpEndpoint': (<class 'str'>, False), 'HttpPutResponseHopLimit': (<function integer>, False), 'HttpTokens': (<class 'str'>, False)}

class troposphere.autoscaling.Metric(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

Metric

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Dimensions': ([<class 'troposphere.autoscaling.MetricDimension'>], False), 'MetricName': (<class 'str'>, True), 'Namespace': (<class 'str'>, True)}

class troposphere.autoscaling.MetricDataQuery(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

MetricDataQuery

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Expression': (<class 'str'>, False), 'Id': (<class 'str'>, True), 'Label': (<class 'str'>, False), 'MetricStat': (<class 'troposphere.autoscaling.MetricStat'>, False), 'ReturnData': (<function boolean>, False)}

class troposphere.autoscaling.MetricDimension(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

MetricDimension

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Name': (<class 'str'>, True), 'Value': (<class 'str'>, True)}

class troposphere.autoscaling.MetricStat(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

MetricStat

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Metric': (<class 'troposphere.autoscaling.Metric'>, True), 'Stat': (<class 'str'>, True), 'Unit': (<class 'str'>, False)}

class troposphere.autoscaling.MetricsCollection(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

MetricsCollection

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Granularity': (<class 'str'>, True), 'Metrics': ([<class 'str'>], False)}

class troposphere.autoscaling.MixedInstancesPolicy(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

MixedInstancesPolicy

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'InstancesDistribution': (<class 'troposphere.autoscaling.InstancesDistribution'>, False), 'LaunchTemplate': (<class 'troposphere.autoscaling.LaunchTemplate'>, True)}

class troposphere.autoscaling.NetworkBandwidthGbpsRequest(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

NetworkBandwidthGbpsRequest

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Max': (<function double>, False), 'Min': (<function double>, False)}

class troposphere.autoscaling.NetworkInterfaceCountRequest(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

NetworkInterfaceCountRequest

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Max': (<function integer>, False), 'Min': (<function integer>, False)}

class troposphere.autoscaling.NotificationConfigurations(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

NotificationConfigurations

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'NotificationTypes': ([<class 'str'>], False), 'TopicARN': ([<class 'str'>], True)}

class troposphere.autoscaling.PerformanceFactorReferenceRequest(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

PerformanceFactorReferenceRequest

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'InstanceFamily': (<class 'str'>, False)}

class troposphere.autoscaling.PredefinedMetricSpecification(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

PredefinedMetricSpecification

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'PredefinedMetricType': (<class 'str'>, True), 'ResourceLabel': (<class 'str'>, False)}

class troposphere.autoscaling.PredictiveScalingConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

PredictiveScalingConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'MaxCapacityBreachBehavior': (<class 'str'>, False), 'MaxCapacityBuffer': (<function integer>, False), 'MetricSpecifications': ([<class 'troposphere.autoscaling.PredictiveScalingMetricSpecification'>], True), 'Mode': (<class 'str'>, False), 'SchedulingBufferTime': (<function integer>, False)}

class troposphere.autoscaling.PredictiveScalingCustomizedCapacityMetric(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

PredictiveScalingCustomizedCapacityMetric

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'MetricDataQueries': ([<class 'troposphere.autoscaling.MetricDataQuery'>], True)}

class troposphere.autoscaling.PredictiveScalingCustomizedLoadMetric(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

PredictiveScalingCustomizedLoadMetric

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'MetricDataQueries': ([<class 'troposphere.autoscaling.MetricDataQuery'>], True)}

class troposphere.autoscaling.PredictiveScalingCustomizedScalingMetric(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

PredictiveScalingCustomizedScalingMetric

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'MetricDataQueries': ([<class 'troposphere.autoscaling.MetricDataQuery'>], True)}

class troposphere.autoscaling.PredictiveScalingMetricSpecification(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

PredictiveScalingMetricSpecification

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CustomizedCapacityMetricSpecification': (<class 'troposphere.autoscaling.PredictiveScalingCustomizedCapacityMetric'>, False), 'CustomizedLoadMetricSpecification': (<class 'troposphere.autoscaling.PredictiveScalingCustomizedLoadMetric'>, False), 'CustomizedScalingMetricSpecification': (<class 'troposphere.autoscaling.PredictiveScalingCustomizedScalingMetric'>, False), 'PredefinedLoadMetricSpecification': (<class 'troposphere.autoscaling.PredictiveScalingPredefinedLoadMetric'>, False), 'PredefinedMetricPairSpecification': (<class 'troposphere.autoscaling.PredictiveScalingPredefinedMetricPair'>, False), 'PredefinedScalingMetricSpecification': (<class 'troposphere.autoscaling.PredictiveScalingPredefinedScalingMetric'>, False), 'TargetValue': (<function double>, True)}

class troposphere.autoscaling.PredictiveScalingPredefinedLoadMetric(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

PredictiveScalingPredefinedLoadMetric

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'PredefinedMetricType': (<class 'str'>, True), 'ResourceLabel': (<class 'str'>, False)}

class troposphere.autoscaling.PredictiveScalingPredefinedMetricPair(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

PredictiveScalingPredefinedMetricPair

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'PredefinedMetricType': (<class 'str'>, True), 'ResourceLabel': (<class 'str'>, False)}

class troposphere.autoscaling.PredictiveScalingPredefinedScalingMetric(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

PredictiveScalingPredefinedScalingMetric

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'PredefinedMetricType': (<class 'str'>, True), 'ResourceLabel': (<class 'str'>, False)}

class troposphere.autoscaling.RetentionTriggers(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

RetentionTriggers

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'TerminateHookAbandon': (<class 'str'>, False)}

class troposphere.autoscaling.ScalingPolicy(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

ScalingPolicy

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AdjustmentType': (<class 'str'>, False), 'AutoScalingGroupName': (<class 'str'>, True), 'Cooldown': (<class 'str'>, False), 'EstimatedInstanceWarmup': (<function integer>, False), 'MetricAggregationType': (<class 'str'>, False), 'MinAdjustmentMagnitude': (<function integer>, False), 'PolicyType': (<class 'str'>, False), 'PredictiveScalingConfiguration': (<class 'troposphere.autoscaling.PredictiveScalingConfiguration'>, False), 'ScalingAdjustment': (<function integer>, False), 'StepAdjustments': ([<class 'troposphere.autoscaling.StepAdjustments'>], False), 'TargetTrackingConfiguration': (<class 'troposphere.autoscaling.TargetTrackingConfiguration'>, False)}

resource_type: str | None = 'AWS::AutoScaling::ScalingPolicy'

class troposphere.autoscaling.ScheduledAction(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

ScheduledAction

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AutoScalingGroupName': (<class 'str'>, True), 'DesiredCapacity': (<function integer>, False), 'EndTime': (<class 'str'>, False), 'MaxSize': (<function integer>, False), 'MinSize': (<function integer>, False), 'Recurrence': (<class 'str'>, False), 'StartTime': (<class 'str'>, False), 'TimeZone': (<class 'str'>, False)}

resource_type: str | None = 'AWS::AutoScaling::ScheduledAction'

class troposphere.autoscaling.StepAdjustments(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

StepAdjustments

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'MetricIntervalLowerBound': (<function double>, False), 'MetricIntervalUpperBound': (<function double>, False), 'ScalingAdjustment': (<function integer>, True)}

class troposphere.autoscaling.TargetTrackingConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

TargetTrackingConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CustomizedMetricSpecification': (<class 'troposphere.autoscaling.CustomizedMetricSpecification'>, False), 'DisableScaleIn': (<function boolean>, False), 'PredefinedMetricSpecification': (<class 'troposphere.autoscaling.PredefinedMetricSpecification'>, False), 'TargetValue': (<function double>, True)}

class troposphere.autoscaling.TargetTrackingMetricDataQuery(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

TargetTrackingMetricDataQuery

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Expression': (<class 'str'>, False), 'Id': (<class 'str'>, True), 'Label': (<class 'str'>, False), 'MetricStat': (<class 'troposphere.autoscaling.TargetTrackingMetricStat'>, False), 'Period': (<function integer>, False), 'ReturnData': (<function boolean>, False)}

class troposphere.autoscaling.TargetTrackingMetricStat(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

TargetTrackingMetricStat

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Metric': (<class 'troposphere.autoscaling.Metric'>, True), 'Period': (<function integer>, False), 'Stat': (<class 'str'>, True), 'Unit': (<class 'str'>, False)}

class troposphere.autoscaling.TotalLocalStorageGBRequest(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

TotalLocalStorageGBRequest

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Max': (<function double>, False), 'Min': (<function double>, False)}

class troposphere.autoscaling.TrafficSourceIdentifier(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

TrafficSourceIdentifier

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Identifier': (<class 'str'>, True), 'Type': (<class 'str'>, True)}

class troposphere.autoscaling.VCpuCountRequest(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

VCpuCountRequest

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Max': (<function integer>, False), 'Min': (<function integer>, False)}

class troposphere.autoscaling.WarmPool(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

WarmPool

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AutoScalingGroupName': (<class 'str'>, True), 'InstanceReusePolicy': (<class 'troposphere.autoscaling.InstanceReusePolicy'>, False), 'MaxGroupPreparedCapacity': (<function integer>, False), 'MinSize': (<function integer>, False), 'PoolState': (<class 'str'>, False)}

resource_type: str | None = 'AWS::AutoScaling::WarmPool'

troposphere.autoscalingplans module

class troposphere.autoscalingplans.ApplicationSource(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ApplicationSource

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CloudFormationStackARN': (<class 'str'>, False), 'TagFilters': ([<class 'troposphere.autoscalingplans.TagFilter'>], False)}

class troposphere.autoscalingplans.CustomizedLoadMetricSpecification(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

CustomizedLoadMetricSpecification

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Dimensions': ([<class 'troposphere.autoscalingplans.MetricDimension'>], False), 'MetricName': (<class 'str'>, True), 'Namespace': (<class 'str'>, True), 'Statistic': (<class 'str'>, True), 'Unit': (<class 'str'>, False)}

class troposphere.autoscalingplans.CustomizedScalingMetricSpecification(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

CustomizedScalingMetricSpecification

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Dimensions': ([<class 'troposphere.autoscalingplans.MetricDimension'>], False), 'MetricName': (<class 'str'>, True), 'Namespace': (<class 'str'>, True), 'Statistic': (<function statistic_type>, True), 'Unit': (<class 'str'>, False)}

class troposphere.autoscalingplans.MetricDimension(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

MetricDimension

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Name': (<class 'str'>, True), 'Value': (<class 'str'>, True)}

class troposphere.autoscalingplans.PredefinedLoadMetricSpecification(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

PredefinedLoadMetricSpecification

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'PredefinedLoadMetricType': (<class 'str'>, True), 'ResourceLabel': (<class 'str'>, False)}

class troposphere.autoscalingplans.PredefinedScalingMetricSpecification(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

PredefinedScalingMetricSpecification

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'PredefinedScalingMetricType': (<class 'str'>, True), 'ResourceLabel': (<class 'str'>, False)}

class troposphere.autoscalingplans.ScalingInstruction(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

ScalingInstruction

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CustomizedLoadMetricSpecification': (<class 'troposphere.autoscalingplans.CustomizedLoadMetricSpecification'>, False), 'DisableDynamicScaling': (<function boolean>, False), 'MaxCapacity': (<function integer>, True), 'MinCapacity': (<function integer>, True), 'PredefinedLoadMetricSpecification': (<class 'troposphere.autoscalingplans.PredefinedLoadMetricSpecification'>, False), 'PredictiveScalingMaxCapacityBehavior': (<function validate_predictivescalingmaxcapacitybehavior>, False), 'PredictiveScalingMaxCapacityBuffer': (<function integer>, False), 'PredictiveScalingMode': (<function validate_predictivescalingmode>, False), 'ResourceId': (<class 'str'>, True), 'ScalableDimension': (<function scalable_dimension_type>, True), 'ScalingPolicyUpdateBehavior': (<function validate_scalingpolicyupdatebehavior>, False), 'ScheduledActionBufferTime': (<function integer>, False), 'ServiceNamespace': (<function service_namespace_type>, True), 'TargetTrackingConfigurations': ([<class 'troposphere.autoscalingplans.TargetTrackingConfiguration'>], True)}

class troposphere.autoscalingplans.ScalingPlan(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

ScalingPlan

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ApplicationSource': (<class 'troposphere.autoscalingplans.ApplicationSource'>, True), 'ScalingInstructions': ([<class 'troposphere.autoscalingplans.ScalingInstruction'>], True)}

resource_type: str | None = 'AWS::AutoScalingPlans::ScalingPlan'

class troposphere.autoscalingplans.TagFilter(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

TagFilter

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Key': (<class 'str'>, True), 'Values': ([<class 'str'>], False)}

class troposphere.autoscalingplans.TargetTrackingConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

TargetTrackingConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CustomizedScalingMetricSpecification': (<class 'troposphere.autoscalingplans.CustomizedScalingMetricSpecification'>, False), 'DisableScaleIn': (<function boolean>, False), 'EstimatedInstanceWarmup': (<function integer>, False), 'PredefinedScalingMetricSpecification': (<class 'troposphere.autoscalingplans.PredefinedScalingMetricSpecification'>, False), 'ScaleInCooldown': (<function integer>, False), 'ScaleOutCooldown': (<function integer>, False), 'TargetValue': (<function double>, True)}

troposphere.awslambda module

class troposphere.awslambda.Alias(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

Alias

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'Description': (<class 'str'>, False), 'FunctionName': (<class 'str'>, True), 'FunctionVersion': (<class 'str'>, True), 'Name': (<class 'str'>, True), 'ProvisionedConcurrencyConfig': (<class 'troposphere.awslambda.ProvisionedConcurrencyConfiguration'>, False), 'RoutingConfig': (<class 'troposphere.awslambda.AliasRoutingConfiguration'>, False)}

resource_type: str | None = 'AWS::Lambda::Alias'

class troposphere.awslambda.AliasRoutingConfiguration(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

AliasRoutingConfiguration

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'AdditionalVersionWeights': ([<class 'troposphere.awslambda.VersionWeight'>], False)}

class troposphere.awslambda.AllowedPublishers(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

AllowedPublishers

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'SigningProfileVersionArns': ([<class 'str'>], True)}

class troposphere.awslambda.AmazonManagedKafkaEventSourceConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

AmazonManagedKafkaEventSourceConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'ConsumerGroupId': (<class 'str'>, False), 'SchemaRegistryConfig': (<class 'troposphere.awslambda.SchemaRegistryConfig'>, False)}

class troposphere.awslambda.CapacityProvider(title: str | None, template: Template | None = None, validation: bool = True, **kwargs: Any)

Bases: AWSObject

CapacityProvider

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'CapacityProviderName': (<class 'str'>, False), 'CapacityProviderScalingConfig': (<class 'troposphere.awslambda.CapacityProviderScalingConfig'>, False), 'InstanceRequirements': (<class 'troposphere.awslambda.InstanceRequirements'>, False), 'KmsKeyArn': (<class 'str'>, False), 'PermissionsConfig': (<class 'troposphere.awslambda.CapacityProviderPermissionsConfig'>, True), 'PropagateTags': (<class 'troposphere.awslambda.PropagateTagsConfig'>, False), 'Tags': (<class 'troposphere.Tags'>, False), 'TelemetryConfig': (<class 'troposphere.awslambda.CapacityProviderTelemetryConfig'>, False), 'VpcConfig': (<class 'troposphere.awslambda.CapacityProviderVpcConfig'>, True)}

resource_type: str | None = 'AWS::Lambda::CapacityProvider'

class troposphere.awslambda.CapacityProviderConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

CapacityProviderConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'LambdaManagedInstancesCapacityProviderConfig': (<class 'troposphere.awslambda.LambdaManagedInstancesCapacityProviderConfig'>, True)}

class troposphere.awslambda.CapacityProviderLoggingConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

CapacityProviderLoggingConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] | Dict[str, Any] | List[Any] | Tuple[type, ...], bool]] = {'LogGroup': (<class 'str'>, False), 'SystemLogLevel': (<class 'str'>, False)}

class troposphere.awslambda.CapacityProviderPermissionsConfig(title: str | None = None, **kwargs: Any)

Bases: AWSProperty

CapacityProviderPermissionsConfig

props: Dict[str, Tuple[str | AWSProperty | AWSHelperFn | Callable[[Any], Any] |