pulumi-azure-native 2.88.0a1739348902__py3-none-any.whl → 2.89.0__py3-none-any.whl

pulumi_azure_native/keyvault/v20241201preview/outputs.py

@@ -1968,8 +1968,12 @@ class VaultPropertiesResponse(dict):
             suggest = "hsm_pool_resource_id"
         elif key == "privateEndpointConnections":
             suggest = "private_endpoint_connections"
+        elif key == "provisioningState":
+            suggest = "provisioning_state"
         elif key == "tenantId":
             suggest = "tenant_id"
+        elif key == "vaultUri":
+            suggest = "vault_uri"
         elif key == "accessPolicies":
             suggest = "access_policies"
         elif key == "enablePurgeProtection":
@@ -1986,14 +1990,10 @@ class VaultPropertiesResponse(dict):
             suggest = "enabled_for_template_deployment"
         elif key == "networkAcls":
             suggest = "network_acls"
-        elif key == "provisioningState":
-            suggest = "provisioning_state"
         elif key == "publicNetworkAccess":
             suggest = "public_network_access"
         elif key == "softDeleteRetentionInDays":
             suggest = "soft_delete_retention_in_days"
-        elif key == "vaultUri":
-            suggest = "vault_uri"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in VaultPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
@@ -2009,8 +2009,10 @@ class VaultPropertiesResponse(dict):
     def __init__(__self__, *,
                  hsm_pool_resource_id: str,
                  private_endpoint_connections: Sequence['outputs.PrivateEndpointConnectionItemResponse'],
+                 provisioning_state: str,
                  sku: 'outputs.SkuResponse',
                  tenant_id: str,
+                 vault_uri: str,
                  access_policies: Optional[Sequence['outputs.AccessPolicyEntryResponse']] = None,
                  enable_purge_protection: Optional[bool] = None,
                  enable_rbac_authorization: Optional[bool] = None,
@@ -2019,16 +2021,16 @@ class VaultPropertiesResponse(dict):
                  enabled_for_disk_encryption: Optional[bool] = None,
                  enabled_for_template_deployment: Optional[bool] = None,
                  network_acls: Optional['outputs.NetworkRuleSetResponse'] = None,
-                 provisioning_state: Optional[str] = None,
                  public_network_access: Optional[str] = None,
-                 soft_delete_retention_in_days: Optional[int] = None,
-                 vault_uri: Optional[str] = None):
+                 soft_delete_retention_in_days: Optional[int] = None):
         """
         Properties of the vault
         :param str hsm_pool_resource_id: The resource id of HSM Pool.
         :param Sequence['PrivateEndpointConnectionItemResponse'] private_endpoint_connections: List of private endpoint connections associated with the key vault.
+        :param str provisioning_state: Provisioning state of the vault.
         :param 'SkuResponse' sku: SKU details
         :param str tenant_id: The Azure Active Directory tenant ID that should be used for authenticating requests to the key vault.
+        :param str vault_uri: The URI of the vault for performing operations on keys and secrets.
         :param Sequence['AccessPolicyEntryResponse'] access_policies: An array of 0 to 1024 identities that have access to the key vault. All identities in the array must use the same tenant ID as the key vault's tenant ID. When `createMode` is set to `recover`, access policies are not required. Otherwise, access policies are required.
                These are also available as standalone resources. Do not mix inline and standalone resource as they will conflict with each other, leading to resources deletion.
         :param bool enable_purge_protection: Property specifying whether protection against purge is enabled for this vault. Setting this property to true activates protection against purge for this vault and its content - only the Key Vault service may initiate a hard, irrecoverable deletion. The setting is effective only if soft delete is also enabled. Enabling this functionality is irreversible - that is, the property does not accept false as its value.
@@ -2038,15 +2040,15 @@ class VaultPropertiesResponse(dict):
         :param bool enabled_for_disk_encryption: Property to specify whether Azure Disk Encryption is permitted to retrieve secrets from the vault and unwrap keys.
         :param bool enabled_for_template_deployment: Property to specify whether Azure Resource Manager is permitted to retrieve secrets from the key vault.
         :param 'NetworkRuleSetResponse' network_acls: Rules governing the accessibility of the key vault from specific network locations.
-        :param str provisioning_state: Provisioning state of the vault.
         :param str public_network_access: Property to specify whether the vault will accept traffic from public internet. If set to 'disabled' all traffic except private endpoint traffic and that that originates from trusted services will be blocked. This will override the set firewall rules, meaning that even if the firewall rules are present we will not honor the rules.
         :param int soft_delete_retention_in_days: softDelete data retention days. It accepts >=7 and <=90.
-        :param str vault_uri: The URI of the vault for performing operations on keys and secrets.
         """
         pulumi.set(__self__, "hsm_pool_resource_id", hsm_pool_resource_id)
         pulumi.set(__self__, "private_endpoint_connections", private_endpoint_connections)
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
         pulumi.set(__self__, "sku", sku)
         pulumi.set(__self__, "tenant_id", tenant_id)
