pulumi-aws-native 1.39.0a1762385303__py3-none-any.whl → 1.39.0a1762580459__py3-none-any.whl

pulumi_aws_native/cleanrooms/outputs.py

@@ -85,6 +85,7 @@ __all__ = [
     'MembershipProtectedQueryS3OutputConfiguration',
     'MembershipQueryComputePaymentConfig',
     'ParametersProperties',
+    'PrivacyBudgetTemplateBudgetParameter',
 ]
 
 @pulumi.output_type
@@ -1477,12 +1478,15 @@ class ConfiguredTableAthenaTableReference(dict):
                  database_name: _builtins.str,
                  table_name: _builtins.str,
                  work_group: _builtins.str,
-                 output_location: Optional[_builtins.str] = None):
+                 output_location: Optional[_builtins.str] = None,
+                 region: Optional['ConfiguredTableCommercialRegion'] = None):
         pulumi.set(__self__, "database_name", database_name)
         pulumi.set(__self__, "table_name", table_name)
         pulumi.set(__self__, "work_group", work_group)
         if output_location is not None:
             pulumi.set(__self__, "output_location", output_location)
+        if region is not None:
+            pulumi.set(__self__, "region", region)
 
     @_builtins.property
     @pulumi.getter(name="databaseName")
@@ -1504,6 +1508,11 @@ class ConfiguredTableAthenaTableReference(dict):
     def output_location(self) -> Optional[_builtins.str]:
         return pulumi.get(self, "output_location")
 
+    @_builtins.property
+    @pulumi.getter
+    def region(self) -> Optional['ConfiguredTableCommercialRegion']:
+        return pulumi.get(self, "region")
+
 
 @pulumi.output_type
 class ConfiguredTableDifferentialPrivacy(dict):
@@ -1552,9 +1561,12 @@ class ConfiguredTableGlueTableReference(dict):
 
     def __init__(__self__, *,
                  database_name: _builtins.str,
-                 table_name: _builtins.str):
+                 table_name: _builtins.str,
+                 region: Optional['ConfiguredTableCommercialRegion'] = None):
         pulumi.set(__self__, "database_name", database_name)
         pulumi.set(__self__, "table_name", table_name)
+        if region is not None:
+            pulumi.set(__self__, "region", region)
 
     @_builtins.property
     @pulumi.getter(name="databaseName")
@@ -1566,6 +1578,11 @@ class ConfiguredTableGlueTableReference(dict):
     def table_name(self) -> _builtins.str:
         return pulumi.get(self, "table_name")
 
+    @_builtins.property
+    @pulumi.getter
+    def region(self) -> Optional['ConfiguredTableCommercialRegion']:
+        return pulumi.get(self, "region")
+
 
 @pulumi.output_type
 class ConfiguredTableSnowflakeTableReference(dict):
@@ -2578,7 +2595,11 @@ class ParametersProperties(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "usersNoisePerQuery":
+        if key == "budgetParameters":
+            suggest = "budget_parameters"
+        elif key == "resourceArn":
+            suggest = "resource_arn"
+        elif key == "usersNoisePerQuery":
             suggest = "users_noise_per_query"
 
         if suggest:
@@ -2593,30 +2614,106 @@ class ParametersProperties(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 epsilon: _builtins.int,
-                 users_noise_per_query: _builtins.int):
+                 budget_parameters: Optional[Sequence['outputs.PrivacyBudgetTemplateBudgetParameter']] = None,
+                 epsilon: Optional[_builtins.int] = None,
+                 resource_arn: Optional[_builtins.str] = None,
+                 users_noise_per_query: Optional[_builtins.int] = None):
         """
         Specifies the epsilon and noise parameters for the privacy budget template.
         :param _builtins.int epsilon: The epsilon value that you want to use.
         :param _builtins.int users_noise_per_query: Noise added per query is measured in terms of the number of users whose contributions you want to obscure. This value governs the rate at which the privacy budget is depleted.
         """
-        pulumi.set(__self__, "epsilon", epsilon)
-        pulumi.set(__self__, "users_noise_per_query", users_noise_per_query)
+        if budget_parameters is not None:
+            pulumi.set(__self__, "budget_parameters", budget_parameters)
+        if epsilon is not None:
+            pulumi.set(__self__, "epsilon", epsilon)
+        if resource_arn is not None:
+            pulumi.set(__self__, "resource_arn", resource_arn)
+        if users_noise_per_query is not None:
+            pulumi.set(__self__, "users_noise_per_query", users_noise_per_query)
+
+    @_builtins.property
+    @pulumi.getter(name="budgetParameters")
+    def budget_parameters(self) -> Optional[Sequence['outputs.PrivacyBudgetTemplateBudgetParameter']]:
+        return pulumi.get(self, "budget_parameters")
 
     @_builtins.property
     @pulumi.getter
