pulumi-aws-native 1.38.0a1761284362__py3-none-any.whl → 1.38.0a1761310773__py3-none-any.whl

pulumi_aws_native/observabilityadmin/_inputs.py

@@ -49,8 +49,17 @@ MYPY = False
 if not MYPY:
     class OrganizationCentralizationRuleCentralizationRuleDestinationArgsDict(TypedDict):
         region: pulumi.Input[_builtins.str]
+        """
+        The primary destination region to which telemetry data should be centralized.
+        """
         account: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The destination account (within the organization) to which the telemetry data should be centralized.
+        """
         destination_logs_configuration: NotRequired[pulumi.Input['OrganizationCentralizationRuleDestinationLogsConfigurationArgsDict']]
+        """
+        Log specific configuration for centralization destination log groups.
+        """
 elif False:
     OrganizationCentralizationRuleCentralizationRuleDestinationArgsDict: TypeAlias = Mapping[str, Any]
 
@@ -60,6 +69,11 @@ class OrganizationCentralizationRuleCentralizationRuleDestinationArgs:
                  region: pulumi.Input[_builtins.str],
                  account: Optional[pulumi.Input[_builtins.str]] = None,
                  destination_logs_configuration: Optional[pulumi.Input['OrganizationCentralizationRuleDestinationLogsConfigurationArgs']] = None):
+        """
+        :param pulumi.Input[_builtins.str] region: The primary destination region to which telemetry data should be centralized.
+        :param pulumi.Input[_builtins.str] account: The destination account (within the organization) to which the telemetry data should be centralized.
+        :param pulumi.Input['OrganizationCentralizationRuleDestinationLogsConfigurationArgs'] destination_logs_configuration: Log specific configuration for centralization destination log groups.
+        """
         pulumi.set(__self__, "region", region)
         if account is not None:
             pulumi.set(__self__, "account", account)
@@ -69,6 +83,9 @@ class OrganizationCentralizationRuleCentralizationRuleDestinationArgs:
     @_builtins.property
     @pulumi.getter
     def region(self) -> pulumi.Input[_builtins.str]:
+        """
+        The primary destination region to which telemetry data should be centralized.
+        """
         return pulumi.get(self, "region")
 
     @region.setter
@@ -78,6 +95,9 @@ class OrganizationCentralizationRuleCentralizationRuleDestinationArgs:
     @_builtins.property
     @pulumi.getter
     def account(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The destination account (within the organization) to which the telemetry data should be centralized.
+        """
         return pulumi.get(self, "account")
 
     @account.setter
@@ -87,6 +107,9 @@ class OrganizationCentralizationRuleCentralizationRuleDestinationArgs:
     @_builtins.property
     @pulumi.getter(name="destinationLogsConfiguration")
     def destination_logs_configuration(self) -> Optional[pulumi.Input['OrganizationCentralizationRuleDestinationLogsConfigurationArgs']]:
+        """
+        Log specific configuration for centralization destination log groups.
+        """
         return pulumi.get(self, "destination_logs_configuration")
 
     @destination_logs_configuration.setter
@@ -97,8 +120,17 @@ class OrganizationCentralizationRuleCentralizationRuleDestinationArgs:
 if not MYPY:
     class OrganizationCentralizationRuleCentralizationRuleSourceArgsDict(TypedDict):
         regions: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]
+        """
+        The list of source regions from which telemetry data should be centralized.
+        """
         scope: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The organizational scope from which telemetry data should be centralized, specified using organization id, accounts or organizational unit ids.
+        """
         source_logs_configuration: NotRequired[pulumi.Input['OrganizationCentralizationRuleSourceLogsConfigurationArgsDict']]
+        """
+        Log specific configuration for centralization source log groups.
+        """
 elif False:
     OrganizationCentralizationRuleCentralizationRuleSourceArgsDict: TypeAlias = Mapping[str, Any]
 
@@ -108,6 +140,11 @@ class OrganizationCentralizationRuleCentralizationRuleSourceArgs:
                  regions: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]],
                  scope: Optional[pulumi.Input[_builtins.str]] = None,
                  source_logs_configuration: Optional[pulumi.Input['OrganizationCentralizationRuleSourceLogsConfigurationArgs']] = None):
+        """
+        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] regions: The list of source regions from which telemetry data should be centralized.
+        :param pulumi.Input[_builtins.str] scope: The organizational scope from which telemetry data should be centralized, specified using organization id, accounts or organizational unit ids.
+        :param pulumi.Input['OrganizationCentralizationRuleSourceLogsConfigurationArgs'] source_logs_configuration: Log specific configuration for centralization source log groups.
+        """
         pulumi.set(__self__, "regions", regions)
         if scope is not None:
             pulumi.set(__self__, "scope", scope)
@@ -117,6 +154,9 @@ class OrganizationCentralizationRuleCentralizationRuleSourceArgs:
     @_builtins.property
     @pulumi.getter
     def regions(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
+        """
+        The list of source regions from which telemetry data should be centralized.
+        """
         return pulumi.get(self, "regions")
 
     @regions.setter
@@ -126,6 +166,9 @@ class OrganizationCentralizationRuleCentralizationRuleSourceArgs:
     @_builtins.property
     @pulumi.getter
     def scope(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The organizational scope from which telemetry data should be centralized, specified using organization id, accounts or organizational unit ids.
+        """
         return pulumi.get(self, "scope")
 
     @scope.setter
