pulumi-azure-native 2.51.0a1721670234__py3-none-any.whl → 2.51.0a1721718685__py3-none-any.whl

pulumi_azure_native/compute/v20240302/get_disk_access.py

@@ -0,0 +1,188 @@
+# 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__ = [
+    'GetDiskAccessResult',
+    'AwaitableGetDiskAccessResult',
+    'get_disk_access',
+    'get_disk_access_output',
+]
+
+@pulumi.output_type
+class GetDiskAccessResult:
+    """
+    disk access resource.
+    """
+    def __init__(__self__, extended_location=None, id=None, location=None, name=None, private_endpoint_connections=None, provisioning_state=None, tags=None, time_created=None, type=None):
+        if extended_location and not isinstance(extended_location, dict):
+            raise TypeError("Expected argument 'extended_location' to be a dict")
+        pulumi.set(__self__, "extended_location", extended_location)
+        if id and not isinstance(id, str):
+            raise TypeError("Expected argument 'id' to be a str")
+        pulumi.set(__self__, "id", id)
+        if location and not isinstance(location, str):
+            raise TypeError("Expected argument 'location' to be a str")
+        pulumi.set(__self__, "location", location)
+        if name and not isinstance(name, str):
+            raise TypeError("Expected argument 'name' to be a str")
+        pulumi.set(__self__, "name", name)
+        if private_endpoint_connections and not isinstance(private_endpoint_connections, list):
+            raise TypeError("Expected argument 'private_endpoint_connections' to be a list")
+        pulumi.set(__self__, "private_endpoint_connections", private_endpoint_connections)
+        if provisioning_state and not isinstance(provisioning_state, str):
+            raise TypeError("Expected argument 'provisioning_state' to be a str")
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+        if tags and not isinstance(tags, dict):
+            raise TypeError("Expected argument 'tags' to be a dict")
+        pulumi.set(__self__, "tags", tags)
+        if time_created and not isinstance(time_created, str):
+            raise TypeError("Expected argument 'time_created' to be a str")
+        pulumi.set(__self__, "time_created", time_created)
+        if type and not isinstance(type, str):
+            raise TypeError("Expected argument 'type' to be a str")
+        pulumi.set(__self__, "type", type)
+
+    @property
+    @pulumi.getter(name="extendedLocation")
+    def extended_location(self) -> Optional['outputs.ExtendedLocationResponse']:
+        """
+        The extended location where the disk access will be created. Extended location cannot be changed.
+        """
+        return pulumi.get(self, "extended_location")
+
+    @property
+    @pulumi.getter
+    def id(self) -> str:
+        """
+        Resource Id
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter
+    def location(self) -> str:
+        """
+        Resource location
+        """
+        return pulumi.get(self, "location")
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        Resource name
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter(name="privateEndpointConnections")
+    def private_endpoint_connections(self) -> Sequence['outputs.PrivateEndpointConnectionResponse']:
+        """
+        A readonly collection of private endpoint connections created on the disk. Currently only one endpoint connection is supported.
+        """
+        return pulumi.get(self, "private_endpoint_connections")
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> str:
+        """
+        The disk access resource provisioning state.
+        """
+        return pulumi.get(self, "provisioning_state")
+
+    @property
+    @pulumi.getter
+    def tags(self) -> Optional[Mapping[str, str]]:
+        """
+        Resource tags
+        """
+        return pulumi.get(self, "tags")
+
+    @property
+    @pulumi.getter(name="timeCreated")
+    def time_created(self) -> str:
+        """
+        The time when the disk access was created.
+        """
+        return pulumi.get(self, "time_created")
+
+    @property
+    @pulumi.getter
+    def type(self) -> str:
+        """
+        Resource type
+        """
+        return pulumi.get(self, "type")
+
+
+class AwaitableGetDiskAccessResult(GetDiskAccessResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetDiskAccessResult(
+            extended_location=self.extended_location,
+            id=self.id,
+            location=self.location,
+            name=self.name,
+            private_endpoint_connections=self.private_endpoint_connections,
+            provisioning_state=self.provisioning_state,
+            tags=self.tags,
+            time_created=self.time_created,
+            type=self.type)
+
+
+def get_disk_access(disk_access_name: Optional[str] = None,
+                    resource_group_name: Optional[str] = None,
+                    opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetDiskAccessResult:
+    """
+    Gets information about a disk access resource.
+
+
+    :param str disk_access_name: The name of the disk access resource that is being created. The name can't be changed after the disk encryption set is created. Supported characters for the name are a-z, A-Z, 0-9, _ and -. The maximum name length is 80 characters.
+    :param str resource_group_name: The name of the resource group.
+    """
+    __args__ = dict()
+    __args__['diskAccessName'] = disk_access_name
+    __args__['resourceGroupName'] = resource_group_name
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('azure-native:compute/v20240302:getDiskAccess', __args__, opts=opts, typ=GetDiskAccessResult).value
+
+    return AwaitableGetDiskAccessResult(
+        extended_location=pulumi.get(__ret__, 'extended_location'),
+        id=pulumi.get(__ret__, 'id'),
+        location=pulumi.get(__ret__, 'location'),
+        name=pulumi.get(__ret__, 'name'),
+        private_endpoint_connections=pulumi.get(__ret__, 'private_endpoint_connections'),
+        provisioning_state=pulumi.get(__ret__, 'provisioning_state'),
+        tags=pulumi.get(__ret__, 'tags'),
+        time_created=pulumi.get(__ret__, 'time_created'),
+        type=pulumi.get(__ret__, 'type'))
+
+
+@_utilities.lift_output_func(get_disk_access)
+def get_disk_access_output(disk_access_name: Optional[pulumi.Input[str]] = None,
+                           resource_group_name: Optional[pulumi.Input[str]] = None,
+                           opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetDiskAccessResult]:
+    """
+    Gets information about a disk access resource.
+
+
+    :param str disk_access_name: The name of the disk access resource that is being created. The name can't be changed after the disk encryption set is created. Supported characters for the name are a-z, A-Z, 0-9, _ and -. The maximum name length is 80 characters.
+    :param str resource_group_name: The name of the resource group.
+    """
+    ...

pulumi_azure_native/compute/v20240302/get_disk_access_a_private_endpoint_connection.py

@@ -0,0 +1,154 @@
+# 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__ = [
+    'GetDiskAccessAPrivateEndpointConnectionResult',
+    'AwaitableGetDiskAccessAPrivateEndpointConnectionResult',
+    'get_disk_access_a_private_endpoint_connection',
+    'get_disk_access_a_private_endpoint_connection_output',
+]
+
+@pulumi.output_type
+class GetDiskAccessAPrivateEndpointConnectionResult:
+    """
+    The Private Endpoint Connection resource.
+    """
+    def __init__(__self__, id=None, name=None, private_endpoint=None, private_link_service_connection_state=None, provisioning_state=None, type=None):
+        if id and not isinstance(id, str):
+            raise TypeError("Expected argument 'id' to be a str")
+        pulumi.set(__self__, "id", id)
+        if name and not isinstance(name, str):
+            raise TypeError("Expected argument 'name' to be a str")
+        pulumi.set(__self__, "name", name)
+        if private_endpoint and not isinstance(private_endpoint, dict):
+            raise TypeError("Expected argument 'private_endpoint' to be a dict")
+        pulumi.set(__self__, "private_endpoint", private_endpoint)
+        if private_link_service_connection_state and not isinstance(private_link_service_connection_state, dict):
+            raise TypeError("Expected argument 'private_link_service_connection_state' to be a dict")
+        pulumi.set(__self__, "private_link_service_connection_state", private_link_service_connection_state)
+        if provisioning_state and not isinstance(provisioning_state, str):
+            raise TypeError("Expected argument 'provisioning_state' to be a str")
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+        if type and not isinstance(type, str):
+            raise TypeError("Expected argument 'type' to be a str")
+        pulumi.set(__self__, "type", type)
+
+    @property
+    @pulumi.getter
+    def id(self) -> str:
+        """
+        private endpoint connection Id
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        private endpoint connection name
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter(name="privateEndpoint")
+    def private_endpoint(self) -> 'outputs.PrivateEndpointResponse':
+        """
+        The resource of private end point.
+        """
+        return pulumi.get(self, "private_endpoint")
+
+    @property
+    @pulumi.getter(name="privateLinkServiceConnectionState")
+    def private_link_service_connection_state(self) -> 'outputs.PrivateLinkServiceConnectionStateResponse':
+        """
+        A collection of information about the state of the connection between DiskAccess and Virtual Network.
+        """
+        return pulumi.get(self, "private_link_service_connection_state")
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> str:
+        """
+        The provisioning state of the private endpoint connection resource.
+        """
+        return pulumi.get(self, "provisioning_state")
+
+    @property
+    @pulumi.getter
+    def type(self) -> str:
+        """
+        private endpoint connection type
+        """
+        return pulumi.get(self, "type")
+
+
+class AwaitableGetDiskAccessAPrivateEndpointConnectionResult(GetDiskAccessAPrivateEndpointConnectionResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetDiskAccessAPrivateEndpointConnectionResult(
+            id=self.id,
+            name=self.name,
+            private_endpoint=self.private_endpoint,
+            private_link_service_connection_state=self.private_link_service_connection_state,
+            provisioning_state=self.provisioning_state,
+            type=self.type)
+
+
+def get_disk_access_a_private_endpoint_connection(disk_access_name: Optional[str] = None,
+                                                  private_endpoint_connection_name: Optional[str] = None,
+                                                  resource_group_name: Optional[str] = None,
+                                                  opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetDiskAccessAPrivateEndpointConnectionResult:
+    """
+    Gets information about a private endpoint connection under a disk access resource.
+
+
+    :param str disk_access_name: The name of the disk access resource that is being created. The name can't be changed after the disk encryption set is created. Supported characters for the name are a-z, A-Z, 0-9, _ and -. The maximum name length is 80 characters.
+    :param str private_endpoint_connection_name: The name of the private endpoint connection.
+    :param str resource_group_name: The name of the resource group.
+    """
+    __args__ = dict()
+    __args__['diskAccessName'] = disk_access_name
+    __args__['privateEndpointConnectionName'] = private_endpoint_connection_name
+    __args__['resourceGroupName'] = resource_group_name
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('azure-native:compute/v20240302:getDiskAccessAPrivateEndpointConnection', __args__, opts=opts, typ=GetDiskAccessAPrivateEndpointConnectionResult).value
+
+    return AwaitableGetDiskAccessAPrivateEndpointConnectionResult(
+        id=pulumi.get(__ret__, 'id'),
+        name=pulumi.get(__ret__, 'name'),
+        private_endpoint=pulumi.get(__ret__, 'private_endpoint'),
+        private_link_service_connection_state=pulumi.get(__ret__, 'private_link_service_connection_state'),
+        provisioning_state=pulumi.get(__ret__, 'provisioning_state'),
+        type=pulumi.get(__ret__, 'type'))
+
+
+@_utilities.lift_output_func(get_disk_access_a_private_endpoint_connection)
+def get_disk_access_a_private_endpoint_connection_output(disk_access_name: Optional[pulumi.Input[str]] = None,
+                                                         private_endpoint_connection_name: Optional[pulumi.Input[str]] = None,
+                                                         resource_group_name: Optional[pulumi.Input[str]] = None,
+                                                         opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetDiskAccessAPrivateEndpointConnectionResult]:
+    """
+    Gets information about a private endpoint connection under a disk access resource.
+
+
+    :param str disk_access_name: The name of the disk access resource that is being created. The name can't be changed after the disk encryption set is created. Supported characters for the name are a-z, A-Z, 0-9, _ and -. The maximum name length is 80 characters.
+    :param str private_endpoint_connection_name: The name of the private endpoint connection.
+    :param str resource_group_name: The name of the resource group.
+    """
+    ...

pulumi_azure_native/compute/v20240302/get_disk_encryption_set.py

@@ -0,0 +1,253 @@
+# 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__ = [
+    'GetDiskEncryptionSetResult',
+    'AwaitableGetDiskEncryptionSetResult',
+    'get_disk_encryption_set',
+    'get_disk_encryption_set_output',
+]
+
+@pulumi.output_type
+class GetDiskEncryptionSetResult:
+    """
+    disk encryption set resource.
+    """
+    def __init__(__self__, active_key=None, auto_key_rotation_error=None, encryption_type=None, federated_client_id=None, id=None, identity=None, last_key_rotation_timestamp=None, location=None, name=None, previous_keys=None, provisioning_state=None, rotation_to_latest_key_version_enabled=None, tags=None, type=None):
+        if active_key and not isinstance(active_key, dict):
+            raise TypeError("Expected argument 'active_key' to be a dict")
+        pulumi.set(__self__, "active_key", active_key)
+        if auto_key_rotation_error and not isinstance(auto_key_rotation_error, dict):
+            raise TypeError("Expected argument 'auto_key_rotation_error' to be a dict")
+        pulumi.set(__self__, "auto_key_rotation_error", auto_key_rotation_error)
+        if encryption_type and not isinstance(encryption_type, str):
+            raise TypeError("Expected argument 'encryption_type' to be a str")
+        pulumi.set(__self__, "encryption_type", encryption_type)
+        if federated_client_id and not isinstance(federated_client_id, str):
+            raise TypeError("Expected argument 'federated_client_id' to be a str")
+        pulumi.set(__self__, "federated_client_id", federated_client_id)
+        if id and not isinstance(id, str):
+            raise TypeError("Expected argument 'id' to be a str")
+        pulumi.set(__self__, "id", id)
+        if identity and not isinstance(identity, dict):
+            raise TypeError("Expected argument 'identity' to be a dict")
+        pulumi.set(__self__, "identity", identity)
+        if last_key_rotation_timestamp and not isinstance(last_key_rotation_timestamp, str):
+            raise TypeError("Expected argument 'last_key_rotation_timestamp' to be a str")
+        pulumi.set(__self__, "last_key_rotation_timestamp", last_key_rotation_timestamp)
+        if location and not isinstance(location, str):
+            raise TypeError("Expected argument 'location' to be a str")
+        pulumi.set(__self__, "location", location)
+        if name and not isinstance(name, str):
+            raise TypeError("Expected argument 'name' to be a str")
+        pulumi.set(__self__, "name", name)
+        if previous_keys and not isinstance(previous_keys, list):
+            raise TypeError("Expected argument 'previous_keys' to be a list")
+        pulumi.set(__self__, "previous_keys", previous_keys)
+        if provisioning_state and not isinstance(provisioning_state, str):
+            raise TypeError("Expected argument 'provisioning_state' to be a str")
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+        if rotation_to_latest_key_version_enabled and not isinstance(rotation_to_latest_key_version_enabled, bool):
+            raise TypeError("Expected argument 'rotation_to_latest_key_version_enabled' to be a bool")
+        pulumi.set(__self__, "rotation_to_latest_key_version_enabled", rotation_to_latest_key_version_enabled)
+        if tags and not isinstance(tags, dict):
+            raise TypeError("Expected argument 'tags' to be a dict")
+        pulumi.set(__self__, "tags", tags)
+        if type and not isinstance(type, str):
+            raise TypeError("Expected argument 'type' to be a str")
+        pulumi.set(__self__, "type", type)
+
+    @property
+    @pulumi.getter(name="activeKey")
+    def active_key(self) -> Optional['outputs.KeyForDiskEncryptionSetResponse']:
+        """
+        The key vault key which is currently used by this disk encryption set.
+        """
+        return pulumi.get(self, "active_key")
+
+    @property
+    @pulumi.getter(name="autoKeyRotationError")
+    def auto_key_rotation_error(self) -> 'outputs.ApiErrorResponse':
+        """
+        The error that was encountered during auto-key rotation. If an error is present, then auto-key rotation will not be attempted until the error on this disk encryption set is fixed.
+        """
+        return pulumi.get(self, "auto_key_rotation_error")
+
+    @property
+    @pulumi.getter(name="encryptionType")
+    def encryption_type(self) -> Optional[str]:
+        """
+        The type of key used to encrypt the data of the disk.
+        """
+        return pulumi.get(self, "encryption_type")
+
+    @property
+    @pulumi.getter(name="federatedClientId")
+    def federated_client_id(self) -> Optional[str]:
+        """
+        Multi-tenant application client id to access key vault in a different tenant. Setting the value to 'None' will clear the property.
+        """
+        return pulumi.get(self, "federated_client_id")
+
+    @property
+    @pulumi.getter
+    def id(self) -> str:
+        """
+        Resource Id
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter
+    def identity(self) -> Optional['outputs.EncryptionSetIdentityResponse']:
+        """
+        The managed identity for the disk encryption set. It should be given permission on the key vault before it can be used to encrypt disks.
+        """
+        return pulumi.get(self, "identity")
+
+    @property
+    @pulumi.getter(name="lastKeyRotationTimestamp")
+    def last_key_rotation_timestamp(self) -> str:
+        """
+        The time when the active key of this disk encryption set was updated.
+        """
+        return pulumi.get(self, "last_key_rotation_timestamp")
+
+    @property
+    @pulumi.getter
+    def location(self) -> str:
+        """
+        Resource location
+        """
+        return pulumi.get(self, "location")
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        Resource name
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter(name="previousKeys")
+    def previous_keys(self) -> Sequence['outputs.KeyForDiskEncryptionSetResponse']:
+        """
+        A readonly collection of key vault keys previously used by this disk encryption set while a key rotation is in progress. It will be empty if there is no ongoing key rotation.
+        """
+        return pulumi.get(self, "previous_keys")
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> str:
+        """
+        The disk encryption set provisioning state.
+        """
+        return pulumi.get(self, "provisioning_state")
+
+    @property
+    @pulumi.getter(name="rotationToLatestKeyVersionEnabled")
+    def rotation_to_latest_key_version_enabled(self) -> Optional[bool]:
+        """
+        Set this flag to true to enable auto-updating of this disk encryption set to the latest key version.
+        """
+        return pulumi.get(self, "rotation_to_latest_key_version_enabled")
+
+    @property
+    @pulumi.getter
+    def tags(self) -> Optional[Mapping[str, str]]:
+        """
+        Resource tags
+        """
+        return pulumi.get(self, "tags")
+
+    @property
+    @pulumi.getter
+    def type(self) -> str:
+        """
+        Resource type
+        """
+        return pulumi.get(self, "type")
+
+
+class AwaitableGetDiskEncryptionSetResult(GetDiskEncryptionSetResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetDiskEncryptionSetResult(
+            active_key=self.active_key,
+            auto_key_rotation_error=self.auto_key_rotation_error,
+            encryption_type=self.encryption_type,
+            federated_client_id=self.federated_client_id,
+            id=self.id,
+            identity=self.identity,
+            last_key_rotation_timestamp=self.last_key_rotation_timestamp,
+            location=self.location,
+            name=self.name,
+            previous_keys=self.previous_keys,
+            provisioning_state=self.provisioning_state,
+            rotation_to_latest_key_version_enabled=self.rotation_to_latest_key_version_enabled,
+            tags=self.tags,
+            type=self.type)
+
+
+def get_disk_encryption_set(disk_encryption_set_name: Optional[str] = None,
+                            resource_group_name: Optional[str] = None,
+                            opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetDiskEncryptionSetResult:
+    """
+    Gets information about a disk encryption set.
+
+
+    :param str disk_encryption_set_name: The name of the disk encryption set that is being created. The name can't be changed after the disk encryption set is created. Supported characters for the name are a-z, A-Z, 0-9, _ and -. The maximum name length is 80 characters.
+    :param str resource_group_name: The name of the resource group.
+    """
+    __args__ = dict()
+    __args__['diskEncryptionSetName'] = disk_encryption_set_name
+    __args__['resourceGroupName'] = resource_group_name
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('azure-native:compute/v20240302:getDiskEncryptionSet', __args__, opts=opts, typ=GetDiskEncryptionSetResult).value
+
+    return AwaitableGetDiskEncryptionSetResult(
+        active_key=pulumi.get(__ret__, 'active_key'),
+        auto_key_rotation_error=pulumi.get(__ret__, 'auto_key_rotation_error'),
+        encryption_type=pulumi.get(__ret__, 'encryption_type'),
+        federated_client_id=pulumi.get(__ret__, 'federated_client_id'),
+        id=pulumi.get(__ret__, 'id'),
+        identity=pulumi.get(__ret__, 'identity'),
+        last_key_rotation_timestamp=pulumi.get(__ret__, 'last_key_rotation_timestamp'),
+        location=pulumi.get(__ret__, 'location'),
+        name=pulumi.get(__ret__, 'name'),
+        previous_keys=pulumi.get(__ret__, 'previous_keys'),
+        provisioning_state=pulumi.get(__ret__, 'provisioning_state'),
+        rotation_to_latest_key_version_enabled=pulumi.get(__ret__, 'rotation_to_latest_key_version_enabled'),
+        tags=pulumi.get(__ret__, 'tags'),
+        type=pulumi.get(__ret__, 'type'))
+
+
+@_utilities.lift_output_func(get_disk_encryption_set)
+def get_disk_encryption_set_output(disk_encryption_set_name: Optional[pulumi.Input[str]] = None,
+                                   resource_group_name: Optional[pulumi.Input[str]] = None,
+                                   opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetDiskEncryptionSetResult]:
+    """
+    Gets information about a disk encryption set.
+
+
+    :param str disk_encryption_set_name: The name of the disk encryption set that is being created. The name can't be changed after the disk encryption set is created. Supported characters for the name are a-z, A-Z, 0-9, _ and -. The maximum name length is 80 characters.
+    :param str resource_group_name: The name of the resource group.
+    """
+    ...