-    def epsilon(self) -> _builtins.int:
+    def epsilon(self) -> Optional[_builtins.int]:
         """
         The epsilon value that you want to use.
         """
         return pulumi.get(self, "epsilon")
 
+    @_builtins.property
+    @pulumi.getter(name="resourceArn")
+    def resource_arn(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "resource_arn")
+
     @_builtins.property
     @pulumi.getter(name="usersNoisePerQuery")
-    def users_noise_per_query(self) -> _builtins.int:
+    def users_noise_per_query(self) -> Optional[_builtins.int]:
         """
         Noise added per query is measured in terms of the number of users whose contributions you want to obscure. This value governs the rate at which the privacy budget is depleted.
         """
         return pulumi.get(self, "users_noise_per_query")
 
 
+@pulumi.output_type
+class PrivacyBudgetTemplateBudgetParameter(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "autoRefresh":
+            suggest = "auto_refresh"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in PrivacyBudgetTemplateBudgetParameter. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        PrivacyBudgetTemplateBudgetParameter.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        PrivacyBudgetTemplateBudgetParameter.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 budget: _builtins.int,
+                 type: 'PrivacyBudgetTemplateBudgetParameterType',
+                 auto_refresh: Optional['PrivacyBudgetTemplateBudgetParameterAutoRefresh'] = None):
+        """
+        :param _builtins.int budget: The budget allocation amount for this specific parameter.
+        :param 'PrivacyBudgetTemplateBudgetParameterType' type: The type of budget parameter being configured.
+        :param 'PrivacyBudgetTemplateBudgetParameterAutoRefresh' auto_refresh: Whether this individual budget parameter automatically refreshes when the budget period resets.
+        """
+        pulumi.set(__self__, "budget", budget)
+        pulumi.set(__self__, "type", type)
+        if auto_refresh is not None:
+            pulumi.set(__self__, "auto_refresh", auto_refresh)
+
+    @_builtins.property
+    @pulumi.getter
+    def budget(self) -> _builtins.int:
+        """
+        The budget allocation amount for this specific parameter.
+        """
+        return pulumi.get(self, "budget")
+
+    @_builtins.property
+    @pulumi.getter
+    def type(self) -> 'PrivacyBudgetTemplateBudgetParameterType':
+        """
+        The type of budget parameter being configured.
+        """
+        return pulumi.get(self, "type")
+
+    @_builtins.property
+    @pulumi.getter(name="autoRefresh")
+    def auto_refresh(self) -> Optional['PrivacyBudgetTemplateBudgetParameterAutoRefresh']:
+        """
+        Whether this individual budget parameter automatically refreshes when the budget period resets.
+        """
+        return pulumi.get(self, "auto_refresh")
+
+

pulumi_aws_native/cloudfront/_inputs.py

