pulumi-akamai 9.1.0a1754716222__py3-none-any.whl → 10.3.0a1766467020__py3-none-any.whl

pulumi_akamai/_inputs.py

@@ -15,8 +15,16 @@ else:
 from . import _utilities
 
 __all__ = [
+    'AppSecIPGeoAsnControlsArgs',
+    'AppSecIPGeoAsnControlsArgsDict',
+    'AppSecIPGeoGeoControlsArgs',
+    'AppSecIPGeoGeoControlsArgsDict',
+    'AppSecIPGeoIpControlsArgs',
+    'AppSecIPGeoIpControlsArgsDict',
     'AppSecSiemSettingsExceptionsArgs',
     'AppSecSiemSettingsExceptionsArgsDict',
+    'AppsecAdvancedSettingsAsePenaltyBoxQualificationExclusionsArgs',
+    'AppsecAdvancedSettingsAsePenaltyBoxQualificationExclusionsArgsDict',
     'ClientlistListItemArgs',
     'ClientlistListItemArgsDict',
     'CloudAccessKeyCredentialsAArgs',
@@ -27,6 +35,8 @@ __all__ = [
     'CloudAccessKeyNetworkConfigurationArgsDict',
     'CloudAccessKeyTimeoutsArgs',
     'CloudAccessKeyTimeoutsArgsDict',
+    'CloudcertificatesCertificateSubjectArgs',
+    'CloudcertificatesCertificateSubjectArgsDict',
     'CloudletsApplicationLoadBalancerActivationTimeoutsArgs',
     'CloudletsApplicationLoadBalancerActivationTimeoutsArgsDict',
     'CloudletsApplicationLoadBalancerDataCenterArgs',
@@ -91,6 +101,8 @@ __all__ = [
     'DatastreamDeliveryConfigurationArgsDict',
     'DatastreamDeliveryConfigurationFrequencyArgs',
     'DatastreamDeliveryConfigurationFrequencyArgsDict',
+    'DatastreamDynatraceConnectorArgs',
+    'DatastreamDynatraceConnectorArgsDict',
     'DatastreamElasticsearchConnectorArgs',
     'DatastreamElasticsearchConnectorArgsDict',
     'DatastreamGcsConnectorArgs',
@@ -103,12 +115,16 @@ __all__ = [
     'DatastreamNewRelicConnectorArgsDict',
     'DatastreamOracleConnectorArgs',
     'DatastreamOracleConnectorArgsDict',
+    'DatastreamS3CompatibleConnectorArgs',
+    'DatastreamS3CompatibleConnectorArgsDict',
     'DatastreamS3ConnectorArgs',
     'DatastreamS3ConnectorArgsDict',
     'DatastreamSplunkConnectorArgs',
     'DatastreamSplunkConnectorArgsDict',
     'DatastreamSumologicConnectorArgs',
     'DatastreamSumologicConnectorArgsDict',
+    'DatastreamTrafficpeakConnectorArgs',
+    'DatastreamTrafficpeakConnectorArgsDict',
     'DnsZoneOutboundZoneTransferArgs',
     'DnsZoneOutboundZoneTransferArgsDict',
     'DnsZoneOutboundZoneTransferTsigKeyArgs',
@@ -173,6 +189,26 @@ __all__ = [
     'IamCidrBlockActionsArgsDict',
     'IamUserUserNotificationsArgs',
     'IamUserUserNotificationsArgsDict',
+    'MtlskeystoreClientCertificateAkamaiTimeoutsArgs',
+    'MtlskeystoreClientCertificateAkamaiTimeoutsArgsDict',
+    'MtlskeystoreClientCertificateAkamaiVersionArgs',
+    'MtlskeystoreClientCertificateAkamaiVersionArgsDict',
+    'MtlskeystoreClientCertificateAkamaiVersionCertificateBlockArgs',
+    'MtlskeystoreClientCertificateAkamaiVersionCertificateBlockArgsDict',
+    'MtlskeystoreClientCertificateThirdPartyVersionsArgs',
+    'MtlskeystoreClientCertificateThirdPartyVersionsArgsDict',
+    'MtlskeystoreClientCertificateThirdPartyVersionsCertificateBlockArgs',
+    'MtlskeystoreClientCertificateThirdPartyVersionsCertificateBlockArgsDict',
+    'MtlskeystoreClientCertificateThirdPartyVersionsCsrBlockArgs',
+    'MtlskeystoreClientCertificateThirdPartyVersionsCsrBlockArgsDict',
+    'MtlskeystoreClientCertificateUploadTimeoutsArgs',
+    'MtlskeystoreClientCertificateUploadTimeoutsArgsDict',
+    'MtlstruststoreCaSetActivationTimeoutsArgs',
+    'MtlstruststoreCaSetActivationTimeoutsArgsDict',
+    'MtlstruststoreCaSetCertificateArgs',
+    'MtlstruststoreCaSetCertificateArgsDict',
+    'MtlstruststoreCaSetTimeoutsArgs',
+    'MtlstruststoreCaSetTimeoutsArgsDict',
     'PropertyActivationComplianceRecordArgs',
     'PropertyActivationComplianceRecordArgsDict',
     'PropertyActivationComplianceRecordNoncomplianceReasonEmergencyArgs',
@@ -187,10 +223,30 @@ __all__ = [
     'PropertyActivationRuleErrorArgsDict',
     'PropertyActivationTimeoutsArgs',
     'PropertyActivationTimeoutsArgsDict',
+    'PropertyDomainownershipDomainsDomainArgs',
+    'PropertyDomainownershipDomainsDomainArgsDict',
+    'PropertyDomainownershipDomainsDomainValidationChallengeArgs',
+    'PropertyDomainownershipDomainsDomainValidationChallengeArgsDict',
+    'PropertyDomainownershipDomainsDomainValidationChallengeCnameRecordArgs',
+    'PropertyDomainownershipDomainsDomainValidationChallengeCnameRecordArgsDict',
+    'PropertyDomainownershipDomainsDomainValidationChallengeHttpFileArgs',
+    'PropertyDomainownershipDomainsDomainValidationChallengeHttpFileArgsDict',
+    'PropertyDomainownershipDomainsDomainValidationChallengeHttpRedirectArgs',
+    'PropertyDomainownershipDomainsDomainValidationChallengeHttpRedirectArgsDict',
+    'PropertyDomainownershipDomainsDomainValidationChallengeTxtRecordArgs',
+    'PropertyDomainownershipDomainsDomainValidationChallengeTxtRecordArgsDict',
+    'PropertyDomainownershipValidationDomainArgs',
+    'PropertyDomainownershipValidationDomainArgsDict',
+    'PropertyDomainownershipValidationTimeoutsArgs',
+    'PropertyDomainownershipValidationTimeoutsArgsDict',
     'PropertyHostnameArgs',
     'PropertyHostnameArgsDict',
     'PropertyHostnameBucketHostnamesArgs',
     'PropertyHostnameBucketHostnamesArgsDict',
+    'PropertyHostnameCcmCertStatusArgs',
+    'PropertyHostnameCcmCertStatusArgsDict',
+    'PropertyHostnameCcmCertificatesArgs',
+    'PropertyHostnameCcmCertificatesArgsDict',
     'PropertyHostnameCertStatusArgs',
     'PropertyHostnameCertStatusArgsDict',
     'PropertyIncludeActivationComplianceRecordArgs',
@@ -619,6 +675,18 @@ __all__ = [
     'GetImagingPolicyVideoPolicyVariableArgsDict',
     'GetImagingPolicyVideoPolicyVariableEnumOptionArgs',
     'GetImagingPolicyVideoPolicyVariableEnumOptionArgsDict',
+    'GetPropertyDomainownershipSearchDomainsDomainArgs',
+    'GetPropertyDomainownershipSearchDomainsDomainArgsDict',
+    'GetPropertyDomainownershipSearchDomainsDomainValidationChallengeArgs',
+    'GetPropertyDomainownershipSearchDomainsDomainValidationChallengeArgsDict',
+    'GetPropertyDomainownershipSearchDomainsDomainValidationChallengeCnameRecordArgs',
+    'GetPropertyDomainownershipSearchDomainsDomainValidationChallengeCnameRecordArgsDict',
+    'GetPropertyDomainownershipSearchDomainsDomainValidationChallengeHttpFileArgs',
+    'GetPropertyDomainownershipSearchDomainsDomainValidationChallengeHttpFileArgsDict',
+    'GetPropertyDomainownershipSearchDomainsDomainValidationChallengeHttpRedirectArgs',
+    'GetPropertyDomainownershipSearchDomainsDomainValidationChallengeHttpRedirectArgsDict',
+    'GetPropertyDomainownershipSearchDomainsDomainValidationChallengeTxtRecordArgs',
+    'GetPropertyDomainownershipSearchDomainsDomainValidationChallengeTxtRecordArgsDict',
     'GetPropertyIncludesParentPropertyArgs',
     'GetPropertyIncludesParentPropertyArgsDict',
     'GetPropertyRulesTemplateTemplateArgs',
@@ -629,6 +697,162 @@ __all__ = [
 
 MYPY = False
 
+if not MYPY:
+    class AppSecIPGeoAsnControlsArgsDict(TypedDict):
+        action: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Action set for ASN Controls
+        """
+        asn_network_lists: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
+        """
+        List of IDs of ASN network list to be blocked.
+        """
+elif False:
+    AppSecIPGeoAsnControlsArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class AppSecIPGeoAsnControlsArgs:
+    def __init__(__self__, *,
+                 action: Optional[pulumi.Input[_builtins.str]] = None,
+                 asn_network_lists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
+        """
+        :param pulumi.Input[_builtins.str] action: Action set for ASN Controls
+        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] asn_network_lists: List of IDs of ASN network list to be blocked.
+        """
+        if action is not None:
+            pulumi.set(__self__, "action", action)
+        if asn_network_lists is not None:
+            pulumi.set(__self__, "asn_network_lists", asn_network_lists)
+
+    @_builtins.property
+    @pulumi.getter
+    def action(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Action set for ASN Controls
+        """
+        return pulumi.get(self, "action")
+
+    @action.setter
+    def action(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "action", value)
+
+    @_builtins.property
+    @pulumi.getter(name="asnNetworkLists")
+    def asn_network_lists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
+        """
+        List of IDs of ASN network list to be blocked.
+        """
+        return pulumi.get(self, "asn_network_lists")
+
+    @asn_network_lists.setter
+    def asn_network_lists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
+        pulumi.set(self, "asn_network_lists", value)
+
+
+if not MYPY:
+    class AppSecIPGeoGeoControlsArgsDict(TypedDict):
+        action: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Action set for GEO Controls.
+        """
+        geo_network_lists: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
+        """
+        List of IDs of geographic network list to be blocked.
+        """
+elif False:
+    AppSecIPGeoGeoControlsArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class AppSecIPGeoGeoControlsArgs:
+    def __init__(__self__, *,
+                 action: Optional[pulumi.Input[_builtins.str]] = None,
+                 geo_network_lists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
+        """
+        :param pulumi.Input[_builtins.str] action: Action set for GEO Controls.
+        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] geo_network_lists: List of IDs of geographic network list to be blocked.
+        """
+        if action is not None:
+            pulumi.set(__self__, "action", action)
+        if geo_network_lists is not None:
+            pulumi.set(__self__, "geo_network_lists", geo_network_lists)
+
+    @_builtins.property
+    @pulumi.getter
+    def action(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Action set for GEO Controls.
+        """
+        return pulumi.get(self, "action")
+
+    @action.setter
+    def action(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "action", value)
+
+    @_builtins.property
+    @pulumi.getter(name="geoNetworkLists")
+    def geo_network_lists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
+        """
+        List of IDs of geographic network list to be blocked.
+        """
+        return pulumi.get(self, "geo_network_lists")
+
+    @geo_network_lists.setter
+    def geo_network_lists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
+        pulumi.set(self, "geo_network_lists", value)
+
+
+if not MYPY:
+    class AppSecIPGeoIpControlsArgsDict(TypedDict):
+        action: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Action set for IP Controls.
+        """
+        ip_network_lists: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
+        """
+        List of IDs of IP network list to be blocked.
+        """
+elif False:
+    AppSecIPGeoIpControlsArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class AppSecIPGeoIpControlsArgs:
+    def __init__(__self__, *,
+                 action: Optional[pulumi.Input[_builtins.str]] = None,
+                 ip_network_lists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
+        """
+        :param pulumi.Input[_builtins.str] action: Action set for IP Controls.
+        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ip_network_lists: List of IDs of IP network list to be blocked.
+        """
+        if action is not None:
+            pulumi.set(__self__, "action", action)
+        if ip_network_lists is not None:
+            pulumi.set(__self__, "ip_network_lists", ip_network_lists)
+
+    @_builtins.property
+    @pulumi.getter
+    def action(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Action set for IP Controls.
+        """
+        return pulumi.get(self, "action")
+
+    @action.setter
+    def action(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "action", value)
+
+    @_builtins.property
+    @pulumi.getter(name="ipNetworkLists")
+    def ip_network_lists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
+        """
+        List of IDs of IP network list to be blocked.
+        """
+        return pulumi.get(self, "ip_network_lists")
+
+    @ip_network_lists.setter
+    def ip_network_lists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
+        pulumi.set(self, "ip_network_lists", value)
+
+
 if not MYPY:
     class AppSecSiemSettingsExceptionsArgsDict(TypedDict):
         api_request_constraints: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
@@ -861,6 +1085,58 @@ class AppSecSiemSettingsExceptionsArgs:
         pulumi.set(self, "wafs", value)
 
 
+if not MYPY:
+    class AppsecAdvancedSettingsAsePenaltyBoxQualificationExclusionsArgsDict(TypedDict):
+        attack_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
+        """
+        List of attack group names.
+        """
+        rules: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.int]]]]
+        """
+        List of rule IDs.
+        """
+elif False:
+    AppsecAdvancedSettingsAsePenaltyBoxQualificationExclusionsArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class AppsecAdvancedSettingsAsePenaltyBoxQualificationExclusionsArgs:
+    def __init__(__self__, *,
+                 attack_groups: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
+                 rules: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.int]]]] = None):
+        """
+        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] attack_groups: List of attack group names.
+        :param pulumi.Input[Sequence[pulumi.Input[_builtins.int]]] rules: List of rule IDs.
+        """
+        if attack_groups is not None:
+            pulumi.set(__self__, "attack_groups", attack_groups)
+        if rules is not None:
+            pulumi.set(__self__, "rules", rules)
+
+    @_builtins.property
+    @pulumi.getter(name="attackGroups")
+    def attack_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
+        """
+        List of attack group names.
+        """
+        return pulumi.get(self, "attack_groups")
+
+    @attack_groups.setter
+    def attack_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
+        pulumi.set(self, "attack_groups", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.int]]]]:
+        """
+        List of rule IDs.
+        """
+        return pulumi.get(self, "rules")
+
+    @rules.setter
+    def rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.int]]]]):
+        pulumi.set(self, "rules", value)
+
+
 if not MYPY:
     class ClientlistListItemArgsDict(TypedDict):
         value: pulumi.Input[_builtins.str]
@@ -1293,6 +1569,118 @@ class CloudAccessKeyTimeoutsArgs:
         pulumi.set(self, "update", value)
 
 
