From 1d0fe896b2b43ffa102e788f72a0f890fd701389 Mon Sep 17 00:00:00 2001 From: markpeek Date: Wed, 6 Dec 2023 22:08:52 +0000 Subject: [PATCH] Updates from spec version 149.0.0 --- package-lock.json | 2 +- package.json | 2 +- troposphere/accessanalyzer.py | 23 +++- troposphere/applicationautoscaling.py | 58 +++++++++- troposphere/autoscaling.py | 12 ++ troposphere/awslambda.py | 14 +++ troposphere/backup.py | 72 ++++++++++++ troposphere/cloudtrail.py | 23 ++-- troposphere/codestarconnections.py | 33 ++++++ troposphere/controltower.py | 28 ++++- troposphere/dlm.py | 37 ++++++ troposphere/dms.py | 3 + troposphere/docdb.py | 19 +++ troposphere/ec2.py | 22 ++++ troposphere/ecr.py | 2 + troposphere/efs.py | 12 ++ troposphere/eks.py | 16 +++ troposphere/elasticache.py | 68 +++++++++++ troposphere/elasticloadbalancingv2.py | 70 ++++++++++- troposphere/fsx.py | 18 ++- troposphere/gamelift.py | 17 +-- troposphere/grafana.py | 3 +- troposphere/guardduty.py | 18 +-- troposphere/imagebuilder.py | 125 ++++++++++++++++++++ troposphere/iot.py | 14 +++ troposphere/iottwinmaker.py | 28 +++++ troposphere/logs.py | 63 ++++++++++ troposphere/managedblockchain.py | 1 + troposphere/mwaa.py | 1 + troposphere/opensearchserverless.py | 16 +++ troposphere/pipes.py | 48 ++++++++ troposphere/quicksight.py | 3 +- troposphere/resourceexplorer2.py | 1 + troposphere/route53resolver.py | 2 + troposphere/s3.py | 146 +++++++++++++++++++++++ troposphere/sagemaker.py | 161 +++++++++++++++++++++++--- troposphere/transfer.py | 12 ++ 37 files changed, 1140 insertions(+), 53 deletions(-) diff --git a/package-lock.json b/package-lock.json index 366865522..95820d860 100644 --- a/package-lock.json +++ b/package-lock.json @@ -9,7 +9,7 @@ "version": "0.0.0", "license": "BSD-3-Clause", "devDependencies": { - "pyright": "=1.1.261" + "pyright": "^1.1.261" }, "engines": { "node": ">=16.0.0", diff --git a/package.json b/package.json index 70db73057..f8258da83 100644 --- a/package.json +++ b/package.json @@ -19,7 +19,7 @@ }, "homepage": "https://github.com/cloudtools/troposphere#readme", "devDependencies": { - "pyright": "=1.1.261" + "pyright": "^1.1.261" }, "engines": { "npm": ">=7.0.0", diff --git a/troposphere/accessanalyzer.py b/troposphere/accessanalyzer.py index d52b86300..7f67cbafa 100644 --- a/troposphere/accessanalyzer.py +++ b/troposphere/accessanalyzer.py @@ -7,7 +7,27 @@ from . import AWSObject, AWSProperty, PropsDictType, Tags -from .validators import boolean +from .validators import boolean, integer + + +class UnusedAccessConfiguration(AWSProperty): + """ + `UnusedAccessConfiguration `__ + """ + + props: PropsDictType = { + "UnusedAccessAge": (integer, False), + } + + +class AnalyzerConfiguration(AWSProperty): + """ + `AnalyzerConfiguration `__ + """ + + props: PropsDictType = { + "UnusedAccessConfiguration": (UnusedAccessConfiguration, False), + } class Filter(AWSProperty): @@ -43,6 +63,7 @@ class Analyzer(AWSObject): resource_type = "AWS::AccessAnalyzer::Analyzer" props: PropsDictType = { + "AnalyzerConfiguration": (AnalyzerConfiguration, False), "AnalyzerName": (str, False), "ArchiveRules": ([ArchiveRule], False), "Tags": (Tags, False), diff --git a/troposphere/applicationautoscaling.py b/troposphere/applicationautoscaling.py index 983b4e9aa..b61b36f9a 100644 --- a/troposphere/applicationautoscaling.py +++ b/troposphere/applicationautoscaling.py @@ -69,7 +69,7 @@ class ScalableTarget(AWSObject): class StepAdjustment(AWSProperty): """ - `StepAdjustment `__ + `StepAdjustment `__ """ props: PropsDictType = { @@ -104,6 +104,55 @@ class MetricDimension(AWSProperty): } +class TargetTrackingMetricDimension(AWSProperty): + """ + `TargetTrackingMetricDimension `__ + """ + + props: PropsDictType = { + "Name": (str, False), + "Value": (str, False), + } + + +class TargetTrackingMetric(AWSProperty): + """ + `TargetTrackingMetric `__ + """ + + props: PropsDictType = { + "Dimensions": ([TargetTrackingMetricDimension], False), + "MetricName": (str, False), + "Namespace": (str, False), + } + + +class TargetTrackingMetricStat(AWSProperty): + """ + `TargetTrackingMetricStat `__ + """ + + props: PropsDictType = { + "Metric": (TargetTrackingMetric, False), + "Stat": (str, False), + "Unit": (str, False), + } + + +class TargetTrackingMetricDataQuery(AWSProperty): + """ + `TargetTrackingMetricDataQuery `__ + """ + + props: PropsDictType = { + "Expression": (str, False), + "Id": (str, False), + "Label": (str, False), + "MetricStat": (TargetTrackingMetricStat, False), + "ReturnData": (boolean, False), + } + + class CustomizedMetricSpecification(AWSProperty): """ `CustomizedMetricSpecification `__ @@ -111,9 +160,10 @@ class CustomizedMetricSpecification(AWSProperty): props: PropsDictType = { "Dimensions": ([MetricDimension], False), - "MetricName": (str, True), - "Namespace": (str, True), - "Statistic": (str, True), + "MetricName": (str, False), + "Metrics": ([TargetTrackingMetricDataQuery], False), + "Namespace": (str, False), + "Statistic": (str, False), "Unit": (str, False), } diff --git a/troposphere/autoscaling.py b/troposphere/autoscaling.py index af3951118..fdbed9b36 100644 --- a/troposphere/autoscaling.py +++ b/troposphere/autoscaling.py @@ -31,6 +31,17 @@ ) +class InstanceMaintenancePolicy(AWSProperty): + """ + `InstanceMaintenancePolicy `__ + """ + + props: PropsDictType = { + "MaxHealthyPercentage": (integer, False), + "MinHealthyPercentage": (integer, False), + } + + class LaunchTemplateSpecification(AWSProperty): """ `LaunchTemplateSpecification `__ @@ -284,6 +295,7 @@ class AutoScalingGroup(AWSObject): "HealthCheckGracePeriod": (integer, False), "HealthCheckType": (str, False), "InstanceId": (str, False), + "InstanceMaintenancePolicy": (InstanceMaintenancePolicy, False), "LaunchConfigurationName": (str, False), "LaunchTemplate": (LaunchTemplateSpecification, False), "LifecycleHookSpecificationList": ([LifecycleHookSpecification], False), diff --git a/troposphere/awslambda.py b/troposphere/awslambda.py index 7ce054e88..b330d3c94 100644 --- a/troposphere/awslambda.py +++ b/troposphere/awslambda.py @@ -351,6 +351,19 @@ def validate(self): validate_image_config(self) +class LoggingConfig(AWSProperty): + """ + `LoggingConfig `__ + """ + + props: PropsDictType = { + "ApplicationLogLevel": (str, False), + "LogFormat": (str, False), + "LogGroup": (str, False), + "SystemLogLevel": (str, False), + } + + class RuntimeManagementConfig(AWSProperty): """ `RuntimeManagementConfig `__ @@ -415,6 +428,7 @@ class Function(AWSObject): "ImageConfig": (ImageConfig, False), "KmsKeyArn": (str, False), "Layers": ([str], False), + "LoggingConfig": (LoggingConfig, False), "MemorySize": (validate_memory_size, False), "PackageType": (validate_package_type, False), "Policy": (dict, False), diff --git a/troposphere/backup.py b/troposphere/backup.py index b5a36a713..09dbf2f27 100644 --- a/troposphere/backup.py +++ b/troposphere/backup.py @@ -289,3 +289,75 @@ class ReportPlan(AWSObject): "ReportPlanTags": (Tags, False), "ReportSetting": (ReportSetting, True), } + + +class RestoreTestingRecoveryPointSelection(AWSProperty): + """ + `RestoreTestingRecoveryPointSelection `__ + """ + + props: PropsDictType = { + "Algorithm": (str, True), + "ExcludeVaults": ([str], False), + "IncludeVaults": ([str], True), + "RecoveryPointTypes": ([str], True), + "SelectionWindowDays": (integer, False), + } + + +class RestoreTestingPlan(AWSObject): + """ + `RestoreTestingPlan `__ + """ + + resource_type = "AWS::Backup::RestoreTestingPlan" + + props: PropsDictType = { + "RecoveryPointSelection": (RestoreTestingRecoveryPointSelection, True), + "RestoreTestingPlanName": (str, True), + "ScheduleExpression": (str, True), + "ScheduleExpressionTimezone": (str, False), + "StartWindowHours": (integer, False), + "Tags": (Tags, False), + } + + +class KeyValue(AWSProperty): + """ + `KeyValue `__ + """ + + props: PropsDictType = { + "Key": (str, True), + "Value": (str, True), + } + + +class ProtectedResourceConditions(AWSProperty): + """ + `ProtectedResourceConditions `__ + """ + + props: PropsDictType = { + "StringEquals": ([KeyValue], False), + "StringNotEquals": ([KeyValue], False), + } + + +class RestoreTestingSelection(AWSObject): + """ + `RestoreTestingSelection `__ + """ + + resource_type = "AWS::Backup::RestoreTestingSelection" + + props: PropsDictType = { + "IamRoleArn": (str, True), + "ProtectedResourceArns": ([str], False), + "ProtectedResourceConditions": (ProtectedResourceConditions, False), + "ProtectedResourceType": (str, True), + "RestoreMetadataOverrides": (dict, False), + "RestoreTestingPlanName": (str, True), + "RestoreTestingSelectionName": (str, True), + "ValidationWindowHours": (integer, False), + } diff --git a/troposphere/cloudtrail.py b/troposphere/cloudtrail.py index e9130df4e..4056b1b1d 100644 --- a/troposphere/cloudtrail.py +++ b/troposphere/cloudtrail.py @@ -63,6 +63,16 @@ class AdvancedEventSelector(AWSProperty): } +class InsightSelector(AWSProperty): + """ + `InsightSelector `__ + """ + + props: PropsDictType = { + "InsightType": (str, False), + } + + class EventDataStore(AWSObject): """ `EventDataStore `__ @@ -72,7 +82,10 @@ class EventDataStore(AWSObject): props: PropsDictType = { "AdvancedEventSelectors": ([AdvancedEventSelector], False), + "BillingMode": (str, False), "IngestionEnabled": (boolean, False), + "InsightSelectors": ([InsightSelector], False), + "InsightsDestination": (str, False), "KmsKeyId": (str, False), "MultiRegionEnabled": (boolean, False), "Name": (str, False), @@ -120,16 +133,6 @@ class EventSelector(AWSProperty): } -class InsightSelector(AWSProperty): - """ - `InsightSelector `__ - """ - - props: PropsDictType = { - "InsightType": (str, False), - } - - class Trail(AWSObject): """ `Trail `__ diff --git a/troposphere/codestarconnections.py b/troposphere/codestarconnections.py index 7cdbd7f78..4b422b124 100644 --- a/troposphere/codestarconnections.py +++ b/troposphere/codestarconnections.py @@ -23,3 +23,36 @@ class Connection(AWSObject): "ProviderType": (validate_connection_providertype, False), "Tags": (Tags, False), } + + +class RepositoryLink(AWSObject): + """ + `RepositoryLink `__ + """ + + resource_type = "AWS::CodeStarConnections::RepositoryLink" + + props: PropsDictType = { + "ConnectionArn": (str, True), + "EncryptionKeyArn": (str, False), + "OwnerId": (str, True), + "RepositoryName": (str, True), + "Tags": (Tags, False), + } + + +class SyncConfiguration(AWSObject): + """ + `SyncConfiguration `__ + """ + + resource_type = "AWS::CodeStarConnections::SyncConfiguration" + + props: PropsDictType = { + "Branch": (str, True), + "ConfigFile": (str, True), + "RepositoryLinkId": (str, True), + "ResourceName": (str, True), + "RoleArn": (str, True), + "SyncType": (str, True), + } diff --git a/troposphere/controltower.py b/troposphere/controltower.py index 8346b0556..0628204ba 100644 --- a/troposphere/controltower.py +++ b/troposphere/controltower.py @@ -6,7 +6,18 @@ # *** Do not modify - this file is autogenerated *** -from . import AWSObject, PropsDictType +from . import AWSObject, AWSProperty, PropsDictType, Tags + + +class EnabledControlParameter(AWSProperty): + """ + `EnabledControlParameter `__ + """ + + props: PropsDictType = { + "Key": (str, True), + "Value": (dict, True), + } class EnabledControl(AWSObject): @@ -18,5 +29,20 @@ class EnabledControl(AWSObject): props: PropsDictType = { "ControlIdentifier": (str, True), + "Parameters": ([EnabledControlParameter], False), "TargetIdentifier": (str, True), } + + +class LandingZone(AWSObject): + """ + `LandingZone `__ + """ + + resource_type = "AWS::ControlTower::LandingZone" + + props: PropsDictType = { + "Manifest": (dict, True), + "Tags": (Tags, False), + "Version": (str, True), + } diff --git a/troposphere/dlm.py b/troposphere/dlm.py index 109f0613e..396534577 100644 --- a/troposphere/dlm.py +++ b/troposphere/dlm.py @@ -16,6 +16,18 @@ ) +class Exclusions(AWSProperty): + """ + `Exclusions `__ + """ + + props: PropsDictType = { + "ExcludeBootVolumes": (boolean, False), + "ExcludeTags": ([], False), + "ExcludeVolumeTypes": ([], False), + } + + class CrossRegionCopyRetainRule(AWSProperty): """ `CrossRegionCopyRetainRule `__ @@ -261,11 +273,19 @@ class PolicyDetails(AWSProperty): props: PropsDictType = { "Actions": ([Action], False), + "CopyTags": (boolean, False), + "CreateInterval": (integer, False), + "CrossRegionCopyTargets": ([], False), "EventSource": (EventSource, False), + "Exclusions": (Exclusions, False), + "ExtendDeletion": (boolean, False), "Parameters": (Parameters, False), + "PolicyLanguage": (str, False), "PolicyType": (str, False), "ResourceLocations": ([str], False), + "ResourceType": (str, False), "ResourceTypes": ([str], False), + "RetainInterval": (integer, False), "Schedules": ([Schedule], False), "TargetTags": (validate_tags_or_list, False), } @@ -279,9 +299,26 @@ class LifecyclePolicy(AWSObject): resource_type = "AWS::DLM::LifecyclePolicy" props: PropsDictType = { + "CopyTags": (boolean, False), + "CreateInterval": (integer, False), + "CrossRegionCopyTargets": ([], False), + "DefaultPolicy": (str, False), "Description": (str, False), + "Exclusions": (Exclusions, False), "ExecutionRoleArn": (str, False), + "ExtendDeletion": (boolean, False), "PolicyDetails": (PolicyDetails, False), + "RetainInterval": (integer, False), "State": (validate_state, False), "Tags": (validate_tags_or_list, False), } + + +class CrossRegionCopyTarget(AWSProperty): + """ + `CrossRegionCopyTarget `__ + """ + + props: PropsDictType = { + "TargetRegion": (str, False), + } diff --git a/troposphere/dms.py b/troposphere/dms.py index 4b5ecac2f..ab1c17aea 100644 --- a/troposphere/dms.py +++ b/troposphere/dms.py @@ -356,6 +356,7 @@ class S3Settings(AWSProperty): props: PropsDictType = { "AddColumnName": (boolean, False), + "AddTrailingPaddingCharacter": (boolean, False), "BucketFolder": (str, False), "BucketName": (str, False), "CannedAclForObjects": (str, False), @@ -379,7 +380,9 @@ class S3Settings(AWSProperty): "EnableStatistics": (boolean, False), "EncodingType": (str, False), "EncryptionMode": (str, False), + "ExpectedBucketOwner": (str, False), "ExternalTableDefinition": (str, False), + "GlueCatalogGeneration": (boolean, False), "IgnoreHeaderRows": (integer, False), "IncludeOpForFullLoad": (boolean, False), "MaxFileSize": (integer, False), diff --git a/troposphere/docdb.py b/troposphere/docdb.py index 1fb2d7936..3df5136e3 100644 --- a/troposphere/docdb.py +++ b/troposphere/docdb.py @@ -70,6 +70,8 @@ class DBInstance(AWSObject): props: PropsDictType = { "AutoMinorVersionUpgrade": (boolean, False), "AvailabilityZone": (str, False), + "CACertificateIdentifier": (str, False), + "CertificateRotationRestart": (boolean, False), "DBClusterIdentifier": (str, True), "DBInstanceClass": (str, True), "DBInstanceIdentifier": (str, False), @@ -92,3 +94,20 @@ class DBSubnetGroup(AWSObject): "SubnetIds": ([str], True), "Tags": (Tags, False), } + + +class EventSubscription(AWSObject): + """ + `EventSubscription `__ + """ + + resource_type = "AWS::DocDB::EventSubscription" + + props: PropsDictType = { + "Enabled": (boolean, False), + "EventCategories": ([str], False), + "SnsTopicArn": (str, True), + "SourceIds": ([str], False), + "SourceType": (str, False), + "SubscriptionName": (str, False), + } diff --git a/troposphere/ec2.py b/troposphere/ec2.py index 70cf87aad..f87c5974c 100644 --- a/troposphere/ec2.py +++ b/troposphere/ec2.py @@ -1393,6 +1393,27 @@ class Monitoring(AWSProperty): } +class EnaSrdUdpSpecification(AWSProperty): + """ + `EnaSrdUdpSpecification `__ + """ + + props: PropsDictType = { + "EnaSrdUdpEnabled": (boolean, False), + } + + +class EnaSrdSpecification(AWSProperty): + """ + `EnaSrdSpecification `__ + """ + + props: PropsDictType = { + "EnaSrdEnabled": (boolean, False), + "EnaSrdUdpSpecification": (EnaSrdUdpSpecification, False), + } + + class Ipv4PrefixSpecification(AWSProperty): """ `Ipv4PrefixSpecification `__ @@ -1434,6 +1455,7 @@ class NetworkInterfaces(AWSProperty): "DeleteOnTermination": (boolean, False), "Description": (str, False), "DeviceIndex": (integer, False), + "EnaSrdSpecification": (EnaSrdSpecification, False), "Groups": ([str], False), "InterfaceType": (str, False), "Ipv4PrefixCount": (integer, False), diff --git a/troposphere/ecr.py b/troposphere/ecr.py index 9b95c3638..5b48a3138 100644 --- a/troposphere/ecr.py +++ b/troposphere/ecr.py @@ -48,7 +48,9 @@ class PullThroughCacheRule(AWSObject): resource_type = "AWS::ECR::PullThroughCacheRule" props: PropsDictType = { + "CredentialArn": (str, False), "EcrRepositoryPrefix": (str, False), + "UpstreamRegistry": (str, False), "UpstreamRegistryUrl": (str, False), } diff --git a/troposphere/efs.py b/troposphere/efs.py index 94d3ac47c..85d36bfad 100644 --- a/troposphere/efs.py +++ b/troposphere/efs.py @@ -82,12 +82,23 @@ def validate(self): validate_backup_policy(self) +class FileSystemProtection(AWSProperty): + """ + `FileSystemProtection `__ + """ + + props: PropsDictType = { + "ReplicationOverwriteProtection": (str, False), + } + + class LifecyclePolicy(AWSProperty): """ `LifecyclePolicy `__ """ props: PropsDictType = { + "TransitionToArchive": (str, False), "TransitionToIA": (str, False), "TransitionToPrimaryStorageClass": (str, False), } @@ -129,6 +140,7 @@ class FileSystem(AWSObject): "BypassPolicyLockoutSafetyCheck": (boolean, False), "Encrypted": (boolean, False), "FileSystemPolicy": (dict, False), + "FileSystemProtection": (FileSystemProtection, False), "FileSystemTags": (Tags, False), "KmsKeyId": (str, False), "LifecyclePolicies": ([LifecyclePolicy], False), diff --git a/troposphere/eks.py b/troposphere/eks.py index eb3d264e3..61244c276 100644 --- a/troposphere/eks.py +++ b/troposphere/eks.py @@ -325,3 +325,19 @@ class Nodegroup(AWSObject): "UpdateConfig": (UpdateConfig, False), "Version": (str, False), } + + +class PodIdentityAssociation(AWSObject): + """ + `PodIdentityAssociation `__ + """ + + resource_type = "AWS::EKS::PodIdentityAssociation" + + props: PropsDictType = { + "ClusterName": (str, True), + "Namespace": (str, True), + "RoleArn": (str, True), + "ServiceAccount": (str, True), + "Tags": (Tags, False), + } diff --git a/troposphere/elasticache.py b/troposphere/elasticache.py index 1f2930d55..39a7f7bdf 100644 --- a/troposphere/elasticache.py +++ b/troposphere/elasticache.py @@ -263,6 +263,63 @@ class SecurityGroupIngress(AWSObject): } +class DataStorage(AWSProperty): + """ + `DataStorage `__ + """ + + props: PropsDictType = { + "Maximum": (integer, True), + "Unit": (str, True), + } + + +class ECPUPerSecond(AWSProperty): + """ + `ECPUPerSecond `__ + """ + + props: PropsDictType = { + "Maximum": (integer, True), + } + + +class CacheUsageLimits(AWSProperty): + """ + `CacheUsageLimits `__ + """ + + props: PropsDictType = { + "DataStorage": (DataStorage, False), + "ECPUPerSecond": (ECPUPerSecond, False), + } + + +class ServerlessCache(AWSObject): + """ + `ServerlessCache `__ + """ + + resource_type = "AWS::ElastiCache::ServerlessCache" + + props: PropsDictType = { + "CacheUsageLimits": (CacheUsageLimits, False), + "DailySnapshotTime": (str, False), + "Description": (str, False), + "Engine": (str, True), + "FinalSnapshotName": (str, False), + "KmsKeyId": (str, False), + "MajorEngineVersion": (str, False), + "SecurityGroupIds": ([str], False), + "ServerlessCacheName": (str, True), + "SnapshotArnsToRestore": ([str], False), + "SnapshotRetentionLimit": (integer, False), + "SubnetIds": ([str], False), + "Tags": (Tags, False), + "UserGroupId": (str, False), + } + + class SubnetGroup(AWSObject): """ `SubnetGroup `__ @@ -321,3 +378,14 @@ class UserGroup(AWSObject): "UserGroupId": (str, True), "UserIds": ([str], True), } + + +class Endpoint(AWSProperty): + """ + `Endpoint `__ + """ + + props: PropsDictType = { + "Address": (str, False), + "Port": (integer, False), + } diff --git a/troposphere/elasticloadbalancingv2.py b/troposphere/elasticloadbalancingv2.py index ba5e22501..ab39bd66f 100644 --- a/troposphere/elasticloadbalancingv2.py +++ b/troposphere/elasticloadbalancingv2.py @@ -6,7 +6,7 @@ # *** Do not modify - this file is autogenerated *** -from . import AWSObject, AWSProperty, PropsDictType +from . import AWSObject, AWSProperty, PropsDictType, Tags from .validators import boolean, integer from .validators.elasticloadbalancingv2 import TARGET_TYPE_ALB # noqa: F401 from .validators.elasticloadbalancingv2 import TARGET_TYPE_INSTANCE # noqa: F401 @@ -160,6 +160,18 @@ class Certificate(AWSProperty): } +class MutualAuthentication(AWSProperty): + """ + `MutualAuthentication `__ + """ + + props: PropsDictType = { + "IgnoreClientCertificateExpiry": (boolean, False), + "Mode": (str, False), + "TrustStoreArn": (str, False), + } + + class Listener(AWSObject): """ `Listener `__ @@ -172,6 +184,7 @@ class Listener(AWSObject): "Certificates": ([Certificate], False), "DefaultActions": ([Action], True), "LoadBalancerArn": (str, True), + "MutualAuthentication": (MutualAuthentication, False), "Port": (validate_network_port, False), "Protocol": (str, False), "SslPolicy": (str, False), @@ -445,3 +458,58 @@ class TargetGroup(AWSObject): def validate(self): validate_target_group(self) + + +class TrustStore(AWSObject): + """ + `TrustStore `__ + """ + + resource_type = "AWS::ElasticLoadBalancingV2::TrustStore" + + props: PropsDictType = { + "CaCertificatesBundleS3Bucket": (str, False), + "CaCertificatesBundleS3Key": (str, False), + "CaCertificatesBundleS3ObjectVersion": (str, False), + "Name": (str, False), + "Tags": (Tags, False), + } + + +class RevocationContent(AWSProperty): + """ + `RevocationContent `__ + """ + + props: PropsDictType = { + "RevocationType": (str, False), + "S3Bucket": (str, False), + "S3Key": (str, False), + "S3ObjectVersion": (str, False), + } + + +class TrustStoreRevocation(AWSObject): + """ + `TrustStoreRevocation `__ + """ + + resource_type = "AWS::ElasticLoadBalancingV2::TrustStoreRevocation" + + props: PropsDictType = { + "RevocationContents": ([RevocationContent], False), + "TrustStoreArn": (str, False), + } + + +class TrustStoreRevocationProperty(AWSProperty): + """ + `TrustStoreRevocationProperty `__ + """ + + props: PropsDictType = { + "NumberOfRevokedEntries": (integer, False), + "RevocationId": (str, False), + "RevocationType": (str, False), + "TrustStoreArn": (str, False), + } diff --git a/troposphere/fsx.py b/troposphere/fsx.py index 2521f7495..3d02d62d9 100644 --- a/troposphere/fsx.py +++ b/troposphere/fsx.py @@ -115,9 +115,11 @@ class OntapConfiguration(AWSProperty): "DiskIopsConfiguration": (DiskIopsConfiguration, False), "EndpointIpAddressRange": (str, False), "FsxAdminPassword": (str, False), + "HAPairs": (integer, False), "PreferredSubnetId": (str, False), "RouteTableIds": ([str], False), "ThroughputCapacity": (integer, False), + "ThroughputCapacityPerHAPair": (integer, False), "WeeklyMaintenanceStartTime": (str, False), } @@ -312,6 +314,17 @@ class StorageVirtualMachine(AWSObject): } +class AggregateConfiguration(AWSProperty): + """ + `AggregateConfiguration `__ + """ + + props: PropsDictType = { + "Aggregates": ([str], False), + "ConstituentsPerAggregate": (integer, False), + } + + class AutocommitPeriod(AWSProperty): """ `AutocommitPeriod `__ @@ -378,16 +391,19 @@ class VolumeOntapConfiguration(AWSProperty): """ props: PropsDictType = { + "AggregateConfiguration": (AggregateConfiguration, False), "CopyTagsToBackups": (str, False), "JunctionPath": (str, False), "OntapVolumeType": (str, False), "SecurityStyle": (str, False), - "SizeInMegabytes": (str, True), + "SizeInBytes": (str, False), + "SizeInMegabytes": (str, False), "SnaplockConfiguration": (SnaplockConfiguration, False), "SnapshotPolicy": (str, False), "StorageEfficiencyEnabled": (str, False), "StorageVirtualMachineId": (str, True), "TieringPolicy": (TieringPolicy, False), + "VolumeStyle": (str, False), } diff --git a/troposphere/gamelift.py b/troposphere/gamelift.py index 482d37500..3ad517bf4 100644 --- a/troposphere/gamelift.py +++ b/troposphere/gamelift.py @@ -196,7 +196,6 @@ class Fleet(AWSObject): props: PropsDictType = { "AnywhereConfiguration": (AnywhereConfiguration, False), - "ApplyCapacity": (str, False), "BuildId": (str, False), "CertificateConfiguration": (CertificateConfiguration, False), "ComputeType": (str, False), @@ -289,23 +288,23 @@ class GameServerGroup(AWSObject): } -class Destination(AWSProperty): +class FilterConfiguration(AWSProperty): """ - `Destination `__ + `FilterConfiguration `__ """ props: PropsDictType = { - "DestinationArn": (str, False), + "AllowedLocations": ([str], False), } -class FilterConfiguration(AWSProperty): +class GameSessionQueueDestination(AWSProperty): """ - `FilterConfiguration `__ + `GameSessionQueueDestination `__ """ props: PropsDictType = { - "AllowedLocations": ([str], False), + "DestinationArn": (str, False), } @@ -340,7 +339,7 @@ class GameSessionQueue(AWSObject): props: PropsDictType = { "CustomEventData": (str, False), - "Destinations": ([Destination], False), + "Destinations": ([GameSessionQueueDestination], False), "FilterConfiguration": (FilterConfiguration, False), "Name": (str, True), "NotificationTarget": (str, False), @@ -387,6 +386,7 @@ class MatchmakingConfiguration(AWSObject): "AcceptanceTimeoutSeconds": (integer, False), "AdditionalPlayerCount": (integer, False), "BackfillMode": (str, False), + "CreationTime": (str, False), "CustomEventData": (str, False), "Description": (str, False), "FlexMatchMode": (str, False), @@ -396,6 +396,7 @@ class MatchmakingConfiguration(AWSObject): "Name": (str, True), "NotificationTarget": (str, False), "RequestTimeoutSeconds": (integer, True), + "RuleSetArn": (str, False), "RuleSetName": (str, True), "Tags": (Tags, False), } diff --git a/troposphere/grafana.py b/troposphere/grafana.py index 96ed76733..9626aa72e 100644 --- a/troposphere/grafana.py +++ b/troposphere/grafana.py @@ -7,7 +7,7 @@ from . import AWSObject, AWSProperty, PropsDictType -from .validators import double +from .validators import boolean, double class NetworkAccessControl(AWSProperty): @@ -103,6 +103,7 @@ class Workspace(AWSObject): "OrganizationRoleName": (str, False), "OrganizationalUnits": ([str], False), "PermissionType": (str, True), + "PluginAdminEnabled": (boolean, False), "RoleArn": (str, False), "SamlConfiguration": (SamlConfiguration, False), "StackSetName": (str, False), diff --git a/troposphere/guardduty.py b/troposphere/guardduty.py index 0fca7cb01..39d200c58 100644 --- a/troposphere/guardduty.py +++ b/troposphere/guardduty.py @@ -100,7 +100,7 @@ class CFNFeatureConfiguration(AWSProperty): class TagItem(AWSProperty): """ - `TagItem `__ + `TagItem `__ """ props: PropsDictType = { @@ -183,12 +183,12 @@ class IPSet(AWSObject): resource_type = "AWS::GuardDuty::IPSet" props: PropsDictType = { - "Activate": (boolean, True), - "DetectorId": (str, True), + "Activate": (boolean, False), + "DetectorId": (str, False), "Format": (str, True), "Location": (str, True), - "Name": (str, False), - "Tags": (Tags, False), + "Name": (str, True), + "Tags": ([TagItem], False), } @@ -231,10 +231,10 @@ class ThreatIntelSet(AWSObject): resource_type = "AWS::GuardDuty::ThreatIntelSet" props: PropsDictType = { - "Activate": (boolean, True), - "DetectorId": (str, True), + "Activate": (boolean, False), + "DetectorId": (str, False), "Format": (str, True), "Location": (str, True), - "Name": (str, False), - "Tags": (Tags, False), + "Name": (str, True), + "Tags": ([TagItem], False), } diff --git a/troposphere/imagebuilder.py b/troposphere/imagebuilder.py index d8769a985..1163c7c85 100644 --- a/troposphere/imagebuilder.py +++ b/troposphere/imagebuilder.py @@ -453,3 +453,128 @@ class InfrastructureConfiguration(AWSObject): "Tags": (dict, False), "TerminateInstanceOnFailure": (boolean, False), } + + +class IncludeResources(AWSProperty): + """ + `IncludeResources `__ + """ + + props: PropsDictType = { + "Amis": (boolean, False), + "Containers": (boolean, False), + "Snapshots": (boolean, False), + } + + +class Action(AWSProperty): + """ + `Action `__ + """ + + props: PropsDictType = { + "IncludeResources": (IncludeResources, False), + "Type": (str, True), + } + + +class LastLaunched(AWSProperty): + """ + `LastLaunched `__ + """ + + props: PropsDictType = { + "Unit": (str, True), + "Value": (integer, True), + } + + +class AmiExclusionRules(AWSProperty): + """ + `AmiExclusionRules `__ + """ + + props: PropsDictType = { + "IsPublic": (boolean, False), + "LastLaunched": (LastLaunched, False), + "Regions": ([str], False), + "SharedAccounts": ([str], False), + "TagMap": (dict, False), + } + + +class ExclusionRules(AWSProperty): + """ + `ExclusionRules `__ + """ + + props: PropsDictType = { + "Amis": (AmiExclusionRules, False), + "TagMap": (dict, False), + } + + +class Filter(AWSProperty): + """ + `Filter `__ + """ + + props: PropsDictType = { + "RetainAtLeast": (integer, False), + "Type": (str, True), + "Unit": (str, False), + "Value": (integer, True), + } + + +class PolicyDetail(AWSProperty): + """ + `PolicyDetail `__ + """ + + props: PropsDictType = { + "Action": (Action, True), + "ExclusionRules": (ExclusionRules, False), + "Filter": (Filter, True), + } + + +class RecipeSelection(AWSProperty): + """ + `RecipeSelection `__ + """ + + props: PropsDictType = { + "Name": (str, True), + "SemanticVersion": (str, False), + } + + +class ResourceSelection(AWSProperty): + """ + `ResourceSelection `__ + """ + + props: PropsDictType = { + "Recipes": ([RecipeSelection], False), + "TagMap": (dict, False), + } + + +class LifecyclePolicy(AWSObject): + """ + `LifecyclePolicy `__ + """ + + resource_type = "AWS::ImageBuilder::LifecyclePolicy" + + props: PropsDictType = { + "Description": (str, False), + "ExecutionRole": (str, True), + "Name": (str, True), + "PolicyDetails": ([PolicyDetail], True), + "ResourceSelection": (ResourceSelection, True), + "ResourceType": (str, True), + "Status": (str, False), + "Tags": (dict, False), + } diff --git a/troposphere/iot.py b/troposphere/iot.py index dd4aa35c9..7af87f9af 100644 --- a/troposphere/iot.py +++ b/troposphere/iot.py @@ -714,6 +714,7 @@ class Behavior(AWSProperty): props: PropsDictType = { "Criteria": (BehaviorCriteria, False), + "ExportMetric": (boolean, False), "Metric": (str, False), "MetricDimension": (MetricDimension, False), "Name": (str, True), @@ -727,11 +728,23 @@ class MetricToRetain(AWSProperty): """ props: PropsDictType = { + "ExportMetric": (boolean, False), "Metric": (str, True), "MetricDimension": (MetricDimension, False), } +class MetricsExportConfig(AWSProperty): + """ + `MetricsExportConfig `__ + """ + + props: PropsDictType = { + "MqttTopic": (str, True), + "RoleArn": (str, True), + } + + class SecurityProfile(AWSObject): """ `SecurityProfile `__ @@ -743,6 +756,7 @@ class SecurityProfile(AWSObject): "AdditionalMetricsToRetainV2": ([MetricToRetain], False), "AlertTargets": (dict, False), "Behaviors": ([Behavior], False), + "MetricsExportConfig": (MetricsExportConfig, False), "SecurityProfileDescription": (str, False), "SecurityProfileName": (str, False), "Tags": (Tags, False), diff --git a/troposphere/iottwinmaker.py b/troposphere/iottwinmaker.py index 69d2d7d83..76bdde7ec 100644 --- a/troposphere/iottwinmaker.py +++ b/troposphere/iottwinmaker.py @@ -11,6 +11,16 @@ from .validators.iottwinmaker import validate_listvalue, validate_nestedtypel +class CompositeComponentType(AWSProperty): + """ + `CompositeComponentType `__ + """ + + props: PropsDictType = { + "ComponentTypeId": (str, False), + } + + class LambdaFunction(AWSProperty): """ `LambdaFunction `__ @@ -134,6 +144,7 @@ class ComponentType(AWSObject): props: PropsDictType = { "ComponentTypeId": (str, True), + "CompositeComponentTypes": (dict, False), "Description": (str, False), "ExtendsFrom": ([str], False), "Functions": (dict, False), @@ -213,6 +224,22 @@ class Component(AWSProperty): } +class CompositeComponent(AWSProperty): + """ + `CompositeComponent `__ + """ + + props: PropsDictType = { + "ComponentName": (str, False), + "ComponentPath": (str, False), + "ComponentTypeId": (str, False), + "Description": (str, False), + "Properties": (dict, False), + "PropertyGroups": (dict, False), + "Status": (Status, False), + } + + class Entity(AWSObject): """ `Entity `__ @@ -222,6 +249,7 @@ class Entity(AWSObject): props: PropsDictType = { "Components": (dict, False), + "CompositeComponents": (dict, False), "Description": (str, False), "EntityId": (str, False), "EntityName": (str, True), diff --git a/troposphere/logs.py b/troposphere/logs.py index cd5e5f5c0..d4468c694 100644 --- a/troposphere/logs.py +++ b/troposphere/logs.py @@ -30,6 +30,50 @@ class AccountPolicy(AWSObject): } +class Delivery(AWSObject): + """ + `Delivery `__ + """ + + resource_type = "AWS::Logs::Delivery" + + props: PropsDictType = { + "DeliveryDestinationArn": (str, True), + "DeliverySourceName": (str, True), + "Tags": (Tags, False), + } + + +class DeliveryDestination(AWSObject): + """ + `DeliveryDestination `__ + """ + + resource_type = "AWS::Logs::DeliveryDestination" + + props: PropsDictType = { + "DeliveryDestinationPolicy": (dict, False), + "DestinationResourceArn": (str, False), + "Name": (str, True), + "Tags": (Tags, False), + } + + +class DeliverySource(AWSObject): + """ + `DeliverySource `__ + """ + + resource_type = "AWS::Logs::DeliverySource" + + props: PropsDictType = { + "LogType": (str, False), + "Name": (str, True), + "ResourceArn": (str, False), + "Tags": (Tags, False), + } + + class Destination(AWSObject): """ `Destination `__ @@ -45,6 +89,24 @@ class Destination(AWSObject): } +class LogAnomalyDetector(AWSObject): + """ + `LogAnomalyDetector `__ + """ + + resource_type = "AWS::Logs::LogAnomalyDetector" + + props: PropsDictType = { + "AccountId": (str, False), + "AnomalyVisibilityTime": (double, False), + "DetectorName": (str, False), + "EvaluationFrequency": (str, False), + "FilterPattern": (str, False), + "KmsKeyId": (str, False), + "LogGroupArnList": ([str], False), + } + + class LogGroup(AWSObject): """ `LogGroup `__ @@ -55,6 +117,7 @@ class LogGroup(AWSObject): props: PropsDictType = { "DataProtectionPolicy": (dict, False), "KmsKeyId": (str, False), + "LogGroupClass": (str, False), "LogGroupName": (str, False), "RetentionInDays": (validate_loggroup_retention_in_days, False), "Tags": (Tags, False), diff --git a/troposphere/managedblockchain.py b/troposphere/managedblockchain.py index b79876847..f37cdd1df 100644 --- a/troposphere/managedblockchain.py +++ b/troposphere/managedblockchain.py @@ -19,6 +19,7 @@ class Accessor(AWSObject): props: PropsDictType = { "AccessorType": (str, True), + "NetworkType": (str, False), "Tags": (Tags, False), } diff --git a/troposphere/mwaa.py b/troposphere/mwaa.py index ce795fe5e..248acd752 100644 --- a/troposphere/mwaa.py +++ b/troposphere/mwaa.py @@ -58,6 +58,7 @@ class Environment(AWSObject): "AirflowConfigurationOptions": (dict, False), "AirflowVersion": (str, False), "DagS3Path": (str, False), + "EndpointManagement": (str, False), "EnvironmentClass": (str, False), "ExecutionRoleArn": (str, False), "KmsKey": (str, False), diff --git a/troposphere/opensearchserverless.py b/troposphere/opensearchserverless.py index 2d1801da4..5f7d21cc1 100644 --- a/troposphere/opensearchserverless.py +++ b/troposphere/opensearchserverless.py @@ -35,11 +35,27 @@ class Collection(AWSObject): props: PropsDictType = { "Description": (str, False), "Name": (str, True), + "StandbyReplicas": (str, False), "Tags": (Tags, False), "Type": (str, False), } +class LifecyclePolicy(AWSObject): + """ + `LifecyclePolicy `__ + """ + + resource_type = "AWS::OpenSearchServerless::LifecyclePolicy" + + props: PropsDictType = { + "Description": (str, False), + "Name": (str, True), + "Policy": (str, True), + "Type": (str, True), + } + + class SamlConfigOptions(AWSProperty): """ `SamlConfigOptions `__ diff --git a/troposphere/pipes.py b/troposphere/pipes.py index 5233d76be..f90c98fc9 100644 --- a/troposphere/pipes.py +++ b/troposphere/pipes.py @@ -33,6 +33,53 @@ class PipeEnrichmentParameters(AWSProperty): } +class CloudwatchLogsLogDestination(AWSProperty): + """ + `CloudwatchLogsLogDestination `__ + """ + + props: PropsDictType = { + "LogGroupArn": (str, False), + } + + +class FirehoseLogDestination(AWSProperty): + """ + `FirehoseLogDestination `__ + """ + + props: PropsDictType = { + "DeliveryStreamArn": (str, False), + } + + +class S3LogDestination(AWSProperty): + """ + `S3LogDestination `__ + """ + + props: PropsDictType = { + "BucketName": (str, False), + "BucketOwner": (str, False), + "OutputFormat": (str, False), + "Prefix": (str, False), + } + + +class PipeLogConfiguration(AWSProperty): + """ + `PipeLogConfiguration `__ + """ + + props: PropsDictType = { + "CloudwatchLogsLogDestination": (CloudwatchLogsLogDestination, False), + "FirehoseLogDestination": (FirehoseLogDestination, False), + "IncludeExecutionData": ([str], False), + "Level": (str, False), + "S3LogDestination": (S3LogDestination, False), + } + + class Filter(AWSProperty): """ `Filter `__ @@ -633,6 +680,7 @@ class Pipe(AWSObject): "DesiredState": (str, False), "Enrichment": (str, False), "EnrichmentParameters": (PipeEnrichmentParameters, False), + "LogConfiguration": (PipeLogConfiguration, False), "Name": (str, False), "RoleArn": (str, True), "Source": (str, True), diff --git a/troposphere/quicksight.py b/troposphere/quicksight.py index 81fa35cc3..72ed77b9e 100644 --- a/troposphere/quicksight.py +++ b/troposphere/quicksight.py @@ -6295,6 +6295,7 @@ class CastColumnTypeOperation(AWSProperty): "ColumnName": (str, True), "Format": (str, False), "NewColumnType": (str, True), + "SubType": (str, False), } @@ -6443,6 +6444,7 @@ class InputColumn(AWSProperty): props: PropsDictType = { "Name": (str, True), + "SubType": (str, False), "Type": (str, True), } @@ -7722,7 +7724,6 @@ class TemplateVersion(AWSProperty): "DataSetConfigurations": ([DataSetConfiguration], False), "Description": (str, False), "Errors": ([TemplateError], False), - "Options": (AssetOptions, False), "Sheets": ([Sheet], False), "SourceEntityArn": (str, False), "Status": (str, False), diff --git a/troposphere/resourceexplorer2.py b/troposphere/resourceexplorer2.py index 0d69ac2fd..1a71bb373 100644 --- a/troposphere/resourceexplorer2.py +++ b/troposphere/resourceexplorer2.py @@ -64,6 +64,7 @@ class View(AWSObject): props: PropsDictType = { "Filters": (SearchFilter, False), "IncludedProperties": ([IncludedProperty], False), + "Scope": (str, False), "Tags": (dict, False), "ViewName": (str, True), } diff --git a/troposphere/route53resolver.py b/troposphere/route53resolver.py index 4dbef3eb6..c01aa14fd 100644 --- a/troposphere/route53resolver.py +++ b/troposphere/route53resolver.py @@ -139,6 +139,7 @@ class ResolverEndpoint(AWSObject): "Name": (str, False), "OutpostArn": (str, False), "PreferredInstanceType": (str, False), + "Protocols": ([str], False), "ResolverEndpointType": (str, False), "SecurityGroupIds": ([str], True), "Tags": (Tags, False), @@ -180,6 +181,7 @@ class TargetAddress(AWSProperty): "Ip": (str, False), "Ipv6": (str, False), "Port": (str, False), + "Protocol": (str, False), } diff --git a/troposphere/s3.py b/troposphere/s3.py index affec90c8..afd2c90d5 100644 --- a/troposphere/s3.py +++ b/troposphere/s3.py @@ -24,6 +24,72 @@ ) +class AccessGrantsLocationConfiguration(AWSProperty): + """ + `AccessGrantsLocationConfiguration `__ + """ + + props: PropsDictType = { + "S3SubPrefix": (str, True), + } + + +class Grantee(AWSProperty): + """ + `Grantee `__ + """ + + props: PropsDictType = { + "GranteeIdentifier": (str, True), + "GranteeType": (str, True), + } + + +class AccessGrant(AWSObject): + """ + `AccessGrant `__ + """ + + resource_type = "AWS::S3::AccessGrant" + + props: PropsDictType = { + "AccessGrantsLocationConfiguration": (AccessGrantsLocationConfiguration, False), + "AccessGrantsLocationId": (str, True), + "ApplicationArn": (str, False), + "Grantee": (Grantee, True), + "Permission": (str, True), + "S3PrefixType": (str, False), + "Tags": (Tags, False), + } + + +class AccessGrantsInstance(AWSObject): + """ + `AccessGrantsInstance `__ + """ + + resource_type = "AWS::S3::AccessGrantsInstance" + + props: PropsDictType = { + "IdentityCenterArn": (str, False), + "Tags": (Tags, False), + } + + +class AccessGrantsLocation(AWSObject): + """ + `AccessGrantsLocation `__ + """ + + resource_type = "AWS::S3::AccessGrantsLocation" + + props: PropsDictType = { + "IamRoleArn": (str, False), + "LocationScope": (str, False), + "Tags": (Tags, False), + } + + class PublicAccessBlockConfiguration(AWSProperty): """ `PublicAccessBlockConfiguration `__ @@ -1026,6 +1092,86 @@ class StorageLens(AWSObject): } +class MatchObjectAge(AWSProperty): + """ + `MatchObjectAge `__ + """ + + props: PropsDictType = { + "DaysGreaterThan": (integer, False), + "DaysLessThan": (integer, False), + } + + +class MatchObjectSize(AWSProperty): + """ + `MatchObjectSize `__ + """ + + props: PropsDictType = { + "BytesGreaterThan": (integer, False), + "BytesLessThan": (integer, False), + } + + +class And(AWSProperty): + """ + `And `__ + """ + + props: PropsDictType = { + "MatchAnyPrefix": ([str], False), + "MatchAnySuffix": ([str], False), + "MatchAnyTag": (Tags, False), + "MatchObjectAge": (MatchObjectAge, False), + "MatchObjectSize": (MatchObjectSize, False), + } + + +class Or(AWSProperty): + """ + `Or `__ + """ + + props: PropsDictType = { + "MatchAnyPrefix": ([str], False), + "MatchAnySuffix": ([str], False), + "MatchAnyTag": (Tags, False), + "MatchObjectAge": (MatchObjectAge, False), + "MatchObjectSize": (MatchObjectSize, False), + } + + +class StorageLensFilter(AWSProperty): + """ + `StorageLensFilter `__ + """ + + props: PropsDictType = { + "And": (And, False), + "MatchAnyPrefix": ([str], False), + "MatchAnySuffix": ([str], False), + "MatchAnyTag": (Tags, False), + "MatchObjectAge": (MatchObjectAge, False), + "MatchObjectSize": (MatchObjectSize, False), + "Or": (Or, False), + } + + +class StorageLensGroup(AWSObject): + """ + `StorageLensGroup `__ + """ + + resource_type = "AWS::S3::StorageLensGroup" + + props: PropsDictType = { + "Filter": (StorageLensFilter, True), + "Name": (str, True), + "Tags": (Tags, False), + } + + class PolicyStatus(AWSProperty): """ `PolicyStatus `__ diff --git a/troposphere/sagemaker.py b/troposphere/sagemaker.py index 7d49cf9f0..7032c5f2c 100644 --- a/troposphere/sagemaker.py +++ b/troposphere/sagemaker.py @@ -796,6 +796,28 @@ class ExplainerConfig(AWSProperty): } +class ManagedInstanceScaling(AWSProperty): + """ + `ManagedInstanceScaling `__ + """ + + props: PropsDictType = { + "MaxInstanceCount": (integer, False), + "MinInstanceCount": (integer, False), + "Status": (str, False), + } + + +class RoutingConfig(AWSProperty): + """ + `RoutingConfig `__ + """ + + props: PropsDictType = { + "RoutingStrategy": (str, False), + } + + class ServerlessConfig(AWSProperty): """ `ServerlessConfig `__ @@ -818,10 +840,12 @@ class ProductionVariant(AWSProperty): "ContainerStartupHealthCheckTimeoutInSeconds": (integer, False), "EnableSSMAccess": (boolean, False), "InitialInstanceCount": (integer, False), - "InitialVariantWeight": (double, True), + "InitialVariantWeight": (double, False), "InstanceType": (str, False), + "ManagedInstanceScaling": (ManagedInstanceScaling, False), "ModelDataDownloadTimeoutInSeconds": (integer, False), - "ModelName": (str, True), + "ModelName": (str, False), + "RoutingConfig": (RoutingConfig, False), "ServerlessConfig": (ServerlessConfig, False), "VariantName": (str, True), "VolumeSizeInGB": (integer, False), @@ -838,12 +862,15 @@ class EndpointConfig(AWSObject): props: PropsDictType = { "AsyncInferenceConfig": (AsyncInferenceConfig, False), "DataCaptureConfig": (DataCaptureConfig, False), + "EnableNetworkIsolation": (boolean, False), "EndpointConfigName": (str, False), + "ExecutionRoleArn": (str, False), "ExplainerConfig": (ExplainerConfig, False), "KmsKeyId": (str, False), "ProductionVariants": ([ProductionVariant], True), "ShadowProductionVariants": ([ProductionVariant], False), "Tags": (Tags, False), + "VpcConfig": (VpcConfig, False), } @@ -973,6 +1000,101 @@ class ImageVersion(AWSObject): } +class InferenceComponentRuntimeConfig(AWSProperty): + """ + `InferenceComponentRuntimeConfig `__ + """ + + props: PropsDictType = { + "CopyCount": (integer, False), + "CurrentCopyCount": (integer, False), + "DesiredCopyCount": (integer, False), + } + + +class InferenceComponentComputeResourceRequirements(AWSProperty): + """ + `InferenceComponentComputeResourceRequirements `__ + """ + + props: PropsDictType = { + "MaxMemoryRequiredInMb": (integer, False), + "MinMemoryRequiredInMb": (integer, False), + "NumberOfAcceleratorDevicesRequired": (double, False), + "NumberOfCpuCoresRequired": (double, False), + } + + +class DeployedImage(AWSProperty): + """ + `DeployedImage `__ + """ + + props: PropsDictType = { + "ResolutionTime": (str, False), + "ResolvedImage": (str, False), + "SpecifiedImage": (str, False), + } + + +class InferenceComponentContainerSpecification(AWSProperty): + """ + `InferenceComponentContainerSpecification `__ + """ + + props: PropsDictType = { + "ArtifactUrl": (str, False), + "DeployedImage": (DeployedImage, False), + "Environment": (dict, False), + "Image": (str, False), + } + + +class InferenceComponentStartupParameters(AWSProperty): + """ + `InferenceComponentStartupParameters `__ + """ + + props: PropsDictType = { + "ContainerStartupHealthCheckTimeoutInSeconds": (integer, False), + "ModelDataDownloadTimeoutInSeconds": (integer, False), + } + + +class InferenceComponentSpecification(AWSProperty): + """ + `InferenceComponentSpecification `__ + """ + + props: PropsDictType = { + "ComputeResourceRequirements": ( + InferenceComponentComputeResourceRequirements, + True, + ), + "Container": (InferenceComponentContainerSpecification, False), + "ModelName": (str, False), + "StartupParameters": (InferenceComponentStartupParameters, False), + } + + +class InferenceComponent(AWSObject): + """ + `InferenceComponent `__ + """ + + resource_type = "AWS::SageMaker::InferenceComponent" + + props: PropsDictType = { + "EndpointArn": (str, False), + "EndpointName": (str, True), + "InferenceComponentName": (str, False), + "RuntimeConfig": (InferenceComponentRuntimeConfig, True), + "Specification": (InferenceComponentSpecification, True), + "Tags": (Tags, False), + "VariantName": (str, True), + } + + class DataStorageConfig(AWSProperty): """ `DataStorageConfig `__ @@ -1097,6 +1219,27 @@ class ImageConfig(AWSProperty): } +class S3DataSource(AWSProperty): + """ + `S3DataSource `__ + """ + + props: PropsDictType = { + "S3DataType": (str, True), + "S3Uri": (str, True), + } + + +class ModelDataSource(AWSProperty): + """ + `ModelDataSource `__ + """ + + props: PropsDictType = { + "S3DataSource": (S3DataSource, True), + } + + class MultiModelConfig(AWSProperty): """ `MultiModelConfig `__ @@ -1119,6 +1262,7 @@ class ContainerDefinition(AWSProperty): "ImageConfig": (ImageConfig, False), "InferenceSpecificationName": (str, False), "Mode": (str, False), + "ModelDataSource": (ModelDataSource, False), "ModelDataUrl": (str, False), "ModelPackageName": (str, False), "MultiModelConfig": (MultiModelConfig, False), @@ -1145,7 +1289,7 @@ class Model(AWSObject): props: PropsDictType = { "Containers": ([ContainerDefinition], False), "EnableNetworkIsolation": (boolean, False), - "ExecutionRoleArn": (str, True), + "ExecutionRoleArn": (str, False), "InferenceExecutionConfig": (InferenceExecutionConfig, False), "ModelName": (str, False), "PrimaryContainer": (ContainerDefinition, False), @@ -1848,17 +1992,6 @@ class SourceAlgorithmSpecification(AWSProperty): } -class S3DataSource(AWSProperty): - """ - `S3DataSource `__ - """ - - props: PropsDictType = { - "S3DataType": (str, True), - "S3Uri": (str, True), - } - - class DataSource(AWSProperty): """ `DataSource `__ diff --git a/troposphere/transfer.py b/troposphere/transfer.py index 0ddccef50..04a06d5bd 100644 --- a/troposphere/transfer.py +++ b/troposphere/transfer.py @@ -151,6 +151,16 @@ class ProtocolDetails(AWSProperty): } +class S3StorageOptions(AWSProperty): + """ + `S3StorageOptions `__ + """ + + props: PropsDictType = { + "DirectoryListingOptimization": (str, False), + } + + class WorkflowDetail(AWSProperty): """ `WorkflowDetail `__ @@ -192,6 +202,7 @@ class Server(AWSObject): "PreAuthenticationLoginBanner": (str, False), "ProtocolDetails": (ProtocolDetails, False), "Protocols": ([str], False), + "S3StorageOptions": (S3StorageOptions, False), "SecurityPolicyName": (str, False), "StructuredLogDestinations": ([str], False), "Tags": (Tags, False), @@ -207,6 +218,7 @@ class HomeDirectoryMapEntry(AWSProperty): props: PropsDictType = { "Entry": (str, True), "Target": (str, True), + "Type": (str, False), }