@@ -135,6 +178,9 @@ class OrganizationCentralizationRuleCentralizationRuleSourceArgs:
     @_builtins.property
     @pulumi.getter(name="sourceLogsConfiguration")
     def source_logs_configuration(self) -> Optional[pulumi.Input['OrganizationCentralizationRuleSourceLogsConfigurationArgs']]:
+        """
+        Log specific configuration for centralization source log groups.
+        """
         return pulumi.get(self, "source_logs_configuration")
 
     @source_logs_configuration.setter
@@ -145,7 +191,13 @@ class OrganizationCentralizationRuleCentralizationRuleSourceArgs:
 if not MYPY:
     class OrganizationCentralizationRuleCentralizationRuleArgsDict(TypedDict):
         destination: pulumi.Input['OrganizationCentralizationRuleCentralizationRuleDestinationArgsDict']
+        """
+        Configuration determining where the telemetry data should be centralized, backed up, as well as encryption configuration for the primary and backup destinations.
+        """
         source: pulumi.Input['OrganizationCentralizationRuleCentralizationRuleSourceArgsDict']
+        """
+        Configuration determining the source of the telemetry data to be centralized.
+        """
 elif False:
     OrganizationCentralizationRuleCentralizationRuleArgsDict: TypeAlias = Mapping[str, Any]
 
@@ -154,12 +206,19 @@ class OrganizationCentralizationRuleCentralizationRuleArgs:
     def __init__(__self__, *,
                  destination: pulumi.Input['OrganizationCentralizationRuleCentralizationRuleDestinationArgs'],
                  source: pulumi.Input['OrganizationCentralizationRuleCentralizationRuleSourceArgs']):
+        """
+        :param pulumi.Input['OrganizationCentralizationRuleCentralizationRuleDestinationArgs'] destination: Configuration determining where the telemetry data should be centralized, backed up, as well as encryption configuration for the primary and backup destinations.
+        :param pulumi.Input['OrganizationCentralizationRuleCentralizationRuleSourceArgs'] source: Configuration determining the source of the telemetry data to be centralized.
+        """
         pulumi.set(__self__, "destination", destination)
         pulumi.set(__self__, "source", source)
 
     @_builtins.property
     @pulumi.getter
     def destination(self) -> pulumi.Input['OrganizationCentralizationRuleCentralizationRuleDestinationArgs']:
+        """
+        Configuration determining where the telemetry data should be centralized, backed up, as well as encryption configuration for the primary and backup destinations.
+        """
         return pulumi.get(self, "destination")
 
     @destination.setter
@@ -169,6 +228,9 @@ class OrganizationCentralizationRuleCentralizationRuleArgs:
     @_builtins.property
     @pulumi.getter
     def source(self) -> pulumi.Input['OrganizationCentralizationRuleCentralizationRuleSourceArgs']:
+        """
+        Configuration determining the source of the telemetry data to be centralized.
+        """
         return pulumi.get(self, "source")
 
     @source.setter
@@ -179,7 +241,13 @@ class OrganizationCentralizationRuleCentralizationRuleArgs:
 if not MYPY:
     class OrganizationCentralizationRuleDestinationLogsConfigurationArgsDict(TypedDict):
         backup_configuration: NotRequired[pulumi.Input['OrganizationCentralizationRuleLogsBackupConfigurationArgsDict']]
+        """
+        Configuration defining the backup region and an optional KMS key for the backup destination.
+        """
         logs_encryption_configuration: NotRequired[pulumi.Input['OrganizationCentralizationRuleLogsEncryptionConfigurationArgsDict']]
+        """
+        The encryption configuration for centralization destination log groups.
+        """
 elif False:
     OrganizationCentralizationRuleDestinationLogsConfigurationArgsDict: TypeAlias = Mapping[str, Any]
 