+        pulumi.set(__self__, "vault_uri", vault_uri)
         if access_policies is not None:
             pulumi.set(__self__, "access_policies", access_policies)
         if enable_purge_protection is not None:
@@ -2073,8 +2075,6 @@ class VaultPropertiesResponse(dict):
             pulumi.set(__self__, "enabled_for_template_deployment", enabled_for_template_deployment)
         if network_acls is not None:
             pulumi.set(__self__, "network_acls", network_acls)
-        if provisioning_state is not None:
-            pulumi.set(__self__, "provisioning_state", provisioning_state)
         if public_network_access is None:
             public_network_access = 'enabled'
         if public_network_access is not None:
@@ -2083,8 +2083,6 @@ class VaultPropertiesResponse(dict):
             soft_delete_retention_in_days = 90
         if soft_delete_retention_in_days is not None:
             pulumi.set(__self__, "soft_delete_retention_in_days", soft_delete_retention_in_days)
-        if vault_uri is not None:
-            pulumi.set(__self__, "vault_uri", vault_uri)
 
     @property
     @pulumi.getter(name="hsmPoolResourceId")
@@ -2102,6 +2100,14 @@ class VaultPropertiesResponse(dict):
         """
         return pulumi.get(self, "private_endpoint_connections")
 
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> str:
+        """
+        Provisioning state of the vault.
+        """
+        return pulumi.get(self, "provisioning_state")
+
     @property
     @pulumi.getter
     def sku(self) -> 'outputs.SkuResponse':
@@ -2118,6 +2124,14 @@ class VaultPropertiesResponse(dict):
         """
         return pulumi.get(self, "tenant_id")
 
+    @property
+    @pulumi.getter(name="vaultUri")
+    def vault_uri(self) -> str:
+        """
+        The URI of the vault for performing operations on keys and secrets.
+        """
+        return pulumi.get(self, "vault_uri")
+
     @property
     @pulumi.getter(name="accessPolicies")
     def access_policies(self) -> Optional[Sequence['outputs.AccessPolicyEntryResponse']]:
@@ -2183,14 +2197,6 @@ class VaultPropertiesResponse(dict):
         """
         return pulumi.get(self, "network_acls")
 
-    @property
-    @pulumi.getter(name="provisioningState")
-    def provisioning_state(self) -> Optional[str]:
-        """
-        Provisioning state of the vault.
-        """
-        return pulumi.get(self, "provisioning_state")
-
     @property
     @pulumi.getter(name="publicNetworkAccess")
     def public_network_access(self) -> Optional[str]:
@@ -2207,14 +2213,6 @@ class VaultPropertiesResponse(dict):
         """
         return pulumi.get(self, "soft_delete_retention_in_days")
 
-    @property
-    @pulumi.getter(name="vaultUri")
-    def vault_uri(self) -> Optional[str]:
-        """
-        The URI of the vault for performing operations on keys and secrets.
-        """
-        return pulumi.get(self, "vault_uri")
-
 
 @pulumi.output_type
 class VirtualNetworkRuleResponse(dict):