+if not MYPY:
+    class CloudcertificatesCertificateSubjectArgsDict(TypedDict):
+        common_name: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Fully qualified domain name (FQDN) or other name associated with the subject. If specified, this value must also be included in the SANs list.
+        """
+        country: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Two-letter ISO 3166 country code.
+        """
+        locality: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        City or locality name.
+        """
+        organization: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Legal name of the organization.
+        """
+        state: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Full name of the state or province.
+        """
+elif False:
+    CloudcertificatesCertificateSubjectArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class CloudcertificatesCertificateSubjectArgs:
+    def __init__(__self__, *,
+                 common_name: Optional[pulumi.Input[_builtins.str]] = None,
+                 country: Optional[pulumi.Input[_builtins.str]] = None,
+                 locality: Optional[pulumi.Input[_builtins.str]] = None,
+                 organization: Optional[pulumi.Input[_builtins.str]] = None,
+                 state: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_builtins.str] common_name: Fully qualified domain name (FQDN) or other name associated with the subject. If specified, this value must also be included in the SANs list.
+        :param pulumi.Input[_builtins.str] country: Two-letter ISO 3166 country code.
+        :param pulumi.Input[_builtins.str] locality: City or locality name.
+        :param pulumi.Input[_builtins.str] organization: Legal name of the organization.
+        :param pulumi.Input[_builtins.str] state: Full name of the state or province.
+        """
+        if common_name is not None:
+            pulumi.set(__self__, "common_name", common_name)
+        if country is not None:
+            pulumi.set(__self__, "country", country)
+        if locality is not None:
+            pulumi.set(__self__, "locality", locality)
+        if organization is not None:
+            pulumi.set(__self__, "organization", organization)
+        if state is not None:
+            pulumi.set(__self__, "state", state)
+
+    @_builtins.property
+    @pulumi.getter(name="commonName")
+    def common_name(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Fully qualified domain name (FQDN) or other name associated with the subject. If specified, this value must also be included in the SANs list.
+        """
+        return pulumi.get(self, "common_name")
+
+    @common_name.setter
+    def common_name(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "common_name", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def country(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Two-letter ISO 3166 country code.
+        """
+        return pulumi.get(self, "country")
+
+    @country.setter
+    def country(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "country", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def locality(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        City or locality name.
+        """
+        return pulumi.get(self, "locality")
+
+    @locality.setter
+    def locality(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "locality", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def organization(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Legal name of the organization.
+        """
+        return pulumi.get(self, "organization")
+
+    @organization.setter
+    def organization(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "organization", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def state(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Full name of the state or province.
+        """
+        return pulumi.get(self, "state")
+
+    @state.setter
+    def state(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "state", value)
+
+
 if not MYPY:
     class CloudletsApplicationLoadBalancerActivationTimeoutsArgsDict(TypedDict):
         default: NotRequired[pulumi.Input[_builtins.str]]
@@ -4817,42 +5205,18 @@ class DatastreamDeliveryConfigurationFrequencyArgs:
 
 
 if not MYPY:
-    class DatastreamElasticsearchConnectorArgsDict(TypedDict):
-        display_name: pulumi.Input[_builtins.str]
+    class DatastreamDynatraceConnectorArgsDict(TypedDict):
+        api_token: pulumi.Input[_builtins.str]
         """
-        The name of the connector.
+        The Dynatrace Log Ingest access token.
         """
-        endpoint: pulumi.Input[_builtins.str]
-        """
-        The Elasticsearch bulk endpoint URL in the https://hostname.elastic-cloud.com:9243/_bulk/ format. Set indexName in the appropriate field instead of providing it in the URL. You can use Akamaized property hostnames as endpoint URLs. See Stream logs to Elasticsearch.
-        """
-        index_name: pulumi.Input[_builtins.str]
-        """
-        The index name of the Elastic cloud where you want to store log files.
-        """
-        password: pulumi.Input[_builtins.str]
-        """
-        The Elasticsearch basic access authentication password.
-        """
-        user_name: pulumi.Input[_builtins.str]
-        """
-        The Elasticsearch basic access authentication username.
-        """
-        ca_cert: NotRequired[pulumi.Input[_builtins.str]]
-        """
-        The certification authority (CA) certificate used to verify the origin server's certificate. If the certificate is not signed by a well-known certification authority, enter the CA certificate in the PEM format for verification.
-        """
-        client_cert: NotRequired[pulumi.Input[_builtins.str]]
-        """
-        The PEM-formatted digital certificate you want to authenticate requests to your destination with. If you want to use mutual authentication, you need to provide both the client certificate and the client key.
-        """
-        client_key: NotRequired[pulumi.Input[_builtins.str]]
+        display_name: pulumi.Input[_builtins.str]
         """
-        The private key in the non-encrypted PKCS8 format you want to use to authenticate with the backend server. If you want to use mutual authentication, you need to provide both the client certificate and the client key.
+        The destination's name.
         """
-        content_type: NotRequired[pulumi.Input[_builtins.str]]
+        endpoint: pulumi.Input[_builtins.str]
         """
-        The type of the resource passed in the request's custom header. For details, see Additional options in the DataStream user guide.
+        The Dynatrace Ingestion API endpoint URL in the https://{dynatrace-environment-id}.live.dynatrace.com/api/v2/logs/ingest format.
         """
         custom_header_name: NotRequired[pulumi.Input[_builtins.str]]
         """
@@ -4862,75 +5226,49 @@ if not MYPY:
         """
         The custom header's contents passed with the request that contains information about the client connection. For details, see Additional options in the DataStream user guide.
         """
-        m_tls: NotRequired[pulumi.Input[_builtins.bool]]
-        """
-        Indicates whether mTLS is enabled or not.
-        """
-        tls_hostname: NotRequired[pulumi.Input[_builtins.str]]
-        """
-        The hostname that verifies the server's certificate and matches the Subject Alternative Names (SANs) in the certificate. If not provided, DataStream fetches the hostname from the endpoint URL.
-        """
 elif False:
-    DatastreamElasticsearchConnectorArgsDict: TypeAlias = Mapping[str, Any]
+    DatastreamDynatraceConnectorArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
-class DatastreamElasticsearchConnectorArgs:
+class DatastreamDynatraceConnectorArgs:
     def __init__(__self__, *,
+                 api_token: pulumi.Input[_builtins.str],
                  display_name: pulumi.Input[_builtins.str],
                  endpoint: pulumi.Input[_builtins.str],
-                 index_name: pulumi.Input[_builtins.str],
-                 password: pulumi.Input[_builtins.str],
-                 user_name: pulumi.Input[_builtins.str],
-                 ca_cert: Optional[pulumi.Input[_builtins.str]] = None,
-                 client_cert: Optional[pulumi.Input[_builtins.str]] = None,
-                 client_key: Optional[pulumi.Input[_builtins.str]] = None,
-                 content_type: Optional[pulumi.Input[_builtins.str]] = None,
                  custom_header_name: Optional[pulumi.Input[_builtins.str]] = None,
-                 custom_header_value: Optional[pulumi.Input[_builtins.str]] = None,
-                 m_tls: Optional[pulumi.Input[_builtins.bool]] = None,
-                 tls_hostname: Optional[pulumi.Input[_builtins.str]] = None):
+                 custom_header_value: Optional[pulumi.Input[_builtins.str]] = None):
         """
-        :param pulumi.Input[_builtins.str] display_name: The name of the connector.
-        :param pulumi.Input[_builtins.str] endpoint: The Elasticsearch bulk endpoint URL in the https://hostname.elastic-cloud.com:9243/_bulk/ format. Set indexName in the appropriate field instead of providing it in the URL. You can use Akamaized property hostnames as endpoint URLs. See Stream logs to Elasticsearch.
-        :param pulumi.Input[_builtins.str] index_name: The index name of the Elastic cloud where you want to store log files.
-        :param pulumi.Input[_builtins.str] password: The Elasticsearch basic access authentication password.
-        :param pulumi.Input[_builtins.str] user_name: The Elasticsearch basic access authentication username.
-        :param pulumi.Input[_builtins.str] ca_cert: The certification authority (CA) certificate used to verify the origin server's certificate. If the certificate is not signed by a well-known certification authority, enter the CA certificate in the PEM format for verification.
-        :param pulumi.Input[_builtins.str] client_cert: The PEM-formatted digital certificate you want to authenticate requests to your destination with. If you want to use mutual authentication, you need to provide both the client certificate and the client key.
-        :param pulumi.Input[_builtins.str] client_key: The private key in the non-encrypted PKCS8 format you want to use to authenticate with the backend server. If you want to use mutual authentication, you need to provide both the client certificate and the client key.
-        :param pulumi.Input[_builtins.str] content_type: The type of the resource passed in the request's custom header. For details, see Additional options in the DataStream user guide.
+        :param pulumi.Input[_builtins.str] api_token: The Dynatrace Log Ingest access token.
+        :param pulumi.Input[_builtins.str] display_name: The destination's name.
+        :param pulumi.Input[_builtins.str] endpoint: The Dynatrace Ingestion API endpoint URL in the https://{dynatrace-environment-id}.live.dynatrace.com/api/v2/logs/ingest format.
         :param pulumi.Input[_builtins.str] custom_header_name: A human-readable name for the request's custom header, containing only alphanumeric, dash, and underscore characters. For details, see Additional options in the DataStream user guide.
         :param pulumi.Input[_builtins.str] custom_header_value: The custom header's contents passed with the request that contains information about the client connection. For details, see Additional options in the DataStream user guide.
-        :param pulumi.Input[_builtins.bool] m_tls: Indicates whether mTLS is enabled or not.
-        :param pulumi.Input[_builtins.str] tls_hostname: The hostname that verifies the server's certificate and matches the Subject Alternative Names (SANs) in the certificate. If not provided, DataStream fetches the hostname from the endpoint URL.
         """
+        pulumi.set(__self__, "api_token", api_token)
         pulumi.set(__self__, "display_name", display_name)
         pulumi.set(__self__, "endpoint", endpoint)
-        pulumi.set(__self__, "index_name", index_name)
-        pulumi.set(__self__, "password", password)
-        pulumi.set(__self__, "user_name", user_name)
-        if ca_cert is not None:
-            pulumi.set(__self__, "ca_cert", ca_cert)
-        if client_cert is not None:
-            pulumi.set(__self__, "client_cert", client_cert)
-        if client_key is not None:
-            pulumi.set(__self__, "client_key", client_key)
-        if content_type is not None:
-            pulumi.set(__self__, "content_type", content_type)
         if custom_header_name is not None:
             pulumi.set(__self__, "custom_header_name", custom_header_name)
         if custom_header_value is not None:
             pulumi.set(__self__, "custom_header_value", custom_header_value)
-        if m_tls is not None:
-            pulumi.set(__self__, "m_tls", m_tls)
-        if tls_hostname is not None:
-            pulumi.set(__self__, "tls_hostname", tls_hostname)
+
+    @_builtins.property
+    @pulumi.getter(name="apiToken")
+    def api_token(self) -> pulumi.Input[_builtins.str]:
+        """
+        The Dynatrace Log Ingest access token.
+        """
+        return pulumi.get(self, "api_token")
+
+    @api_token.setter
+    def api_token(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "api_token", value)
 
     @_builtins.property
     @pulumi.getter(name="displayName")
     def display_name(self) -> pulumi.Input[_builtins.str]:
         """
-        The name of the connector.
+        The destination's name.
         """
         return pulumi.get(self, "display_name")
 
@@ -4942,7 +5280,7 @@ class DatastreamElasticsearchConnectorArgs:
     @pulumi.getter
     def endpoint(self) -> pulumi.Input[_builtins.str]:
         """
-        The Elasticsearch bulk endpoint URL in the https://hostname.elastic-cloud.com:9243/_bulk/ format. Set indexName in the appropriate field instead of providing it in the URL. You can use Akamaized property hostnames as endpoint URLs. See Stream logs to Elasticsearch.
+        The Dynatrace Ingestion API endpoint URL in the https://{dynatrace-environment-id}.live.dynatrace.com/api/v2/logs/ingest format.
         """
         return pulumi.get(self, "endpoint")
 
@@ -4950,90 +5288,249 @@ class DatastreamElasticsearchConnectorArgs:
     def endpoint(self, value: pulumi.Input[_builtins.str]):
         pulumi.set(self, "endpoint", value)
 
-    @_builtins.property
-    @pulumi.getter(name="indexName")
-    def index_name(self) -> pulumi.Input[_builtins.str]:
-        """
-        The index name of the Elastic cloud where you want to store log files.
-        """
-        return pulumi.get(self, "index_name")
-
-    @index_name.setter
-    def index_name(self, value: pulumi.Input[_builtins.str]):
-        pulumi.set(self, "index_name", value)
-
-    @_builtins.property
-    @pulumi.getter
-    def password(self) -> pulumi.Input[_builtins.str]:
-        """
-        The Elasticsearch basic access authentication password.
-        """
-        return pulumi.get(self, "password")
-
-    @password.setter
-    def password(self, value: pulumi.Input[_builtins.str]):
-        pulumi.set(self, "password", value)
-
-    @_builtins.property
-    @pulumi.getter(name="userName")
-    def user_name(self) -> pulumi.Input[_builtins.str]:
-        """
-        The Elasticsearch basic access authentication username.
-        """
-        return pulumi.get(self, "user_name")
-
-    @user_name.setter
-    def user_name(self, value: pulumi.Input[_builtins.str]):
-        pulumi.set(self, "user_name", value)
-
-    @_builtins.property
-    @pulumi.getter(name="caCert")
-    def ca_cert(self) -> Optional[pulumi.Input[_builtins.str]]:
-        """
-        The certification authority (CA) certificate used to verify the origin server's certificate. If the certificate is not signed by a well-known certification authority, enter the CA certificate in the PEM format for verification.
-        """
-        return pulumi.get(self, "ca_cert")
-
-    @ca_cert.setter
-    def ca_cert(self, value: Optional[pulumi.Input[_builtins.str]]):
-        pulumi.set(self, "ca_cert", value)
-
-    @_builtins.property
-    @pulumi.getter(name="clientCert")
-    def client_cert(self) -> Optional[pulumi.Input[_builtins.str]]:
-        """
-        The PEM-formatted digital certificate you want to authenticate requests to your destination with. If you want to use mutual authentication, you need to provide both the client certificate and the client key.
-        """
-        return pulumi.get(self, "client_cert")
-
-    @client_cert.setter
-    def client_cert(self, value: Optional[pulumi.Input[_builtins.str]]):
-        pulumi.set(self, "client_cert", value)
-
-    @_builtins.property
-    @pulumi.getter(name="clientKey")
-    def client_key(self) -> Optional[pulumi.Input[_builtins.str]]:
-        """
-        The private key in the non-encrypted PKCS8 format you want to use to authenticate with the backend server. If you want to use mutual authentication, you need to provide both the client certificate and the client key.
-        """
-        return pulumi.get(self, "client_key")
-
-    @client_key.setter
-    def client_key(self, value: Optional[pulumi.Input[_builtins.str]]):
-        pulumi.set(self, "client_key", value)
-
-    @_builtins.property
-    @pulumi.getter(name="contentType")
-    def content_type(self) -> Optional[pulumi.Input[_builtins.str]]:
-        """
-        The type of the resource passed in the request's custom header. For details, see Additional options in the DataStream user guide.
-        """
-        return pulumi.get(self, "content_type")
-
-    @content_type.setter
-    def content_type(self, value: Optional[pulumi.Input[_builtins.str]]):
-        pulumi.set(self, "content_type", value)
-
+    @_builtins.property
+    @pulumi.getter(name="customHeaderName")
+    def custom_header_name(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        A human-readable name for the request's custom header, containing only alphanumeric, dash, and underscore characters. For details, see Additional options in the DataStream user guide.
+        """
+        return pulumi.get(self, "custom_header_name")
+
+    @custom_header_name.setter
+    def custom_header_name(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "custom_header_name", value)
+
+    @_builtins.property
+    @pulumi.getter(name="customHeaderValue")
+    def custom_header_value(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The custom header's contents passed with the request that contains information about the client connection. For details, see Additional options in the DataStream user guide.
+        """
+        return pulumi.get(self, "custom_header_value")
+
+    @custom_header_value.setter
+    def custom_header_value(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "custom_header_value", value)
+
+
+if not MYPY:
+    class DatastreamElasticsearchConnectorArgsDict(TypedDict):
+        display_name: pulumi.Input[_builtins.str]
+        """
+        The name of the connector.
+        """
+        endpoint: pulumi.Input[_builtins.str]
+        """
+        The Elasticsearch bulk endpoint URL in the https://hostname.elastic-cloud.com:9243/_bulk/ format. Set indexName in the appropriate field instead of providing it in the URL. You can use Akamaized property hostnames as endpoint URLs. See Stream logs to Elasticsearch.
+        """
+        index_name: pulumi.Input[_builtins.str]
+        """
+        The index name of the Elastic cloud where you want to store log files.
+        """
+        password: pulumi.Input[_builtins.str]
+        """
+        The Elasticsearch basic access authentication password.
+        """
+        user_name: pulumi.Input[_builtins.str]
+        """
+        The Elasticsearch basic access authentication username.
+        """
+        ca_cert: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The certification authority (CA) certificate used to verify the origin server's certificate. If the certificate is not signed by a well-known certification authority, enter the CA certificate in the PEM format for verification.
+        """
+        client_cert: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The PEM-formatted digital certificate you want to authenticate requests to your destination with. If you want to use mutual authentication, you need to provide both the client certificate and the client key.
+        """
+        client_key: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The private key in the non-encrypted PKCS8 format you want to use to authenticate with the backend server. If you want to use mutual authentication, you need to provide both the client certificate and the client key.
+        """
+        content_type: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The type of the resource passed in the request's custom header. For details, see Additional options in the DataStream user guide.
+        """
+        custom_header_name: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        A human-readable name for the request's custom header, containing only alphanumeric, dash, and underscore characters. For details, see Additional options in the DataStream user guide.
+        """
+        custom_header_value: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The custom header's contents passed with the request that contains information about the client connection. For details, see Additional options in the DataStream user guide.
+        """
+        m_tls: NotRequired[pulumi.Input[_builtins.bool]]
+        """
+        Indicates whether mTLS is enabled or not.
+        """
+        tls_hostname: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The hostname that verifies the server's certificate and matches the Subject Alternative Names (SANs) in the certificate. If not provided, DataStream fetches the hostname from the endpoint URL.
+        """
+elif False:
+    DatastreamElasticsearchConnectorArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DatastreamElasticsearchConnectorArgs:
+    def __init__(__self__, *,
+                 display_name: pulumi.Input[_builtins.str],
+                 endpoint: pulumi.Input[_builtins.str],
+                 index_name: pulumi.Input[_builtins.str],
+                 password: pulumi.Input[_builtins.str],
+                 user_name: pulumi.Input[_builtins.str],
+                 ca_cert: Optional[pulumi.Input[_builtins.str]] = None,
+                 client_cert: Optional[pulumi.Input[_builtins.str]] = None,
+                 client_key: Optional[pulumi.Input[_builtins.str]] = None,
+                 content_type: Optional[pulumi.Input[_builtins.str]] = None,
+                 custom_header_name: Optional[pulumi.Input[_builtins.str]] = None,
+                 custom_header_value: Optional[pulumi.Input[_builtins.str]] = None,
+                 m_tls: Optional[pulumi.Input[_builtins.bool]] = None,
+                 tls_hostname: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_builtins.str] display_name: The name of the connector.
+        :param pulumi.Input[_builtins.str] endpoint: The Elasticsearch bulk endpoint URL in the https://hostname.elastic-cloud.com:9243/_bulk/ format. Set indexName in the appropriate field instead of providing it in the URL. You can use Akamaized property hostnames as endpoint URLs. See Stream logs to Elasticsearch.
+        :param pulumi.Input[_builtins.str] index_name: The index name of the Elastic cloud where you want to store log files.
+        :param pulumi.Input[_builtins.str] password: The Elasticsearch basic access authentication password.
+        :param pulumi.Input[_builtins.str] user_name: The Elasticsearch basic access authentication username.
+        :param pulumi.Input[_builtins.str] ca_cert: The certification authority (CA) certificate used to verify the origin server's certificate. If the certificate is not signed by a well-known certification authority, enter the CA certificate in the PEM format for verification.
+        :param pulumi.Input[_builtins.str] client_cert: The PEM-formatted digital certificate you want to authenticate requests to your destination with. If you want to use mutual authentication, you need to provide both the client certificate and the client key.
+        :param pulumi.Input[_builtins.str] client_key: The private key in the non-encrypted PKCS8 format you want to use to authenticate with the backend server. If you want to use mutual authentication, you need to provide both the client certificate and the client key.
+        :param pulumi.Input[_builtins.str] content_type: The type of the resource passed in the request's custom header. For details, see Additional options in the DataStream user guide.
+        :param pulumi.Input[_builtins.str] custom_header_name: A human-readable name for the request's custom header, containing only alphanumeric, dash, and underscore characters. For details, see Additional options in the DataStream user guide.
+        :param pulumi.Input[_builtins.str] custom_header_value: The custom header's contents passed with the request that contains information about the client connection. For details, see Additional options in the DataStream user guide.
+        :param pulumi.Input[_builtins.bool] m_tls: Indicates whether mTLS is enabled or not.
+        :param pulumi.Input[_builtins.str] tls_hostname: The hostname that verifies the server's certificate and matches the Subject Alternative Names (SANs) in the certificate. If not provided, DataStream fetches the hostname from the endpoint URL.
+        """
+        pulumi.set(__self__, "display_name", display_name)
+        pulumi.set(__self__, "endpoint", endpoint)
+        pulumi.set(__self__, "index_name", index_name)
+        pulumi.set(__self__, "password", password)
+        pulumi.set(__self__, "user_name", user_name)
+        if ca_cert is not None:
+            pulumi.set(__self__, "ca_cert", ca_cert)
+        if client_cert is not None:
+            pulumi.set(__self__, "client_cert", client_cert)
+        if client_key is not None:
+            pulumi.set(__self__, "client_key", client_key)
+        if content_type is not None:
+            pulumi.set(__self__, "content_type", content_type)
+        if custom_header_name is not None:
+            pulumi.set(__self__, "custom_header_name", custom_header_name)
+        if custom_header_value is not None:
+            pulumi.set(__self__, "custom_header_value", custom_header_value)
+        if m_tls is not None:
+            pulumi.set(__self__, "m_tls", m_tls)
+        if tls_hostname is not None:
+            pulumi.set(__self__, "tls_hostname", tls_hostname)
+
+    @_builtins.property
+    @pulumi.getter(name="displayName")
+    def display_name(self) -> pulumi.Input[_builtins.str]:
+        """
+        The name of the connector.
+        """
+        return pulumi.get(self, "display_name")
+
+    @display_name.setter
+    def display_name(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "display_name", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def endpoint(self) -> pulumi.Input[_builtins.str]:
+        """
+        The Elasticsearch bulk endpoint URL in the https://hostname.elastic-cloud.com:9243/_bulk/ format. Set indexName in the appropriate field instead of providing it in the URL. You can use Akamaized property hostnames as endpoint URLs. See Stream logs to Elasticsearch.
+        """
+        return pulumi.get(self, "endpoint")
+
+    @endpoint.setter
+    def endpoint(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "endpoint", value)
+
+    @_builtins.property
+    @pulumi.getter(name="indexName")
+    def index_name(self) -> pulumi.Input[_builtins.str]:
+        """
+        The index name of the Elastic cloud where you want to store log files.
+        """
+        return pulumi.get(self, "index_name")
+
+    @index_name.setter
+    def index_name(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "index_name", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def password(self) -> pulumi.Input[_builtins.str]:
+        """
+        The Elasticsearch basic access authentication password.
+        """
+        return pulumi.get(self, "password")
+
+    @password.setter
+    def password(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "password", value)
+
+    @_builtins.property
+    @pulumi.getter(name="userName")
+    def user_name(self) -> pulumi.Input[_builtins.str]:
+        """
+        The Elasticsearch basic access authentication username.
+        """
+        return pulumi.get(self, "user_name")
+
+    @user_name.setter
+    def user_name(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "user_name", value)
+
+    @_builtins.property
+    @pulumi.getter(name="caCert")
+    def ca_cert(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The certification authority (CA) certificate used to verify the origin server's certificate. If the certificate is not signed by a well-known certification authority, enter the CA certificate in the PEM format for verification.
+        """
+        return pulumi.get(self, "ca_cert")
+
+    @ca_cert.setter
+    def ca_cert(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "ca_cert", value)
+
+    @_builtins.property
+    @pulumi.getter(name="clientCert")
+    def client_cert(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The PEM-formatted digital certificate you want to authenticate requests to your destination with. If you want to use mutual authentication, you need to provide both the client certificate and the client key.
+        """
+        return pulumi.get(self, "client_cert")
+
+    @client_cert.setter
+    def client_cert(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "client_cert", value)
+
+    @_builtins.property
+    @pulumi.getter(name="clientKey")
+    def client_key(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The private key in the non-encrypted PKCS8 format you want to use to authenticate with the backend server. If you want to use mutual authentication, you need to provide both the client certificate and the client key.
+        """
+        return pulumi.get(self, "client_key")
+
+    @client_key.setter
+    def client_key(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "client_key", value)
+
+    @_builtins.property
+    @pulumi.getter(name="contentType")
+    def content_type(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The type of the resource passed in the request's custom header. For details, see Additional options in the DataStream user guide.
+        """
+        return pulumi.get(self, "content_type")
+
+    @content_type.setter
+    def content_type(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "content_type", value)
+
     @_builtins.property
     @pulumi.getter(name="customHeaderName")
     def custom_header_name(self) -> Optional[pulumi.Input[_builtins.str]]:
@@ -5962,6 +6459,172 @@ class DatastreamOracleConnectorArgs:
         pulumi.set(self, "compress_logs", value)
 
 
+if not MYPY:
+    class DatastreamS3CompatibleConnectorArgsDict(TypedDict):
+        access_key: pulumi.Input[_builtins.str]
+        """
+        The access key identifier of the S3-compatible object storage bucket.
+        """
+        bucket: pulumi.Input[_builtins.str]
+        """
+        The name of the S3-compatible object storage bucket.
+        """
+        display_name: pulumi.Input[_builtins.str]
+        """
+        The name of the destination.
+        """
+        endpoint: pulumi.Input[_builtins.str]
+        """
+        The scheme-qualified host of your S3-compatible object storage bucket.
+        """
+        region: pulumi.Input[_builtins.str]
+        """
+        The physical storage location of your S3-compatible object storage bucket.
+        """
+        secret_access_key: pulumi.Input[_builtins.str]
+        """
+        The secret access key identifier of the S3-compatible object storage bucket.
+        """
+        compress_logs: NotRequired[pulumi.Input[_builtins.bool]]
+        """
+        Enables gzip compression for a log file sent to a destination. This value is always true for this destination type.
+        """
+        path: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The path to the folder within your S3-compatible object storage bucket where you want to store logs. Optional field.
+        """
+elif False:
+    DatastreamS3CompatibleConnectorArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DatastreamS3CompatibleConnectorArgs:
+    def __init__(__self__, *,
+                 access_key: pulumi.Input[_builtins.str],
+                 bucket: pulumi.Input[_builtins.str],
+                 display_name: pulumi.Input[_builtins.str],
+                 endpoint: pulumi.Input[_builtins.str],
+                 region: pulumi.Input[_builtins.str],
+                 secret_access_key: pulumi.Input[_builtins.str],
+                 compress_logs: Optional[pulumi.Input[_builtins.bool]] = None,
+                 path: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_builtins.str] access_key: The access key identifier of the S3-compatible object storage bucket.
+        :param pulumi.Input[_builtins.str] bucket: The name of the S3-compatible object storage bucket.
+        :param pulumi.Input[_builtins.str] display_name: The name of the destination.
+        :param pulumi.Input[_builtins.str] endpoint: The scheme-qualified host of your S3-compatible object storage bucket.
+        :param pulumi.Input[_builtins.str] region: The physical storage location of your S3-compatible object storage bucket.
+        :param pulumi.Input[_builtins.str] secret_access_key: The secret access key identifier of the S3-compatible object storage bucket.
+        :param pulumi.Input[_builtins.bool] compress_logs: Enables gzip compression for a log file sent to a destination. This value is always true for this destination type.
+        :param pulumi.Input[_builtins.str] path: The path to the folder within your S3-compatible object storage bucket where you want to store logs. Optional field.
+        """
+        pulumi.set(__self__, "access_key", access_key)
+        pulumi.set(__self__, "bucket", bucket)
+        pulumi.set(__self__, "display_name", display_name)
+        pulumi.set(__self__, "endpoint", endpoint)
+        pulumi.set(__self__, "region", region)
+        pulumi.set(__self__, "secret_access_key", secret_access_key)
+        if compress_logs is not None:
+            pulumi.set(__self__, "compress_logs", compress_logs)
+        if path is not None:
+            pulumi.set(__self__, "path", path)
+
+    @_builtins.property
+    @pulumi.getter(name="accessKey")
+    def access_key(self) -> pulumi.Input[_builtins.str]:
+        """
+        The access key identifier of the S3-compatible object storage bucket.
+        """
+        return pulumi.get(self, "access_key")
+
+    @access_key.setter
+    def access_key(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "access_key", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def bucket(self) -> pulumi.Input[_builtins.str]:
+        """
+        The name of the S3-compatible object storage bucket.
+        """
+        return pulumi.get(self, "bucket")
+
+    @bucket.setter
+    def bucket(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "bucket", value)
+
+    @_builtins.property
+    @pulumi.getter(name="displayName")
+    def display_name(self) -> pulumi.Input[_builtins.str]:
+        """
+        The name of the destination.
+        """
+        return pulumi.get(self, "display_name")
+
+    @display_name.setter
+    def display_name(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "display_name", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def endpoint(self) -> pulumi.Input[_builtins.str]:
+        """
+        The scheme-qualified host of your S3-compatible object storage bucket.
+        """
+        return pulumi.get(self, "endpoint")
+
+    @endpoint.setter
+    def endpoint(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "endpoint", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def region(self) -> pulumi.Input[_builtins.str]:
+        """
+        The physical storage location of your S3-compatible object storage bucket.
+        """
+        return pulumi.get(self, "region")
+
+    @region.setter
+    def region(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "region", value)
+
+    @_builtins.property
+    @pulumi.getter(name="secretAccessKey")
+    def secret_access_key(self) -> pulumi.Input[_builtins.str]:
+        """
+        The secret access key identifier of the S3-compatible object storage bucket.
+        """
+        return pulumi.get(self, "secret_access_key")
+
+    @secret_access_key.setter
+    def secret_access_key(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "secret_access_key", value)
+
+    @_builtins.property
+    @pulumi.getter(name="compressLogs")
+    def compress_logs(self) -> Optional[pulumi.Input[_builtins.bool]]:
+        """
+        Enables gzip compression for a log file sent to a destination. This value is always true for this destination type.
+        """
+        return pulumi.get(self, "compress_logs")
+
+    @compress_logs.setter
+    def compress_logs(self, value: Optional[pulumi.Input[_builtins.bool]]):
+        pulumi.set(self, "compress_logs", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def path(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The path to the folder within your S3-compatible object storage bucket where you want to store logs. Optional field.
+        """
+        return pulumi.get(self, "path")
+
+    @path.setter
+    def path(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "path", value)
+
+
 if not MYPY:
     class DatastreamS3ConnectorArgsDict(TypedDict):
         access_key: pulumi.Input[_builtins.str]
@@ -6486,6 +7149,192 @@ class DatastreamSumologicConnectorArgs:
         pulumi.set(self, "custom_header_value", value)
 
 
+if not MYPY:
+    class DatastreamTrafficpeakConnectorArgsDict(TypedDict):
+        authentication_type: pulumi.Input[_builtins.str]
+        """
+        Only BASIC authentication is supported for TrafficPeak destination.
+        """
+        content_type: pulumi.Input[_builtins.str]
+        """
+        The type of the resource passed in the request's custom header. - Supported headers: `application/json` or `application/json; charset=utf-8`.
+        """
+        display_name: pulumi.Input[_builtins.str]
+        """
+        The destination's name.
+        """
+        endpoint: pulumi.Input[_builtins.str]
+        """
+        Enter the Hydrolix endpoint URL in the https://<host>/ingest/event?table=<tablename>&token=<token> format, where the token is the HTTP streaming ingest token, and the tablename is the Hydrolix data set table name.
+        """
+        password: pulumi.Input[_builtins.str]
+        """
+        Enter the password you set in your TrafficPeak endpoint for authentication.
+        """
+        user_name: pulumi.Input[_builtins.str]
+        """
+        Enter the valid username you set in your TrafficPeak endpoint for authentication.
+        """
+        compress_logs: NotRequired[pulumi.Input[_builtins.bool]]
+        """
+        Enables gzip compression for a log file sent to a destination. The value is true by default.
+        """
+        custom_header_name: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        A human-readable name for the request's custom header, containing only alphanumeric, dash, and underscore characters. Optional field.
+        """
+        custom_header_value: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The custom header's contents passed with the request that contains information about the client connection. Optional field.
+        """
+elif False:
+    DatastreamTrafficpeakConnectorArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DatastreamTrafficpeakConnectorArgs:
+    def __init__(__self__, *,
+                 authentication_type: pulumi.Input[_builtins.str],
+                 content_type: pulumi.Input[_builtins.str],
+                 display_name: pulumi.Input[_builtins.str],
+                 endpoint: pulumi.Input[_builtins.str],
+                 password: pulumi.Input[_builtins.str],
+                 user_name: pulumi.Input[_builtins.str],
+                 compress_logs: Optional[pulumi.Input[_builtins.bool]] = None,
+                 custom_header_name: Optional[pulumi.Input[_builtins.str]] = None,
+                 custom_header_value: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_builtins.str] authentication_type: Only BASIC authentication is supported for TrafficPeak destination.
+        :param pulumi.Input[_builtins.str] content_type: The type of the resource passed in the request's custom header. - Supported headers: `application/json` or `application/json; charset=utf-8`.
+        :param pulumi.Input[_builtins.str] display_name: The destination's name.
+        :param pulumi.Input[_builtins.str] endpoint: Enter the Hydrolix endpoint URL in the https://<host>/ingest/event?table=<tablename>&token=<token> format, where the token is the HTTP streaming ingest token, and the tablename is the Hydrolix data set table name.
+        :param pulumi.Input[_builtins.str] password: Enter the password you set in your TrafficPeak endpoint for authentication.
+        :param pulumi.Input[_builtins.str] user_name: Enter the valid username you set in your TrafficPeak endpoint for authentication.
+        :param pulumi.Input[_builtins.bool] compress_logs: Enables gzip compression for a log file sent to a destination. The value is true by default.
+        :param pulumi.Input[_builtins.str] custom_header_name: A human-readable name for the request's custom header, containing only alphanumeric, dash, and underscore characters. Optional field.
+        :param pulumi.Input[_builtins.str] custom_header_value: The custom header's contents passed with the request that contains information about the client connection. Optional field.
+        """
+        pulumi.set(__self__, "authentication_type", authentication_type)
+        pulumi.set(__self__, "content_type", content_type)
+        pulumi.set(__self__, "display_name", display_name)
+        pulumi.set(__self__, "endpoint", endpoint)
+        pulumi.set(__self__, "password", password)
+        pulumi.set(__self__, "user_name", user_name)
+        if compress_logs is not None:
+            pulumi.set(__self__, "compress_logs", compress_logs)
+        if custom_header_name is not None:
+            pulumi.set(__self__, "custom_header_name", custom_header_name)
+        if custom_header_value is not None:
+            pulumi.set(__self__, "custom_header_value", custom_header_value)
+
+    @_builtins.property
+    @pulumi.getter(name="authenticationType")
+    def authentication_type(self) -> pulumi.Input[_builtins.str]:
+        """
+        Only BASIC authentication is supported for TrafficPeak destination.
+        """
+        return pulumi.get(self, "authentication_type")
+
+    @authentication_type.setter
+    def authentication_type(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "authentication_type", value)
+
+    @_builtins.property
+    @pulumi.getter(name="contentType")
+    def content_type(self) -> pulumi.Input[_builtins.str]:
+        """
+        The type of the resource passed in the request's custom header. - Supported headers: `application/json` or `application/json; charset=utf-8`.
+        """
+        return pulumi.get(self, "content_type")
+
+    @content_type.setter
+    def content_type(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "content_type", value)
+
+    @_builtins.property
+    @pulumi.getter(name="displayName")
+    def display_name(self) -> pulumi.Input[_builtins.str]:
+        """
+        The destination's name.
+        """
+        return pulumi.get(self, "display_name")
+
+    @display_name.setter
+    def display_name(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "display_name", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def endpoint(self) -> pulumi.Input[_builtins.str]:
+        """
+        Enter the Hydrolix endpoint URL in the https://<host>/ingest/event?table=<tablename>&token=<token> format, where the token is the HTTP streaming ingest token, and the tablename is the Hydrolix data set table name.
+        """
+        return pulumi.get(self, "endpoint")
+
+    @endpoint.setter
+    def endpoint(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "endpoint", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def password(self) -> pulumi.Input[_builtins.str]:
+        """
+        Enter the password you set in your TrafficPeak endpoint for authentication.
+        """
+        return pulumi.get(self, "password")
+
+    @password.setter
+    def password(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "password", value)
+
+    @_builtins.property
+    @pulumi.getter(name="userName")
+    def user_name(self) -> pulumi.Input[_builtins.str]:
+        """
+        Enter the valid username you set in your TrafficPeak endpoint for authentication.
+        """
+        return pulumi.get(self, "user_name")
+
+    @user_name.setter
+    def user_name(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "user_name", value)
+
+    @_builtins.property
+    @pulumi.getter(name="compressLogs")
+    def compress_logs(self) -> Optional[pulumi.Input[_builtins.bool]]:
+        """
+        Enables gzip compression for a log file sent to a destination. The value is true by default.
+        """
+        return pulumi.get(self, "compress_logs")
+
+    @compress_logs.setter
+    def compress_logs(self, value: Optional[pulumi.Input[_builtins.bool]]):
+        pulumi.set(self, "compress_logs", value)
+
+    @_builtins.property
+    @pulumi.getter(name="customHeaderName")
+    def custom_header_name(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        A human-readable name for the request's custom header, containing only alphanumeric, dash, and underscore characters. Optional field.
+        """
+        return pulumi.get(self, "custom_header_name")
+
+    @custom_header_name.setter
+    def custom_header_name(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "custom_header_name", value)
+
+    @_builtins.property
+    @pulumi.getter(name="customHeaderValue")
+    def custom_header_value(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The custom header's contents passed with the request that contains information about the client connection. Optional field.
+        """
+        return pulumi.get(self, "custom_header_value")
+
+    @custom_header_value.setter
+    def custom_header_value(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "custom_header_value", value)
+
+
 if not MYPY:
     class DnsZoneOutboundZoneTransferArgsDict(TypedDict):
         acls: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
@@ -8808,13 +9657,13 @@ class IamApiClientGroupAccessGroupSubGroupArgs:
 
 if not MYPY:
     class IamApiClientIpAclArgsDict(TypedDict):
-        enable: pulumi.Input[_builtins.bool]
+        cidrs: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]
         """
-        Enables the API client to access the IP access control list (ACL).
+        IP addresses or CIDR blocks the API client can access.
         """
-        cidrs: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
+        enable: pulumi.Input[_builtins.bool]
         """
-        IP addresses or CIDR blocks the API client can access.
+        Enables the API client to access the IP access control list (ACL).
         """
 elif False:
     IamApiClientIpAclArgsDict: TypeAlias = Mapping[str, Any]
@@ -8822,39 +9671,38 @@ elif False:
 @pulumi.input_type
 class IamApiClientIpAclArgs:
     def __init__(__self__, *,
-                 enable: pulumi.Input[_builtins.bool],
-                 cidrs: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
+                 cidrs: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]],
+                 enable: pulumi.Input[_builtins.bool]):
         """
-        :param pulumi.Input[_builtins.bool] enable: Enables the API client to access the IP access control list (ACL).
         :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] cidrs: IP addresses or CIDR blocks the API client can access.
+        :param pulumi.Input[_builtins.bool] enable: Enables the API client to access the IP access control list (ACL).
         """
+        pulumi.set(__self__, "cidrs", cidrs)
         pulumi.set(__self__, "enable", enable)
-        if cidrs is not None:
-            pulumi.set(__self__, "cidrs", cidrs)
 
     @_builtins.property
     @pulumi.getter
-    def enable(self) -> pulumi.Input[_builtins.bool]:
+    def cidrs(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
         """
-        Enables the API client to access the IP access control list (ACL).
+        IP addresses or CIDR blocks the API client can access.
         """
-        return pulumi.get(self, "enable")
+        return pulumi.get(self, "cidrs")
 
-    @enable.setter
-    def enable(self, value: pulumi.Input[_builtins.bool]):
-        pulumi.set(self, "enable", value)
+    @cidrs.setter
+    def cidrs(self, value: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
+        pulumi.set(self, "cidrs", value)
 
     @_builtins.property
     @pulumi.getter
-    def cidrs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
+    def enable(self) -> pulumi.Input[_builtins.bool]:
         """
-        IP addresses or CIDR blocks the API client can access.
+        Enables the API client to access the IP access control list (ACL).
         """
-        return pulumi.get(self, "cidrs")
+        return pulumi.get(self, "enable")
 
-    @cidrs.setter
-    def cidrs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
-        pulumi.set(self, "cidrs", value)
+    @enable.setter
+    def enable(self, value: pulumi.Input[_builtins.bool]):
+        pulumi.set(self, "enable", value)
 
 
 if not MYPY:
@@ -9158,327 +10006,1646 @@ class IamUserUserNotificationsArgs:
 
 
 if not MYPY:
-    class PropertyActivationComplianceRecordArgsDict(TypedDict):
-        noncompliance_reason_emergency: NotRequired[pulumi.Input['PropertyActivationComplianceRecordNoncomplianceReasonEmergencyArgsDict']]
-        """
-        Provides an audit record when activating on a production network with noncompliance reason as `EMERGENCY`
-        """
-        noncompliance_reason_no_production_traffic: NotRequired[pulumi.Input['PropertyActivationComplianceRecordNoncomplianceReasonNoProductionTrafficArgsDict']]
-        """
-        Provides an audit record when activating on a production network with noncompliance reason as `NO_PRODUCTION_TRAFFIC`
-        """
-        noncompliance_reason_none: NotRequired[pulumi.Input['PropertyActivationComplianceRecordNoncomplianceReasonNoneArgsDict']]
+    class MtlskeystoreClientCertificateAkamaiTimeoutsArgsDict(TypedDict):
+        create: NotRequired[pulumi.Input[_builtins.str]]
         """
-        Provides an audit record when activating on a production network with noncompliance reason as `NONE`
+        Optional configurable resource create timeout. By default it's 30m.
         """
-        noncompliance_reason_other: NotRequired[pulumi.Input['PropertyActivationComplianceRecordNoncomplianceReasonOtherArgsDict']]
+        update: NotRequired[pulumi.Input[_builtins.str]]
         """
-        Provides an audit record when activating on a production network with noncompliance reason as `OTHER`
+        Optional configurable resource update timeout. By default it's 30m.
         """
 elif False:
-    PropertyActivationComplianceRecordArgsDict: TypeAlias = Mapping[str, Any]
+    MtlskeystoreClientCertificateAkamaiTimeoutsArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
-class PropertyActivationComplianceRecordArgs:
+class MtlskeystoreClientCertificateAkamaiTimeoutsArgs:
     def __init__(__self__, *,
-                 noncompliance_reason_emergency: Optional[pulumi.Input['PropertyActivationComplianceRecordNoncomplianceReasonEmergencyArgs']] = None,
-                 noncompliance_reason_no_production_traffic: Optional[pulumi.Input['PropertyActivationComplianceRecordNoncomplianceReasonNoProductionTrafficArgs']] = None,
-                 noncompliance_reason_none: Optional[pulumi.Input['PropertyActivationComplianceRecordNoncomplianceReasonNoneArgs']] = None,
-                 noncompliance_reason_other: Optional[pulumi.Input['PropertyActivationComplianceRecordNoncomplianceReasonOtherArgs']] = None):
+                 create: Optional[pulumi.Input[_builtins.str]] = None,
+                 update: Optional[pulumi.Input[_builtins.str]] = None):
         """
-        :param pulumi.Input['PropertyActivationComplianceRecordNoncomplianceReasonEmergencyArgs'] noncompliance_reason_emergency: Provides an audit record when activating on a production network with noncompliance reason as `EMERGENCY`
-        :param pulumi.Input['PropertyActivationComplianceRecordNoncomplianceReasonNoProductionTrafficArgs'] noncompliance_reason_no_production_traffic: Provides an audit record when activating on a production network with noncompliance reason as `NO_PRODUCTION_TRAFFIC`
-        :param pulumi.Input['PropertyActivationComplianceRecordNoncomplianceReasonNoneArgs'] noncompliance_reason_none: Provides an audit record when activating on a production network with noncompliance reason as `NONE`
-        :param pulumi.Input['PropertyActivationComplianceRecordNoncomplianceReasonOtherArgs'] noncompliance_reason_other: Provides an audit record when activating on a production network with noncompliance reason as `OTHER`
+        :param pulumi.Input[_builtins.str] create: Optional configurable resource create timeout. By default it's 30m.
+        :param pulumi.Input[_builtins.str] update: Optional configurable resource update timeout. By default it's 30m.
         """
-        if noncompliance_reason_emergency is not None:
-            pulumi.set(__self__, "noncompliance_reason_emergency", noncompliance_reason_emergency)
-        if noncompliance_reason_no_production_traffic is not None:
-            pulumi.set(__self__, "noncompliance_reason_no_production_traffic", noncompliance_reason_no_production_traffic)
-        if noncompliance_reason_none is not None:
-            pulumi.set(__self__, "noncompliance_reason_none", noncompliance_reason_none)
-        if noncompliance_reason_other is not None:
-            pulumi.set(__self__, "noncompliance_reason_other", noncompliance_reason_other)
+        if create is not None:
+            pulumi.set(__self__, "create", create)
+        if update is not None:
+            pulumi.set(__self__, "update", update)
 
     @_builtins.property
-    @pulumi.getter(name="noncomplianceReasonEmergency")
-    def noncompliance_reason_emergency(self) -> Optional[pulumi.Input['PropertyActivationComplianceRecordNoncomplianceReasonEmergencyArgs']]:
+    @pulumi.getter
+    def create(self) -> Optional[pulumi.Input[_builtins.str]]:
         """
-        Provides an audit record when activating on a production network with noncompliance reason as `EMERGENCY`
+        Optional configurable resource create timeout. By default it's 30m.
         """
-        return pulumi.get(self, "noncompliance_reason_emergency")
+        return pulumi.get(self, "create")
 
-    @noncompliance_reason_emergency.setter
-    def noncompliance_reason_emergency(self, value: Optional[pulumi.Input['PropertyActivationComplianceRecordNoncomplianceReasonEmergencyArgs']]):
-        pulumi.set(self, "noncompliance_reason_emergency", value)
+    @create.setter
+    def create(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "create", value)
 
     @_builtins.property
-    @pulumi.getter(name="noncomplianceReasonNoProductionTraffic")
-    def noncompliance_reason_no_production_traffic(self) -> Optional[pulumi.Input['PropertyActivationComplianceRecordNoncomplianceReasonNoProductionTrafficArgs']]:
+    @pulumi.getter
+    def update(self) -> Optional[pulumi.Input[_builtins.str]]:
         """
-        Provides an audit record when activating on a production network with noncompliance reason as `NO_PRODUCTION_TRAFFIC`
+        Optional configurable resource update timeout. By default it's 30m.
         """
-        return pulumi.get(self, "noncompliance_reason_no_production_traffic")
+        return pulumi.get(self, "update")
 
-    @noncompliance_reason_no_production_traffic.setter
-    def noncompliance_reason_no_production_traffic(self, value: Optional[pulumi.Input['PropertyActivationComplianceRecordNoncomplianceReasonNoProductionTrafficArgs']]):
-        pulumi.set(self, "noncompliance_reason_no_production_traffic", value)
+    @update.setter
+    def update(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "update", value)
 
-    @_builtins.property
-    @pulumi.getter(name="noncomplianceReasonNone")
-    def noncompliance_reason_none(self) -> Optional[pulumi.Input['PropertyActivationComplianceRecordNoncomplianceReasonNoneArgs']]:
+
+if not MYPY:
+    class MtlskeystoreClientCertificateAkamaiVersionArgsDict(TypedDict):
+        certificate_block: NotRequired[pulumi.Input['MtlskeystoreClientCertificateAkamaiVersionCertificateBlockArgsDict']]
         """
-        Provides an audit record when activating on a production network with noncompliance reason as `NONE`
+        Details of the certificate block for the client certificate version.
         """
-        return pulumi.get(self, "noncompliance_reason_none")
-
-    @noncompliance_reason_none.setter
-    def noncompliance_reason_none(self, value: Optional[pulumi.Input['PropertyActivationComplianceRecordNoncomplianceReasonNoneArgs']]):
-        pulumi.set(self, "noncompliance_reason_none", value)
-
-    @_builtins.property
-    @pulumi.getter(name="noncomplianceReasonOther")
-    def noncompliance_reason_other(self) -> Optional[pulumi.Input['PropertyActivationComplianceRecordNoncomplianceReasonOtherArgs']]:
+        created_by: NotRequired[pulumi.Input[_builtins.str]]
         """
-        Provides an audit record when activating on a production network with noncompliance reason as `OTHER`
+        The user who created the client certificate version.
         """
-        return pulumi.get(self, "noncompliance_reason_other")
-
-    @noncompliance_reason_other.setter
-    def noncompliance_reason_other(self, value: Optional[pulumi.Input['PropertyActivationComplianceRecordNoncomplianceReasonOtherArgs']]):
-        pulumi.set(self, "noncompliance_reason_other", value)
-
-
-if not MYPY:
-    class PropertyActivationComplianceRecordNoncomplianceReasonEmergencyArgsDict(TypedDict):
-        ticket_id: NotRequired[pulumi.Input[_builtins.str]]
+        created_date: NotRequired[pulumi.Input[_builtins.str]]
         """
-        Identifies the ticket that describes the need for the activation
+        An ISO 8601 timestamp indicating the client certificate version's creation.
+        """
+        delete_requested_date: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        An ISO 8601 timestamp indicating the client certificate version's deletion request. Appears as null if there's no request.
+        """
+        elliptic_curve: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Specifies the key elliptic curve when key algorithm `ECDSA` is used.
+        """
+        expiry_date: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        An ISO 8601 timestamp indicating when the client certificate version expires.
+        """
+        issued_date: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        An ISO 8601 timestamp indicating the client certificate version's availability.
+        """
+        issuer: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The signing entity of the client certificate version.
+        """
+        key_algorithm: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Identifies the client certificate version's encryption algorithm. Supported values are `RSA` and `ECDSA`.
+        """
+        key_size_in_bytes: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The private key length of the client certificate version when key algorithm `RSA` is used.
+        """
+        scheduled_delete_date: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        An ISO 8601 timestamp indicating the client certificate version's deletion. Appears as null if there's no request.
+        """
+        signature_algorithm: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Specifies the algorithm that secures the data exchange between the edge server and origin.
+        """
+        status: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The client certificate version status. Possible values: `DEPLOYMENT_PENDING`, `DEPLOYED`, or `DELETE_PENDING`.
+        """
+        subject: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The public key's entity stored in the client certificate version's subject public key field.
+        """
+        version: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        The unique identifier of the client certificate version.
+        """
+        version_guid: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Unique identifier for the client certificate version. Use it to configure mutual authentication (mTLS) sessions between the origin and edge servers in Property Manager's Mutual TLS Origin Keystore behavior.
         """
 elif False:
-    PropertyActivationComplianceRecordNoncomplianceReasonEmergencyArgsDict: TypeAlias = Mapping[str, Any]
+    MtlskeystoreClientCertificateAkamaiVersionArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
-class PropertyActivationComplianceRecordNoncomplianceReasonEmergencyArgs:
+class MtlskeystoreClientCertificateAkamaiVersionArgs:
     def __init__(__self__, *,
-                 ticket_id: Optional[pulumi.Input[_builtins.str]] = None):
+                 certificate_block: Optional[pulumi.Input['MtlskeystoreClientCertificateAkamaiVersionCertificateBlockArgs']] = None,
+                 created_by: Optional[pulumi.Input[_builtins.str]] = None,
+                 created_date: Optional[pulumi.Input[_builtins.str]] = None,
+                 delete_requested_date: Optional[pulumi.Input[_builtins.str]] = None,
+                 elliptic_curve: Optional[pulumi.Input[_builtins.str]] = None,
+                 expiry_date: Optional[pulumi.Input[_builtins.str]] = None,
+                 issued_date: Optional[pulumi.Input[_builtins.str]] = None,
+                 issuer: Optional[pulumi.Input[_builtins.str]] = None,
+                 key_algorithm: Optional[pulumi.Input[_builtins.str]] = None,
+                 key_size_in_bytes: Optional[pulumi.Input[_builtins.str]] = None,
+                 scheduled_delete_date: Optional[pulumi.Input[_builtins.str]] = None,
+                 signature_algorithm: Optional[pulumi.Input[_builtins.str]] = None,
+                 status: Optional[pulumi.Input[_builtins.str]] = None,
+                 subject: Optional[pulumi.Input[_builtins.str]] = None,
+                 version: Optional[pulumi.Input[_builtins.int]] = None,
+                 version_guid: Optional[pulumi.Input[_builtins.str]] = None):
         """
-        :param pulumi.Input[_builtins.str] ticket_id: Identifies the ticket that describes the need for the activation
+        :param pulumi.Input['MtlskeystoreClientCertificateAkamaiVersionCertificateBlockArgs'] certificate_block: Details of the certificate block for the client certificate version.
+        :param pulumi.Input[_builtins.str] created_by: The user who created the client certificate version.
+        :param pulumi.Input[_builtins.str] created_date: An ISO 8601 timestamp indicating the client certificate version's creation.
+        :param pulumi.Input[_builtins.str] delete_requested_date: An ISO 8601 timestamp indicating the client certificate version's deletion request. Appears as null if there's no request.
+        :param pulumi.Input[_builtins.str] elliptic_curve: Specifies the key elliptic curve when key algorithm `ECDSA` is used.
+        :param pulumi.Input[_builtins.str] expiry_date: An ISO 8601 timestamp indicating when the client certificate version expires.
+        :param pulumi.Input[_builtins.str] issued_date: An ISO 8601 timestamp indicating the client certificate version's availability.
+        :param pulumi.Input[_builtins.str] issuer: The signing entity of the client certificate version.
+        :param pulumi.Input[_builtins.str] key_algorithm: Identifies the client certificate version's encryption algorithm. Supported values are `RSA` and `ECDSA`.
+        :param pulumi.Input[_builtins.str] key_size_in_bytes: The private key length of the client certificate version when key algorithm `RSA` is used.
+        :param pulumi.Input[_builtins.str] scheduled_delete_date: An ISO 8601 timestamp indicating the client certificate version's deletion. Appears as null if there's no request.
+        :param pulumi.Input[_builtins.str] signature_algorithm: Specifies the algorithm that secures the data exchange between the edge server and origin.
+        :param pulumi.Input[_builtins.str] status: The client certificate version status. Possible values: `DEPLOYMENT_PENDING`, `DEPLOYED`, or `DELETE_PENDING`.
+        :param pulumi.Input[_builtins.str] subject: The public key's entity stored in the client certificate version's subject public key field.
+        :param pulumi.Input[_builtins.int] version: The unique identifier of the client certificate version.
+        :param pulumi.Input[_builtins.str] version_guid: Unique identifier for the client certificate version. Use it to configure mutual authentication (mTLS) sessions between the origin and edge servers in Property Manager's Mutual TLS Origin Keystore behavior.
+        """
+        if certificate_block is not None:
+            pulumi.set(__self__, "certificate_block", certificate_block)
+        if created_by is not None:
+            pulumi.set(__self__, "created_by", created_by)
+        if created_date is not None:
+            pulumi.set(__self__, "created_date", created_date)
+        if delete_requested_date is not None:
+            pulumi.set(__self__, "delete_requested_date", delete_requested_date)
+        if elliptic_curve is not None:
+            pulumi.set(__self__, "elliptic_curve", elliptic_curve)
+        if expiry_date is not None:
+            pulumi.set(__self__, "expiry_date", expiry_date)
+        if issued_date is not None:
+            pulumi.set(__self__, "issued_date", issued_date)
+        if issuer is not None:
+            pulumi.set(__self__, "issuer", issuer)
+        if key_algorithm is not None:
+            pulumi.set(__self__, "key_algorithm", key_algorithm)
+        if key_size_in_bytes is not None:
+            pulumi.set(__self__, "key_size_in_bytes", key_size_in_bytes)
+        if scheduled_delete_date is not None:
+            pulumi.set(__self__, "scheduled_delete_date", scheduled_delete_date)
+        if signature_algorithm is not None:
+            pulumi.set(__self__, "signature_algorithm", signature_algorithm)
+        if status is not None:
+            pulumi.set(__self__, "status", status)
+        if subject is not None:
+            pulumi.set(__self__, "subject", subject)
+        if version is not None:
+            pulumi.set(__self__, "version", version)
+        if version_guid is not None:
+            pulumi.set(__self__, "version_guid", version_guid)
+
+    @_builtins.property
+    @pulumi.getter(name="certificateBlock")
+    def certificate_block(self) -> Optional[pulumi.Input['MtlskeystoreClientCertificateAkamaiVersionCertificateBlockArgs']]:
         """
-        if ticket_id is not None:
-            pulumi.set(__self__, "ticket_id", ticket_id)
+        Details of the certificate block for the client certificate version.
+        """
+        return pulumi.get(self, "certificate_block")
+
+    @certificate_block.setter
+    def certificate_block(self, value: Optional[pulumi.Input['MtlskeystoreClientCertificateAkamaiVersionCertificateBlockArgs']]):
+        pulumi.set(self, "certificate_block", value)
 
     @_builtins.property
-    @pulumi.getter(name="ticketId")
-    def ticket_id(self) -> Optional[pulumi.Input[_builtins.str]]:
+    @pulumi.getter(name="createdBy")
+    def created_by(self) -> Optional[pulumi.Input[_builtins.str]]:
         """
-        Identifies the ticket that describes the need for the activation
+        The user who created the client certificate version.
         """
-        return pulumi.get(self, "ticket_id")
+        return pulumi.get(self, "created_by")
 
-    @ticket_id.setter
-    def ticket_id(self, value: Optional[pulumi.Input[_builtins.str]]):
-        pulumi.set(self, "ticket_id", value)
+    @created_by.setter
+    def created_by(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "created_by", value)
 
+    @_builtins.property
+    @pulumi.getter(name="createdDate")
+    def created_date(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        An ISO 8601 timestamp indicating the client certificate version's creation.
+        """
+        return pulumi.get(self, "created_date")
 
-if not MYPY:
-    class PropertyActivationComplianceRecordNoncomplianceReasonNoProductionTrafficArgsDict(TypedDict):
-        ticket_id: NotRequired[pulumi.Input[_builtins.str]]
+    @created_date.setter
+    def created_date(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "created_date", value)
+
+    @_builtins.property
+    @pulumi.getter(name="deleteRequestedDate")
+    def delete_requested_date(self) -> Optional[pulumi.Input[_builtins.str]]:
         """
-        Identifies the ticket that describes the need for the activation
+        An ISO 8601 timestamp indicating the client certificate version's deletion request. Appears as null if there's no request.
         """
-elif False:
-    PropertyActivationComplianceRecordNoncomplianceReasonNoProductionTrafficArgsDict: TypeAlias = Mapping[str, Any]
+        return pulumi.get(self, "delete_requested_date")
 
-@pulumi.input_type
-class PropertyActivationComplianceRecordNoncomplianceReasonNoProductionTrafficArgs:
-    def __init__(__self__, *,
-                 ticket_id: Optional[pulumi.Input[_builtins.str]] = None):
+    @delete_requested_date.setter
+    def delete_requested_date(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "delete_requested_date", value)
+
+    @_builtins.property
+    @pulumi.getter(name="ellipticCurve")
+    def elliptic_curve(self) -> Optional[pulumi.Input[_builtins.str]]:
         """
-        :param pulumi.Input[_builtins.str] ticket_id: Identifies the ticket that describes the need for the activation
+        Specifies the key elliptic curve when key algorithm `ECDSA` is used.
         """
-        if ticket_id is not None:
-            pulumi.set(__self__, "ticket_id", ticket_id)
+        return pulumi.get(self, "elliptic_curve")
+
+    @elliptic_curve.setter
+    def elliptic_curve(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "elliptic_curve", value)
 
     @_builtins.property
-    @pulumi.getter(name="ticketId")
-    def ticket_id(self) -> Optional[pulumi.Input[_builtins.str]]:
+    @pulumi.getter(name="expiryDate")
+    def expiry_date(self) -> Optional[pulumi.Input[_builtins.str]]:
         """
-        Identifies the ticket that describes the need for the activation
+        An ISO 8601 timestamp indicating when the client certificate version expires.
         """
-        return pulumi.get(self, "ticket_id")
+        return pulumi.get(self, "expiry_date")
 
-    @ticket_id.setter
-    def ticket_id(self, value: Optional[pulumi.Input[_builtins.str]]):
-        pulumi.set(self, "ticket_id", value)
+    @expiry_date.setter
+    def expiry_date(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "expiry_date", value)
+
+    @_builtins.property
+    @pulumi.getter(name="issuedDate")
+    def issued_date(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        An ISO 8601 timestamp indicating the client certificate version's availability.
+        """
+        return pulumi.get(self, "issued_date")
 
+    @issued_date.setter
+    def issued_date(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "issued_date", value)
 
-if not MYPY:
-    class PropertyActivationComplianceRecordNoncomplianceReasonNoneArgsDict(TypedDict):
-        customer_email: NotRequired[pulumi.Input[_builtins.str]]
+    @_builtins.property
+    @pulumi.getter
+    def issuer(self) -> Optional[pulumi.Input[_builtins.str]]:
         """
-        Identifies the customer
+        The signing entity of the client certificate version.
         """
-        peer_reviewed_by: NotRequired[pulumi.Input[_builtins.str]]
+        return pulumi.get(self, "issuer")
+
+    @issuer.setter
+    def issuer(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "issuer", value)
+
+    @_builtins.property
+    @pulumi.getter(name="keyAlgorithm")
+    def key_algorithm(self) -> Optional[pulumi.Input[_builtins.str]]:
         """
-        Identifies person who has independently approved the activation request
+        Identifies the client certificate version's encryption algorithm. Supported values are `RSA` and `ECDSA`.
         """
-        ticket_id: NotRequired[pulumi.Input[_builtins.str]]
+        return pulumi.get(self, "key_algorithm")
+
+    @key_algorithm.setter
+    def key_algorithm(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "key_algorithm", value)
+
+    @_builtins.property
+    @pulumi.getter(name="keySizeInBytes")
+    def key_size_in_bytes(self) -> Optional[pulumi.Input[_builtins.str]]:
         """
-        Identifies the ticket that describes the need for the activation
+        The private key length of the client certificate version when key algorithm `RSA` is used.
         """
-        unit_tested: NotRequired[pulumi.Input[_builtins.bool]]
+        return pulumi.get(self, "key_size_in_bytes")
+
+    @key_size_in_bytes.setter
+    def key_size_in_bytes(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "key_size_in_bytes", value)
+
+    @_builtins.property
+    @pulumi.getter(name="scheduledDeleteDate")
+    def scheduled_delete_date(self) -> Optional[pulumi.Input[_builtins.str]]:
         """
-        Whether the metadata to activate has been fully tested
+        An ISO 8601 timestamp indicating the client certificate version's deletion. Appears as null if there's no request.
         """
-elif False:
-    PropertyActivationComplianceRecordNoncomplianceReasonNoneArgsDict: TypeAlias = Mapping[str, Any]
+        return pulumi.get(self, "scheduled_delete_date")
 
-@pulumi.input_type
-class PropertyActivationComplianceRecordNoncomplianceReasonNoneArgs:
-    def __init__(__self__, *,
-                 customer_email: Optional[pulumi.Input[_builtins.str]] = None,
-                 peer_reviewed_by: Optional[pulumi.Input[_builtins.str]] = None,
-                 ticket_id: Optional[pulumi.Input[_builtins.str]] = None,
-                 unit_tested: Optional[pulumi.Input[_builtins.bool]] = None):
+    @scheduled_delete_date.setter
+    def scheduled_delete_date(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "scheduled_delete_date", value)
+
+    @_builtins.property
+    @pulumi.getter(name="signatureAlgorithm")
+    def signature_algorithm(self) -> Optional[pulumi.Input[_builtins.str]]:
         """
-        :param pulumi.Input[_builtins.str] customer_email: Identifies the customer
-        :param pulumi.Input[_builtins.str] peer_reviewed_by: Identifies person who has independently approved the activation request
-        :param pulumi.Input[_builtins.str] ticket_id: Identifies the ticket that describes the need for the activation
-        :param pulumi.Input[_builtins.bool] unit_tested: Whether the metadata to activate has been fully tested
+        Specifies the algorithm that secures the data exchange between the edge server and origin.
         """
-        if customer_email is not None:
-            pulumi.set(__self__, "customer_email", customer_email)
-        if peer_reviewed_by is not None:
-            pulumi.set(__self__, "peer_reviewed_by", peer_reviewed_by)
-        if ticket_id is not None:
-            pulumi.set(__self__, "ticket_id", ticket_id)
-        if unit_tested is not None:
-            pulumi.set(__self__, "unit_tested", unit_tested)
+        return pulumi.get(self, "signature_algorithm")
+
+    @signature_algorithm.setter
+    def signature_algorithm(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "signature_algorithm", value)
 
     @_builtins.property
-    @pulumi.getter(name="customerEmail")
-    def customer_email(self) -> Optional[pulumi.Input[_builtins.str]]:
+    @pulumi.getter
+    def status(self) -> Optional[pulumi.Input[_builtins.str]]:
         """
-        Identifies the customer
+        The client certificate version status. Possible values: `DEPLOYMENT_PENDING`, `DEPLOYED`, or `DELETE_PENDING`.
         """
-        return pulumi.get(self, "customer_email")
+        return pulumi.get(self, "status")
 
-    @customer_email.setter
-    def customer_email(self, value: Optional[pulumi.Input[_builtins.str]]):
-        pulumi.set(self, "customer_email", value)
+    @status.setter
+    def status(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "status", value)
 
     @_builtins.property
-    @pulumi.getter(name="peerReviewedBy")
-    def peer_reviewed_by(self) -> Optional[pulumi.Input[_builtins.str]]:
+    @pulumi.getter
+    def subject(self) -> Optional[pulumi.Input[_builtins.str]]:
         """
-        Identifies person who has independently approved the activation request
+        The public key's entity stored in the client certificate version's subject public key field.
         """
-        return pulumi.get(self, "peer_reviewed_by")
+        return pulumi.get(self, "subject")
 
-    @peer_reviewed_by.setter
-    def peer_reviewed_by(self, value: Optional[pulumi.Input[_builtins.str]]):
-        pulumi.set(self, "peer_reviewed_by", value)
+    @subject.setter
+    def subject(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "subject", value)
 
     @_builtins.property
-    @pulumi.getter(name="ticketId")
-    def ticket_id(self) -> Optional[pulumi.Input[_builtins.str]]:
+    @pulumi.getter
+    def version(self) -> Optional[pulumi.Input[_builtins.int]]:
         """
-        Identifies the ticket that describes the need for the activation
+        The unique identifier of the client certificate version.
         """
-        return pulumi.get(self, "ticket_id")
+        return pulumi.get(self, "version")
 
-    @ticket_id.setter
-    def ticket_id(self, value: Optional[pulumi.Input[_builtins.str]]):
-        pulumi.set(self, "ticket_id", value)
+    @version.setter
+    def version(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "version", value)
 
     @_builtins.property
-    @pulumi.getter(name="unitTested")
-    def unit_tested(self) -> Optional[pulumi.Input[_builtins.bool]]:
+    @pulumi.getter(name="versionGuid")
+    def version_guid(self) -> Optional[pulumi.Input[_builtins.str]]:
         """
-        Whether the metadata to activate has been fully tested
+        Unique identifier for the client certificate version. Use it to configure mutual authentication (mTLS) sessions between the origin and edge servers in Property Manager's Mutual TLS Origin Keystore behavior.
         """
-        return pulumi.get(self, "unit_tested")
+        return pulumi.get(self, "version_guid")
 
-    @unit_tested.setter
-    def unit_tested(self, value: Optional[pulumi.Input[_builtins.bool]]):
-        pulumi.set(self, "unit_tested", value)
+    @version_guid.setter
+    def version_guid(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "version_guid", value)
 
 
 if not MYPY:
-    class PropertyActivationComplianceRecordNoncomplianceReasonOtherArgsDict(TypedDict):
-        other_noncompliance_reason: NotRequired[pulumi.Input[_builtins.str]]
+    class MtlskeystoreClientCertificateAkamaiVersionCertificateBlockArgsDict(TypedDict):
+        certificate: NotRequired[pulumi.Input[_builtins.str]]
         """
-        Describes the reason why the activation must occur immediately, out of compliance with the standard procedure
+        A text representation of the client certificate in PEM format.
         """
-        ticket_id: NotRequired[pulumi.Input[_builtins.str]]
+        trust_chain: NotRequired[pulumi.Input[_builtins.str]]
         """
-        Identifies the ticket that describes the need for the activation
+        A text representation of the trust chain in PEM format.
         """
 elif False:
-    PropertyActivationComplianceRecordNoncomplianceReasonOtherArgsDict: TypeAlias = Mapping[str, Any]
+    MtlskeystoreClientCertificateAkamaiVersionCertificateBlockArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
-class PropertyActivationComplianceRecordNoncomplianceReasonOtherArgs:
+class MtlskeystoreClientCertificateAkamaiVersionCertificateBlockArgs:
     def __init__(__self__, *,
-                 other_noncompliance_reason: Optional[pulumi.Input[_builtins.str]] = None,
-                 ticket_id: Optional[pulumi.Input[_builtins.str]] = None):
+                 certificate: Optional[pulumi.Input[_builtins.str]] = None,
+                 trust_chain: Optional[pulumi.Input[_builtins.str]] = None):
         """
-        :param pulumi.Input[_builtins.str] other_noncompliance_reason: Describes the reason why the activation must occur immediately, out of compliance with the standard procedure
-        :param pulumi.Input[_builtins.str] ticket_id: Identifies the ticket that describes the need for the activation
+        :param pulumi.Input[_builtins.str] certificate: A text representation of the client certificate in PEM format.
+        :param pulumi.Input[_builtins.str] trust_chain: A text representation of the trust chain in PEM format.
         """
-        if other_noncompliance_reason is not None:
-            pulumi.set(__self__, "other_noncompliance_reason", other_noncompliance_reason)
-        if ticket_id is not None:
-            pulumi.set(__self__, "ticket_id", ticket_id)
+        if certificate is not None:
+            pulumi.set(__self__, "certificate", certificate)
+        if trust_chain is not None:
+            pulumi.set(__self__, "trust_chain", trust_chain)
 
     @_builtins.property
-    @pulumi.getter(name="otherNoncomplianceReason")
-    def other_noncompliance_reason(self) -> Optional[pulumi.Input[_builtins.str]]:
+    @pulumi.getter
+    def certificate(self) -> Optional[pulumi.Input[_builtins.str]]:
         """
-        Describes the reason why the activation must occur immediately, out of compliance with the standard procedure
+        A text representation of the client certificate in PEM format.
         """
-        return pulumi.get(self, "other_noncompliance_reason")
+        return pulumi.get(self, "certificate")
 
-    @other_noncompliance_reason.setter
-    def other_noncompliance_reason(self, value: Optional[pulumi.Input[_builtins.str]]):
-        pulumi.set(self, "other_noncompliance_reason", value)
+    @certificate.setter
+    def certificate(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "certificate", value)
 
     @_builtins.property
-    @pulumi.getter(name="ticketId")
-    def ticket_id(self) -> Optional[pulumi.Input[_builtins.str]]:
+    @pulumi.getter(name="trustChain")
+    def trust_chain(self) -> Optional[pulumi.Input[_builtins.str]]:
         """
-        Identifies the ticket that describes the need for the activation
+        A text representation of the trust chain in PEM format.
         """
-        return pulumi.get(self, "ticket_id")
+        return pulumi.get(self, "trust_chain")
 
-    @ticket_id.setter
-    def ticket_id(self, value: Optional[pulumi.Input[_builtins.str]]):
-        pulumi.set(self, "ticket_id", value)
+    @trust_chain.setter
+    def trust_chain(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "trust_chain", value)
 
 
 if not MYPY:
-    class PropertyActivationRuleErrorArgsDict(TypedDict):
-        behavior_name: NotRequired[pulumi.Input[_builtins.str]]
-        detail: NotRequired[pulumi.Input[_builtins.str]]
-        error_location: NotRequired[pulumi.Input[_builtins.str]]
-        instance: NotRequired[pulumi.Input[_builtins.str]]
-        status_code: NotRequired[pulumi.Input[_builtins.int]]
-        title: NotRequired[pulumi.Input[_builtins.str]]
-        type: NotRequired[pulumi.Input[_builtins.str]]
-elif False:
-    PropertyActivationRuleErrorArgsDict: TypeAlias = Mapping[str, Any]
-
-@pulumi.input_type
-class PropertyActivationRuleErrorArgs:
-    def __init__(__self__, *,
-                 behavior_name: Optional[pulumi.Input[_builtins.str]] = None,
-                 detail: Optional[pulumi.Input[_builtins.str]] = None,
-                 error_location: Optional[pulumi.Input[_builtins.str]] = None,
-                 instance: Optional[pulumi.Input[_builtins.str]] = None,
-                 status_code: Optional[pulumi.Input[_builtins.int]] = None,
-                 title: Optional[pulumi.Input[_builtins.str]] = None,
-                 type: Optional[pulumi.Input[_builtins.str]] = None):
+    class MtlskeystoreClientCertificateThirdPartyVersionsArgsDict(TypedDict):
+        certificate_block: NotRequired[pulumi.Input['MtlskeystoreClientCertificateThirdPartyVersionsCertificateBlockArgsDict']]
+        """
+        Details of the certificate block for the client certificate version.
+        """
+        certificate_submitted_by: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The user who uploaded the THIRD_PARTY client certificate version. Appears as null if not specified.
+        """
+        certificate_submitted_date: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        An ISO 8601 timestamp indicating when the THIRD_PARTY signer client certificate version was uploaded. Appears as null if not specified.
+        """
+        created_by: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The user who created the client certificate version.
+        """
+        created_date: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        An ISO 8601 timestamp indicating the client certificate version's creation.
+        """
+        csr_block: NotRequired[pulumi.Input['MtlskeystoreClientCertificateThirdPartyVersionsCsrBlockArgsDict']]
+        """
+        Details of the Certificate Signing Request (CSR) for the client certificate version.
+        """
+        delete_requested_date: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        An ISO 8601 timestamp indicating the client certificate version's deletion request. Appears as null if there's no request.
+        """
+        elliptic_curve: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Specifies the key elliptic curve when key algorithm `ECDSA` is used.
+        """
+        expiry_date: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        An ISO 8601 timestamp indicating when the client certificate version expires.
+        """
+        issued_date: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        An ISO 8601 timestamp indicating the client certificate version's availability.
+        """
+        issuer: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The signing entity of the client certificate version.
+        """
+        key_algorithm: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Identifies the client certificate version's encryption algorithm. Supported values are `RSA` and `ECDSA`.
+        """
+        key_size_in_bytes: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The private key length of the client certificate version when key algorithm `RSA` is used.
+        """
+        scheduled_delete_date: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        An ISO 8601 timestamp indicating the client certificate version's deletion. Appears as null if there's no request.
+        """
+        signature_algorithm: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Specifies the algorithm that secures the data exchange between the edge server and origin.
+        """
+        status: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The client certificate version status. Possible values: `AWAITING_SIGNED_CERTIFICATE`, `DEPLOYMENT_PENDING`, `DEPLOYED`, or `DELETE_PENDING`.
+        """
+        subject: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The public key's entity stored in the client certificate version's subject public key field.
+        """
+        version: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        The unique identifier of the client certificate version.
+        """
+        version_guid: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Unique identifier for the client certificate version. Use it to configure mutual authentication (mTLS) sessions between the origin and edge servers in Property Manager's Mutual TLS Origin Keystore behavior.
+        """
+elif False:
+    MtlskeystoreClientCertificateThirdPartyVersionsArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class MtlskeystoreClientCertificateThirdPartyVersionsArgs:
+    def __init__(__self__, *,
+                 certificate_block: Optional[pulumi.Input['MtlskeystoreClientCertificateThirdPartyVersionsCertificateBlockArgs']] = None,
+                 certificate_submitted_by: Optional[pulumi.Input[_builtins.str]] = None,
+                 certificate_submitted_date: Optional[pulumi.Input[_builtins.str]] = None,
+                 created_by: Optional[pulumi.Input[_builtins.str]] = None,
+                 created_date: Optional[pulumi.Input[_builtins.str]] = None,
+                 csr_block: Optional[pulumi.Input['MtlskeystoreClientCertificateThirdPartyVersionsCsrBlockArgs']] = None,
+                 delete_requested_date: Optional[pulumi.Input[_builtins.str]] = None,
+                 elliptic_curve: Optional[pulumi.Input[_builtins.str]] = None,
+                 expiry_date: Optional[pulumi.Input[_builtins.str]] = None,
+                 issued_date: Optional[pulumi.Input[_builtins.str]] = None,
+                 issuer: Optional[pulumi.Input[_builtins.str]] = None,
+                 key_algorithm: Optional[pulumi.Input[_builtins.str]] = None,
+                 key_size_in_bytes: Optional[pulumi.Input[_builtins.str]] = None,
+                 scheduled_delete_date: Optional[pulumi.Input[_builtins.str]] = None,
+                 signature_algorithm: Optional[pulumi.Input[_builtins.str]] = None,
+                 status: Optional[pulumi.Input[_builtins.str]] = None,
+                 subject: Optional[pulumi.Input[_builtins.str]] = None,
+                 version: Optional[pulumi.Input[_builtins.int]] = None,
+                 version_guid: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input['MtlskeystoreClientCertificateThirdPartyVersionsCertificateBlockArgs'] certificate_block: Details of the certificate block for the client certificate version.
+        :param pulumi.Input[_builtins.str] certificate_submitted_by: The user who uploaded the THIRD_PARTY client certificate version. Appears as null if not specified.
+        :param pulumi.Input[_builtins.str] certificate_submitted_date: An ISO 8601 timestamp indicating when the THIRD_PARTY signer client certificate version was uploaded. Appears as null if not specified.
+        :param pulumi.Input[_builtins.str] created_by: The user who created the client certificate version.
+        :param pulumi.Input[_builtins.str] created_date: An ISO 8601 timestamp indicating the client certificate version's creation.
+        :param pulumi.Input['MtlskeystoreClientCertificateThirdPartyVersionsCsrBlockArgs'] csr_block: Details of the Certificate Signing Request (CSR) for the client certificate version.
+        :param pulumi.Input[_builtins.str] delete_requested_date: An ISO 8601 timestamp indicating the client certificate version's deletion request. Appears as null if there's no request.
+        :param pulumi.Input[_builtins.str] elliptic_curve: Specifies the key elliptic curve when key algorithm `ECDSA` is used.
+        :param pulumi.Input[_builtins.str] expiry_date: An ISO 8601 timestamp indicating when the client certificate version expires.
+        :param pulumi.Input[_builtins.str] issued_date: An ISO 8601 timestamp indicating the client certificate version's availability.
+        :param pulumi.Input[_builtins.str] issuer: The signing entity of the client certificate version.
+        :param pulumi.Input[_builtins.str] key_algorithm: Identifies the client certificate version's encryption algorithm. Supported values are `RSA` and `ECDSA`.
+        :param pulumi.Input[_builtins.str] key_size_in_bytes: The private key length of the client certificate version when key algorithm `RSA` is used.
+        :param pulumi.Input[_builtins.str] scheduled_delete_date: An ISO 8601 timestamp indicating the client certificate version's deletion. Appears as null if there's no request.
+        :param pulumi.Input[_builtins.str] signature_algorithm: Specifies the algorithm that secures the data exchange between the edge server and origin.
+        :param pulumi.Input[_builtins.str] status: The client certificate version status. Possible values: `AWAITING_SIGNED_CERTIFICATE`, `DEPLOYMENT_PENDING`, `DEPLOYED`, or `DELETE_PENDING`.
+        :param pulumi.Input[_builtins.str] subject: The public key's entity stored in the client certificate version's subject public key field.
+        :param pulumi.Input[_builtins.int] version: The unique identifier of the client certificate version.
+        :param pulumi.Input[_builtins.str] version_guid: Unique identifier for the client certificate version. Use it to configure mutual authentication (mTLS) sessions between the origin and edge servers in Property Manager's Mutual TLS Origin Keystore behavior.
+        """
+        if certificate_block is not None:
+            pulumi.set(__self__, "certificate_block", certificate_block)
+        if certificate_submitted_by is not None:
+            pulumi.set(__self__, "certificate_submitted_by", certificate_submitted_by)
+        if certificate_submitted_date is not None:
+            pulumi.set(__self__, "certificate_submitted_date", certificate_submitted_date)
+        if created_by is not None:
+            pulumi.set(__self__, "created_by", created_by)
+        if created_date is not None:
+            pulumi.set(__self__, "created_date", created_date)
+        if csr_block is not None:
+            pulumi.set(__self__, "csr_block", csr_block)
+        if delete_requested_date is not None:
+            pulumi.set(__self__, "delete_requested_date", delete_requested_date)
+        if elliptic_curve is not None:
+            pulumi.set(__self__, "elliptic_curve", elliptic_curve)
+        if expiry_date is not None:
+            pulumi.set(__self__, "expiry_date", expiry_date)
+        if issued_date is not None:
+            pulumi.set(__self__, "issued_date", issued_date)
+        if issuer is not None:
+            pulumi.set(__self__, "issuer", issuer)
+        if key_algorithm is not None:
+            pulumi.set(__self__, "key_algorithm", key_algorithm)
+        if key_size_in_bytes is not None:
+            pulumi.set(__self__, "key_size_in_bytes", key_size_in_bytes)
+        if scheduled_delete_date is not None:
+            pulumi.set(__self__, "scheduled_delete_date", scheduled_delete_date)
+        if signature_algorithm is not None:
+            pulumi.set(__self__, "signature_algorithm", signature_algorithm)
+        if status is not None:
+            pulumi.set(__self__, "status", status)
+        if subject is not None:
+            pulumi.set(__self__, "subject", subject)
+        if version is not None:
+            pulumi.set(__self__, "version", version)
+        if version_guid is not None:
+            pulumi.set(__self__, "version_guid", version_guid)
+
+    @_builtins.property
+    @pulumi.getter(name="certificateBlock")
+    def certificate_block(self) -> Optional[pulumi.Input['MtlskeystoreClientCertificateThirdPartyVersionsCertificateBlockArgs']]:
+        """
+        Details of the certificate block for the client certificate version.
+        """
+        return pulumi.get(self, "certificate_block")
+
+    @certificate_block.setter
+    def certificate_block(self, value: Optional[pulumi.Input['MtlskeystoreClientCertificateThirdPartyVersionsCertificateBlockArgs']]):
+        pulumi.set(self, "certificate_block", value)
+
+    @_builtins.property
+    @pulumi.getter(name="certificateSubmittedBy")
+    def certificate_submitted_by(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The user who uploaded the THIRD_PARTY client certificate version. Appears as null if not specified.
+        """
+        return pulumi.get(self, "certificate_submitted_by")
+
+    @certificate_submitted_by.setter
+    def certificate_submitted_by(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "certificate_submitted_by", value)
+
+    @_builtins.property
+    @pulumi.getter(name="certificateSubmittedDate")
+    def certificate_submitted_date(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        An ISO 8601 timestamp indicating when the THIRD_PARTY signer client certificate version was uploaded. Appears as null if not specified.
+        """
+        return pulumi.get(self, "certificate_submitted_date")
+
+    @certificate_submitted_date.setter
+    def certificate_submitted_date(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "certificate_submitted_date", value)
+
+    @_builtins.property
+    @pulumi.getter(name="createdBy")
+    def created_by(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The user who created the client certificate version.
+        """
+        return pulumi.get(self, "created_by")
+
+    @created_by.setter
+    def created_by(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "created_by", value)
+
+    @_builtins.property
+    @pulumi.getter(name="createdDate")
+    def created_date(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        An ISO 8601 timestamp indicating the client certificate version's creation.
+        """
+        return pulumi.get(self, "created_date")
+
+    @created_date.setter
+    def created_date(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "created_date", value)
+
+    @_builtins.property
+    @pulumi.getter(name="csrBlock")
+    def csr_block(self) -> Optional[pulumi.Input['MtlskeystoreClientCertificateThirdPartyVersionsCsrBlockArgs']]:
+        """
+        Details of the Certificate Signing Request (CSR) for the client certificate version.
+        """
+        return pulumi.get(self, "csr_block")
+
+    @csr_block.setter
+    def csr_block(self, value: Optional[pulumi.Input['MtlskeystoreClientCertificateThirdPartyVersionsCsrBlockArgs']]):
+        pulumi.set(self, "csr_block", value)
+
+    @_builtins.property
+    @pulumi.getter(name="deleteRequestedDate")
+    def delete_requested_date(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        An ISO 8601 timestamp indicating the client certificate version's deletion request. Appears as null if there's no request.
+        """
+        return pulumi.get(self, "delete_requested_date")
+
+    @delete_requested_date.setter
+    def delete_requested_date(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "delete_requested_date", value)
+
+    @_builtins.property
+    @pulumi.getter(name="ellipticCurve")
+    def elliptic_curve(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Specifies the key elliptic curve when key algorithm `ECDSA` is used.
+        """
+        return pulumi.get(self, "elliptic_curve")
+
+    @elliptic_curve.setter
+    def elliptic_curve(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "elliptic_curve", value)
+
+    @_builtins.property
+    @pulumi.getter(name="expiryDate")
+    def expiry_date(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        An ISO 8601 timestamp indicating when the client certificate version expires.
+        """
+        return pulumi.get(self, "expiry_date")
+
+    @expiry_date.setter
+    def expiry_date(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "expiry_date", value)
+
+    @_builtins.property
+    @pulumi.getter(name="issuedDate")
+    def issued_date(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        An ISO 8601 timestamp indicating the client certificate version's availability.
+        """
+        return pulumi.get(self, "issued_date")
+
+    @issued_date.setter
+    def issued_date(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "issued_date", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def issuer(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The signing entity of the client certificate version.
+        """
+        return pulumi.get(self, "issuer")
+
+    @issuer.setter
+    def issuer(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "issuer", value)
+
+    @_builtins.property
+    @pulumi.getter(name="keyAlgorithm")
+    def key_algorithm(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Identifies the client certificate version's encryption algorithm. Supported values are `RSA` and `ECDSA`.
+        """
+        return pulumi.get(self, "key_algorithm")
+
+    @key_algorithm.setter
+    def key_algorithm(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "key_algorithm", value)
+
+    @_builtins.property
+    @pulumi.getter(name="keySizeInBytes")
+    def key_size_in_bytes(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The private key length of the client certificate version when key algorithm `RSA` is used.
+        """
+        return pulumi.get(self, "key_size_in_bytes")
+
+    @key_size_in_bytes.setter
+    def key_size_in_bytes(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "key_size_in_bytes", value)
+
+    @_builtins.property
+    @pulumi.getter(name="scheduledDeleteDate")
+    def scheduled_delete_date(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        An ISO 8601 timestamp indicating the client certificate version's deletion. Appears as null if there's no request.
+        """
+        return pulumi.get(self, "scheduled_delete_date")
+
+    @scheduled_delete_date.setter
+    def scheduled_delete_date(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "scheduled_delete_date", value)
+
+    @_builtins.property
+    @pulumi.getter(name="signatureAlgorithm")
+    def signature_algorithm(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Specifies the algorithm that secures the data exchange between the edge server and origin.
+        """
+        return pulumi.get(self, "signature_algorithm")
+
+    @signature_algorithm.setter
+    def signature_algorithm(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "signature_algorithm", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def status(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The client certificate version status. Possible values: `AWAITING_SIGNED_CERTIFICATE`, `DEPLOYMENT_PENDING`, `DEPLOYED`, or `DELETE_PENDING`.
+        """
+        return pulumi.get(self, "status")
+
+    @status.setter
+    def status(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "status", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def subject(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The public key's entity stored in the client certificate version's subject public key field.
+        """
+        return pulumi.get(self, "subject")
+
+    @subject.setter
+    def subject(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "subject", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def version(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The unique identifier of the client certificate version.
+        """
+        return pulumi.get(self, "version")
+
+    @version.setter
+    def version(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "version", value)
+
+    @_builtins.property
+    @pulumi.getter(name="versionGuid")
+    def version_guid(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Unique identifier for the client certificate version. Use it to configure mutual authentication (mTLS) sessions between the origin and edge servers in Property Manager's Mutual TLS Origin Keystore behavior.
+        """
+        return pulumi.get(self, "version_guid")
+
+    @version_guid.setter
+    def version_guid(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "version_guid", value)
+
+
+if not MYPY:
+    class MtlskeystoreClientCertificateThirdPartyVersionsCertificateBlockArgsDict(TypedDict):
+        certificate: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        A text representation of the client certificate in PEM format.
+        """
+        trust_chain: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        A text representation of the trust chain in PEM format.
+        """
+elif False:
+    MtlskeystoreClientCertificateThirdPartyVersionsCertificateBlockArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class MtlskeystoreClientCertificateThirdPartyVersionsCertificateBlockArgs:
+    def __init__(__self__, *,
+                 certificate: Optional[pulumi.Input[_builtins.str]] = None,
+                 trust_chain: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_builtins.str] certificate: A text representation of the client certificate in PEM format.
+        :param pulumi.Input[_builtins.str] trust_chain: A text representation of the trust chain in PEM format.
+        """
+        if certificate is not None:
+            pulumi.set(__self__, "certificate", certificate)
+        if trust_chain is not None:
+            pulumi.set(__self__, "trust_chain", trust_chain)
+
+    @_builtins.property
+    @pulumi.getter
+    def certificate(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        A text representation of the client certificate in PEM format.
+        """
+        return pulumi.get(self, "certificate")
+
+    @certificate.setter
+    def certificate(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "certificate", value)
+
+    @_builtins.property
+    @pulumi.getter(name="trustChain")
+    def trust_chain(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        A text representation of the trust chain in PEM format.
+        """
+        return pulumi.get(self, "trust_chain")
+
+    @trust_chain.setter
+    def trust_chain(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "trust_chain", value)
+
+
+if not MYPY:
+    class MtlskeystoreClientCertificateThirdPartyVersionsCsrBlockArgsDict(TypedDict):
+        csr: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Text of the certificate signing request.
+        """
+        key_algorithm: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Identifies the client certificate's encryption algorithm.
+        """
+elif False:
+    MtlskeystoreClientCertificateThirdPartyVersionsCsrBlockArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class MtlskeystoreClientCertificateThirdPartyVersionsCsrBlockArgs:
+    def __init__(__self__, *,
+                 csr: Optional[pulumi.Input[_builtins.str]] = None,
+                 key_algorithm: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_builtins.str] csr: Text of the certificate signing request.
+        :param pulumi.Input[_builtins.str] key_algorithm: Identifies the client certificate's encryption algorithm.
+        """
+        if csr is not None:
+            pulumi.set(__self__, "csr", csr)
+        if key_algorithm is not None:
+            pulumi.set(__self__, "key_algorithm", key_algorithm)
+
+    @_builtins.property
+    @pulumi.getter
+    def csr(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Text of the certificate signing request.
+        """
+        return pulumi.get(self, "csr")
+
+    @csr.setter
+    def csr(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "csr", value)
+
+    @_builtins.property
+    @pulumi.getter(name="keyAlgorithm")
+    def key_algorithm(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Identifies the client certificate's encryption algorithm.
+        """
+        return pulumi.get(self, "key_algorithm")
+
+    @key_algorithm.setter
+    def key_algorithm(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "key_algorithm", value)
+
+
+if not MYPY:
+    class MtlskeystoreClientCertificateUploadTimeoutsArgsDict(TypedDict):
+        create: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Optional configurable resource create timeout. By default it's 30m.
+        """
+        update: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Optional configurable resource update timeout. By default it's 30m.
+        """
+elif False:
+    MtlskeystoreClientCertificateUploadTimeoutsArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class MtlskeystoreClientCertificateUploadTimeoutsArgs:
+    def __init__(__self__, *,
+                 create: Optional[pulumi.Input[_builtins.str]] = None,
+                 update: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_builtins.str] create: Optional configurable resource create timeout. By default it's 30m.
+        :param pulumi.Input[_builtins.str] update: Optional configurable resource update timeout. By default it's 30m.
+        """
+        if create is not None:
+            pulumi.set(__self__, "create", create)
+        if update is not None:
+            pulumi.set(__self__, "update", update)
+
+    @_builtins.property
+    @pulumi.getter
+    def create(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Optional configurable resource create timeout. By default it's 30m.
+        """
+        return pulumi.get(self, "create")
+
+    @create.setter
+    def create(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "create", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def update(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Optional configurable resource update timeout. By default it's 30m.
+        """
+        return pulumi.get(self, "update")
+
+    @update.setter
+    def update(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "update", value)
+
+
+if not MYPY:
+    class MtlstruststoreCaSetActivationTimeoutsArgsDict(TypedDict):
+        create: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Optional configurable resource create timeout. By default it's 1h.
+        """
+        delete: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Optional configurable resource delete timeout. By default it's 1h.
+        """
+        update: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Optional configurable resource update timeout. By default it's 1h.
+        """
+elif False:
+    MtlstruststoreCaSetActivationTimeoutsArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class MtlstruststoreCaSetActivationTimeoutsArgs:
+    def __init__(__self__, *,
+                 create: Optional[pulumi.Input[_builtins.str]] = None,
+                 delete: Optional[pulumi.Input[_builtins.str]] = None,
+                 update: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_builtins.str] create: Optional configurable resource create timeout. By default it's 1h.
+        :param pulumi.Input[_builtins.str] delete: Optional configurable resource delete timeout. By default it's 1h.
+        :param pulumi.Input[_builtins.str] update: Optional configurable resource update timeout. By default it's 1h.
+        """
+        if create is not None:
+            pulumi.set(__self__, "create", create)
+        if delete is not None:
+            pulumi.set(__self__, "delete", delete)
+        if update is not None:
+            pulumi.set(__self__, "update", update)
+
+    @_builtins.property
+    @pulumi.getter
+    def create(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Optional configurable resource create timeout. By default it's 1h.
+        """
+        return pulumi.get(self, "create")
+
+    @create.setter
+    def create(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "create", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def delete(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Optional configurable resource delete timeout. By default it's 1h.
+        """
+        return pulumi.get(self, "delete")
+
+    @delete.setter
+    def delete(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "delete", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def update(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Optional configurable resource update timeout. By default it's 1h.
+        """
+        return pulumi.get(self, "update")
+
+    @update.setter
+    def update(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "update", value)
+
+
+if not MYPY:
+    class MtlstruststoreCaSetCertificateArgsDict(TypedDict):
+        certificate_pem: pulumi.Input[_builtins.str]
+        """
+        The certificate in PEM format, as found in a Base64 ASCII encoded file.
+        """
+        created_by: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The user who created this CA certificate.
+        """
+        created_date: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        When the CA certificate was created.
+        """
+        description: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Optional description for the certificate.
+        """
+        end_date: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The certificate's ISO 8601 formatted expiration date.
+        """
+        fingerprint: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The fingerprint of the certificate.
+        """
+        issuer: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The certificate's issuer.
+        """
+        serial_number: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The unique serial number of the certificate.
+        """
+        signature_algorithm: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The signature algorithm of the CA certificate.
+        """
+        start_date: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The start date of the certificate.
+        """
+        subject: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The certificate's subject field.
+        """
+elif False:
+    MtlstruststoreCaSetCertificateArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class MtlstruststoreCaSetCertificateArgs:
+    def __init__(__self__, *,
+                 certificate_pem: pulumi.Input[_builtins.str],
+                 created_by: Optional[pulumi.Input[_builtins.str]] = None,
+                 created_date: Optional[pulumi.Input[_builtins.str]] = None,
+                 description: Optional[pulumi.Input[_builtins.str]] = None,
+                 end_date: Optional[pulumi.Input[_builtins.str]] = None,
+                 fingerprint: Optional[pulumi.Input[_builtins.str]] = None,
+                 issuer: Optional[pulumi.Input[_builtins.str]] = None,
+                 serial_number: Optional[pulumi.Input[_builtins.str]] = None,
+                 signature_algorithm: Optional[pulumi.Input[_builtins.str]] = None,
+                 start_date: Optional[pulumi.Input[_builtins.str]] = None,
+                 subject: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_builtins.str] certificate_pem: The certificate in PEM format, as found in a Base64 ASCII encoded file.
+        :param pulumi.Input[_builtins.str] created_by: The user who created this CA certificate.
+        :param pulumi.Input[_builtins.str] created_date: When the CA certificate was created.
+        :param pulumi.Input[_builtins.str] description: Optional description for the certificate.
+        :param pulumi.Input[_builtins.str] end_date: The certificate's ISO 8601 formatted expiration date.
+        :param pulumi.Input[_builtins.str] fingerprint: The fingerprint of the certificate.
+        :param pulumi.Input[_builtins.str] issuer: The certificate's issuer.
+        :param pulumi.Input[_builtins.str] serial_number: The unique serial number of the certificate.
+        :param pulumi.Input[_builtins.str] signature_algorithm: The signature algorithm of the CA certificate.
+        :param pulumi.Input[_builtins.str] start_date: The start date of the certificate.
+        :param pulumi.Input[_builtins.str] subject: The certificate's subject field.
+        """
+        pulumi.set(__self__, "certificate_pem", certificate_pem)
+        if created_by is not None:
+            pulumi.set(__self__, "created_by", created_by)
+        if created_date is not None:
+            pulumi.set(__self__, "created_date", created_date)
+        if description is not None:
+            pulumi.set(__self__, "description", description)
+        if end_date is not None:
+            pulumi.set(__self__, "end_date", end_date)
+        if fingerprint is not None:
+            pulumi.set(__self__, "fingerprint", fingerprint)
+        if issuer is not None:
+            pulumi.set(__self__, "issuer", issuer)
+        if serial_number is not None:
+            pulumi.set(__self__, "serial_number", serial_number)
+        if signature_algorithm is not None:
+            pulumi.set(__self__, "signature_algorithm", signature_algorithm)
+        if start_date is not None:
+            pulumi.set(__self__, "start_date", start_date)
+        if subject is not None:
+            pulumi.set(__self__, "subject", subject)
+
+    @_builtins.property
+    @pulumi.getter(name="certificatePem")
+    def certificate_pem(self) -> pulumi.Input[_builtins.str]:
+        """
+        The certificate in PEM format, as found in a Base64 ASCII encoded file.
+        """
+        return pulumi.get(self, "certificate_pem")
+
+    @certificate_pem.setter
+    def certificate_pem(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "certificate_pem", value)
+
+    @_builtins.property
+    @pulumi.getter(name="createdBy")
+    def created_by(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The user who created this CA certificate.
+        """
+        return pulumi.get(self, "created_by")
+
+    @created_by.setter
+    def created_by(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "created_by", value)
+
+    @_builtins.property
+    @pulumi.getter(name="createdDate")
+    def created_date(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        When the CA certificate was created.
+        """
+        return pulumi.get(self, "created_date")
+
+    @created_date.setter
+    def created_date(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "created_date", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def description(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Optional description for the certificate.
+        """
+        return pulumi.get(self, "description")
+
+    @description.setter
+    def description(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "description", value)
+
+    @_builtins.property
+    @pulumi.getter(name="endDate")
+    def end_date(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The certificate's ISO 8601 formatted expiration date.
+        """
+        return pulumi.get(self, "end_date")
+
+    @end_date.setter
+    def end_date(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "end_date", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def fingerprint(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The fingerprint of the certificate.
+        """
+        return pulumi.get(self, "fingerprint")
+
+    @fingerprint.setter
+    def fingerprint(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "fingerprint", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def issuer(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The certificate's issuer.
+        """
+        return pulumi.get(self, "issuer")
+
+    @issuer.setter
+    def issuer(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "issuer", value)
+
+    @_builtins.property
+    @pulumi.getter(name="serialNumber")
+    def serial_number(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The unique serial number of the certificate.
+        """
+        return pulumi.get(self, "serial_number")
+
+    @serial_number.setter
+    def serial_number(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "serial_number", value)
+
+    @_builtins.property
+    @pulumi.getter(name="signatureAlgorithm")
+    def signature_algorithm(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The signature algorithm of the CA certificate.
+        """
+        return pulumi.get(self, "signature_algorithm")
+
+    @signature_algorithm.setter
+    def signature_algorithm(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "signature_algorithm", value)
+
+    @_builtins.property
+    @pulumi.getter(name="startDate")
+    def start_date(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The start date of the certificate.
+        """
+        return pulumi.get(self, "start_date")
+
+    @start_date.setter
+    def start_date(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "start_date", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def subject(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The certificate's subject field.
+        """
+        return pulumi.get(self, "subject")
+
+    @subject.setter
+    def subject(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "subject", value)
+
+
+if not MYPY:
+    class MtlstruststoreCaSetTimeoutsArgsDict(TypedDict):
+        delete: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Optional configurable resource delete timeout. By default it's 1h.
+        """
+elif False:
+    MtlstruststoreCaSetTimeoutsArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class MtlstruststoreCaSetTimeoutsArgs:
+    def __init__(__self__, *,
+                 delete: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_builtins.str] delete: Optional configurable resource delete timeout. By default it's 1h.
+        """
+        if delete is not None:
+            pulumi.set(__self__, "delete", delete)
+
+    @_builtins.property
+    @pulumi.getter
+    def delete(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Optional configurable resource delete timeout. By default it's 1h.
+        """
+        return pulumi.get(self, "delete")
+
+    @delete.setter
+    def delete(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "delete", value)
+
+
+if not MYPY:
+    class PropertyActivationComplianceRecordArgsDict(TypedDict):
+        noncompliance_reason_emergency: NotRequired[pulumi.Input['PropertyActivationComplianceRecordNoncomplianceReasonEmergencyArgsDict']]
+        """
+        Provides an audit record when activating on a production network with noncompliance reason as `EMERGENCY`
+        """
+        noncompliance_reason_no_production_traffic: NotRequired[pulumi.Input['PropertyActivationComplianceRecordNoncomplianceReasonNoProductionTrafficArgsDict']]
+        """
+        Provides an audit record when activating on a production network with noncompliance reason as `NO_PRODUCTION_TRAFFIC`
+        """
+        noncompliance_reason_none: NotRequired[pulumi.Input['PropertyActivationComplianceRecordNoncomplianceReasonNoneArgsDict']]
+        """
+        Provides an audit record when activating on a production network with noncompliance reason as `NONE`
+        """
+        noncompliance_reason_other: NotRequired[pulumi.Input['PropertyActivationComplianceRecordNoncomplianceReasonOtherArgsDict']]
+        """
+        Provides an audit record when activating on a production network with noncompliance reason as `OTHER`
+        """
+elif False:
+    PropertyActivationComplianceRecordArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class PropertyActivationComplianceRecordArgs:
+    def __init__(__self__, *,
+                 noncompliance_reason_emergency: Optional[pulumi.Input['PropertyActivationComplianceRecordNoncomplianceReasonEmergencyArgs']] = None,
+                 noncompliance_reason_no_production_traffic: Optional[pulumi.Input['PropertyActivationComplianceRecordNoncomplianceReasonNoProductionTrafficArgs']] = None,
+                 noncompliance_reason_none: Optional[pulumi.Input['PropertyActivationComplianceRecordNoncomplianceReasonNoneArgs']] = None,
+                 noncompliance_reason_other: Optional[pulumi.Input['PropertyActivationComplianceRecordNoncomplianceReasonOtherArgs']] = None):
+        """
+        :param pulumi.Input['PropertyActivationComplianceRecordNoncomplianceReasonEmergencyArgs'] noncompliance_reason_emergency: Provides an audit record when activating on a production network with noncompliance reason as `EMERGENCY`
+        :param pulumi.Input['PropertyActivationComplianceRecordNoncomplianceReasonNoProductionTrafficArgs'] noncompliance_reason_no_production_traffic: Provides an audit record when activating on a production network with noncompliance reason as `NO_PRODUCTION_TRAFFIC`
+        :param pulumi.Input['PropertyActivationComplianceRecordNoncomplianceReasonNoneArgs'] noncompliance_reason_none: Provides an audit record when activating on a production network with noncompliance reason as `NONE`
+        :param pulumi.Input['PropertyActivationComplianceRecordNoncomplianceReasonOtherArgs'] noncompliance_reason_other: Provides an audit record when activating on a production network with noncompliance reason as `OTHER`
+        """
+        if noncompliance_reason_emergency is not None:
+            pulumi.set(__self__, "noncompliance_reason_emergency", noncompliance_reason_emergency)
+        if noncompliance_reason_no_production_traffic is not None:
+            pulumi.set(__self__, "noncompliance_reason_no_production_traffic", noncompliance_reason_no_production_traffic)
+        if noncompliance_reason_none is not None:
+            pulumi.set(__self__, "noncompliance_reason_none", noncompliance_reason_none)
+        if noncompliance_reason_other is not None:
+            pulumi.set(__self__, "noncompliance_reason_other", noncompliance_reason_other)
+
+    @_builtins.property
+    @pulumi.getter(name="noncomplianceReasonEmergency")
+    def noncompliance_reason_emergency(self) -> Optional[pulumi.Input['PropertyActivationComplianceRecordNoncomplianceReasonEmergencyArgs']]:
+        """
+        Provides an audit record when activating on a production network with noncompliance reason as `EMERGENCY`
+        """
+        return pulumi.get(self, "noncompliance_reason_emergency")
+
+    @noncompliance_reason_emergency.setter
+    def noncompliance_reason_emergency(self, value: Optional[pulumi.Input['PropertyActivationComplianceRecordNoncomplianceReasonEmergencyArgs']]):
+        pulumi.set(self, "noncompliance_reason_emergency", value)
+
+    @_builtins.property
+    @pulumi.getter(name="noncomplianceReasonNoProductionTraffic")
+    def noncompliance_reason_no_production_traffic(self) -> Optional[pulumi.Input['PropertyActivationComplianceRecordNoncomplianceReasonNoProductionTrafficArgs']]:
+        """
+        Provides an audit record when activating on a production network with noncompliance reason as `NO_PRODUCTION_TRAFFIC`
+        """
+        return pulumi.get(self, "noncompliance_reason_no_production_traffic")
+
+    @noncompliance_reason_no_production_traffic.setter
+    def noncompliance_reason_no_production_traffic(self, value: Optional[pulumi.Input['PropertyActivationComplianceRecordNoncomplianceReasonNoProductionTrafficArgs']]):
+        pulumi.set(self, "noncompliance_reason_no_production_traffic", value)
+
+    @_builtins.property
+    @pulumi.getter(name="noncomplianceReasonNone")
+    def noncompliance_reason_none(self) -> Optional[pulumi.Input['PropertyActivationComplianceRecordNoncomplianceReasonNoneArgs']]:
+        """
+        Provides an audit record when activating on a production network with noncompliance reason as `NONE`
+        """
+        return pulumi.get(self, "noncompliance_reason_none")
+
+    @noncompliance_reason_none.setter
+    def noncompliance_reason_none(self, value: Optional[pulumi.Input['PropertyActivationComplianceRecordNoncomplianceReasonNoneArgs']]):
+        pulumi.set(self, "noncompliance_reason_none", value)
+
+    @_builtins.property
+    @pulumi.getter(name="noncomplianceReasonOther")
+    def noncompliance_reason_other(self) -> Optional[pulumi.Input['PropertyActivationComplianceRecordNoncomplianceReasonOtherArgs']]:
+        """
+        Provides an audit record when activating on a production network with noncompliance reason as `OTHER`
+        """
+        return pulumi.get(self, "noncompliance_reason_other")
+
+    @noncompliance_reason_other.setter
+    def noncompliance_reason_other(self, value: Optional[pulumi.Input['PropertyActivationComplianceRecordNoncomplianceReasonOtherArgs']]):
+        pulumi.set(self, "noncompliance_reason_other", value)
+
+
+if not MYPY:
+    class PropertyActivationComplianceRecordNoncomplianceReasonEmergencyArgsDict(TypedDict):
+        ticket_id: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Identifies the ticket that describes the need for the activation
+        """
+elif False:
+    PropertyActivationComplianceRecordNoncomplianceReasonEmergencyArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class PropertyActivationComplianceRecordNoncomplianceReasonEmergencyArgs:
+    def __init__(__self__, *,
+                 ticket_id: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_builtins.str] ticket_id: Identifies the ticket that describes the need for the activation
+        """
+        if ticket_id is not None:
+            pulumi.set(__self__, "ticket_id", ticket_id)
+
+    @_builtins.property
+    @pulumi.getter(name="ticketId")
+    def ticket_id(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Identifies the ticket that describes the need for the activation
+        """
+        return pulumi.get(self, "ticket_id")
+
+    @ticket_id.setter
+    def ticket_id(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "ticket_id", value)
+
+
+if not MYPY:
+    class PropertyActivationComplianceRecordNoncomplianceReasonNoProductionTrafficArgsDict(TypedDict):
+        ticket_id: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Identifies the ticket that describes the need for the activation
+        """
+elif False:
+    PropertyActivationComplianceRecordNoncomplianceReasonNoProductionTrafficArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class PropertyActivationComplianceRecordNoncomplianceReasonNoProductionTrafficArgs:
+    def __init__(__self__, *,
+                 ticket_id: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_builtins.str] ticket_id: Identifies the ticket that describes the need for the activation
+        """
+        if ticket_id is not None:
+            pulumi.set(__self__, "ticket_id", ticket_id)
+
+    @_builtins.property
+    @pulumi.getter(name="ticketId")
+    def ticket_id(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Identifies the ticket that describes the need for the activation
+        """
+        return pulumi.get(self, "ticket_id")
+
+    @ticket_id.setter
+    def ticket_id(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "ticket_id", value)
+
+
+if not MYPY:
+    class PropertyActivationComplianceRecordNoncomplianceReasonNoneArgsDict(TypedDict):
+        customer_email: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Identifies the customer
+        """
+        peer_reviewed_by: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Identifies person who has independently approved the activation request
+        """
+        ticket_id: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Identifies the ticket that describes the need for the activation
+        """
+        unit_tested: NotRequired[pulumi.Input[_builtins.bool]]
+        """
+        Whether the metadata to activate has been fully tested
+        """
+elif False:
+    PropertyActivationComplianceRecordNoncomplianceReasonNoneArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class PropertyActivationComplianceRecordNoncomplianceReasonNoneArgs:
+    def __init__(__self__, *,
+                 customer_email: Optional[pulumi.Input[_builtins.str]] = None,
+                 peer_reviewed_by: Optional[pulumi.Input[_builtins.str]] = None,
+                 ticket_id: Optional[pulumi.Input[_builtins.str]] = None,
+                 unit_tested: Optional[pulumi.Input[_builtins.bool]] = None):
+        """
+        :param pulumi.Input[_builtins.str] customer_email: Identifies the customer
+        :param pulumi.Input[_builtins.str] peer_reviewed_by: Identifies person who has independently approved the activation request
+        :param pulumi.Input[_builtins.str] ticket_id: Identifies the ticket that describes the need for the activation
+        :param pulumi.Input[_builtins.bool] unit_tested: Whether the metadata to activate has been fully tested
+        """
+        if customer_email is not None:
+            pulumi.set(__self__, "customer_email", customer_email)
+        if peer_reviewed_by is not None:
+            pulumi.set(__self__, "peer_reviewed_by", peer_reviewed_by)
+        if ticket_id is not None:
+            pulumi.set(__self__, "ticket_id", ticket_id)
+        if unit_tested is not None:
+            pulumi.set(__self__, "unit_tested", unit_tested)
+
+    @_builtins.property
+    @pulumi.getter(name="customerEmail")
+    def customer_email(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Identifies the customer
+        """
+        return pulumi.get(self, "customer_email")
+
+    @customer_email.setter
+    def customer_email(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "customer_email", value)
+
+    @_builtins.property
+    @pulumi.getter(name="peerReviewedBy")
+    def peer_reviewed_by(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Identifies person who has independently approved the activation request
+        """
+        return pulumi.get(self, "peer_reviewed_by")
+
+    @peer_reviewed_by.setter
+    def peer_reviewed_by(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "peer_reviewed_by", value)
+
+    @_builtins.property
+    @pulumi.getter(name="ticketId")
+    def ticket_id(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Identifies the ticket that describes the need for the activation
+        """
+        return pulumi.get(self, "ticket_id")
+
+    @ticket_id.setter
+    def ticket_id(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "ticket_id", value)
+
+    @_builtins.property
+    @pulumi.getter(name="unitTested")
+    def unit_tested(self) -> Optional[pulumi.Input[_builtins.bool]]:
+        """
+        Whether the metadata to activate has been fully tested
+        """
+        return pulumi.get(self, "unit_tested")
+
+    @unit_tested.setter
+    def unit_tested(self, value: Optional[pulumi.Input[_builtins.bool]]):
+        pulumi.set(self, "unit_tested", value)
+
+
+if not MYPY:
+    class PropertyActivationComplianceRecordNoncomplianceReasonOtherArgsDict(TypedDict):
+        other_noncompliance_reason: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Describes the reason why the activation must occur immediately, out of compliance with the standard procedure
+        """
+        ticket_id: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Identifies the ticket that describes the need for the activation
+        """
+elif False:
+    PropertyActivationComplianceRecordNoncomplianceReasonOtherArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class PropertyActivationComplianceRecordNoncomplianceReasonOtherArgs:
+    def __init__(__self__, *,
+                 other_noncompliance_reason: Optional[pulumi.Input[_builtins.str]] = None,
+                 ticket_id: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_builtins.str] other_noncompliance_reason: Describes the reason why the activation must occur immediately, out of compliance with the standard procedure
+        :param pulumi.Input[_builtins.str] ticket_id: Identifies the ticket that describes the need for the activation
+        """
+        if other_noncompliance_reason is not None:
+            pulumi.set(__self__, "other_noncompliance_reason", other_noncompliance_reason)
+        if ticket_id is not None:
+            pulumi.set(__self__, "ticket_id", ticket_id)
+
+    @_builtins.property
+    @pulumi.getter(name="otherNoncomplianceReason")
+    def other_noncompliance_reason(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Describes the reason why the activation must occur immediately, out of compliance with the standard procedure
+        """
+        return pulumi.get(self, "other_noncompliance_reason")
+
+    @other_noncompliance_reason.setter
+    def other_noncompliance_reason(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "other_noncompliance_reason", value)
+
+    @_builtins.property
+    @pulumi.getter(name="ticketId")
+    def ticket_id(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Identifies the ticket that describes the need for the activation
+        """
+        return pulumi.get(self, "ticket_id")
+
+    @ticket_id.setter
+    def ticket_id(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "ticket_id", value)
+
+
+if not MYPY:
+    class PropertyActivationRuleErrorArgsDict(TypedDict):
+        behavior_name: NotRequired[pulumi.Input[_builtins.str]]
+        detail: NotRequired[pulumi.Input[_builtins.str]]
+        error_location: NotRequired[pulumi.Input[_builtins.str]]
+        instance: NotRequired[pulumi.Input[_builtins.str]]
+        status_code: NotRequired[pulumi.Input[_builtins.int]]
+        title: NotRequired[pulumi.Input[_builtins.str]]
+        type: NotRequired[pulumi.Input[_builtins.str]]
+elif False:
+    PropertyActivationRuleErrorArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class PropertyActivationRuleErrorArgs:
+    def __init__(__self__, *,
+                 behavior_name: Optional[pulumi.Input[_builtins.str]] = None,
+                 detail: Optional[pulumi.Input[_builtins.str]] = None,
+                 error_location: Optional[pulumi.Input[_builtins.str]] = None,
+                 instance: Optional[pulumi.Input[_builtins.str]] = None,
+                 status_code: Optional[pulumi.Input[_builtins.int]] = None,
+                 title: Optional[pulumi.Input[_builtins.str]] = None,
+                 type: Optional[pulumi.Input[_builtins.str]] = None):
         if behavior_name is not None:
             pulumi.set(__self__, "behavior_name", behavior_name)
         if detail is not None:
@@ -9581,11 +11748,728 @@ class PropertyActivationTimeoutsArgs:
         pulumi.set(self, "default", value)
 
 
+if not MYPY:
+    class PropertyDomainownershipDomainsDomainArgsDict(TypedDict):
+        domain_name: pulumi.Input[_builtins.str]
+        """
+        Your domain's name.
+        """
+        validation_scope: pulumi.Input[_builtins.str]
+        """
+        Your domain's validation scope. Possible values are: 
+        * `HOST` - The scope is only the exactly specified domain.
+        * `WILDCARD` - The scope covers any hostname within one subdomain level.
+        * `DOMAIN` - The scope covers any hostnames under the domain, regardless of the level of subdomains.
+        """
+        account_id: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Your account's ID.
+        """
+        domain_status: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The domain's validation status. Possible values are: 
+        * `REQUEST_ACCEPTED` - When you successfully submit the domain for validation.
+        * `VALIDATION_IN_PROGRESS` - When the DOM background jobs are trying to validate the domain.
+        * `VALIDATED` - When the validation is completed successfully. Akamai recognizes you as the domain owner.
+        * `TOKEN_EXPIRED` - When you haven't completed the validation in the requested time frame and the challenge token is not valid anymore. You need to generate new validation challenges for the domain.
+        * `INVALIDATED` - When the domain was invalidated and Akamai doesn't recognize you as its owner.
+        """
+        validation_challenge: NotRequired[pulumi.Input['PropertyDomainownershipDomainsDomainValidationChallengeArgsDict']]
+        """
+        The domain's validation challenge details.
+        """
+        validation_completed_date: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The timestamp indicating when the domain validation was completed.
+        """
+        validation_method: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The method used to validate the domain. Possible values are: 
+        * `DNS_CNAME` - For this method, Akamai generates a `cname_record` that you copy as the `target` to a `CNAME` record of your DNS configuration. The record's name needs to be in the `_acme-challenge.domain-name` format.
+        * `DNS_TXT` - For this method, Akamai generates a `txt_record` with a token `value` that you copy as the `target` to a `TXT` record of your DNS configuration. The record's name needs to be in the `_akamai-{host|wildcard|domain}-challenge.domainName` format based on the validation scope.
+        * `HTTP` - Applies only to domains with the `HOST` validation scope. For this method, you create the file containing a token and place it on your HTTP server in the location specified by the `validation_challenge.http_file.path` or use a redirect to the `validation_challenge.http_redirect.to` with the token.
+        * `SYSTEM` - This method refers to domains that were automatically validated before Domain Validation Manager (DOM) was introduced.
+        * `MANUAL` - For this method, the DOM team manually performed the validation.
+        """
+        validation_requested_by: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The name of the user who requested the domain validation.
+        """
+        validation_requested_date: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The timestamp indicating when the domain validation was requested.
+        """
+elif False:
+    PropertyDomainownershipDomainsDomainArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class PropertyDomainownershipDomainsDomainArgs:
+    def __init__(__self__, *,
+                 domain_name: pulumi.Input[_builtins.str],
+                 validation_scope: pulumi.Input[_builtins.str],
+                 account_id: Optional[pulumi.Input[_builtins.str]] = None,
+                 domain_status: Optional[pulumi.Input[_builtins.str]] = None,
+                 validation_challenge: Optional[pulumi.Input['PropertyDomainownershipDomainsDomainValidationChallengeArgs']] = None,
+                 validation_completed_date: Optional[pulumi.Input[_builtins.str]] = None,
+                 validation_method: Optional[pulumi.Input[_builtins.str]] = None,
+                 validation_requested_by: Optional[pulumi.Input[_builtins.str]] = None,
+                 validation_requested_date: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_builtins.str] domain_name: Your domain's name.
+        :param pulumi.Input[_builtins.str] validation_scope: Your domain's validation scope. Possible values are: 
+               * `HOST` - The scope is only the exactly specified domain.
+               * `WILDCARD` - The scope covers any hostname within one subdomain level.
+               * `DOMAIN` - The scope covers any hostnames under the domain, regardless of the level of subdomains.
+        :param pulumi.Input[_builtins.str] account_id: Your account's ID.
+        :param pulumi.Input[_builtins.str] domain_status: The domain's validation status. Possible values are: 
+               * `REQUEST_ACCEPTED` - When you successfully submit the domain for validation.
+               * `VALIDATION_IN_PROGRESS` - When the DOM background jobs are trying to validate the domain.
+               * `VALIDATED` - When the validation is completed successfully. Akamai recognizes you as the domain owner.
+               * `TOKEN_EXPIRED` - When you haven't completed the validation in the requested time frame and the challenge token is not valid anymore. You need to generate new validation challenges for the domain.
+               * `INVALIDATED` - When the domain was invalidated and Akamai doesn't recognize you as its owner.
+        :param pulumi.Input['PropertyDomainownershipDomainsDomainValidationChallengeArgs'] validation_challenge: The domain's validation challenge details.
+        :param pulumi.Input[_builtins.str] validation_completed_date: The timestamp indicating when the domain validation was completed.
+        :param pulumi.Input[_builtins.str] validation_method: The method used to validate the domain. Possible values are: 
+               * `DNS_CNAME` - For this method, Akamai generates a `cname_record` that you copy as the `target` to a `CNAME` record of your DNS configuration. The record's name needs to be in the `_acme-challenge.domain-name` format.
+               * `DNS_TXT` - For this method, Akamai generates a `txt_record` with a token `value` that you copy as the `target` to a `TXT` record of your DNS configuration. The record's name needs to be in the `_akamai-{host|wildcard|domain}-challenge.domainName` format based on the validation scope.
+               * `HTTP` - Applies only to domains with the `HOST` validation scope. For this method, you create the file containing a token and place it on your HTTP server in the location specified by the `validation_challenge.http_file.path` or use a redirect to the `validation_challenge.http_redirect.to` with the token.
+               * `SYSTEM` - This method refers to domains that were automatically validated before Domain Validation Manager (DOM) was introduced.
+               * `MANUAL` - For this method, the DOM team manually performed the validation.
+        :param pulumi.Input[_builtins.str] validation_requested_by: The name of the user who requested the domain validation.
+        :param pulumi.Input[_builtins.str] validation_requested_date: The timestamp indicating when the domain validation was requested.
+        """
+        pulumi.set(__self__, "domain_name", domain_name)
+        pulumi.set(__self__, "validation_scope", validation_scope)
+        if account_id is not None:
+            pulumi.set(__self__, "account_id", account_id)
+        if domain_status is not None:
+            pulumi.set(__self__, "domain_status", domain_status)
+        if validation_challenge is not None:
+            pulumi.set(__self__, "validation_challenge", validation_challenge)
+        if validation_completed_date is not None:
+            pulumi.set(__self__, "validation_completed_date", validation_completed_date)
+        if validation_method is not None:
+            pulumi.set(__self__, "validation_method", validation_method)
+        if validation_requested_by is not None:
+            pulumi.set(__self__, "validation_requested_by", validation_requested_by)
+        if validation_requested_date is not None:
+            pulumi.set(__self__, "validation_requested_date", validation_requested_date)
+
+    @_builtins.property
+    @pulumi.getter(name="domainName")
+    def domain_name(self) -> pulumi.Input[_builtins.str]:
+        """
+        Your domain's name.
+        """
+        return pulumi.get(self, "domain_name")
+
+    @domain_name.setter
+    def domain_name(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "domain_name", value)
+
+    @_builtins.property
+    @pulumi.getter(name="validationScope")
+    def validation_scope(self) -> pulumi.Input[_builtins.str]:
+        """
+        Your domain's validation scope. Possible values are: 
+        * `HOST` - The scope is only the exactly specified domain.
+        * `WILDCARD` - The scope covers any hostname within one subdomain level.
+        * `DOMAIN` - The scope covers any hostnames under the domain, regardless of the level of subdomains.
+        """
+        return pulumi.get(self, "validation_scope")
+
+    @validation_scope.setter
+    def validation_scope(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "validation_scope", value)
+
+    @_builtins.property
+    @pulumi.getter(name="accountId")
+    def account_id(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Your account's ID.
+        """
+        return pulumi.get(self, "account_id")
+
+    @account_id.setter
+    def account_id(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "account_id", value)
+
+    @_builtins.property
+    @pulumi.getter(name="domainStatus")
+    def domain_status(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The domain's validation status. Possible values are: 
+        * `REQUEST_ACCEPTED` - When you successfully submit the domain for validation.
+        * `VALIDATION_IN_PROGRESS` - When the DOM background jobs are trying to validate the domain.
+        * `VALIDATED` - When the validation is completed successfully. Akamai recognizes you as the domain owner.
+        * `TOKEN_EXPIRED` - When you haven't completed the validation in the requested time frame and the challenge token is not valid anymore. You need to generate new validation challenges for the domain.
+        * `INVALIDATED` - When the domain was invalidated and Akamai doesn't recognize you as its owner.
+        """
+        return pulumi.get(self, "domain_status")
+
+    @domain_status.setter
+    def domain_status(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "domain_status", value)
+
+    @_builtins.property
+    @pulumi.getter(name="validationChallenge")
+    def validation_challenge(self) -> Optional[pulumi.Input['PropertyDomainownershipDomainsDomainValidationChallengeArgs']]:
+        """
+        The domain's validation challenge details.
+        """
+        return pulumi.get(self, "validation_challenge")
+
+    @validation_challenge.setter
+    def validation_challenge(self, value: Optional[pulumi.Input['PropertyDomainownershipDomainsDomainValidationChallengeArgs']]):
+        pulumi.set(self, "validation_challenge", value)
+
+    @_builtins.property
+    @pulumi.getter(name="validationCompletedDate")
+    def validation_completed_date(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The timestamp indicating when the domain validation was completed.
+        """
+        return pulumi.get(self, "validation_completed_date")
+
+    @validation_completed_date.setter
+    def validation_completed_date(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "validation_completed_date", value)
+
+    @_builtins.property
+    @pulumi.getter(name="validationMethod")
+    def validation_method(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The method used to validate the domain. Possible values are: 
+        * `DNS_CNAME` - For this method, Akamai generates a `cname_record` that you copy as the `target` to a `CNAME` record of your DNS configuration. The record's name needs to be in the `_acme-challenge.domain-name` format.
+        * `DNS_TXT` - For this method, Akamai generates a `txt_record` with a token `value` that you copy as the `target` to a `TXT` record of your DNS configuration. The record's name needs to be in the `_akamai-{host|wildcard|domain}-challenge.domainName` format based on the validation scope.
+        * `HTTP` - Applies only to domains with the `HOST` validation scope. For this method, you create the file containing a token and place it on your HTTP server in the location specified by the `validation_challenge.http_file.path` or use a redirect to the `validation_challenge.http_redirect.to` with the token.
+        * `SYSTEM` - This method refers to domains that were automatically validated before Domain Validation Manager (DOM) was introduced.
+        * `MANUAL` - For this method, the DOM team manually performed the validation.
+        """
+        return pulumi.get(self, "validation_method")
+
+    @validation_method.setter
+    def validation_method(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "validation_method", value)
+
+    @_builtins.property
+    @pulumi.getter(name="validationRequestedBy")
+    def validation_requested_by(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The name of the user who requested the domain validation.
+        """
+        return pulumi.get(self, "validation_requested_by")
+
+    @validation_requested_by.setter
+    def validation_requested_by(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "validation_requested_by", value)
+
+    @_builtins.property
+    @pulumi.getter(name="validationRequestedDate")
+    def validation_requested_date(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The timestamp indicating when the domain validation was requested.
+        """
+        return pulumi.get(self, "validation_requested_date")
+
+    @validation_requested_date.setter
+    def validation_requested_date(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "validation_requested_date", value)
+
+
+if not MYPY:
+    class PropertyDomainownershipDomainsDomainValidationChallengeArgsDict(TypedDict):
+        cname_record: NotRequired[pulumi.Input['PropertyDomainownershipDomainsDomainValidationChallengeCnameRecordArgsDict']]
+        """
+        The details of the 'CNAME' record you copy to your DNS configuration to prove you own the domain. You should use the 'DNS_CNAME' method in most cases.
+        """
+        expiration_date: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The timestamp indicating when the challenge data expires.
+        """
+        http_file: NotRequired[pulumi.Input['PropertyDomainownershipDomainsDomainValidationChallengeHttpFileArgsDict']]
+        """
+        Available only for the 'HOST' validation scope. The details for the HTTP validation method in which you create a file containing a token and save it on your HTTP server at the provided URL. Alternatively, you can use the 'http_redirect' method.
+        """
+        http_redirect: NotRequired[pulumi.Input['PropertyDomainownershipDomainsDomainValidationChallengeHttpRedirectArgsDict']]
+        """
+        Available only for the 'HOST' validation scope. The details for the HTTP validation method in which you use a redirect URL with the token. Alternatively, you can use the 'http_file' method.
+        """
+        txt_record: NotRequired[pulumi.Input['PropertyDomainownershipDomainsDomainValidationChallengeTxtRecordArgsDict']]
+        """
+        The details of the 'TXT' record with the challenge token that you copy to your DNS configuration to prove you own the domain.
+        """
+elif False:
+    PropertyDomainownershipDomainsDomainValidationChallengeArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class PropertyDomainownershipDomainsDomainValidationChallengeArgs:
+    def __init__(__self__, *,
+                 cname_record: Optional[pulumi.Input['PropertyDomainownershipDomainsDomainValidationChallengeCnameRecordArgs']] = None,
+                 expiration_date: Optional[pulumi.Input[_builtins.str]] = None,
+                 http_file: Optional[pulumi.Input['PropertyDomainownershipDomainsDomainValidationChallengeHttpFileArgs']] = None,
+                 http_redirect: Optional[pulumi.Input['PropertyDomainownershipDomainsDomainValidationChallengeHttpRedirectArgs']] = None,
+                 txt_record: Optional[pulumi.Input['PropertyDomainownershipDomainsDomainValidationChallengeTxtRecordArgs']] = None):
+        """
+        :param pulumi.Input['PropertyDomainownershipDomainsDomainValidationChallengeCnameRecordArgs'] cname_record: The details of the 'CNAME' record you copy to your DNS configuration to prove you own the domain. You should use the 'DNS_CNAME' method in most cases.
+        :param pulumi.Input[_builtins.str] expiration_date: The timestamp indicating when the challenge data expires.
+        :param pulumi.Input['PropertyDomainownershipDomainsDomainValidationChallengeHttpFileArgs'] http_file: Available only for the 'HOST' validation scope. The details for the HTTP validation method in which you create a file containing a token and save it on your HTTP server at the provided URL. Alternatively, you can use the 'http_redirect' method.
+        :param pulumi.Input['PropertyDomainownershipDomainsDomainValidationChallengeHttpRedirectArgs'] http_redirect: Available only for the 'HOST' validation scope. The details for the HTTP validation method in which you use a redirect URL with the token. Alternatively, you can use the 'http_file' method.
+        :param pulumi.Input['PropertyDomainownershipDomainsDomainValidationChallengeTxtRecordArgs'] txt_record: The details of the 'TXT' record with the challenge token that you copy to your DNS configuration to prove you own the domain.
+        """
+        if cname_record is not None:
+            pulumi.set(__self__, "cname_record", cname_record)
+        if expiration_date is not None:
+            pulumi.set(__self__, "expiration_date", expiration_date)
+        if http_file is not None:
+            pulumi.set(__self__, "http_file", http_file)
+        if http_redirect is not None:
+            pulumi.set(__self__, "http_redirect", http_redirect)
+        if txt_record is not None:
+            pulumi.set(__self__, "txt_record", txt_record)
+
+    @_builtins.property
+    @pulumi.getter(name="cnameRecord")
+    def cname_record(self) -> Optional[pulumi.Input['PropertyDomainownershipDomainsDomainValidationChallengeCnameRecordArgs']]:
+        """
+        The details of the 'CNAME' record you copy to your DNS configuration to prove you own the domain. You should use the 'DNS_CNAME' method in most cases.
+        """
+        return pulumi.get(self, "cname_record")
+
+    @cname_record.setter
+    def cname_record(self, value: Optional[pulumi.Input['PropertyDomainownershipDomainsDomainValidationChallengeCnameRecordArgs']]):
+        pulumi.set(self, "cname_record", value)
+
+    @_builtins.property
+    @pulumi.getter(name="expirationDate")
+    def expiration_date(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The timestamp indicating when the challenge data expires.
+        """
+        return pulumi.get(self, "expiration_date")
+
+    @expiration_date.setter
+    def expiration_date(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "expiration_date", value)
+
+    @_builtins.property
+    @pulumi.getter(name="httpFile")
+    def http_file(self) -> Optional[pulumi.Input['PropertyDomainownershipDomainsDomainValidationChallengeHttpFileArgs']]:
+        """
+        Available only for the 'HOST' validation scope. The details for the HTTP validation method in which you create a file containing a token and save it on your HTTP server at the provided URL. Alternatively, you can use the 'http_redirect' method.
+        """
+        return pulumi.get(self, "http_file")
+
+    @http_file.setter
+    def http_file(self, value: Optional[pulumi.Input['PropertyDomainownershipDomainsDomainValidationChallengeHttpFileArgs']]):
+        pulumi.set(self, "http_file", value)
+
+    @_builtins.property
+    @pulumi.getter(name="httpRedirect")
+    def http_redirect(self) -> Optional[pulumi.Input['PropertyDomainownershipDomainsDomainValidationChallengeHttpRedirectArgs']]:
+        """
+        Available only for the 'HOST' validation scope. The details for the HTTP validation method in which you use a redirect URL with the token. Alternatively, you can use the 'http_file' method.
+        """
+        return pulumi.get(self, "http_redirect")
+
+    @http_redirect.setter
+    def http_redirect(self, value: Optional[pulumi.Input['PropertyDomainownershipDomainsDomainValidationChallengeHttpRedirectArgs']]):
+        pulumi.set(self, "http_redirect", value)
+
+    @_builtins.property
+    @pulumi.getter(name="txtRecord")
+    def txt_record(self) -> Optional[pulumi.Input['PropertyDomainownershipDomainsDomainValidationChallengeTxtRecordArgs']]:
+        """
+        The details of the 'TXT' record with the challenge token that you copy to your DNS configuration to prove you own the domain.
+        """
+        return pulumi.get(self, "txt_record")
+
+    @txt_record.setter
+    def txt_record(self, value: Optional[pulumi.Input['PropertyDomainownershipDomainsDomainValidationChallengeTxtRecordArgs']]):
+        pulumi.set(self, "txt_record", value)
+
+
+if not MYPY:
+    class PropertyDomainownershipDomainsDomainValidationChallengeCnameRecordArgsDict(TypedDict):
+        name: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The 'CNAME' record for your domain that you add to the DNS configuration.
+        """
+        target: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The 'target' value you set in the 'CNAME' record that validates the domain ownership.
+        """
+elif False:
+    PropertyDomainownershipDomainsDomainValidationChallengeCnameRecordArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class PropertyDomainownershipDomainsDomainValidationChallengeCnameRecordArgs:
+    def __init__(__self__, *,
+                 name: Optional[pulumi.Input[_builtins.str]] = None,
+                 target: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_builtins.str] name: The 'CNAME' record for your domain that you add to the DNS configuration.
+        :param pulumi.Input[_builtins.str] target: The 'target' value you set in the 'CNAME' record that validates the domain ownership.
+        """
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if target is not None:
+            pulumi.set(__self__, "target", target)
+
+    @_builtins.property
+    @pulumi.getter
+    def name(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The 'CNAME' record for your domain that you add to the DNS configuration.
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "name", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def target(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The 'target' value you set in the 'CNAME' record that validates the domain ownership.
+        """
+        return pulumi.get(self, "target")
+
+    @target.setter
+    def target(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "target", value)
+
+
+if not MYPY:
+    class PropertyDomainownershipDomainsDomainValidationChallengeHttpFileArgsDict(TypedDict):
+        content: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The content of the file that you should place at the specified URL.
+        """
+        content_type: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The content type of the file containing the token.
+        """
+        path: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The URL where you should place the file containing the challenge token.
+        """
+elif False:
+    PropertyDomainownershipDomainsDomainValidationChallengeHttpFileArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class PropertyDomainownershipDomainsDomainValidationChallengeHttpFileArgs:
+    def __init__(__self__, *,
+                 content: Optional[pulumi.Input[_builtins.str]] = None,
+                 content_type: Optional[pulumi.Input[_builtins.str]] = None,
+                 path: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_builtins.str] content: The content of the file that you should place at the specified URL.
+        :param pulumi.Input[_builtins.str] content_type: The content type of the file containing the token.
+        :param pulumi.Input[_builtins.str] path: The URL where you should place the file containing the challenge token.
+        """
+        if content is not None:
+            pulumi.set(__self__, "content", content)
+        if content_type is not None:
+            pulumi.set(__self__, "content_type", content_type)
+        if path is not None:
+            pulumi.set(__self__, "path", path)
+
+    @_builtins.property
+    @pulumi.getter
+    def content(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The content of the file that you should place at the specified URL.
+        """
+        return pulumi.get(self, "content")
+
+    @content.setter
+    def content(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "content", value)
+
+    @_builtins.property
+    @pulumi.getter(name="contentType")
+    def content_type(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The content type of the file containing the token.
+        """
+        return pulumi.get(self, "content_type")
+
+    @content_type.setter
+    def content_type(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "content_type", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def path(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The URL where you should place the file containing the challenge token.
+        """
+        return pulumi.get(self, "path")
+
+    @path.setter
+    def path(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "path", value)
+
+
+if not MYPY:
+    class PropertyDomainownershipDomainsDomainValidationChallengeHttpRedirectArgsDict(TypedDict):
+        from_: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The location on your HTTP server where you set up the redirect.
+        """
+        to: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The redirect URL with the token that you place on your HTTP server.
+        """
+elif False:
+    PropertyDomainownershipDomainsDomainValidationChallengeHttpRedirectArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class PropertyDomainownershipDomainsDomainValidationChallengeHttpRedirectArgs:
+    def __init__(__self__, *,
+                 from_: Optional[pulumi.Input[_builtins.str]] = None,
+                 to: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_builtins.str] from_: The location on your HTTP server where you set up the redirect.
+        :param pulumi.Input[_builtins.str] to: The redirect URL with the token that you place on your HTTP server.
+        """
+        if from_ is not None:
+            pulumi.set(__self__, "from_", from_)
+        if to is not None:
+            pulumi.set(__self__, "to", to)
+
+    @_builtins.property
+    @pulumi.getter(name="from")
+    def from_(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The location on your HTTP server where you set up the redirect.
+        """
+        return pulumi.get(self, "from_")
+
+    @from_.setter
+    def from_(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "from_", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def to(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The redirect URL with the token that you place on your HTTP server.
+        """
+        return pulumi.get(self, "to")
+
+    @to.setter
+    def to(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "to", value)
+
+
+if not MYPY:
+    class PropertyDomainownershipDomainsDomainValidationChallengeTxtRecordArgsDict(TypedDict):
+        name: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The hostname where you should add the 'TXT' record to validate the domain ownership.
+        """
+        value: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The token you need to copy to the DNS 'TXT' record that validates the domain ownership.
+        """
+elif False:
+    PropertyDomainownershipDomainsDomainValidationChallengeTxtRecordArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class PropertyDomainownershipDomainsDomainValidationChallengeTxtRecordArgs:
+    def __init__(__self__, *,
+                 name: Optional[pulumi.Input[_builtins.str]] = None,
+                 value: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_builtins.str] name: The hostname where you should add the 'TXT' record to validate the domain ownership.
+        :param pulumi.Input[_builtins.str] value: The token you need to copy to the DNS 'TXT' record that validates the domain ownership.
+        """
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if value is not None:
+            pulumi.set(__self__, "value", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def name(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The hostname where you should add the 'TXT' record to validate the domain ownership.
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "name", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def value(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The token you need to copy to the DNS 'TXT' record that validates the domain ownership.
+        """
+        return pulumi.get(self, "value")
+
+    @value.setter
+    def value(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "value", value)
+
+
+if not MYPY:
+    class PropertyDomainownershipValidationDomainArgsDict(TypedDict):
+        domain_name: pulumi.Input[_builtins.str]
+        """
+        Your domain's name.
+        """
+        validation_scope: pulumi.Input[_builtins.str]
+        """
+        Your domain's validation scope. Possible values are: 
+        * `HOST` - The scope is only the exactly specified domain.
+        * `WILDCARD` - The scope covers any hostname within one subdomain level.
+        * `DOMAIN` - The scope covers any hostnames under the domain, regardless of the level of subdomains.
+        """
+        validation_method: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The method used to validate the domain. Possible values are: 
+        * `DNS_CNAME` - For this method, Akamai generates a `cname_record` that you copy as the `target` to a `CNAME` record of your DNS configuration. The record's name needs to be in the `_acme-challenge.domain-name` format.
+        * `DNS_TXT` - For this method, Akamai generates a `txt_record` with a token `value` that you copy as the `target` to a `TXT` record of your DNS configuration. The record's name needs to be in the `_akamai-{host|wildcard|domain}-challenge.domainName` format based on the validation scope.
+        * `HTTP` - Applies only to domains with the `HOST` validation scope. For this method, you create the file containing a token and place it on your HTTP server in the location specified by the `validation_challenge.http_file.path` or use a redirect to the `validation_challenge.http_redirect.to` with the token.
+        """
+elif False:
+    PropertyDomainownershipValidationDomainArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class PropertyDomainownershipValidationDomainArgs:
+    def __init__(__self__, *,
+                 domain_name: pulumi.Input[_builtins.str],
+                 validation_scope: pulumi.Input[_builtins.str],
+                 validation_method: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_builtins.str] domain_name: Your domain's name.
+        :param pulumi.Input[_builtins.str] validation_scope: Your domain's validation scope. Possible values are: 
+               * `HOST` - The scope is only the exactly specified domain.
+               * `WILDCARD` - The scope covers any hostname within one subdomain level.
+               * `DOMAIN` - The scope covers any hostnames under the domain, regardless of the level of subdomains.
+        :param pulumi.Input[_builtins.str] validation_method: The method used to validate the domain. Possible values are: 
+               * `DNS_CNAME` - For this method, Akamai generates a `cname_record` that you copy as the `target` to a `CNAME` record of your DNS configuration. The record's name needs to be in the `_acme-challenge.domain-name` format.
+               * `DNS_TXT` - For this method, Akamai generates a `txt_record` with a token `value` that you copy as the `target` to a `TXT` record of your DNS configuration. The record's name needs to be in the `_akamai-{host|wildcard|domain}-challenge.domainName` format based on the validation scope.
+               * `HTTP` - Applies only to domains with the `HOST` validation scope. For this method, you create the file containing a token and place it on your HTTP server in the location specified by the `validation_challenge.http_file.path` or use a redirect to the `validation_challenge.http_redirect.to` with the token.
+        """
+        pulumi.set(__self__, "domain_name", domain_name)
+        pulumi.set(__self__, "validation_scope", validation_scope)
+        if validation_method is not None:
+            pulumi.set(__self__, "validation_method", validation_method)
+
+    @_builtins.property
+    @pulumi.getter(name="domainName")
+    def domain_name(self) -> pulumi.Input[_builtins.str]:
+        """
+        Your domain's name.
+        """
+        return pulumi.get(self, "domain_name")
+
+    @domain_name.setter
+    def domain_name(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "domain_name", value)
+
+    @_builtins.property
+    @pulumi.getter(name="validationScope")
+    def validation_scope(self) -> pulumi.Input[_builtins.str]:
+        """
+        Your domain's validation scope. Possible values are: 
+        * `HOST` - The scope is only the exactly specified domain.
+        * `WILDCARD` - The scope covers any hostname within one subdomain level.
+        * `DOMAIN` - The scope covers any hostnames under the domain, regardless of the level of subdomains.
+        """
+        return pulumi.get(self, "validation_scope")
+
+    @validation_scope.setter
+    def validation_scope(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "validation_scope", value)
+
+    @_builtins.property
+    @pulumi.getter(name="validationMethod")
+    def validation_method(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The method used to validate the domain. Possible values are: 
+        * `DNS_CNAME` - For this method, Akamai generates a `cname_record` that you copy as the `target` to a `CNAME` record of your DNS configuration. The record's name needs to be in the `_acme-challenge.domain-name` format.
+        * `DNS_TXT` - For this method, Akamai generates a `txt_record` with a token `value` that you copy as the `target` to a `TXT` record of your DNS configuration. The record's name needs to be in the `_akamai-{host|wildcard|domain}-challenge.domainName` format based on the validation scope.
+        * `HTTP` - Applies only to domains with the `HOST` validation scope. For this method, you create the file containing a token and place it on your HTTP server in the location specified by the `validation_challenge.http_file.path` or use a redirect to the `validation_challenge.http_redirect.to` with the token.
+        """
+        return pulumi.get(self, "validation_method")
+
+    @validation_method.setter
+    def validation_method(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "validation_method", value)
+
+
+if not MYPY:
+    class PropertyDomainownershipValidationTimeoutsArgsDict(TypedDict):
+        create: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Optional configurable domains validation timeout to be used on resource create. By default it's 30m.
+        """
+        update: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Optional configurable domains validation timeout to be used on resource update. By default it's 30m.
+        """
+elif False:
+    PropertyDomainownershipValidationTimeoutsArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class PropertyDomainownershipValidationTimeoutsArgs:
+    def __init__(__self__, *,
+                 create: Optional[pulumi.Input[_builtins.str]] = None,
+                 update: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_builtins.str] create: Optional configurable domains validation timeout to be used on resource create. By default it's 30m.
+        :param pulumi.Input[_builtins.str] update: Optional configurable domains validation timeout to be used on resource update. By default it's 30m.
+        """
+        if create is not None:
+            pulumi.set(__self__, "create", create)
+        if update is not None:
+            pulumi.set(__self__, "update", update)
+
+    @_builtins.property
+    @pulumi.getter
+    def create(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Optional configurable domains validation timeout to be used on resource create. By default it's 30m.
+        """
+        return pulumi.get(self, "create")
+
+    @create.setter
+    def create(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "create", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def update(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Optional configurable domains validation timeout to be used on resource update. By default it's 30m.
+        """
+        return pulumi.get(self, "update")
+
+    @update.setter
+    def update(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "update", value)
+
+
 if not MYPY:
     class PropertyHostnameArgsDict(TypedDict):
         cert_provisioning_type: pulumi.Input[_builtins.str]
         cname_from: pulumi.Input[_builtins.str]
         cname_to: pulumi.Input[_builtins.str]
+        ccm_cert_statuses: NotRequired[pulumi.Input[Sequence[pulumi.Input['PropertyHostnameCcmCertStatusArgsDict']]]]
+        """
+        Deployment status for the RSA and ECDSA certificates created with Cloud Certificate Manager (CCM).
+        """
+        ccm_certificates: NotRequired[pulumi.Input['PropertyHostnameCcmCertificatesArgsDict']]
+        """
+        Certificate identifiers and links for the CCM-managed certificates.
+        """
         cert_statuses: NotRequired[pulumi.Input[Sequence[pulumi.Input['PropertyHostnameCertStatusArgsDict']]]]
         cname_type: NotRequired[pulumi.Input[_builtins.str]]
         edge_hostname_id: NotRequired[pulumi.Input[_builtins.str]]
@@ -9598,12 +12482,22 @@ class PropertyHostnameArgs:
                  cert_provisioning_type: pulumi.Input[_builtins.str],
                  cname_from: pulumi.Input[_builtins.str],
                  cname_to: pulumi.Input[_builtins.str],
+                 ccm_cert_statuses: Optional[pulumi.Input[Sequence[pulumi.Input['PropertyHostnameCcmCertStatusArgs']]]] = None,
+                 ccm_certificates: Optional[pulumi.Input['PropertyHostnameCcmCertificatesArgs']] = None,
                  cert_statuses: Optional[pulumi.Input[Sequence[pulumi.Input['PropertyHostnameCertStatusArgs']]]] = None,
                  cname_type: Optional[pulumi.Input[_builtins.str]] = None,
                  edge_hostname_id: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[Sequence[pulumi.Input['PropertyHostnameCcmCertStatusArgs']]] ccm_cert_statuses: Deployment status for the RSA and ECDSA certificates created with Cloud Certificate Manager (CCM).
+        :param pulumi.Input['PropertyHostnameCcmCertificatesArgs'] ccm_certificates: Certificate identifiers and links for the CCM-managed certificates.
+        """
         pulumi.set(__self__, "cert_provisioning_type", cert_provisioning_type)
         pulumi.set(__self__, "cname_from", cname_from)
         pulumi.set(__self__, "cname_to", cname_to)
+        if ccm_cert_statuses is not None:
+            pulumi.set(__self__, "ccm_cert_statuses", ccm_cert_statuses)
+        if ccm_certificates is not None:
+            pulumi.set(__self__, "ccm_certificates", ccm_certificates)
         if cert_statuses is not None:
             pulumi.set(__self__, "cert_statuses", cert_statuses)
         if cname_type is not None:
@@ -9638,6 +12532,30 @@ class PropertyHostnameArgs:
     def cname_to(self, value: pulumi.Input[_builtins.str]):
         pulumi.set(self, "cname_to", value)
 
+    @_builtins.property
+    @pulumi.getter(name="ccmCertStatuses")
+    def ccm_cert_statuses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['PropertyHostnameCcmCertStatusArgs']]]]:
+        """
+        Deployment status for the RSA and ECDSA certificates created with Cloud Certificate Manager (CCM).
+        """
+        return pulumi.get(self, "ccm_cert_statuses")
+
+    @ccm_cert_statuses.setter
+    def ccm_cert_statuses(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['PropertyHostnameCcmCertStatusArgs']]]]):
+        pulumi.set(self, "ccm_cert_statuses", value)
+
+    @_builtins.property
+    @pulumi.getter(name="ccmCertificates")
+    def ccm_certificates(self) -> Optional[pulumi.Input['PropertyHostnameCcmCertificatesArgs']]:
+        """
+        Certificate identifiers and links for the CCM-managed certificates.
+        """
+        return pulumi.get(self, "ccm_certificates")
+
+    @ccm_certificates.setter
+    def ccm_certificates(self, value: Optional[pulumi.Input['PropertyHostnameCcmCertificatesArgs']]):
+        pulumi.set(self, "ccm_certificates", value)
+
     @_builtins.property
     @pulumi.getter(name="certStatuses")
     def cert_statuses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['PropertyHostnameCertStatusArgs']]]]:
@@ -9736,6 +12654,150 @@ class PropertyHostnameBucketHostnamesArgs:
         pulumi.set(self, "cname_to", value)
 
 
+if not MYPY:
+    class PropertyHostnameCcmCertStatusArgsDict(TypedDict):
+        ecdsa_production_status: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Status of the ECDSA certificate on production network.
+        """
+        ecdsa_staging_status: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Status of the ECDSA certificate on staging network.
+        """
+        rsa_production_status: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Status of the RSA certificate on production network.
+        """
+        rsa_staging_status: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Status of the RSA certificate on staging network.
+        """
+elif False:
+    PropertyHostnameCcmCertStatusArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class PropertyHostnameCcmCertStatusArgs:
+    def __init__(__self__, *,
+                 ecdsa_production_status: Optional[pulumi.Input[_builtins.str]] = None,
+                 ecdsa_staging_status: Optional[pulumi.Input[_builtins.str]] = None,
+                 rsa_production_status: Optional[pulumi.Input[_builtins.str]] = None,
+                 rsa_staging_status: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_builtins.str] ecdsa_production_status: Status of the ECDSA certificate on production network.
+        :param pulumi.Input[_builtins.str] ecdsa_staging_status: Status of the ECDSA certificate on staging network.
+        :param pulumi.Input[_builtins.str] rsa_production_status: Status of the RSA certificate on production network.
+        :param pulumi.Input[_builtins.str] rsa_staging_status: Status of the RSA certificate on staging network.
+        """
+        if ecdsa_production_status is not None:
+            pulumi.set(__self__, "ecdsa_production_status", ecdsa_production_status)
+        if ecdsa_staging_status is not None:
+            pulumi.set(__self__, "ecdsa_staging_status", ecdsa_staging_status)
+        if rsa_production_status is not None:
+            pulumi.set(__self__, "rsa_production_status", rsa_production_status)
+        if rsa_staging_status is not None:
+            pulumi.set(__self__, "rsa_staging_status", rsa_staging_status)
+
+    @_builtins.property
+    @pulumi.getter(name="ecdsaProductionStatus")
+    def ecdsa_production_status(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Status of the ECDSA certificate on production network.
+        """
+        return pulumi.get(self, "ecdsa_production_status")
+
+    @ecdsa_production_status.setter
+    def ecdsa_production_status(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "ecdsa_production_status", value)
+
+    @_builtins.property
+    @pulumi.getter(name="ecdsaStagingStatus")
+    def ecdsa_staging_status(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Status of the ECDSA certificate on staging network.
+        """
+        return pulumi.get(self, "ecdsa_staging_status")
+
+    @ecdsa_staging_status.setter
+    def ecdsa_staging_status(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "ecdsa_staging_status", value)
+
+    @_builtins.property
+    @pulumi.getter(name="rsaProductionStatus")
+    def rsa_production_status(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Status of the RSA certificate on production network.
+        """
+        return pulumi.get(self, "rsa_production_status")
+
+    @rsa_production_status.setter
+    def rsa_production_status(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "rsa_production_status", value)
+
+    @_builtins.property
+    @pulumi.getter(name="rsaStagingStatus")
+    def rsa_staging_status(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Status of the RSA certificate on staging network.
+        """
+        return pulumi.get(self, "rsa_staging_status")
+
+    @rsa_staging_status.setter
+    def rsa_staging_status(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "rsa_staging_status", value)
+
+
+if not MYPY:
+    class PropertyHostnameCcmCertificatesArgsDict(TypedDict):
+        ecdsa_cert_id: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Certificate ID for ECDSA.
+        """
+        rsa_cert_id: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Certificate ID for RSA.
+        """
+elif False:
+    PropertyHostnameCcmCertificatesArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class PropertyHostnameCcmCertificatesArgs:
+    def __init__(__self__, *,
+                 ecdsa_cert_id: Optional[pulumi.Input[_builtins.str]] = None,
+                 rsa_cert_id: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_builtins.str] ecdsa_cert_id: Certificate ID for ECDSA.
+        :param pulumi.Input[_builtins.str] rsa_cert_id: Certificate ID for RSA.
+        """
+        if ecdsa_cert_id is not None:
+            pulumi.set(__self__, "ecdsa_cert_id", ecdsa_cert_id)
+        if rsa_cert_id is not None:
+            pulumi.set(__self__, "rsa_cert_id", rsa_cert_id)
+
+    @_builtins.property
+    @pulumi.getter(name="ecdsaCertId")
+    def ecdsa_cert_id(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Certificate ID for ECDSA.
+        """
+        return pulumi.get(self, "ecdsa_cert_id")
+
+    @ecdsa_cert_id.setter
+    def ecdsa_cert_id(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "ecdsa_cert_id", value)
+
+    @_builtins.property
+    @pulumi.getter(name="rsaCertId")
+    def rsa_cert_id(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Certificate ID for RSA.
+        """
+        return pulumi.get(self, "rsa_cert_id")
+
+    @rsa_cert_id.setter
+    def rsa_cert_id(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "rsa_cert_id", value)
+
+
 if not MYPY:
     class PropertyHostnameCertStatusArgsDict(TypedDict):
         hostname: NotRequired[pulumi.Input[_builtins.str]]
@@ -35009,6 +38071,573 @@ class GetImagingPolicyVideoPolicyVariableEnumOptionArgs:
         pulumi.set(self, "value", value)
 
 
+if not MYPY:
+    class GetPropertyDomainownershipSearchDomainsDomainArgsDict(TypedDict):
+        account_id: _builtins.str
+        """
+        Your account's ID.
+        """
+        domain_name: _builtins.str
+        """
+        Your domain's name.
+        """
+        domain_status: _builtins.str
+        """
+        The domain's validation status. Possible values are: 
+        * `REQUEST_ACCEPTED` - When you successfully submit the domain for validation.
+        * `VALIDATION_IN_PROGRESS` - When the DOM background jobs are trying to validate the domain.
+        * `VALIDATED` - When the validation is completed successfully. Akamai recognizes you as the domain owner.
+        * `TOKEN_EXPIRED` - When you haven't completed the validation in the requested time frame and the challenge token is not valid anymore. You need to generate new validation challenges for the domain.
+        * `INVALIDATED` - When the domain was invalidated and Akamai doesn't recognize you as its owner.
+        """
+        validation_challenge: 'GetPropertyDomainownershipSearchDomainsDomainValidationChallengeArgsDict'
+        """
+        The domain's validation challenge details.
+        """
+        validation_completed_date: _builtins.str
+        """
+        The timestamp indicating when the domain validation was completed.
+        """
+        validation_level: _builtins.str
+        """
+        The domain's validation level, either 'FQDN' (fully qualified domain name) or 'ROOT/WILDCARD'.
+        """
+        validation_method: _builtins.str
+        """
+        The method used to validate the domain. Possible values are: 
+        * `DNS_CNAME` - For this method, Akamai generates a `cname_record` that you copy as the `target` to a `CNAME` record of your DNS configuration. The record's name needs to be in the `_acme-challenge.domain-name` format.
+        * `DNS_TXT` - For this method, Akamai generates a `txt_record` with a token `value` that you copy as the `target` to a `TXT` record of your DNS configuration. The record's name needs to be in the `_akamai-{host|wildcard|domain}-challenge.domainName` format based on the validation scope.
+        * `HTTP` - Applies only to domains with the `HOST` validation scope. For this method, you create the file containing a token and place it on your HTTP server in the location specified by the `validation_challenge.http_file.path` or use a redirect to the `validation_challenge.http_redirect.to` with the token.
+        * `SYSTEM` - This method refers to domains that were automatically validated before Domain Validation Manager (DOM) was introduced.
+        * `MANUAL` - For this method, the DOM team manually performed the validation.
+        """
+        validation_requested_by: _builtins.str
+        """
+        The name of the user who requested the domain validation.
+        """
+        validation_requested_date: _builtins.str
+        """
+        The timestamp indicating when the domain validation was requested.
+        """
+        validation_scope: _builtins.str
+        """
+        Your domain's validation scope. Possible values are: 
+        * `HOST` - The scope is only the exactly specified domain.
+        * `WILDCARD` - The scope covers any hostname within one subdomain level.
+        * `DOMAIN` - The scope covers any hostnames under the domain, regardless of the level of subdomains.
+        """
+elif False:
+    GetPropertyDomainownershipSearchDomainsDomainArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class GetPropertyDomainownershipSearchDomainsDomainArgs:
+    def __init__(__self__, *,
+                 account_id: _builtins.str,
+                 domain_name: _builtins.str,
+                 domain_status: _builtins.str,
+                 validation_challenge: 'GetPropertyDomainownershipSearchDomainsDomainValidationChallengeArgs',
+                 validation_completed_date: _builtins.str,
+                 validation_level: _builtins.str,
+                 validation_method: _builtins.str,
+                 validation_requested_by: _builtins.str,
+                 validation_requested_date: _builtins.str,
+                 validation_scope: _builtins.str):
+        """
+        :param _builtins.str account_id: Your account's ID.
+        :param _builtins.str domain_name: Your domain's name.
+        :param _builtins.str domain_status: The domain's validation status. Possible values are: 
+               * `REQUEST_ACCEPTED` - When you successfully submit the domain for validation.
+               * `VALIDATION_IN_PROGRESS` - When the DOM background jobs are trying to validate the domain.
+               * `VALIDATED` - When the validation is completed successfully. Akamai recognizes you as the domain owner.
+               * `TOKEN_EXPIRED` - When you haven't completed the validation in the requested time frame and the challenge token is not valid anymore. You need to generate new validation challenges for the domain.
+               * `INVALIDATED` - When the domain was invalidated and Akamai doesn't recognize you as its owner.
+        :param 'GetPropertyDomainownershipSearchDomainsDomainValidationChallengeArgs' validation_challenge: The domain's validation challenge details.
+        :param _builtins.str validation_completed_date: The timestamp indicating when the domain validation was completed.
+        :param _builtins.str validation_level: The domain's validation level, either 'FQDN' (fully qualified domain name) or 'ROOT/WILDCARD'.
+        :param _builtins.str validation_method: The method used to validate the domain. Possible values are: 
+               * `DNS_CNAME` - For this method, Akamai generates a `cname_record` that you copy as the `target` to a `CNAME` record of your DNS configuration. The record's name needs to be in the `_acme-challenge.domain-name` format.
+               * `DNS_TXT` - For this method, Akamai generates a `txt_record` with a token `value` that you copy as the `target` to a `TXT` record of your DNS configuration. The record's name needs to be in the `_akamai-{host|wildcard|domain}-challenge.domainName` format based on the validation scope.
+               * `HTTP` - Applies only to domains with the `HOST` validation scope. For this method, you create the file containing a token and place it on your HTTP server in the location specified by the `validation_challenge.http_file.path` or use a redirect to the `validation_challenge.http_redirect.to` with the token.
+               * `SYSTEM` - This method refers to domains that were automatically validated before Domain Validation Manager (DOM) was introduced.
+               * `MANUAL` - For this method, the DOM team manually performed the validation.
+        :param _builtins.str validation_requested_by: The name of the user who requested the domain validation.
+        :param _builtins.str validation_requested_date: The timestamp indicating when the domain validation was requested.
+        :param _builtins.str validation_scope: Your domain's validation scope. Possible values are: 
+               * `HOST` - The scope is only the exactly specified domain.
+               * `WILDCARD` - The scope covers any hostname within one subdomain level.
+               * `DOMAIN` - The scope covers any hostnames under the domain, regardless of the level of subdomains.
+        """
+        pulumi.set(__self__, "account_id", account_id)
+        pulumi.set(__self__, "domain_name", domain_name)
+        pulumi.set(__self__, "domain_status", domain_status)
+        pulumi.set(__self__, "validation_challenge", validation_challenge)
+        pulumi.set(__self__, "validation_completed_date", validation_completed_date)
+        pulumi.set(__self__, "validation_level", validation_level)
+        pulumi.set(__self__, "validation_method", validation_method)
+        pulumi.set(__self__, "validation_requested_by", validation_requested_by)
+        pulumi.set(__self__, "validation_requested_date", validation_requested_date)
+        pulumi.set(__self__, "validation_scope", validation_scope)
+
+    @_builtins.property
+    @pulumi.getter(name="accountId")
+    def account_id(self) -> _builtins.str:
+        """
+        Your account's ID.
+        """
+        return pulumi.get(self, "account_id")
+
+    @account_id.setter
+    def account_id(self, value: _builtins.str):
+        pulumi.set(self, "account_id", value)
+
+    @_builtins.property
+    @pulumi.getter(name="domainName")
+    def domain_name(self) -> _builtins.str:
+        """
+        Your domain's name.
+        """
+        return pulumi.get(self, "domain_name")
+
+    @domain_name.setter
+    def domain_name(self, value: _builtins.str):
+        pulumi.set(self, "domain_name", value)
+
+    @_builtins.property
+    @pulumi.getter(name="domainStatus")
+    def domain_status(self) -> _builtins.str:
+        """
+        The domain's validation status. Possible values are: 
+        * `REQUEST_ACCEPTED` - When you successfully submit the domain for validation.
+        * `VALIDATION_IN_PROGRESS` - When the DOM background jobs are trying to validate the domain.
+        * `VALIDATED` - When the validation is completed successfully. Akamai recognizes you as the domain owner.
+        * `TOKEN_EXPIRED` - When you haven't completed the validation in the requested time frame and the challenge token is not valid anymore. You need to generate new validation challenges for the domain.
+        * `INVALIDATED` - When the domain was invalidated and Akamai doesn't recognize you as its owner.
+        """
+        return pulumi.get(self, "domain_status")
+
+    @domain_status.setter
+    def domain_status(self, value: _builtins.str):
+        pulumi.set(self, "domain_status", value)
+
+    @_builtins.property
+    @pulumi.getter(name="validationChallenge")
+    def validation_challenge(self) -> 'GetPropertyDomainownershipSearchDomainsDomainValidationChallengeArgs':
+        """
+        The domain's validation challenge details.
+        """
+        return pulumi.get(self, "validation_challenge")
+
+    @validation_challenge.setter
+    def validation_challenge(self, value: 'GetPropertyDomainownershipSearchDomainsDomainValidationChallengeArgs'):
+        pulumi.set(self, "validation_challenge", value)
+
+    @_builtins.property
+    @pulumi.getter(name="validationCompletedDate")
+    def validation_completed_date(self) -> _builtins.str:
+        """
+        The timestamp indicating when the domain validation was completed.
+        """
+        return pulumi.get(self, "validation_completed_date")
+
+    @validation_completed_date.setter
+    def validation_completed_date(self, value: _builtins.str):
+        pulumi.set(self, "validation_completed_date", value)
+
+    @_builtins.property
+    @pulumi.getter(name="validationLevel")
+    def validation_level(self) -> _builtins.str:
+        """
+        The domain's validation level, either 'FQDN' (fully qualified domain name) or 'ROOT/WILDCARD'.
+        """
+        return pulumi.get(self, "validation_level")
+
+    @validation_level.setter
+    def validation_level(self, value: _builtins.str):
+        pulumi.set(self, "validation_level", value)
+
+    @_builtins.property
+    @pulumi.getter(name="validationMethod")
+    def validation_method(self) -> _builtins.str:
+        """
+        The method used to validate the domain. Possible values are: 
+        * `DNS_CNAME` - For this method, Akamai generates a `cname_record` that you copy as the `target` to a `CNAME` record of your DNS configuration. The record's name needs to be in the `_acme-challenge.domain-name` format.
+        * `DNS_TXT` - For this method, Akamai generates a `txt_record` with a token `value` that you copy as the `target` to a `TXT` record of your DNS configuration. The record's name needs to be in the `_akamai-{host|wildcard|domain}-challenge.domainName` format based on the validation scope.
+        * `HTTP` - Applies only to domains with the `HOST` validation scope. For this method, you create the file containing a token and place it on your HTTP server in the location specified by the `validation_challenge.http_file.path` or use a redirect to the `validation_challenge.http_redirect.to` with the token.
+        * `SYSTEM` - This method refers to domains that were automatically validated before Domain Validation Manager (DOM) was introduced.
+        * `MANUAL` - For this method, the DOM team manually performed the validation.
+        """
+        return pulumi.get(self, "validation_method")
+
+    @validation_method.setter
+    def validation_method(self, value: _builtins.str):
+        pulumi.set(self, "validation_method", value)
+
+    @_builtins.property
+    @pulumi.getter(name="validationRequestedBy")
+    def validation_requested_by(self) -> _builtins.str:
+        """
+        The name of the user who requested the domain validation.
+        """
+        return pulumi.get(self, "validation_requested_by")
+
+    @validation_requested_by.setter
+    def validation_requested_by(self, value: _builtins.str):
+        pulumi.set(self, "validation_requested_by", value)
+
+    @_builtins.property
+    @pulumi.getter(name="validationRequestedDate")
+    def validation_requested_date(self) -> _builtins.str:
+        """
+        The timestamp indicating when the domain validation was requested.
+        """
+        return pulumi.get(self, "validation_requested_date")
+
+    @validation_requested_date.setter
+    def validation_requested_date(self, value: _builtins.str):
+        pulumi.set(self, "validation_requested_date", value)
+
+    @_builtins.property
+    @pulumi.getter(name="validationScope")
+    def validation_scope(self) -> _builtins.str:
+        """
+        Your domain's validation scope. Possible values are: 
+        * `HOST` - The scope is only the exactly specified domain.
+        * `WILDCARD` - The scope covers any hostname within one subdomain level.
+        * `DOMAIN` - The scope covers any hostnames under the domain, regardless of the level of subdomains.
+        """
+        return pulumi.get(self, "validation_scope")
+
+    @validation_scope.setter
+    def validation_scope(self, value: _builtins.str):
+        pulumi.set(self, "validation_scope", value)
+
+
+if not MYPY:
+    class GetPropertyDomainownershipSearchDomainsDomainValidationChallengeArgsDict(TypedDict):
+        cname_record: 'GetPropertyDomainownershipSearchDomainsDomainValidationChallengeCnameRecordArgsDict'
+        """
+        The details of the 'CNAME' record you copy to your DNS configuration to prove you own the domain. You should use the 'DNS_CNAME' method in most cases.
+        """
+        expiration_date: _builtins.str
+        """
+        The timestamp indicating when the challenge data expires.
+        """
+        http_file: 'GetPropertyDomainownershipSearchDomainsDomainValidationChallengeHttpFileArgsDict'
+        """
+        Available only for the 'HOST' validation scope. The details for the HTTP validation method in which you create a file containing a token and save it on your HTTP server at the provided URL. Alternatively, you can use the 'http_redirect' method.
+        """
+        http_redirect: 'GetPropertyDomainownershipSearchDomainsDomainValidationChallengeHttpRedirectArgsDict'
+        """
+        Available only for the 'HOST' validation scope. The details for the HTTP validation method in which you use a redirect URL with the token. Alternatively, you can use the 'http_file' method.
+        """
+        txt_record: 'GetPropertyDomainownershipSearchDomainsDomainValidationChallengeTxtRecordArgsDict'
+        """
+        The details of the 'TXT' record with the challenge token that you copy to your DNS configuration to prove you own the domain.
+        """
+elif False:
+    GetPropertyDomainownershipSearchDomainsDomainValidationChallengeArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class GetPropertyDomainownershipSearchDomainsDomainValidationChallengeArgs:
+    def __init__(__self__, *,
+                 cname_record: 'GetPropertyDomainownershipSearchDomainsDomainValidationChallengeCnameRecordArgs',
+                 expiration_date: _builtins.str,
+                 http_file: 'GetPropertyDomainownershipSearchDomainsDomainValidationChallengeHttpFileArgs',
+                 http_redirect: 'GetPropertyDomainownershipSearchDomainsDomainValidationChallengeHttpRedirectArgs',
+                 txt_record: 'GetPropertyDomainownershipSearchDomainsDomainValidationChallengeTxtRecordArgs'):
+        """
+        :param 'GetPropertyDomainownershipSearchDomainsDomainValidationChallengeCnameRecordArgs' cname_record: The details of the 'CNAME' record you copy to your DNS configuration to prove you own the domain. You should use the 'DNS_CNAME' method in most cases.
+        :param _builtins.str expiration_date: The timestamp indicating when the challenge data expires.
+        :param 'GetPropertyDomainownershipSearchDomainsDomainValidationChallengeHttpFileArgs' http_file: Available only for the 'HOST' validation scope. The details for the HTTP validation method in which you create a file containing a token and save it on your HTTP server at the provided URL. Alternatively, you can use the 'http_redirect' method.
+        :param 'GetPropertyDomainownershipSearchDomainsDomainValidationChallengeHttpRedirectArgs' http_redirect: Available only for the 'HOST' validation scope. The details for the HTTP validation method in which you use a redirect URL with the token. Alternatively, you can use the 'http_file' method.
+        :param 'GetPropertyDomainownershipSearchDomainsDomainValidationChallengeTxtRecordArgs' txt_record: The details of the 'TXT' record with the challenge token that you copy to your DNS configuration to prove you own the domain.
+        """
+        pulumi.set(__self__, "cname_record", cname_record)
+        pulumi.set(__self__, "expiration_date", expiration_date)
+        pulumi.set(__self__, "http_file", http_file)
+        pulumi.set(__self__, "http_redirect", http_redirect)
+        pulumi.set(__self__, "txt_record", txt_record)
+
+    @_builtins.property
+    @pulumi.getter(name="cnameRecord")
+    def cname_record(self) -> 'GetPropertyDomainownershipSearchDomainsDomainValidationChallengeCnameRecordArgs':
+        """
+        The details of the 'CNAME' record you copy to your DNS configuration to prove you own the domain. You should use the 'DNS_CNAME' method in most cases.
+        """
+        return pulumi.get(self, "cname_record")
+
+    @cname_record.setter
+    def cname_record(self, value: 'GetPropertyDomainownershipSearchDomainsDomainValidationChallengeCnameRecordArgs'):
+        pulumi.set(self, "cname_record", value)
+
+    @_builtins.property
+    @pulumi.getter(name="expirationDate")
+    def expiration_date(self) -> _builtins.str:
+        """
+        The timestamp indicating when the challenge data expires.
+        """
+        return pulumi.get(self, "expiration_date")
+
+    @expiration_date.setter
+    def expiration_date(self, value: _builtins.str):
+        pulumi.set(self, "expiration_date", value)
+
+    @_builtins.property
+    @pulumi.getter(name="httpFile")
+    def http_file(self) -> 'GetPropertyDomainownershipSearchDomainsDomainValidationChallengeHttpFileArgs':
+        """
+        Available only for the 'HOST' validation scope. The details for the HTTP validation method in which you create a file containing a token and save it on your HTTP server at the provided URL. Alternatively, you can use the 'http_redirect' method.
+        """
+        return pulumi.get(self, "http_file")
+
+    @http_file.setter
+    def http_file(self, value: 'GetPropertyDomainownershipSearchDomainsDomainValidationChallengeHttpFileArgs'):
+        pulumi.set(self, "http_file", value)
+
+    @_builtins.property
+    @pulumi.getter(name="httpRedirect")
+    def http_redirect(self) -> 'GetPropertyDomainownershipSearchDomainsDomainValidationChallengeHttpRedirectArgs':
+        """
+        Available only for the 'HOST' validation scope. The details for the HTTP validation method in which you use a redirect URL with the token. Alternatively, you can use the 'http_file' method.
+        """
+        return pulumi.get(self, "http_redirect")
+
+    @http_redirect.setter
+    def http_redirect(self, value: 'GetPropertyDomainownershipSearchDomainsDomainValidationChallengeHttpRedirectArgs'):
+        pulumi.set(self, "http_redirect", value)
+
+    @_builtins.property
+    @pulumi.getter(name="txtRecord")
+    def txt_record(self) -> 'GetPropertyDomainownershipSearchDomainsDomainValidationChallengeTxtRecordArgs':
+        """
+        The details of the 'TXT' record with the challenge token that you copy to your DNS configuration to prove you own the domain.
+        """
+        return pulumi.get(self, "txt_record")
+
+    @txt_record.setter
+    def txt_record(self, value: 'GetPropertyDomainownershipSearchDomainsDomainValidationChallengeTxtRecordArgs'):
+        pulumi.set(self, "txt_record", value)
+
+
+if not MYPY:
+    class GetPropertyDomainownershipSearchDomainsDomainValidationChallengeCnameRecordArgsDict(TypedDict):
+        name: _builtins.str
+        """
+        The 'CNAME' record for your domain that you add to the DNS configuration.
+        """
+        target: _builtins.str
+        """
+        The 'target' value you set in the 'CNAME' record that validates the domain ownership.
+        """
+elif False:
+    GetPropertyDomainownershipSearchDomainsDomainValidationChallengeCnameRecordArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class GetPropertyDomainownershipSearchDomainsDomainValidationChallengeCnameRecordArgs:
+    def __init__(__self__, *,
+                 name: _builtins.str,
+                 target: _builtins.str):
+        """
+        :param _builtins.str name: The 'CNAME' record for your domain that you add to the DNS configuration.
+        :param _builtins.str target: The 'target' value you set in the 'CNAME' record that validates the domain ownership.
+        """
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "target", target)
+
+    @_builtins.property
+    @pulumi.getter
+    def name(self) -> _builtins.str:
+        """
+        The 'CNAME' record for your domain that you add to the DNS configuration.
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: _builtins.str):
+        pulumi.set(self, "name", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def target(self) -> _builtins.str:
+        """
+        The 'target' value you set in the 'CNAME' record that validates the domain ownership.
+        """
+        return pulumi.get(self, "target")
+
+    @target.setter
+    def target(self, value: _builtins.str):
+        pulumi.set(self, "target", value)
+
+
+if not MYPY:
+    class GetPropertyDomainownershipSearchDomainsDomainValidationChallengeHttpFileArgsDict(TypedDict):
+        content: _builtins.str
+        """
+        The content of the file that you should place at the specified URL.
+        """
+        content_type: _builtins.str
+        """
+        The content type of the file containing the token.
+        """
+        path: _builtins.str
+        """
+        The URL where you should place the file containing the challenge token.
+        """
+elif False:
+    GetPropertyDomainownershipSearchDomainsDomainValidationChallengeHttpFileArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class GetPropertyDomainownershipSearchDomainsDomainValidationChallengeHttpFileArgs:
+    def __init__(__self__, *,
+                 content: _builtins.str,
+                 content_type: _builtins.str,
+                 path: _builtins.str):
+        """
+        :param _builtins.str content: The content of the file that you should place at the specified URL.
+        :param _builtins.str content_type: The content type of the file containing the token.
+        :param _builtins.str path: The URL where you should place the file containing the challenge token.
+        """
+        pulumi.set(__self__, "content", content)
+        pulumi.set(__self__, "content_type", content_type)
+        pulumi.set(__self__, "path", path)
+
+    @_builtins.property
+    @pulumi.getter
+    def content(self) -> _builtins.str:
+        """
+        The content of the file that you should place at the specified URL.
+        """
+        return pulumi.get(self, "content")
+
+    @content.setter
+    def content(self, value: _builtins.str):
+        pulumi.set(self, "content", value)
+
+    @_builtins.property
+    @pulumi.getter(name="contentType")
+    def content_type(self) -> _builtins.str:
+        """
+        The content type of the file containing the token.
+        """
+        return pulumi.get(self, "content_type")
+
+    @content_type.setter
+    def content_type(self, value: _builtins.str):
+        pulumi.set(self, "content_type", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def path(self) -> _builtins.str:
+        """
+        The URL where you should place the file containing the challenge token.
+        """
+        return pulumi.get(self, "path")
+
+    @path.setter
+    def path(self, value: _builtins.str):
+        pulumi.set(self, "path", value)
+
+
+if not MYPY:
+    class GetPropertyDomainownershipSearchDomainsDomainValidationChallengeHttpRedirectArgsDict(TypedDict):
+        from_: _builtins.str
+        """
+        The location on your HTTP server where you set up the redirect.
+        """
+        to: _builtins.str
+        """
+        The redirect URL with the token that you place on your HTTP server.
+        """
+elif False:
+    GetPropertyDomainownershipSearchDomainsDomainValidationChallengeHttpRedirectArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class GetPropertyDomainownershipSearchDomainsDomainValidationChallengeHttpRedirectArgs:
+    def __init__(__self__, *,
+                 from_: _builtins.str,
+                 to: _builtins.str):
+        """
+        :param _builtins.str from_: The location on your HTTP server where you set up the redirect.
+        :param _builtins.str to: The redirect URL with the token that you place on your HTTP server.
+        """
+        pulumi.set(__self__, "from_", from_)
+        pulumi.set(__self__, "to", to)
+
+    @_builtins.property
+    @pulumi.getter(name="from")
+    def from_(self) -> _builtins.str:
+        """
+        The location on your HTTP server where you set up the redirect.
+        """
+        return pulumi.get(self, "from_")
+
+    @from_.setter
+    def from_(self, value: _builtins.str):
+        pulumi.set(self, "from_", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def to(self) -> _builtins.str:
+        """
+        The redirect URL with the token that you place on your HTTP server.
+        """
+        return pulumi.get(self, "to")
+
+    @to.setter
+    def to(self, value: _builtins.str):
+        pulumi.set(self, "to", value)
+
+
+if not MYPY:
+    class GetPropertyDomainownershipSearchDomainsDomainValidationChallengeTxtRecordArgsDict(TypedDict):
+        name: _builtins.str
+        """
+        The hostname where you should add the 'TXT' record to validate the domain ownership.
+        """
+        value: _builtins.str
+        """
+        The token you need to copy to the DNS 'TXT' record that validates the domain ownership.
+        """
+elif False:
+    GetPropertyDomainownershipSearchDomainsDomainValidationChallengeTxtRecordArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class GetPropertyDomainownershipSearchDomainsDomainValidationChallengeTxtRecordArgs:
+    def __init__(__self__, *,
+                 name: _builtins.str,
+                 value: _builtins.str):
+        """
+        :param _builtins.str name: The hostname where you should add the 'TXT' record to validate the domain ownership.
+        :param _builtins.str value: The token you need to copy to the DNS 'TXT' record that validates the domain ownership.
+        """
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "value", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def name(self) -> _builtins.str:
+        """
+        The hostname where you should add the 'TXT' record to validate the domain ownership.
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: _builtins.str):
+        pulumi.set(self, "name", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def value(self) -> _builtins.str:
+        """
+        The token you need to copy to the DNS 'TXT' record that validates the domain ownership.
+        """
+        return pulumi.get(self, "value")
+
+    @value.setter
+    def value(self, value: _builtins.str):
+        pulumi.set(self, "value", value)
+
+
 if not MYPY:
     class GetPropertyIncludesParentPropertyArgsDict(TypedDict):
         id: _builtins.str