@@ -188,6 +256,10 @@ class OrganizationCentralizationRuleDestinationLogsConfigurationArgs:
     def __init__(__self__, *,
                  backup_configuration: Optional[pulumi.Input['OrganizationCentralizationRuleLogsBackupConfigurationArgs']] = None,
                  logs_encryption_configuration: Optional[pulumi.Input['OrganizationCentralizationRuleLogsEncryptionConfigurationArgs']] = None):
+        """
+        :param pulumi.Input['OrganizationCentralizationRuleLogsBackupConfigurationArgs'] backup_configuration: Configuration defining the backup region and an optional KMS key for the backup destination.
+        :param pulumi.Input['OrganizationCentralizationRuleLogsEncryptionConfigurationArgs'] logs_encryption_configuration: The encryption configuration for centralization destination log groups.
+        """
         if backup_configuration is not None:
             pulumi.set(__self__, "backup_configuration", backup_configuration)
         if logs_encryption_configuration is not None:
@@ -196,6 +268,9 @@ class OrganizationCentralizationRuleDestinationLogsConfigurationArgs:
     @_builtins.property
     @pulumi.getter(name="backupConfiguration")
     def backup_configuration(self) -> Optional[pulumi.Input['OrganizationCentralizationRuleLogsBackupConfigurationArgs']]:
+        """
+        Configuration defining the backup region and an optional KMS key for the backup destination.
+        """
         return pulumi.get(self, "backup_configuration")
 
     @backup_configuration.setter
@@ -205,6 +280,9 @@ class OrganizationCentralizationRuleDestinationLogsConfigurationArgs:
     @_builtins.property
     @pulumi.getter(name="logsEncryptionConfiguration")
     def logs_encryption_configuration(self) -> Optional[pulumi.Input['OrganizationCentralizationRuleLogsEncryptionConfigurationArgs']]:
+        """
+        The encryption configuration for centralization destination log groups.
+        """
         return pulumi.get(self, "logs_encryption_configuration")
 
     @logs_encryption_configuration.setter
@@ -215,7 +293,13 @@ class OrganizationCentralizationRuleDestinationLogsConfigurationArgs:
 if not MYPY:
     class OrganizationCentralizationRuleLogsBackupConfigurationArgsDict(TypedDict):
         region: pulumi.Input[_builtins.str]
+        """
+        Logs specific backup destination region within the primary destination account to which log data should be centralized.
+        """
         kms_key_arn: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        KMS Key ARN belonging to the primary destination account and backup region, to encrypt newly created central log groups in the backup destination.
+        """
 elif False:
     OrganizationCentralizationRuleLogsBackupConfigurationArgsDict: TypeAlias = Mapping[str, Any]
 
@@ -224,6 +308,10 @@ class OrganizationCentralizationRuleLogsBackupConfigurationArgs:
     def __init__(__self__, *,
                  region: pulumi.Input[_builtins.str],
                  kms_key_arn: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_builtins.str] region: Logs specific backup destination region within the primary destination account to which log data should be centralized.
+        :param pulumi.Input[_builtins.str] kms_key_arn: KMS Key ARN belonging to the primary destination account and backup region, to encrypt newly created central log groups in the backup destination.
+        """
         pulumi.set(__self__, "region", region)
         if kms_key_arn is not None:
             pulumi.set(__self__, "kms_key_arn", kms_key_arn)
@@ -231,6 +319,9 @@ class OrganizationCentralizationRuleLogsBackupConfigurationArgs:
     @_builtins.property
     @pulumi.getter
     def region(self) -> pulumi.Input[_builtins.str]:
+        """
+        Logs specific backup destination region within the primary destination account to which log data should be centralized.
+        """
         return pulumi.get(self, "region")
 
     @region.setter