@@ -5546,6 +5546,9 @@ if not MYPY:
          For more information, see [Response timeout](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/DownloadDistValuesOrigin.html#DownloadDistValuesOriginResponseTimeout) in the *Amazon CloudFront Developer Guide*.
         """
         owner_account_id: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The account ID of the AWS account that owns the VPC origin.
+        """
 elif False:
     DistributionVpcOriginConfigArgsDict: TypeAlias = Mapping[str, Any]
 
@@ -5563,6 +5566,7 @@ class DistributionVpcOriginConfigArgs:
                 For more information, see [Keep-alive timeout (custom origins only)](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/DownloadDistValuesOrigin.html#DownloadDistValuesOriginKeepaliveTimeout) in the *Amazon CloudFront Developer Guide*.
         :param pulumi.Input[_builtins.int] origin_read_timeout: Specifies how long, in seconds, CloudFront waits for a response from the origin. This is also known as the *origin response timeout*. The minimum timeout is 1 second, the maximum is 120 seconds, and the default (if you don't specify otherwise) is 30 seconds.
                 For more information, see [Response timeout](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/DownloadDistValuesOrigin.html#DownloadDistValuesOriginResponseTimeout) in the *Amazon CloudFront Developer Guide*.
+        :param pulumi.Input[_builtins.str] owner_account_id: The account ID of the AWS account that owns the VPC origin.
         """
         pulumi.set(__self__, "vpc_origin_id", vpc_origin_id)
         if origin_keepalive_timeout is not None:
@@ -5613,6 +5617,9 @@ class DistributionVpcOriginConfigArgs:
     @_builtins.property
     @pulumi.getter(name="ownerAccountId")
     def owner_account_id(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The account ID of the AWS account that owns the VPC origin.
+        """
         return pulumi.get(self, "owner_account_id")
 
     @owner_account_id.setter

pulumi_aws_native/cloudfront/get_vpc_origin.py

@@ -54,6 +54,9 @@ class GetVpcOriginResult:
     @_builtins.property
     @pulumi.getter(name="accountId")
     def account_id(self) -> Optional[_builtins.str]:
+        """
+        The account ID of the AWS account that owns the VPC origin.
+        """
         return pulumi.get(self, "account_id")
 
     @_builtins.property

pulumi_aws_native/cloudfront/outputs.py

@@ -4373,6 +4373,7 @@ class DistributionVpcOriginConfig(dict):
                 For more information, see [Keep-alive timeout (custom origins only)](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/DownloadDistValuesOrigin.html#DownloadDistValuesOriginKeepaliveTimeout) in the *Amazon CloudFront Developer Guide*.
         :param _builtins.int origin_read_timeout: Specifies how long, in seconds, CloudFront waits for a response from the origin. This is also known as the *origin response timeout*. The minimum timeout is 1 second, the maximum is 120 seconds, and the default (if you don't specify otherwise) is 30 seconds.
                 For more information, see [Response timeout](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/DownloadDistValuesOrigin.html#DownloadDistValuesOriginResponseTimeout) in the *Amazon CloudFront Developer Guide*.
+        :param _builtins.str owner_account_id: The account ID of the AWS account that owns the VPC origin.
         """
         pulumi.set(__self__, "vpc_origin_id", vpc_origin_id)
         if origin_keepalive_timeout is not None:
@@ -4411,6 +4412,9 @@ class DistributionVpcOriginConfig(dict):
     @_builtins.property
     @pulumi.getter(name="ownerAccountId")
     def owner_account_id(self) -> Optional[_builtins.str]:
+        """
+        The account ID of the AWS account that owns the VPC origin.
+        """
         return pulumi.get(self, "owner_account_id")
 
 

pulumi_aws_native/cloudfront/vpc_origin.py

@@ -156,6 +156,9 @@ class VpcOrigin(pulumi.CustomResource):
     @_builtins.property
     @pulumi.getter(name="accountId")
     def account_id(self) -> pulumi.Output[_builtins.str]:
+        """
+        The account ID of the AWS account that owns the VPC origin.
+        """
         return pulumi.get(self, "account_id")
 
     @_builtins.property

pulumi_aws_native/connect/_enums.py

@@ -44,6 +44,7 @@ __all__ = [
     'RuleSendNotificationActionContentType',
     'RuleSendNotificationActionDeliveryMethod',
     'RuleTriggerEventSourceEventSourceName',
+    'SecurityProfilePrimaryAttributeValueAccessType',
     'TaskTemplateFieldType',
     'TaskTemplateStatus',
     'TrafficDistributionGroupStatus',
@@ -444,6 +445,14 @@ class RuleTriggerEventSourceEventSourceName(_builtins.str, Enum):
     ON_CASE_UPDATE = "OnCaseUpdate"
 
 
+@pulumi.type_token("aws-native:connect:SecurityProfilePrimaryAttributeValueAccessType")
+class SecurityProfilePrimaryAttributeValueAccessType(_builtins.str, Enum):
+    """
+    Specifies the type of access granted. Currently, only "ALLOW" is supported
+    """
+    ALLOW = "ALLOW"
+
+
 @pulumi.type_token("aws-native:connect:TaskTemplateFieldType")
 class TaskTemplateFieldType(_builtins.str, Enum):
     """

pulumi_aws_native/connect/_inputs.py

@@ -74,6 +74,8 @@ __all__ = [
     'EvaluationFormTextQuestionAutomationArgsDict',
     'EvaluationFormTextQuestionPropertiesArgs',
     'EvaluationFormTextQuestionPropertiesArgsDict',
+    'GranularAccessControlConfigurationPropertiesArgs',
+    'GranularAccessControlConfigurationPropertiesArgsDict',
     'HoursOfOperationConfigArgs',
     'HoursOfOperationConfigArgsDict',
     'HoursOfOperationOverrideConfigArgs',
@@ -148,6 +150,12 @@ __all__ = [
     'RuleUpdateCaseActionArgsDict',
     'SecurityProfileApplicationArgs',
     'SecurityProfileApplicationArgsDict',
+    'SecurityProfileDataTableAccessControlConfigurationArgs',
+    'SecurityProfileDataTableAccessControlConfigurationArgsDict',
+    'SecurityProfilePrimaryAttributeAccessControlConfigurationItemArgs',
+    'SecurityProfilePrimaryAttributeAccessControlConfigurationItemArgsDict',
+    'SecurityProfilePrimaryAttributeValueArgs',
+    'SecurityProfilePrimaryAttributeValueArgsDict',
     'SecurityProfileTagArgs',
     'SecurityProfileTagArgsDict',
     'TaskTemplateDefaultFieldValueArgs',
@@ -2050,6 +2058,29 @@ class EvaluationFormTextQuestionPropertiesArgs:
         pulumi.set(self, "automation", value)
 
 
+if not MYPY:
+    class GranularAccessControlConfigurationPropertiesArgsDict(TypedDict):
+        data_table_access_control_configuration: NotRequired[pulumi.Input['SecurityProfileDataTableAccessControlConfigurationArgsDict']]
+elif False:
+    GranularAccessControlConfigurationPropertiesArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class GranularAccessControlConfigurationPropertiesArgs:
+    def __init__(__self__, *,
+                 data_table_access_control_configuration: Optional[pulumi.Input['SecurityProfileDataTableAccessControlConfigurationArgs']] = None):
+        if data_table_access_control_configuration is not None:
+            pulumi.set(__self__, "data_table_access_control_configuration", data_table_access_control_configuration)
+
+    @_builtins.property
+    @pulumi.getter(name="dataTableAccessControlConfiguration")
+    def data_table_access_control_configuration(self) -> Optional[pulumi.Input['SecurityProfileDataTableAccessControlConfigurationArgs']]:
+        return pulumi.get(self, "data_table_access_control_configuration")
+
+    @data_table_access_control_configuration.setter
+    def data_table_access_control_configuration(self, value: Optional[pulumi.Input['SecurityProfileDataTableAccessControlConfigurationArgs']]):
+        pulumi.set(self, "data_table_access_control_configuration", value)
+
+
 if not MYPY:
     class HoursOfOperationConfigArgsDict(TypedDict):
         """
@@ -4326,6 +4357,143 @@ class SecurityProfileApplicationArgs:
         pulumi.set(self, "namespace", value)
 
 
+if not MYPY:
+    class SecurityProfileDataTableAccessControlConfigurationArgsDict(TypedDict):
+        """
+        Defines the access control configuration for data tables.
+        """
+        primary_attribute_access_control_configuration: NotRequired[pulumi.Input['SecurityProfilePrimaryAttributeAccessControlConfigurationItemArgsDict']]
+elif False:
+    SecurityProfileDataTableAccessControlConfigurationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class SecurityProfileDataTableAccessControlConfigurationArgs:
+    def __init__(__self__, *,
+                 primary_attribute_access_control_configuration: Optional[pulumi.Input['SecurityProfilePrimaryAttributeAccessControlConfigurationItemArgs']] = None):
+        """
+        Defines the access control configuration for data tables.
+        """
+        if primary_attribute_access_control_configuration is not None:
+            pulumi.set(__self__, "primary_attribute_access_control_configuration", primary_attribute_access_control_configuration)
+
+    @_builtins.property
+    @pulumi.getter(name="primaryAttributeAccessControlConfiguration")
+    def primary_attribute_access_control_configuration(self) -> Optional[pulumi.Input['SecurityProfilePrimaryAttributeAccessControlConfigurationItemArgs']]:
+        return pulumi.get(self, "primary_attribute_access_control_configuration")
+
+    @primary_attribute_access_control_configuration.setter
+    def primary_attribute_access_control_configuration(self, value: Optional[pulumi.Input['SecurityProfilePrimaryAttributeAccessControlConfigurationItemArgs']]):
+        pulumi.set(self, "primary_attribute_access_control_configuration", value)
+
+
+if not MYPY:
+    class SecurityProfilePrimaryAttributeAccessControlConfigurationItemArgsDict(TypedDict):
+        """
+        Contains the configuration for record-based access control.
+        """
+        primary_attribute_values: pulumi.Input[Sequence[pulumi.Input['SecurityProfilePrimaryAttributeValueArgsDict']]]
+        """
+        An array of PrimaryAttributeValue objects.
+        """
+elif False:
+    SecurityProfilePrimaryAttributeAccessControlConfigurationItemArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class SecurityProfilePrimaryAttributeAccessControlConfigurationItemArgs:
+    def __init__(__self__, *,
+                 primary_attribute_values: pulumi.Input[Sequence[pulumi.Input['SecurityProfilePrimaryAttributeValueArgs']]]):
+        """
+        Contains the configuration for record-based access control.
+        :param pulumi.Input[Sequence[pulumi.Input['SecurityProfilePrimaryAttributeValueArgs']]] primary_attribute_values: An array of PrimaryAttributeValue objects.
+        """
+        pulumi.set(__self__, "primary_attribute_values", primary_attribute_values)
+
+    @_builtins.property
+    @pulumi.getter(name="primaryAttributeValues")
+    def primary_attribute_values(self) -> pulumi.Input[Sequence[pulumi.Input['SecurityProfilePrimaryAttributeValueArgs']]]:
+        """
+        An array of PrimaryAttributeValue objects.
+        """
+        return pulumi.get(self, "primary_attribute_values")
+
+    @primary_attribute_values.setter
+    def primary_attribute_values(self, value: pulumi.Input[Sequence[pulumi.Input['SecurityProfilePrimaryAttributeValueArgs']]]):
+        pulumi.set(self, "primary_attribute_values", value)
+
+
+if not MYPY:
+    class SecurityProfilePrimaryAttributeValueArgsDict(TypedDict):
+        """
+        An object defining the access control for a specific attribute and its values.
+        """
+        access_type: pulumi.Input['SecurityProfilePrimaryAttributeValueAccessType']
+        """
+        Specifies the type of access granted. Currently, only "ALLOW" is supported
+        """
+        attribute_name: pulumi.Input[_builtins.str]
+        """
+        The name of the primary attribute.
+        """
+        values: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]
+        """
+        An array of allowed primary values for the specified primary attribute.
+        """
+elif False:
+    SecurityProfilePrimaryAttributeValueArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class SecurityProfilePrimaryAttributeValueArgs:
+    def __init__(__self__, *,
+                 access_type: pulumi.Input['SecurityProfilePrimaryAttributeValueAccessType'],
+                 attribute_name: pulumi.Input[_builtins.str],
+                 values: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
+        """
+        An object defining the access control for a specific attribute and its values.
+        :param pulumi.Input['SecurityProfilePrimaryAttributeValueAccessType'] access_type: Specifies the type of access granted. Currently, only "ALLOW" is supported
+        :param pulumi.Input[_builtins.str] attribute_name: The name of the primary attribute.
+        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] values: An array of allowed primary values for the specified primary attribute.
+        """
+        pulumi.set(__self__, "access_type", access_type)
+        pulumi.set(__self__, "attribute_name", attribute_name)
+        pulumi.set(__self__, "values", values)
+
+    @_builtins.property
+    @pulumi.getter(name="accessType")
+    def access_type(self) -> pulumi.Input['SecurityProfilePrimaryAttributeValueAccessType']:
+        """
+        Specifies the type of access granted. Currently, only "ALLOW" is supported
+        """
+        return pulumi.get(self, "access_type")
+
+    @access_type.setter
+    def access_type(self, value: pulumi.Input['SecurityProfilePrimaryAttributeValueAccessType']):
+        pulumi.set(self, "access_type", value)
+
+    @_builtins.property
+    @pulumi.getter(name="attributeName")
+    def attribute_name(self) -> pulumi.Input[_builtins.str]:
+        """
+        The name of the primary attribute.
+        """
+        return pulumi.get(self, "attribute_name")
+
+    @attribute_name.setter
+    def attribute_name(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "attribute_name", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def values(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
+        """
+        An array of allowed primary values for the specified primary attribute.
+        """
+        return pulumi.get(self, "values")
+
+    @values.setter
+    def values(self, value: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
+        pulumi.set(self, "values", value)
+
+
 if not MYPY:
     class SecurityProfileTagArgsDict(TypedDict):
         """

pulumi_aws_native/connect/get_security_profile.py

@@ -15,6 +15,7 @@ else:
 from .. import _utilities
 from . import outputs
 from .. import outputs as _root_outputs
+from ._enums import *
 
 __all__ = [
     'GetSecurityProfileResult',
@@ -25,7 +26,7 @@ __all__ = [
 
 @pulumi.output_type
 class GetSecurityProfileResult:
-    def __init__(__self__, allowed_access_control_hierarchy_group_id=None, allowed_access_control_tags=None, applications=None, description=None, hierarchy_restricted_resources=None, last_modified_region=None, last_modified_time=None, permissions=None, security_profile_arn=None, tag_restricted_resources=None, tags=None):
+    def __init__(__self__, allowed_access_control_hierarchy_group_id=None, allowed_access_control_tags=None, applications=None, description=None, granular_access_control_configuration=None, hierarchy_restricted_resources=None, last_modified_region=None, last_modified_time=None, permissions=None, security_profile_arn=None, tag_restricted_resources=None, tags=None):
         if allowed_access_control_hierarchy_group_id and not isinstance(allowed_access_control_hierarchy_group_id, str):
             raise TypeError("Expected argument 'allowed_access_control_hierarchy_group_id' to be a str")
         pulumi.set(__self__, "allowed_access_control_hierarchy_group_id", allowed_access_control_hierarchy_group_id)
@@ -38,6 +39,9 @@ class GetSecurityProfileResult:
         if description and not isinstance(description, str):
             raise TypeError("Expected argument 'description' to be a str")
         pulumi.set(__self__, "description", description)
+        if granular_access_control_configuration and not isinstance(granular_access_control_configuration, dict):
+            raise TypeError("Expected argument 'granular_access_control_configuration' to be a dict")
+        pulumi.set(__self__, "granular_access_control_configuration", granular_access_control_configuration)
         if hierarchy_restricted_resources and not isinstance(hierarchy_restricted_resources, list):
             raise TypeError("Expected argument 'hierarchy_restricted_resources' to be a list")
         pulumi.set(__self__, "hierarchy_restricted_resources", hierarchy_restricted_resources)
@@ -92,6 +96,11 @@ class GetSecurityProfileResult:
         """
         return pulumi.get(self, "description")
 
+    @_builtins.property
+    @pulumi.getter(name="granularAccessControlConfiguration")
+    def granular_access_control_configuration(self) -> Optional['outputs.GranularAccessControlConfigurationProperties']:
+        return pulumi.get(self, "granular_access_control_configuration")
+
     @_builtins.property
     @pulumi.getter(name="hierarchyRestrictedResources")
     def hierarchy_restricted_resources(self) -> Optional[Sequence[_builtins.str]]:
@@ -159,6 +168,7 @@ class AwaitableGetSecurityProfileResult(GetSecurityProfileResult):
             allowed_access_control_tags=self.allowed_access_control_tags,
             applications=self.applications,
             description=self.description,
+            granular_access_control_configuration=self.granular_access_control_configuration,
             hierarchy_restricted_resources=self.hierarchy_restricted_resources,
             last_modified_region=self.last_modified_region,
             last_modified_time=self.last_modified_time,
@@ -186,6 +196,7 @@ def get_security_profile(security_profile_arn: Optional[_builtins.str] = None,
         allowed_access_control_tags=pulumi.get(__ret__, 'allowed_access_control_tags'),
         applications=pulumi.get(__ret__, 'applications'),
         description=pulumi.get(__ret__, 'description'),
+        granular_access_control_configuration=pulumi.get(__ret__, 'granular_access_control_configuration'),
         hierarchy_restricted_resources=pulumi.get(__ret__, 'hierarchy_restricted_resources'),
         last_modified_region=pulumi.get(__ret__, 'last_modified_region'),
         last_modified_time=pulumi.get(__ret__, 'last_modified_time'),
@@ -210,6 +221,7 @@ def get_security_profile_output(security_profile_arn: Optional[pulumi.Input[_bui
         allowed_access_control_tags=pulumi.get(__response__, 'allowed_access_control_tags'),
         applications=pulumi.get(__response__, 'applications'),
         description=pulumi.get(__response__, 'description'),
+        granular_access_control_configuration=pulumi.get(__response__, 'granular_access_control_configuration'),
         hierarchy_restricted_resources=pulumi.get(__response__, 'hierarchy_restricted_resources'),
         last_modified_region=pulumi.get(__response__, 'last_modified_region'),
         last_modified_time=pulumi.get(__response__, 'last_modified_time'),