pulumi_azure_native/machinelearningservices/v20241001preview/_inputs.py

@@ -564,8 +564,6 @@ __all__ = [
     'SynapseSparkPropertiesArgsDict',
     'SynapseSparkArgs',
     'SynapseSparkArgsDict',
-    'SyndicatedRegistryArgs',
-    'SyndicatedRegistryArgsDict',
     'SystemCreatedAcrAccountArgs',
     'SystemCreatedAcrAccountArgsDict',
     'SystemCreatedStorageAccountArgs',
@@ -28979,13 +28977,9 @@ class RegistryRegionArmDetailsArgs:
 
 if not MYPY:
     class RegistrySyndicatedRegistriesArgsDict(TypedDict):
-        syndicated_registry: NotRequired[pulumi.Input['SyndicatedRegistryArgsDict']]
-        """
-        A registry that is syndicated
-        """
-        syndicated_registry_guid: NotRequired[pulumi.Input[str]]
+        registry_id: NotRequired[pulumi.Input[str]]
         """
-        The Guid of the syndicated registry
+        Registry id guid of a destination registry that this registry can syndicate to 
         """
 elif False:
     RegistrySyndicatedRegistriesArgsDict: TypeAlias = Mapping[str, Any]
@@ -28993,40 +28987,24 @@ elif False:
 @pulumi.input_type
 class RegistrySyndicatedRegistriesArgs:
     def __init__(__self__, *,
-                 syndicated_registry: Optional[pulumi.Input['SyndicatedRegistryArgs']] = None,
-                 syndicated_registry_guid: Optional[pulumi.Input[str]] = None):
-        """
-        :param pulumi.Input['SyndicatedRegistryArgs'] syndicated_registry: A registry that is syndicated
-        :param pulumi.Input[str] syndicated_registry_guid: The Guid of the syndicated registry
-        """
-        if syndicated_registry is not None:
-            pulumi.set(__self__, "syndicated_registry", syndicated_registry)
-        if syndicated_registry_guid is not None:
-            pulumi.set(__self__, "syndicated_registry_guid", syndicated_registry_guid)
-
-    @property
-    @pulumi.getter(name="syndicatedRegistry")
-    def syndicated_registry(self) -> Optional[pulumi.Input['SyndicatedRegistryArgs']]:
+                 registry_id: Optional[pulumi.Input[str]] = None):
         """
-        A registry that is syndicated
+        :param pulumi.Input[str] registry_id: Registry id guid of a destination registry that this registry can syndicate to 
         """
-        return pulumi.get(self, "syndicated_registry")
-
-    @syndicated_registry.setter
-    def syndicated_registry(self, value: Optional[pulumi.Input['SyndicatedRegistryArgs']]):
-        pulumi.set(self, "syndicated_registry", value)
+        if registry_id is not None:
+            pulumi.set(__self__, "registry_id", registry_id)
 
     @property
-    @pulumi.getter(name="syndicatedRegistryGuid")
-    def syndicated_registry_guid(self) -> Optional[pulumi.Input[str]]:
+    @pulumi.getter(name="registryId")
+    def registry_id(self) -> Optional[pulumi.Input[str]]:
         """
-        The Guid of the syndicated registry
+        Registry id guid of a destination registry that this registry can syndicate to 
         """
-        return pulumi.get(self, "syndicated_registry_guid")
+        return pulumi.get(self, "registry_id")
 
-    @syndicated_registry_guid.setter
-    def syndicated_registry_guid(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "syndicated_registry_guid", value)
+    @registry_id.setter
+    def registry_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "registry_id", value)
 
 
 if not MYPY:
@@ -29064,9 +29042,6 @@ if not MYPY:
         Private endpoint connections info used for pending connections in private link portal
         """
         syndicated_registries: NotRequired[pulumi.Input[Sequence[pulumi.Input['RegistrySyndicatedRegistriesArgsDict']]]]
-        """
-        List of tuples containing Guid and SyndicatedRegistry
-        """
 elif False:
     RegistryArgsDict: TypeAlias = Mapping[str, Any]
 
@@ -29091,7 +29066,6 @@ class RegistryArgs:
                Possible values: "Enabled" or "Disabled"
         :param pulumi.Input[Sequence[pulumi.Input['RegistryRegionArmDetailsArgs']]] region_details: Details of each region the registry is in
         :param pulumi.Input[Sequence[pulumi.Input['RegistryPrivateEndpointConnectionArgs']]] registry_private_endpoint_connections: Private endpoint connections info used for pending connections in private link portal
-        :param pulumi.Input[Sequence[pulumi.Input['RegistrySyndicatedRegistriesArgs']]] syndicated_registries: List of tuples containing Guid and SyndicatedRegistry
         """
         if discovery_url is not None:
             pulumi.set(__self__, "discovery_url", discovery_url)
@@ -29198,9 +29172,6 @@ class RegistryArgs:
     @property
     @pulumi.getter(name="syndicatedRegistries")
     def syndicated_registries(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RegistrySyndicatedRegistriesArgs']]]]:
-        """
-        List of tuples containing Guid and SyndicatedRegistry
-        """
         return pulumi.get(self, "syndicated_registries")
 
     @syndicated_registries.setter
@@ -34142,42 +34113,6 @@ class SynapseSparkArgs:
         pulumi.set(self, "resource_id", value)
 
 
-if not MYPY:
-    class SyndicatedRegistryArgsDict(TypedDict):
-        """
-        A registry that is syndicated
-        """
-        registry_id: NotRequired[pulumi.Input[str]]
-        """
-        The Registry Id of the syndicated Registry
-        """
-elif False:
-    SyndicatedRegistryArgsDict: TypeAlias = Mapping[str, Any]
-
-@pulumi.input_type
-class SyndicatedRegistryArgs:
-    def __init__(__self__, *,
-                 registry_id: Optional[pulumi.Input[str]] = None):
-        """
-        A registry that is syndicated
-        :param pulumi.Input[str] registry_id: The Registry Id of the syndicated Registry
-        """
-        if registry_id is not None:
-            pulumi.set(__self__, "registry_id", registry_id)
-
-    @property
-    @pulumi.getter(name="registryId")
-    def registry_id(self) -> Optional[pulumi.Input[str]]:
-        """
-        The Registry Id of the syndicated Registry
-        """
-        return pulumi.get(self, "registry_id")
-
-    @registry_id.setter
-    def registry_id(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "registry_id", value)
-
-
 if not MYPY:
     class SystemCreatedAcrAccountArgsDict(TypedDict):
         acr_account_name: NotRequired[pulumi.Input[str]]

pulumi_azure_native/machinelearningservices/v20241001preview/outputs.py

@@ -324,7 +324,6 @@ __all__ = [
     'SweepJobResponse',
     'SynapseSparkResponse',
     'SynapseSparkResponseProperties',
-    'SyndicatedRegistryResponse',
     'SystemCreatedAcrAccountResponse',
     'SystemCreatedStorageAccountResponse',
     'SystemDataResponse',
@@ -26257,7 +26256,6 @@ class RegistryResponse(dict):
                Possible values: "Enabled" or "Disabled"
         :param Sequence['RegistryRegionArmDetailsResponse'] region_details: Details of each region the registry is in
         :param Sequence['RegistryPrivateEndpointConnectionResponse'] registry_private_endpoint_connections: Private endpoint connections info used for pending connections in private link portal
-        :param Sequence['RegistryResponseSyndicatedRegistries'] syndicated_registries: List of tuples containing Guid and SyndicatedRegistry
         """
         if discovery_url is not None:
             pulumi.set(__self__, "discovery_url", discovery_url)
@@ -26346,9 +26344,6 @@ class RegistryResponse(dict):
     @property
     @pulumi.getter(name="syndicatedRegistries")
     def syndicated_registries(self) -> Optional[Sequence['outputs.RegistryResponseSyndicatedRegistries']]:
-        """
-        List of tuples containing Guid and SyndicatedRegistry
-        """
         return pulumi.get(self, "syndicated_registries")
 
 
@@ -26357,10 +26352,8 @@ class RegistryResponseSyndicatedRegistries(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "syndicatedRegistry":
-            suggest = "syndicated_registry"
-        elif key == "syndicatedRegistryGuid":
-            suggest = "syndicated_registry_guid"
+        if key == "registryId":
+            suggest = "registry_id"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in RegistryResponseSyndicatedRegistries. Access the value via the '{suggest}' property getter instead.")
@@ -26374,32 +26367,20 @@ class RegistryResponseSyndicatedRegistries(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 syndicated_registry: Optional['outputs.SyndicatedRegistryResponse'] = None,
-                 syndicated_registry_guid: Optional[str] = None):
-        """
-        :param 'SyndicatedRegistryResponse' syndicated_registry: A registry that is syndicated
-        :param str syndicated_registry_guid: The Guid of the syndicated registry
-        """
-        if syndicated_registry is not None:
-            pulumi.set(__self__, "syndicated_registry", syndicated_registry)
-        if syndicated_registry_guid is not None:
-            pulumi.set(__self__, "syndicated_registry_guid", syndicated_registry_guid)
-
-    @property
-    @pulumi.getter(name="syndicatedRegistry")
-    def syndicated_registry(self) -> Optional['outputs.SyndicatedRegistryResponse']:
+                 registry_id: Optional[str] = None):
         """
-        A registry that is syndicated
+        :param str registry_id: Registry id guid of a destination registry that this registry can syndicate to 
         """
-        return pulumi.get(self, "syndicated_registry")
+        if registry_id is not None:
+            pulumi.set(__self__, "registry_id", registry_id)
 
     @property
-    @pulumi.getter(name="syndicatedRegistryGuid")
-    def syndicated_registry_guid(self) -> Optional[str]:
+    @pulumi.getter(name="registryId")
+    def registry_id(self) -> Optional[str]:
         """
-        The Guid of the syndicated registry
+        Registry id guid of a destination registry that this registry can syndicate to 
         """
-        return pulumi.get(self, "syndicated_registry_guid")
+        return pulumi.get(self, "registry_id")
 
 
 @pulumi.output_type
@@ -30339,46 +30320,6 @@ class SynapseSparkResponseProperties(dict):
         return pulumi.get(self, "workspace_name")
 
 
-@pulumi.output_type
-class SyndicatedRegistryResponse(dict):
-    """
-    A registry that is syndicated
-    """
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "registryId":
-            suggest = "registry_id"
-
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in SyndicatedRegistryResponse. Access the value via the '{suggest}' property getter instead.")
-
-    def __getitem__(self, key: str) -> Any:
-        SyndicatedRegistryResponse.__key_warning(key)
-        return super().__getitem__(key)
-
-    def get(self, key: str, default = None) -> Any:
-        SyndicatedRegistryResponse.__key_warning(key)
-        return super().get(key, default)
-
-    def __init__(__self__, *,
-                 registry_id: Optional[str] = None):
-        """
-        A registry that is syndicated
-        :param str registry_id: The Registry Id of the syndicated Registry
-        """
-        if registry_id is not None:
-            pulumi.set(__self__, "registry_id", registry_id)
-
-    @property
-    @pulumi.getter(name="registryId")
-    def registry_id(self) -> Optional[str]:
-        """
-        The Registry Id of the syndicated Registry
-        """
-        return pulumi.get(self, "registry_id")
-
-
 @pulumi.output_type
 class SystemCreatedAcrAccountResponse(dict):
     @staticmethod

pulumi_azure_native/netapp/__init__.py

@@ -11,6 +11,7 @@ from .backup import *
 from .backup_policy import *
 from .backup_vault import *
 from .get_account import *
+from .get_account_key_vault_status import *
 from .get_backup import *
 from .get_backup_policy import *
 from .get_backup_vault import *

pulumi_azure_native/netapp/get_account_key_vault_status.py

@@ -0,0 +1,131 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import copy
+import warnings
+import sys
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
+from .. import _utilities
+from . import outputs
+
+__all__ = [
+    'GetAccountKeyVaultStatusResult',
+    'AwaitableGetAccountKeyVaultStatusResult',
+    'get_account_key_vault_status',
+    'get_account_key_vault_status_output',
+]
+
+@pulumi.output_type
+class GetAccountKeyVaultStatusResult:
+    """
+    Result of getKeyVaultStatus with information about how volumes under NetApp account are encrypted.
+    """
+    def __init__(__self__, key_name=None, key_vault_private_endpoints=None, key_vault_resource_id=None, key_vault_uri=None):
+        if key_name and not isinstance(key_name, str):
+            raise TypeError("Expected argument 'key_name' to be a str")
+        pulumi.set(__self__, "key_name", key_name)
+        if key_vault_private_endpoints and not isinstance(key_vault_private_endpoints, list):
+            raise TypeError("Expected argument 'key_vault_private_endpoints' to be a list")
+        pulumi.set(__self__, "key_vault_private_endpoints", key_vault_private_endpoints)
+        if key_vault_resource_id and not isinstance(key_vault_resource_id, str):
+            raise TypeError("Expected argument 'key_vault_resource_id' to be a str")
+        pulumi.set(__self__, "key_vault_resource_id", key_vault_resource_id)
+        if key_vault_uri and not isinstance(key_vault_uri, str):
+            raise TypeError("Expected argument 'key_vault_uri' to be a str")
+        pulumi.set(__self__, "key_vault_uri", key_vault_uri)
+
+    @property
+    @pulumi.getter(name="keyName")
+    def key_name(self) -> Optional[str]:
+        """
+        The name of the key that should be used for encryption.
+        """
+        return pulumi.get(self, "key_name")
+
+    @property
+    @pulumi.getter(name="keyVaultPrivateEndpoints")
+    def key_vault_private_endpoints(self) -> Optional[Sequence['outputs.KeyVaultPrivateEndpointResponse']]:
+        """
+        Pairs of virtual network ID and private endpoint ID. Every virtual network that has volumes encrypted with customer-managed keys needs its own key vault private endpoint.
+        """
+        return pulumi.get(self, "key_vault_private_endpoints")
+
+    @property
+    @pulumi.getter(name="keyVaultResourceId")
+    def key_vault_resource_id(self) -> Optional[str]:
+        """
+        Azure resource ID of the key vault/managed HSM that should be used for encryption.
+        """
+        return pulumi.get(self, "key_vault_resource_id")
+
+    @property
+    @pulumi.getter(name="keyVaultUri")
+    def key_vault_uri(self) -> Optional[str]:
+        """
+        The URI of the key vault/managed HSM that should be used for encryption.
+        """
+        return pulumi.get(self, "key_vault_uri")
+
+
+class AwaitableGetAccountKeyVaultStatusResult(GetAccountKeyVaultStatusResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetAccountKeyVaultStatusResult(
+            key_name=self.key_name,
+            key_vault_private_endpoints=self.key_vault_private_endpoints,
+            key_vault_resource_id=self.key_vault_resource_id,
+            key_vault_uri=self.key_vault_uri)
+
+
+def get_account_key_vault_status(account_name: Optional[str] = None,
+                                 resource_group_name: Optional[str] = None,
+                                 opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetAccountKeyVaultStatusResult:
+    """
+    Contains data from encryption.keyVaultProperties as well as information about which private endpoint is used by each encryption sibling set. Response from this endpoint can be modified and used as request body for POST request.
+    Azure REST API version: 2024-09-01-preview.
+
+
+    :param str account_name: The name of the NetApp account
+    :param str resource_group_name: The name of the resource group. The name is case insensitive.
+    """
+    __args__ = dict()
+    __args__['accountName'] = account_name
+    __args__['resourceGroupName'] = resource_group_name
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('azure-native:netapp:getAccountKeyVaultStatus', __args__, opts=opts, typ=GetAccountKeyVaultStatusResult).value
+
+    return AwaitableGetAccountKeyVaultStatusResult(
+        key_name=pulumi.get(__ret__, 'key_name'),
+        key_vault_private_endpoints=pulumi.get(__ret__, 'key_vault_private_endpoints'),
+        key_vault_resource_id=pulumi.get(__ret__, 'key_vault_resource_id'),
+        key_vault_uri=pulumi.get(__ret__, 'key_vault_uri'))
+def get_account_key_vault_status_output(account_name: Optional[pulumi.Input[str]] = None,
+                                        resource_group_name: Optional[pulumi.Input[str]] = None,
+                                        opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetAccountKeyVaultStatusResult]:
+    """
+    Contains data from encryption.keyVaultProperties as well as information about which private endpoint is used by each encryption sibling set. Response from this endpoint can be modified and used as request body for POST request.
+    Azure REST API version: 2024-09-01-preview.
+
+
+    :param str account_name: The name of the NetApp account
+    :param str resource_group_name: The name of the resource group. The name is case insensitive.
+    """
+    __args__ = dict()
+    __args__['accountName'] = account_name
+    __args__['resourceGroupName'] = resource_group_name
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('azure-native:netapp:getAccountKeyVaultStatus', __args__, opts=opts, typ=GetAccountKeyVaultStatusResult)
+    return __ret__.apply(lambda __response__: GetAccountKeyVaultStatusResult(
+        key_name=pulumi.get(__response__, 'key_name'),
+        key_vault_private_endpoints=pulumi.get(__response__, 'key_vault_private_endpoints'),
+        key_vault_resource_id=pulumi.get(__response__, 'key_vault_resource_id'),
+        key_vault_uri=pulumi.get(__response__, 'key_vault_uri')))

pulumi_azure_native/netapp/outputs.py

@@ -23,6 +23,7 @@ __all__ = [
     'EncryptionIdentityResponse',
     'ExportPolicyRuleResponse',
     'HourlyScheduleResponse',
+    'KeyVaultPrivateEndpointResponse',
     'KeyVaultPropertiesResponse',
     'LdapSearchScopeOptResponse',
     'ManagedServiceIdentityResponse',
@@ -890,6 +891,41 @@ class HourlyScheduleResponse(dict):
         return pulumi.get(self, "used_bytes")
 
 
+@pulumi.output_type
+class KeyVaultPrivateEndpointResponse(dict):
+    """
+    Pairs of virtual network ID and private endpoint ID. Every virtual network that has volumes encrypted with customer-managed keys needs its own key vault private endpoint.
+    """
+    def __init__(__self__, *,
+                 private_endpoint_id: Optional[str] = None,
+                 virtual_network_id: Optional[str] = None):
+        """
+        Pairs of virtual network ID and private endpoint ID. Every virtual network that has volumes encrypted with customer-managed keys needs its own key vault private endpoint.
+        :param str private_endpoint_id: Identifier of the private endpoint to reach the Azure Key Vault
+        :param str virtual_network_id: Identifier for the virtual network id
+        """
+        if private_endpoint_id is not None:
+            pulumi.set(__self__, "private_endpoint_id", private_endpoint_id)
+        if virtual_network_id is not None:
+            pulumi.set(__self__, "virtual_network_id", virtual_network_id)
+
+    @property
+    @pulumi.getter(name="privateEndpointId")
+    def private_endpoint_id(self) -> Optional[str]:
+        """
+        Identifier of the private endpoint to reach the Azure Key Vault
+        """
+        return pulumi.get(self, "private_endpoint_id")
+
+    @property
+    @pulumi.getter(name="virtualNetworkId")
+    def virtual_network_id(self) -> Optional[str]:
+        """
+        Identifier for the virtual network id
+        """
+        return pulumi.get(self, "virtual_network_id")
+
+
 @pulumi.output_type
 class KeyVaultPropertiesResponse(dict):
     """

pulumi_azure_native/netapp/v20240901/__init__.py

@@ -11,6 +11,7 @@ from .backup import *
 from .backup_policy import *
 from .backup_vault import *
 from .get_account import *
+from .get_account_change_key_vault_information import *
 from .get_backup import *
 from .get_backup_policy import *
 from .get_backup_vault import *