@@ -240,6 +331,9 @@ class OrganizationCentralizationRuleLogsBackupConfigurationArgs:
     @_builtins.property
     @pulumi.getter(name="kmsKeyArn")
     def kms_key_arn(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        KMS Key ARN belonging to the primary destination account and backup region, to encrypt newly created central log groups in the backup destination.
+        """
         return pulumi.get(self, "kms_key_arn")
 
     @kms_key_arn.setter
@@ -250,8 +344,17 @@ class OrganizationCentralizationRuleLogsBackupConfigurationArgs:
 if not MYPY:
     class OrganizationCentralizationRuleLogsEncryptionConfigurationArgsDict(TypedDict):
         encryption_strategy: pulumi.Input['OrganizationCentralizationRuleLogsEncryptionConfigurationEncryptionStrategy']
+        """
+        Configuration that determines the encryption strategy of the destination log groups. CUSTOMER_MANAGED uses the configured KmsKeyArn to encrypt newly created destination log groups.
+        """
         encryption_conflict_resolution_strategy: NotRequired[pulumi.Input['OrganizationCentralizationRuleLogsEncryptionConfigurationEncryptionConflictResolutionStrategy']]
+        """
+        Conflict resolution strategy for centralization if the encryption strategy is set to CUSTOMER_MANAGED and the destination log group is encrypted with an AWS_OWNED KMS Key. ALLOW lets centralization go through while SKIP prevents centralization into the destination log group.
+        """
         kms_key_arn: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        KMS Key ARN belonging to the primary destination account and region, to encrypt newly created central log groups in the primary destination.
+        """
 elif False:
     OrganizationCentralizationRuleLogsEncryptionConfigurationArgsDict: TypeAlias = Mapping[str, Any]
 
@@ -261,6 +364,11 @@ class OrganizationCentralizationRuleLogsEncryptionConfigurationArgs:
                  encryption_strategy: pulumi.Input['OrganizationCentralizationRuleLogsEncryptionConfigurationEncryptionStrategy'],
                  encryption_conflict_resolution_strategy: Optional[pulumi.Input['OrganizationCentralizationRuleLogsEncryptionConfigurationEncryptionConflictResolutionStrategy']] = None,
                  kms_key_arn: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input['OrganizationCentralizationRuleLogsEncryptionConfigurationEncryptionStrategy'] encryption_strategy: Configuration that determines the encryption strategy of the destination log groups. CUSTOMER_MANAGED uses the configured KmsKeyArn to encrypt newly created destination log groups.
+        :param pulumi.Input['OrganizationCentralizationRuleLogsEncryptionConfigurationEncryptionConflictResolutionStrategy'] encryption_conflict_resolution_strategy: Conflict resolution strategy for centralization if the encryption strategy is set to CUSTOMER_MANAGED and the destination log group is encrypted with an AWS_OWNED KMS Key. ALLOW lets centralization go through while SKIP prevents centralization into the destination log group.
+        :param pulumi.Input[_builtins.str] kms_key_arn: KMS Key ARN belonging to the primary destination account and region, to encrypt newly created central log groups in the primary destination.
+        """
         pulumi.set(__self__, "encryption_strategy", encryption_strategy)
         if encryption_conflict_resolution_strategy is not None:
             pulumi.set(__self__, "encryption_conflict_resolution_strategy", encryption_conflict_resolution_strategy)
@@ -270,6 +378,9 @@ class OrganizationCentralizationRuleLogsEncryptionConfigurationArgs:
     @_builtins.property
     @pulumi.getter(name="encryptionStrategy")
     def encryption_strategy(self) -> pulumi.Input['OrganizationCentralizationRuleLogsEncryptionConfigurationEncryptionStrategy']:
+        """
+        Configuration that determines the encryption strategy of the destination log groups. CUSTOMER_MANAGED uses the configured KmsKeyArn to encrypt newly created destination log groups.
+        """
         return pulumi.get(self, "encryption_strategy")
 
     @encryption_strategy.setter
@@ -279,6 +390,9 @@ class OrganizationCentralizationRuleLogsEncryptionConfigurationArgs:
     @_builtins.property
     @pulumi.getter(name="encryptionConflictResolutionStrategy")
     def encryption_conflict_resolution_strategy(self) -> Optional[pulumi.Input['OrganizationCentralizationRuleLogsEncryptionConfigurationEncryptionConflictResolutionStrategy']]:
+        """
+        Conflict resolution strategy for centralization if the encryption strategy is set to CUSTOMER_MANAGED and the destination log group is encrypted with an AWS_OWNED KMS Key. ALLOW lets centralization go through while SKIP prevents centralization into the destination log group.
+        """
         return pulumi.get(self, "encryption_conflict_resolution_strategy")
 
     @encryption_conflict_resolution_strategy.setter
@@ -288,6 +402,9 @@ class OrganizationCentralizationRuleLogsEncryptionConfigurationArgs:
     @_builtins.property
     @pulumi.getter(name="kmsKeyArn")
     def kms_key_arn(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        KMS Key ARN belonging to the primary destination account and region, to encrypt newly created central log groups in the primary destination.
+        """
         return pulumi.get(self, "kms_key_arn")
 
     @kms_key_arn.setter
@@ -298,7 +415,13 @@ class OrganizationCentralizationRuleLogsEncryptionConfigurationArgs:
 if not MYPY:
     class OrganizationCentralizationRuleSourceLogsConfigurationArgsDict(TypedDict):
         encrypted_log_group_strategy: pulumi.Input['OrganizationCentralizationRuleSourceLogsConfigurationEncryptedLogGroupStrategy']
+        """
+        A strategy determining whether to centralize source log groups that are encrypted with customer managed KMS keys (CMK). ALLOW will consider CMK encrypted source log groups for centralization while SKIP will skip CMK encrypted source log groups from centralization.
+        """
         log_group_selection_criteria: pulumi.Input[_builtins.str]
+        """
+        The selection criteria that specifies which source log groups to centralize. The selection criteria uses the same format as OAM link filters.
+        """
 elif False:
     OrganizationCentralizationRuleSourceLogsConfigurationArgsDict: TypeAlias = Mapping[str, Any]
 
@@ -307,12 +430,19 @@ class OrganizationCentralizationRuleSourceLogsConfigurationArgs:
     def __init__(__self__, *,
                  encrypted_log_group_strategy: pulumi.Input['OrganizationCentralizationRuleSourceLogsConfigurationEncryptedLogGroupStrategy'],
                  log_group_selection_criteria: pulumi.Input[_builtins.str]):
+        """
+        :param pulumi.Input['OrganizationCentralizationRuleSourceLogsConfigurationEncryptedLogGroupStrategy'] encrypted_log_group_strategy: A strategy determining whether to centralize source log groups that are encrypted with customer managed KMS keys (CMK). ALLOW will consider CMK encrypted source log groups for centralization while SKIP will skip CMK encrypted source log groups from centralization.
+        :param pulumi.Input[_builtins.str] log_group_selection_criteria: The selection criteria that specifies which source log groups to centralize. The selection criteria uses the same format as OAM link filters.
+        """
         pulumi.set(__self__, "encrypted_log_group_strategy", encrypted_log_group_strategy)
         pulumi.set(__self__, "log_group_selection_criteria", log_group_selection_criteria)
 
     @_builtins.property
     @pulumi.getter(name="encryptedLogGroupStrategy")
     def encrypted_log_group_strategy(self) -> pulumi.Input['OrganizationCentralizationRuleSourceLogsConfigurationEncryptedLogGroupStrategy']:
+        """
+        A strategy determining whether to centralize source log groups that are encrypted with customer managed KMS keys (CMK). ALLOW will consider CMK encrypted source log groups for centralization while SKIP will skip CMK encrypted source log groups from centralization.
+        """
         return pulumi.get(self, "encrypted_log_group_strategy")
 
     @encrypted_log_group_strategy.setter
@@ -322,6 +452,9 @@ class OrganizationCentralizationRuleSourceLogsConfigurationArgs:
     @_builtins.property
     @pulumi.getter(name="logGroupSelectionCriteria")
     def log_group_selection_criteria(self) -> pulumi.Input[_builtins.str]:
+        """
+        The selection criteria that specifies which source log groups to centralize. The selection criteria uses the same format as OAM link filters.
+        """
         return pulumi.get(self, "log_group_selection_criteria")
 
     @log_group_selection_criteria.setter
@@ -335,9 +468,21 @@ if not MYPY:
         The destination configuration for telemetry data
         """
         destination_pattern: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The pattern used to generate the destination path or name, supporting macros like <resourceId> and <accountId>.
+        """
         destination_type: NotRequired[pulumi.Input['OrganizationTelemetryRuleDestinationType']]
+        """
+        The type of destination for the telemetry data (e.g., "Amazon CloudWatch Logs", "S3").
+        """
         retention_in_days: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        The number of days to retain the telemetry data in the destination.
+        """
         vpc_flow_log_parameters: NotRequired[pulumi.Input['OrganizationTelemetryRuleVpcFlowLogParametersArgsDict']]
+        """
+        Configuration parameters specific to VPC Flow Logs when VPC is the resource type.
+        """
 elif False:
     OrganizationTelemetryRuleTelemetryDestinationConfigurationArgsDict: TypeAlias = Mapping[str, Any]
 
@@ -350,6 +495,10 @@ class OrganizationTelemetryRuleTelemetryDestinationConfigurationArgs:
                  vpc_flow_log_parameters: Optional[pulumi.Input['OrganizationTelemetryRuleVpcFlowLogParametersArgs']] = None):
         """
         The destination configuration for telemetry data
+        :param pulumi.Input[_builtins.str] destination_pattern: The pattern used to generate the destination path or name, supporting macros like <resourceId> and <accountId>.
+        :param pulumi.Input['OrganizationTelemetryRuleDestinationType'] destination_type: The type of destination for the telemetry data (e.g., "Amazon CloudWatch Logs", "S3").
+        :param pulumi.Input[_builtins.int] retention_in_days: The number of days to retain the telemetry data in the destination.
+        :param pulumi.Input['OrganizationTelemetryRuleVpcFlowLogParametersArgs'] vpc_flow_log_parameters: Configuration parameters specific to VPC Flow Logs when VPC is the resource type.
         """
         if destination_pattern is not None:
             pulumi.set(__self__, "destination_pattern", destination_pattern)
@@ -363,6 +512,9 @@ class OrganizationTelemetryRuleTelemetryDestinationConfigurationArgs:
     @_builtins.property
     @pulumi.getter(name="destinationPattern")
     def destination_pattern(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The pattern used to generate the destination path or name, supporting macros like <resourceId> and <accountId>.
+        """
         return pulumi.get(self, "destination_pattern")
 
     @destination_pattern.setter
@@ -372,6 +524,9 @@ class OrganizationTelemetryRuleTelemetryDestinationConfigurationArgs:
     @_builtins.property
     @pulumi.getter(name="destinationType")
     def destination_type(self) -> Optional[pulumi.Input['OrganizationTelemetryRuleDestinationType']]:
+        """
+        The type of destination for the telemetry data (e.g., "Amazon CloudWatch Logs", "S3").
+        """
         return pulumi.get(self, "destination_type")
 
     @destination_type.setter
@@ -381,6 +536,9 @@ class OrganizationTelemetryRuleTelemetryDestinationConfigurationArgs:
     @_builtins.property
     @pulumi.getter(name="retentionInDays")
     def retention_in_days(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The number of days to retain the telemetry data in the destination.
+        """
         return pulumi.get(self, "retention_in_days")
 
     @retention_in_days.setter
@@ -390,6 +548,9 @@ class OrganizationTelemetryRuleTelemetryDestinationConfigurationArgs:
     @_builtins.property
     @pulumi.getter(name="vpcFlowLogParameters")
     def vpc_flow_log_parameters(self) -> Optional[pulumi.Input['OrganizationTelemetryRuleVpcFlowLogParametersArgs']]:
+        """
+        Configuration parameters specific to VPC Flow Logs when VPC is the resource type.
+        """
         return pulumi.get(self, "vpc_flow_log_parameters")
 
     @vpc_flow_log_parameters.setter
@@ -403,10 +564,25 @@ if not MYPY:
         The telemetry rule
         """
         resource_type: pulumi.Input['OrganizationTelemetryRuleResourceType']
+        """
+        The type of AWS resource to configure telemetry for (e.g., "AWS::EC2::VPC").
+        """
         telemetry_type: pulumi.Input['OrganizationTelemetryRuleTelemetryType']
+        """
+        The type of telemetry to collect (Logs, Metrics, or Traces).
+        """
         destination_configuration: NotRequired[pulumi.Input['OrganizationTelemetryRuleTelemetryDestinationConfigurationArgsDict']]
+        """
+        Configuration specifying where and how the telemetry data should be delivered.
+        """
         scope: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The organizational scope to which the rule applies, specified using accounts or organizational units.
+        """
         selection_criteria: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Criteria for selecting which resources the rule applies to, such as resource tags.
+        """
 elif False:
     OrganizationTelemetryRuleTelemetryRuleArgsDict: TypeAlias = Mapping[str, Any]
 
@@ -420,6 +596,11 @@ class OrganizationTelemetryRuleTelemetryRuleArgs:
                  selection_criteria: Optional[pulumi.Input[_builtins.str]] = None):
         """
         The telemetry rule
+        :param pulumi.Input['OrganizationTelemetryRuleResourceType'] resource_type: The type of AWS resource to configure telemetry for (e.g., "AWS::EC2::VPC").
+        :param pulumi.Input['OrganizationTelemetryRuleTelemetryType'] telemetry_type: The type of telemetry to collect (Logs, Metrics, or Traces).
+        :param pulumi.Input['OrganizationTelemetryRuleTelemetryDestinationConfigurationArgs'] destination_configuration: Configuration specifying where and how the telemetry data should be delivered.
+        :param pulumi.Input[_builtins.str] scope: The organizational scope to which the rule applies, specified using accounts or organizational units.
+        :param pulumi.Input[_builtins.str] selection_criteria: Criteria for selecting which resources the rule applies to, such as resource tags.
         """
         pulumi.set(__self__, "resource_type", resource_type)
         pulumi.set(__self__, "telemetry_type", telemetry_type)
@@ -433,6 +614,9 @@ class OrganizationTelemetryRuleTelemetryRuleArgs:
     @_builtins.property
     @pulumi.getter(name="resourceType")
     def resource_type(self) -> pulumi.Input['OrganizationTelemetryRuleResourceType']:
+        """
+        The type of AWS resource to configure telemetry for (e.g., "AWS::EC2::VPC").
+        """
         return pulumi.get(self, "resource_type")
 
     @resource_type.setter
@@ -442,6 +626,9 @@ class OrganizationTelemetryRuleTelemetryRuleArgs:
     @_builtins.property
     @pulumi.getter(name="telemetryType")
     def telemetry_type(self) -> pulumi.Input['OrganizationTelemetryRuleTelemetryType']:
+        """
+        The type of telemetry to collect (Logs, Metrics, or Traces).
+        """
         return pulumi.get(self, "telemetry_type")
 
     @telemetry_type.setter
@@ -451,6 +638,9 @@ class OrganizationTelemetryRuleTelemetryRuleArgs:
     @_builtins.property
     @pulumi.getter(name="destinationConfiguration")
     def destination_configuration(self) -> Optional[pulumi.Input['OrganizationTelemetryRuleTelemetryDestinationConfigurationArgs']]:
+        """
+        Configuration specifying where and how the telemetry data should be delivered.
+        """
         return pulumi.get(self, "destination_configuration")
 
     @destination_configuration.setter
@@ -460,6 +650,9 @@ class OrganizationTelemetryRuleTelemetryRuleArgs:
     @_builtins.property
     @pulumi.getter
     def scope(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The organizational scope to which the rule applies, specified using accounts or organizational units.
+        """
         return pulumi.get(self, "scope")
 
     @scope.setter
@@ -469,6 +662,9 @@ class OrganizationTelemetryRuleTelemetryRuleArgs:
     @_builtins.property
     @pulumi.getter(name="selectionCriteria")
     def selection_criteria(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Criteria for selecting which resources the rule applies to, such as resource tags.
+        """
         return pulumi.get(self, "selection_criteria")
 
     @selection_criteria.setter
@@ -558,9 +754,21 @@ if not MYPY:
         The destination configuration for telemetry data
         """
         destination_pattern: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The pattern used to generate the destination path or name, supporting macros like <resourceId> and <accountId>.
+        """
         destination_type: NotRequired[pulumi.Input['TelemetryRuleDestinationType']]
+        """
+        The type of destination for the telemetry data (e.g., "Amazon CloudWatch Logs", "S3").
+        """
         retention_in_days: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        The number of days to retain the telemetry data in the destination.
+        """
         vpc_flow_log_parameters: NotRequired[pulumi.Input['TelemetryRuleVpcFlowLogParametersArgsDict']]
+        """
+        Configuration parameters specific to VPC Flow Logs when VPC is the resource type.
+        """
 elif False:
     TelemetryRuleTelemetryDestinationConfigurationArgsDict: TypeAlias = Mapping[str, Any]
 
@@ -573,6 +781,10 @@ class TelemetryRuleTelemetryDestinationConfigurationArgs:
                  vpc_flow_log_parameters: Optional[pulumi.Input['TelemetryRuleVpcFlowLogParametersArgs']] = None):
         """
         The destination configuration for telemetry data
+        :param pulumi.Input[_builtins.str] destination_pattern: The pattern used to generate the destination path or name, supporting macros like <resourceId> and <accountId>.
+        :param pulumi.Input['TelemetryRuleDestinationType'] destination_type: The type of destination for the telemetry data (e.g., "Amazon CloudWatch Logs", "S3").
+        :param pulumi.Input[_builtins.int] retention_in_days: The number of days to retain the telemetry data in the destination.
+        :param pulumi.Input['TelemetryRuleVpcFlowLogParametersArgs'] vpc_flow_log_parameters: Configuration parameters specific to VPC Flow Logs when VPC is the resource type.
         """
         if destination_pattern is not None:
             pulumi.set(__self__, "destination_pattern", destination_pattern)
@@ -586,6 +798,9 @@ class TelemetryRuleTelemetryDestinationConfigurationArgs:
     @_builtins.property
     @pulumi.getter(name="destinationPattern")
     def destination_pattern(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The pattern used to generate the destination path or name, supporting macros like <resourceId> and <accountId>.
+        """
         return pulumi.get(self, "destination_pattern")
 
     @destination_pattern.setter
@@ -595,6 +810,9 @@ class TelemetryRuleTelemetryDestinationConfigurationArgs:
     @_builtins.property
     @pulumi.getter(name="destinationType")
     def destination_type(self) -> Optional[pulumi.Input['TelemetryRuleDestinationType']]:
+        """
+        The type of destination for the telemetry data (e.g., "Amazon CloudWatch Logs", "S3").
+        """
         return pulumi.get(self, "destination_type")
 
     @destination_type.setter
@@ -604,6 +822,9 @@ class TelemetryRuleTelemetryDestinationConfigurationArgs:
     @_builtins.property
     @pulumi.getter(name="retentionInDays")
     def retention_in_days(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The number of days to retain the telemetry data in the destination.
+        """
         return pulumi.get(self, "retention_in_days")
 
     @retention_in_days.setter
@@ -613,6 +834,9 @@ class TelemetryRuleTelemetryDestinationConfigurationArgs:
     @_builtins.property
     @pulumi.getter(name="vpcFlowLogParameters")
     def vpc_flow_log_parameters(self) -> Optional[pulumi.Input['TelemetryRuleVpcFlowLogParametersArgs']]:
+        """
+        Configuration parameters specific to VPC Flow Logs when VPC is the resource type.
+        """
         return pulumi.get(self, "vpc_flow_log_parameters")
 
     @vpc_flow_log_parameters.setter
@@ -702,9 +926,21 @@ if not MYPY:
         The telemetry rule
         """
         resource_type: pulumi.Input['TelemetryRuleResourceType']
+        """
+        The type of AWS resource to configure telemetry for (e.g., "AWS::EC2::VPC").
+        """
         telemetry_type: pulumi.Input['TelemetryRuleTelemetryType']
+        """
+        The type of telemetry to collect (Logs, Metrics, or Traces).
+        """
         destination_configuration: NotRequired[pulumi.Input['TelemetryRuleTelemetryDestinationConfigurationArgsDict']]
+        """
+        Configuration specifying where and how the telemetry data should be delivered.
+        """
         selection_criteria: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Criteria for selecting which resources the rule applies to, such as resource tags.
+        """
 elif False:
     TelemetryRuleArgsDict: TypeAlias = Mapping[str, Any]
 
@@ -717,6 +953,10 @@ class TelemetryRuleArgs:
                  selection_criteria: Optional[pulumi.Input[_builtins.str]] = None):
         """
         The telemetry rule
+        :param pulumi.Input['TelemetryRuleResourceType'] resource_type: The type of AWS resource to configure telemetry for (e.g., "AWS::EC2::VPC").
+        :param pulumi.Input['TelemetryRuleTelemetryType'] telemetry_type: The type of telemetry to collect (Logs, Metrics, or Traces).
+        :param pulumi.Input['TelemetryRuleTelemetryDestinationConfigurationArgs'] destination_configuration: Configuration specifying where and how the telemetry data should be delivered.
+        :param pulumi.Input[_builtins.str] selection_criteria: Criteria for selecting which resources the rule applies to, such as resource tags.
         """
         pulumi.set(__self__, "resource_type", resource_type)
         pulumi.set(__self__, "telemetry_type", telemetry_type)
@@ -728,6 +968,9 @@ class TelemetryRuleArgs:
     @_builtins.property
     @pulumi.getter(name="resourceType")
     def resource_type(self) -> pulumi.Input['TelemetryRuleResourceType']:
+        """
+        The type of AWS resource to configure telemetry for (e.g., "AWS::EC2::VPC").
+        """
         return pulumi.get(self, "resource_type")
 
     @resource_type.setter
@@ -737,6 +980,9 @@ class TelemetryRuleArgs:
     @_builtins.property
     @pulumi.getter(name="telemetryType")
     def telemetry_type(self) -> pulumi.Input['TelemetryRuleTelemetryType']:
+        """
+        The type of telemetry to collect (Logs, Metrics, or Traces).
+        """
         return pulumi.get(self, "telemetry_type")
 
     @telemetry_type.setter
@@ -746,6 +992,9 @@ class TelemetryRuleArgs:
     @_builtins.property
     @pulumi.getter(name="destinationConfiguration")
     def destination_configuration(self) -> Optional[pulumi.Input['TelemetryRuleTelemetryDestinationConfigurationArgs']]:
+        """
+        Configuration specifying where and how the telemetry data should be delivered.
+        """
         return pulumi.get(self, "destination_configuration")
 
     @destination_configuration.setter
@@ -755,6 +1004,9 @@ class TelemetryRuleArgs:
     @_builtins.property
     @pulumi.getter(name="selectionCriteria")
     def selection_criteria(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Criteria for selecting which resources the rule applies to, such as resource tags.
+        """
         return pulumi.get(self, "selection_criteria")
 
     @selection_criteria.setter