text: # coding=utf-8
  # *** WARNING: this file was generated by the Pulumi SDK Generator. ***
  # *** Do not edit by hand unless you're certain you know what you are doing! ***
  
  import warnings
  import pulumi
  import pulumi.runtime
  from typing import Any, Mapping, Optional, Sequence, Union
  from ... import _utilities, _tables
  from . import outputs
  
  __all__ = [
      'GetImageResult',
      'AwaitableGetImageResult',
      'get_image',
  ]
  
  @pulumi.output_type
  class GetImageResult:
      """
      The source user image virtual hard disk. The virtual hard disk will be copied before being attached to the virtual machine. If SourceImage is provided, the destination virtual hard drive must not exist.
      """
      def __init__(__self__, id=None, location=None, name=None, provisioning_state=None, source_virtual_machine=None, storage_profile=None, tags=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 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 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 source_virtual_machine and not isinstance(source_virtual_machine, dict):
              raise TypeError("Expected argument 'source_virtual_machine' to be a dict")
          pulumi.set(__self__, "source_virtual_machine", source_virtual_machine)
          if storage_profile and not isinstance(storage_profile, dict):
              raise TypeError("Expected argument 'storage_profile' to be a dict")
          pulumi.set(__self__, "storage_profile", storage_profile)
          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
      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="provisioningState")
      def provisioning_state(self) -> str:
          """
          The provisioning state.
          """
          return pulumi.get(self, "provisioning_state")
  
      @property
      @pulumi.getter(name="sourceVirtualMachine")
      def source_virtual_machine(self) -> Optional['outputs.SubResourceResponse']:
          """
          The source virtual machine from which Image is created.
          """
          return pulumi.get(self, "source_virtual_machine")
  
      @property
      @pulumi.getter(name="storageProfile")
      def storage_profile(self) -> Optional['outputs.ImageStorageProfileResponse']:
          """
          Specifies the storage settings for the virtual machine disks.
          """
          return pulumi.get(self, "storage_profile")
  
      @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 AwaitableGetImageResult(GetImageResult):
      # pylint: disable=using-constant-test
      def __await__(self):
          if False:
              yield self
          return GetImageResult(
              id=self.id,
              location=self.location,
              name=self.name,
              provisioning_state=self.provisioning_state,
              source_virtual_machine=self.source_virtual_machine,
              storage_profile=self.storage_profile,
              tags=self.tags,
              type=self.type)
  
  
  def get_image(expand: Optional[str] = None,
                image_name: Optional[str] = None,
                resource_group_name: Optional[str] = None,
                opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetImageResult:
      """
      The source user image virtual hard disk. The virtual hard disk will be copied before being attached to the virtual machine. If SourceImage is provided, the destination virtual hard drive must not exist.
  
  
      :param str expand: The expand expression to apply on the operation.
      :param str image_name: The name of the image.
      :param str resource_group_name: The name of the resource group.
      """
      __args__ = dict()
      __args__['expand'] = expand
      __args__['imageName'] = image_name
      __args__['resourceGroupName'] = resource_group_name
      if opts is None:
          opts = pulumi.InvokeOptions()
      if opts.version is None:
          opts.version = _utilities.get_version()
      __ret__ = pulumi.runtime.invoke('azure-native:compute/v20181001:getImage', __args__, opts=opts, typ=GetImageResult).value
  
      return AwaitableGetImageResult(
          id=__ret__.id,
          location=__ret__.location,
          name=__ret__.name,
          provisioning_state=__ret__.provisioning_state,
          source_virtual_machine=__ret__.source_virtual_machine,
          storage_profile=__ret__.storage_profile,
          tags=__ret__.tags,
          type=__ret__.type)
  