Hyper-V Management

https://learn.microsoft.com/en-us/windows/win32/HyperV_v2/
Admin
Hyper-V Management provides APIs and tools for managing and retrieving information about virtual...
Tokens:311,010
Snippets:3,174
Trust Score:10
Update:1 month ago
Show doc for...
Tokens:
Raw
### StartService()

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/msvm-virtualsystemmigrationservice-startservice

Starts the Msvm_VirtualSystemMigrationService.

```APIDOC
## StartService

### Description
Starts the Msvm_VirtualSystemMigrationService.

### Syntax
`uint32 StartService();`

### Parameters
This method has no parameters.

### Return Value
- **Completed with No Error** (0)
- **Not supported** (1)
```

--------------------------------

### StartService()

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/msvm-transparentbridgingservice-startservice

Starts the Msvm_TransparentBridgingService.

```APIDOC
## StartService

### Description
Starts the transparent bridging service.

### Syntax
`uint32 StartService();`

### Parameters
This method has no parameters.

### Return value
- **Completed with No Error** (0)
- **Not supported** (1)

### Requirements
- **Namespace**: Root\virtualization\v2
- **Minimum supported client**: Windows 8.1
- **Minimum supported server**: Windows Server 2012 R2
```

--------------------------------

### RealizePlannedSystem C# Example

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/realizeplannedsystem-msvm-virtualsystemmanagementservice

This C# example demonstrates how to realize a planned virtual machine using the WMI management service. It requires administrative privileges and must be executed on the Hyper-V host server.

```CSharp
/// <summary>
/// Finds the first Planned VM matching pvmName and realizes it.
/// </summary>
/// <param name="pvmName">The name of the PVM to be realized.</param>
/// <returns>The Realized Virtual Machine.</returns>
internal static ManagementObject
RealizePvm(
    string pvmName
    )
{
    ManagementObject vm = null;
    ManagementScope scope = new ManagementScope(@"root\virtualization\v2");

    using (ManagementObject pvm = WmiUtilities.GetPlannedVirtualMachine(pvmName, scope))
    using (ManagementObject managementService = WmiUtilities.GetVirtualMachineManagementService(scope))
    using (ManagementBaseObject inParams =
        managementService.GetMethodParameters("RealizePlannedSystem"))
    {
        inParams["PlannedSystem"] = pvm.Path;

        Console.WriteLine("Realizing Planned Virtual Machine \"{0}\" ({1})...",
                pvm["ElementName"], pvm["Name"]);

        using (ManagementBaseObject outParams =
            managementService.InvokeMethod("RealizePlannedSystem", inParams, null))
        {
            if (WmiUtilities.ValidateOutput(outParams, scope, true, true))
            {
                using (ManagementObject job =
                    new ManagementObject((string)outParams["Job"]))
                using (ManagementObjectCollection pvmCollection =
                    job.GetRelated("Msvm_ComputerSystem",
                        "Msvm_AffectedJobElement", null, null, null, null, false, null))
                {
                    vm = WmiUtilities.GetFirstObjectFromCollection(pvmCollection);
                }
            }
        }
    }

    return vm;
}
```

--------------------------------

### StartService()

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/msvm-imagemanagementservice-startservice

Starts the Msvm_ImageManagementService.

```APIDOC
## StartService()

### Description
Starts the Msvm_ImageManagementService.

### Syntax
`uint32 StartService();`

### Parameters
This method has no parameters.

### Return value
- **Completed with No Error** (0)
- **Not supported** (1)
```

--------------------------------

### StartService()

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/msvm-metricservice-startservice

Starts the Msvm_MetricService.

```APIDOC
## StartService

### Description
Starts the Msvm_MetricService.

### Syntax
`uint32 StartService();`

### Parameters
This method has no parameters.

### Return Value
- **Completed with No Error** (0)
- **Not supported** (1)
```

--------------------------------

### StartService()

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/msvm-virtualsystemmanagementservice-startservice

Starts the virtual system management service.

```APIDOC
## StartService()

### Description
Starts the virtual system management service.

### Syntax
`uint32 StartService();`

### Parameters
This method has no parameters.

### Return Value
- **Completed with No Error** (0)
- **Not supported** (1)

### Requirements
- **Namespace**: Root\virtualization\v2
- **Minimum supported client**: Windows 8.1
- **Minimum supported server**: Windows Server 2012 R2
```

--------------------------------

### StartService()

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/msvm-collectionmanagementservice-startservice

Starts the Msvm_CollectionManagementService.

```APIDOC
## StartService()

### Description
Starts the Msvm_CollectionManagementService.

### Syntax
`uint32 StartService();`

### Parameters
This method has no parameters.

### Return Value
Returns 0 if successful; otherwise, returns an error.

- **0**: Completed with No Error
- **1**: Not supported
```

--------------------------------

### Msvm_GuestService::StartService

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/startservice-msvm-guestservice

Starts the guest service.

```APIDOC
## Msvm_GuestService::StartService

### Description
Puts the guest service in a started state.

### Syntax
uint32 StartService();

### Return Value
- 0 (uint32) - Success.
- 1 (uint32) - Not supported.
```

--------------------------------

### StartService

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/msvm-guestservice

Puts the guest service in a started state.

```APIDOC
## StartService

### Description
Puts the guest service in a started state.
```

--------------------------------

### Start Virtual Machine

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/getvirtualsystemthumbnailimage-msvm-virtualsystemmanagementservice

Requests a state change to start the virtual machine if it is not already running.

```VBScript
'-----------------------------------------------------------------
' Start the virtual machine 
'-----------------------------------------------------------------
Function StartVm(computerSystem)
    
    dim objInParam, objOutParams
    StartVm = false
    if computerSystem.OperationalStatus(0) = 2 then
        StartVm = true
        Exit Function
    end if
    
    set objInParam = computerSystem.Methods_("RequestStateChange").InParameters.SpawnInstance_()
    objInParam.RequestedState = 2
    set objOutParams = computerSystem.ExecMethod_("RequestStateChange", objInParam)
    
    if objOutParams.ReturnValue = wmiStarted then
        if (WMIJobCompleted(objOutParams)) then
            StartVm = true
        end if
    elseif objOutParams.ReturnValue = wmiSuccessful then
        StartVm = true
    else
        WriteLog Format1("StartVM failed with ReturnValue {0}", wmiStatus)
    end if
    
End Function
```

--------------------------------

### StartService()

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/msvm-securityservice-startservice

Starts the security service.

```APIDOC
## StartService()

### Description
Starts the security service.

### Syntax
`uint32 StartService();`

### Parameters
This method has no parameters.

### Return value
- **0** - Completed with No Error
- **1** - Not supported

### Requirements
- **Namespace**: Root\virtualization\v2
- **DLL**: Vmms.exe
```

--------------------------------

### StartService()

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/msvm-virtualethernetswitchmanagementservice-startservice

Starts the virtual ethernet switch management service.

```APIDOC
## StartService()

### Description
Starts the virtual ethernet switch management service.

### Syntax
`uint32 StartService();`

### Parameters
This method has no parameters.

### Return Value
- **Completed with No Error** (0)
- **Not supported** (1)

### Requirements
- **Namespace**: Root\virtualization\v2
- **Minimum supported client**: Windows 8.1
- **Minimum supported server**: Windows Server 2012 R2
```

--------------------------------

### StartService

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/cim-service

Starts the service.

```APIDOC
## StartService

### Description
Starts the service represented by the CIM_Service instance.
```

--------------------------------

### StartService()

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/cim-service-startservice

Places the service in the started state.

```APIDOC
## Method: StartService()

### Description
Places the service in the started state. This method is maintained for its simple start semantics.

### Syntax
`uint32 StartService();`

### Parameters
This method has no parameters.

### Return Value
Returns a 0 on success; otherwise, returns an error code.

### Requirements
- **Namespace**: Root\virtualization\v2
- **Minimum supported client**: Windows 8.1
- **Minimum supported server**: Windows Server 2012 R2
```

--------------------------------

### StartService method

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/msvm-replicationservice-startservice

Starts the replication service.

```APIDOC
## StartService

### Description
Starts the replication service.

### Syntax
`uint32 StartService();`

### Return value
- **Completed with No Error** (0)
- **Not supported** (1)

### Requirements
- **Namespace**: Root\virtualization\v2
- **Minimum supported client**: Windows 8.1
- **Minimum supported server**: Windows Server 2012 R2
```

--------------------------------

### Compacting a Virtual Hard Disk in C#

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/compactvirtualharddisk-msvm-imagemanagementservice

Example demonstrating how to invoke the CompactVirtualHardDisk method using WMI management objects.

```CSharp
public enum VirtualHardDiskCompactMode
{
    Full = 0,
    Quick = 1,
    Retrim = 2,
    Pretrimmed = 3,
    Prezeroed = 4
}

public static void CompactVirtualHardDisk(string vhdPath, VirtualHardDiskCompactMode compactMode)
{
    ManagementScope scope = new ManagementScope(@"root\virtualization\v2", null);
    ManagementObject imageService = Utility.GetServiceObject(scope, "Msvm_ImageManagementService");

    ManagementBaseObject inParams = imageService.GetMethodParameters("CompactVirtualHardDisk");
    inParams["Path"] = vhdPath;
    inParams["Mode"] = compactMode;
    ManagementBaseObject outParams = imageService.InvokeMethod("CompactVirtualHardDisk", inParams, null);
    if ((UInt32)outParams["ReturnValue"] == ReturnCode.Started)
    {
        if (Utility.JobCompleted(outParams, scope))
        {
            Console.WriteLine("{0} was compacted successfully.", inParams["Path"]);
        }
        else
        {
            Console.WriteLine("Unable to compact {0}", inParams["Path"]);
        }
    }
    else
    {
        Console.WriteLine("Compact {0} returned error {1}", inParams["Path"], outParams["ReturnValue"]);
    }

    inParams.Dispose();
    outParams.Dispose();
    imageService.Dispose();
}
```

--------------------------------

### MergeVirtualHardDisk C# Example

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/mergevirtualharddisk-msvm-imagemanagementservice

A C# implementation demonstrating how to invoke the MergeVirtualHardDisk method using WMI.

```CSharp
// Merges a VHD into a parent VHD.
// ChildPath: The path to the VHD to merge.</param>
// ParentPath: The path to the parent into which to merge.</param>
public static void MergeVirtualHardDisk(string ChildPath, string ParentPath)
{
    ManagementScope scope = new ManagementScope(@"root\virtualization\v2", null);
    ManagementObject imageService = Utility.GetServiceObject(scope, "Msvm_ImageManagementService");

    ManagementBaseObject inParams = imageService.GetMethodParameters("MergeVirtualHardDisk");

    inParams["SourcePath"] = ChildPath;
    inParams["DestinationPath"] = ParentPath;

    ManagementBaseObject outParams = imageService.InvokeMethod("MergeVirtualHardDisk", inParams, null);

    if ((UInt32)outParams["ReturnValue"] == ReturnCode.Started)
    {
        if (Utility.JobCompleted(outParams, scope))
        {
            Console.WriteLine("MergeVirtualHardDisk succeeded.");
        }
        else
        {
            Console.WriteLine("MergeVirtualHardDisk failed.");
        }
    }

    outParams.Dispose();
    inParams.Dispose();
    imageService.Dispose();
}
```

--------------------------------

### Resize a Virtual Hard Disk in C#

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/resizevirtualharddisk-msvm-imagemanagementservice

Example demonstrating how to invoke the ResizeVirtualHardDisk method using WMI in C#.

```csharp
const UInt64 size1G = 0x40000000;

public static void ResizeVirtualHardDisk(string path, UInt64 maxInternalSize)
{
    ManagementScope scope = new ManagementScope(@"root\virtualization\V2", null);
    ManagementObject imageService = Utility.GetServiceObject(scope, "Msvm_ImageManagementService");

    ManagementBaseObject inParams = imageService.GetMethodParameters("ResizeVirtualHardDisk");
    inParams["Path"] = path;
    inParams["MaxInternalSize"] = maxInternalSize * size1G;
    ManagementBaseObject outParams = imageService.InvokeMethod("ResizeVirtualHardDisk", inParams, null);
    if ((UInt32)outParams["ReturnValue"] == ReturnCode.Started)
    {
        if (Utility.JobCompleted(outParams, scope))
        {
            Console.WriteLine("{0} was resized successfully.", inParams["Path"]);
        }
        else
        {
            Console.WriteLine("Unable to resize {0}", inParams["Path"]);
        }
    }

    outParams.Dispose();
    inParams.Dispose();
    imageService.Dispose();
}
```

--------------------------------

### GetVirtualHardDiskSettingData C# Example

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/getvirtualharddisksettingdata-msvm-imagemanagementservice

A C# implementation demonstrating how to invoke the GetVirtualHardDiskSettingData method via WMI.

```CSharp
public static void GetVirtualHardDiskSettingData(string vhdPath)
{
    ManagementScope scope = new ManagementScope(@"root\virtualization\V2", null);
    ManagementObject imageService = Utility.GetServiceObject(scope, "Msvm_ImageManagementService");
    ManagementBaseObject inParams = imageService.GetMethodParameters("GetVirtualHardDiskSettingData");

    inParams["Path"] = vhdPath;

    ManagementBaseObject outParams = imageService.InvokeMethod("GetVirtualHardDiskSettingData", inParams, null);
    if ((UInt32)outParams["ReturnValue"] == ReturnCode.Started)
    {
        if (Utility.JobCompleted(outParams, scope))
        {
            Console.WriteLine("GetVirtualHardDiskSettingData was successful.");
        }
        else
        {
            Console.WriteLine("GetVirtualHardDiskSettingData was not successful.");
        }
    }
    else if ((UInt32)outParams["ReturnValue"] == ReturnCode.Completed)
    {
        string diskStateString = outParams["SettingData"].ToString();
        Utility.PrintEmbeddedInstance(diskStateString);
    }

    outParams.Dispose();
    inParams.Dispose();
    imageService.Dispose();
}
```

--------------------------------

### Simulate a key press using C#

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/presskey-msvm-keyboard

This example demonstrates how to retrieve the Msvm_Keyboard object associated with a virtual machine and invoke the PressKey method.

```csharp
using System;
using System.Management;

namespace HyperVSamples
{
    class PressKeyClass
    {
        static ManagementObject GetComputerKeyboard(ManagementObject vm)
        {
            ManagementObjectCollection keyboardCollection = vm.GetRelated
            (
                "Msvm_Keyboard",
                "Msvm_SystemDevice",
                null,
                null,
                "PartComponent",
                "GroupComponent",
                false,
                null
            );

            ManagementObject keyboard = null;

            foreach (ManagementObject instance in keyboardCollection)
            {
                keyboard = instance;
                break;
            }

            return keyboard;
        }

        static void PressKey(string vmName, int keyCode)
        {
            ManagementScope scope = new ManagementScope(@"root\virtualization\v2", null);
            ManagementObject vm = Utility.GetTargetComputer(vmName, scope);
            ManagementObject keyboard = GetComputerKeyboard(vm);

            ManagementBaseObject inParams = keyboard.GetMethodParameters("PressKey");

            inParams["keyCode"] = keyCode;

            ManagementBaseObject outParams = keyboard.InvokeMethod("PressKey", inParams, null);

            if ((UInt16)outParams["ReturnValue"] == ReturnCode.Completed)
            {
                string.Format("Key {0} was pressed on {1}", keyCode, vm["ElementName"]);
            }
            else
            {
                string.Format("Unable to press key {0}' on {1}", keyCode, vm["ElementName"]);
            }

            inParams.Dispose();
            outParams.Dispose();
            keyboard.Dispose();
            vm.Dispose();
        }

        static void Main(string[] args)
        {
            if (args != null && args.Length != 2)
            {
                Console.WriteLine("Usage: PressKey vmName keyCode");
                return;
            }
            string vmName = args[0];
            int keyCode = int.Parse(args[1]);
            PressKey(args[0], keyCode);
        }

    }
}
```

--------------------------------

### GetVirtualHardDiskState C# Example

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/getvirtualharddiskstate-msvm-imagemanagementservice

Demonstrates how to invoke the GetVirtualHardDiskState method using the ManagementObject class in C#.

```CSharp
public static void GetVirtualHardDiskState(string vhdPath)
{
    ManagementScope scope = new ManagementScope(@"root\virtualization\V2", null);
    ManagementObject imageService = Utility.GetServiceObject(scope, "Msvm_ImageManagementService");
    ManagementBaseObject inParams = imageService.GetMethodParameters("GetVirtualHardDiskState");

    inParams["Path"] = vhdPath;
    
    ManagementBaseObject outParams = imageService.InvokeMethod("GetVirtualHardDiskState", inParams, null);
    if ((UInt32)outParams["ReturnValue"] == ReturnCode.Started)
    {
        if (Utility.JobCompleted(outParams, scope))
        {
            Console.WriteLine("GetVirtualHardDiskState was successful.");
        }
        else
        {
            Console.WriteLine("GetVirtualHardDiskState was not successful.");
        }
    }
    else if ((UInt32)outParams["ReturnValue"] == ReturnCode.Completed)
    {
        string diskStateString = outParams["State"].ToString();
        Utility.PrintEmbeddedInstance(diskStateString);
    }

    outParams.Dispose();
    inParams.Dispose();
    imageService.Dispose();
}
```

--------------------------------

### Simulate Typing Text with C#

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/typetext-msvm-keyboard

This example demonstrates how to retrieve the Msvm_Keyboard instance associated with a virtual machine and invoke the TypeText method to simulate keyboard input.

```csharp
using System;
using System.Management;

namespace HyperVSamples
{
    class TypeTextClass
    {
        static ManagementObject GetComputerKeyboard(ManagementObject vm)
        {
            ManagementObjectCollection keyboardCollection = vm.GetRelated
            (
                "Msvm_Keyboard",
                "Msvm_SystemDevice",
                null,
                null,
                "PartComponent",
                "GroupComponent",
                false,
                null
            );

            ManagementObject keyboard = null;

            foreach (ManagementObject instance in keyboardCollection)
            {
                keyboard = instance;
                break;
            }

            return keyboard;
        }

        static void TypeText(string vmName, string text)
        {
            ManagementScope scope = new ManagementScope(@"root\virtualization\v2", null);
            ManagementObject vm = Utility.GetTargetComputer(vmName, scope);
            ManagementObject keyboard = GetComputerKeyboard(vm);

            ManagementBaseObject inParams = keyboard.GetMethodParameters("TypeText");

            inParams["asciiText"] = text;

            ManagementBaseObject outParams = keyboard.InvokeMethod("TypeText", inParams, null);

            if ((UInt16)outParams["ReturnValue"] == ReturnCode.Completed)
            {
                string.Format("Text {0} was typed on {1}", text, vm["ElementName"]);
            }
            else
            {
                string.Format("Unable to type '{0}' on {1}", text, vm["ElementName"]);
            }

            inParams.Dispose();
            outParams.Dispose();
            keyboard.Dispose();
            vm.Dispose();
        }

        static void Main(string[] args)
        {
            if (args != null && args.Length != 2)
            {
                Console.WriteLine("Usage: TypeText vmName Text");
                return;
            }
            TypeText(args[0], args[1]);
        }
    }
}
```

--------------------------------

### Attach a Virtual Hard Disk in C#

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/attachvirtualharddisk-msvm-imagemanagementservice

Example demonstrating how to invoke the AttachVirtualHardDisk method using the WMI ManagementObject API.

```CSharp
public static void AttachVirtualHardDisk(string path)
{
    ManagementScope scope = new ManagementScope(@"root\virtualization\V2", null);
    ManagementObject imageService = Utility.GetServiceObject(scope, "Msvm_ImageManagementService");

    ManagementBaseObject inParams = imageService.GetMethodParameters("AttachVirtualHardDisk");
    inParams["Path"] = path;
    inParams["AssignDriveLetter"] = true;
    inParams["ReadOnly"] = false;
    ManagementBaseObject outParams = imageService.InvokeMethod("AttachVirtualHardDisk", inParams, null);
    if ((UInt32)outParams["ReturnValue"] == ReturnCode.Started)
    {
        if (Utility.JobCompleted(outParams, scope))
        {
            Console.WriteLine("{0} was attached successfully.", inParams["Path"]);
        }
        else
        {
            Console.WriteLine("Unable to attach {0}", inParams["Path"]);
        }
    }

    outParams.Dispose();
    inParams.Dispose();
    imageService.Dispose();
}
```

--------------------------------

### StartService()

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/msvm-terminalservice-startservice

Starts the terminal service. This method takes no parameters and returns a status code indicating success or failure.

```APIDOC
## Method: StartService

### Description
Starts the terminal service.

### Syntax
`uint32 StartService();`

### Parameters
This method has no parameters.

### Return Value
- **0** (Completed with No Error)
- **1** (Not supported)

### Requirements
- **Namespace**: Root\virtualization\v2
- **Minimum supported client**: Windows 8.1
- **Minimum supported server**: Windows Server 2012 R2
```

--------------------------------

### Validate a Planned Virtual Machine in C#

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/validateplannedsystem-msvm-virtualsystemmanagementservice

Example demonstrating how to find a planned virtual machine and invoke the ValidatePlannedSystem method using WMI.

```CSharp
/// <summary>
/// Finds the first Planned VM matching pvmName and validates it, displaying
/// any warnings produced.
/// </summary>
/// <param name="pvmName">The name of the PVM to be validated.</param>
internal static void
ValidatePvm(
    string pvmName
    )
{
    ManagementScope scope = new ManagementScope(@"root\virtualization\v2");

    using (ManagementObject pvm = WmiUtilities.GetPlannedVirtualMachine(pvmName, scope))
    using (ManagementObject managementService = WmiUtilities.GetVirtualMachineManagementService(scope))
    using (ManagementBaseObject inParams = 
        managementService.GetMethodParameters("ValidatePlannedSystem"))
    {
        inParams["PlannedSystem"] = pvm.Path;

        Console.WriteLine("Validating Planned Virtual Machine \"{0}\" ({1})...",
                pvm["ElementName"], pvm["Name"]);

        using (ManagementBaseObject outParams = 
            managementService.InvokeMethod("ValidatePlannedSystem", inParams, null))
        {
            if (WmiUtilities.ValidateOutput(outParams, scope))
            {
                using (ManagementObject job = 
                    new ManagementObject((string)outParams["Job"]))
                {
                    WmiUtilities.PrintMsvmErrors(job);
                }
            }
        }
    }
}
```

--------------------------------

### Convert a virtual hard disk using C#

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/convertvirtualharddisk-msvm-imagemanagementservice

This example demonstrates how to use the Msvm_ImageManagementService to convert a virtual hard disk by defining the target settings and invoking the ConvertVirtualHardDisk method.

```csharp
public enum VirtualHardDiskType
{
    Fixed = 2,
    Dynamic = 3,
    Differencing = 4
}

public enum VirtualHardDiskFormat
{
    Unknown = 0,
    Vhd = 2,
    Vhdx = 3
}

public static void ConvertVirtualHardDisk(string sourcePath, string destinationPath, VirtualHardDiskType diskType, VirtualHardDiskFormat diskFormat)
{
    ManagementScope scope = new ManagementScope(@"root\virtualization\V2", null);
    ManagementObject imageService = Utility.GetServiceObject(scope, "Msvm_ImageManagementService");

    ManagementPath path = new ManagementPath()
    {
        Server = null,
        NamespacePath = imageService.Path.Path,
        ClassName = "Msvm_VirtualHardDiskSettingData"
    };

    ManagementClass settingsClass = new ManagementClass(path);
    ManagementObject settingsInstance = settingsClass.CreateInstance();
    settingsInstance["Path"] = destinationPath;
    settingsInstance["Type"] = diskType;
    settingsInstance["Format"] = diskFormat;
    settingsInstance["ParentPath"] = null;
    settingsInstance["MaxInternalSize"] = 0;
    settingsInstance["BlockSize"] = 0;
    settingsInstance["LogicalSectorSize"] = 0;
    settingsInstance["PhysicalSectorSize"] = 0;

    ManagementBaseObject inParams = imageService.GetMethodParameters("ConvertVirtualHardDisk");

    inParams["SourcePath"] = sourcePath;
    inParams["VirtualDiskSettingData"] = settingsInstance.GetText(TextFormat.WmiDtd20);

    ManagementBaseObject outParams = imageService.InvokeMethod("ConvertVirtualHardDisk", inParams, null);
    UInt32 result = (UInt32)outParams["ReturnValue"];
    if (ReturnCode.Completed == result)
    {
        Console.WriteLine("{0} was converted successfully.", inParams["SourcePath"]);
    }
    else if (ReturnCode.Started == result)
    {
        if (Utility.JobCompleted(outParams, scope))
        {
            Console.WriteLine("{0} was converted successfully.", inParams["SourcePath"]);
        }
        else
        {
            Console.WriteLine("Unable to convert {0}", inParams["SourcePath"]);
        }
    }
    else
    {
        // The method failed.
        Console.WriteLine("ConvertVirtualHardDisk failed with error code {0}.", result);
    }

    outParams.Dispose();
    inParams.Dispose();
    imageService.Dispose();
}
```

--------------------------------

### EnableEndPoints()

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/enableendpoints-msvm-rdvcomponent

Requests the Remote Desktop Services virtual device to start a pipe connection with the virtual machine.

```APIDOC
## EnableEndPoints()

### Description
Requests the Remote Desktop Services virtual device to start a pipe connection with the virtual machine.

### Syntax
`uint32 EnableEndPoints();`

### Return Values
- **Completed with No Error** (0)
- **Method Parameters Checked - Job Started** (4096)
- **Failed** (32768)
- **Access Denied** (32769)
- **Not Supported** (32770)
- **Status is unknown** (32771)
- **Timeout** (32772)
- **Invalid parameter** (32773)
- **Out of memory** (32774)
- **File not found** (32775)

### Requirements
- **Namespace**: Root\Virtualization\V2
- **DLL**: Vmms.exe
```

--------------------------------

### Create a Virtual Machine Snapshot in C#

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/createsnapshot-msvm-virtualsystemsnapshotservice

This example demonstrates how to invoke the CreateSnapshot method using the ManagementScope and ManagementObject classes. It requires the virtual machine host server and administrative privileges.

```csharp
public static void CreateSnapshot(string vmName)
{
    ManagementScope scope = new ManagementScope(@"root\virtualization\v2", null);
    ManagementObject virtualSystemService = Utility.GetServiceObject(scope, "Msvm_VirtualSystemSnapshotService");

    ManagementBaseObject inParams = virtualSystemService.GetMethodParameters("CreateSnapshot");

    // Set the AffectedSystem property.
    ManagementObject vm = Utility.GetTargetComputer(vmName, scope);
    if (null == vm)
    {
        throw new ArgumentException(string.Format("The virtual machine \"{0}\" could not be found.", vmName));
    }

    inParams["AffectedSystem"] = vm.Path.Path;

    // Set the SnapshotSettings property.
#if(true)
    inParams["SnapshotSettings"] = "";
#else
    ManagementObject snapshotSettings = Utility.GetServiceObject(scope, "CIM_SettingData"); 
    inParams["SnapshotSettings"] = snapshotSettings.ToString();
#endif       
    // Set the SnapshotType property.
    inParams["SnapshotType"] = 2; // Full snapshot.

    ManagementBaseObject outParams = virtualSystemService.InvokeMethod("CreateSnapshot", inParams, null);

    if ((UInt32)outParams["ReturnValue"] == ReturnCode.Started)
    {
        if (Utility.JobCompleted(outParams, scope))
        {
            Console.WriteLine("Snapshot was created successfully.");

            MiscClass.GetAffectedElement(outParams, scope);
        }
        else
        {
            Console.WriteLine("Failed to create snapshot VM");
        }
    }
    else if ((UInt32)outParams["ReturnValue"] == ReturnCode.Completed)
    {
        Console.WriteLine("Snapshot was created successfully.");
    }
    else
    {
        Console.WriteLine("Create virtual system snapshot failed with error {0}", outParams["ReturnValue"]);
    }

    inParams.Dispose();
    outParams.Dispose();
    vm.Dispose();
    virtualSystemService.Dispose();
}
```

--------------------------------

### Retrieve Virtual System Summary Information in C#

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/getsummaryinformation-msvm-virtualsystemmanagementservice

This example demonstrates how to invoke the GetSummaryInformation method to retrieve specific properties like ElementName, MemoryUsage, and MemoryAvailable for a list of virtual machines.

```csharp
public class GetSummaryInformationClassV2
{
    public static void GetSummaryInformation(string[] vmNames)
    {
        ManagementScope scope = new ManagementScope(@"root\virtualization\v2", null);
        ManagementObject virtualSystemService = Utility.GetServiceObject(scope, "Msvm_VirtualSystemManagementService");
        ManagementBaseObject inParams = virtualSystemService.GetMethodParameters("GetSummaryInformation");

        ManagementObject[] virtualSystemSettings = new ManagementObject[vmNames.Length];

        for (int i = 0; i < vmNames.Length; i++)
        {
            virtualSystemSettings[i] = GetVirtualSystemSetting(vmNames[i], scope);
        }

        UInt32[] requestedInformation = new UInt32[4];
        requestedInformation[0] = 1;    // ElementName
        requestedInformation[2] = 103;  // MemoryUsage
        requestedInformation[3] = 112;  // MemoryAvailable

        inParams["SettingData"] = virtualSystemSettings;
        inParams["RequestedInformation"] = requestedInformation;

        ManagementBaseObject outParams = virtualSystemService.InvokeMethod("GetSummaryInformation", inParams, null);

        if ((UInt32)outParams["ReturnValue"] == ReturnCode.Completed)
        {
            Console.WriteLine("Summary information was retrieved successfully.");

            ManagementBaseObject[] summaryInformationArray = 
                (ManagementBaseObject[])outParams["SummaryInformation"];

            foreach (ManagementBaseObject summaryInformation in summaryInformationArray)
            {
                Console.WriteLine("\nVirtual System Summary Information:");
                if ((null == summaryInformation["Name"]) || 
                    (summaryInformation["Name"].ToString().Length == 0))
                {
                    Console.WriteLine("\tThe VM or snapshot could not be found.");
                }
                else
                {
                    Console.WriteLine("\tName: {0}", summaryInformation["Name"].ToString());
                    foreach (UInt32 requested in requestedInformation)
                    {
                        switch (requested)
                        {
                            case 1:
                                Console.WriteLine("\tElementName: {0}", summaryInformation["ElementName"].ToString());
                                break;

                            case 103:
                                Console.WriteLine("\tMemoryUsage: {0}", summaryInformation["MemoryUsage"].ToString());
                                break;

                            case 112:
                                Console.WriteLine("\tMemoryAvailable: {0}", summaryInformation["MemoryAvailable"].ToString());
                                break;
                        }
                    }
                }
            }
        }
        else
        {
            Console.WriteLine("Failed to retrieve virtual system summary information");
        }

        inParams.Dispose();
        outParams.Dispose();
        virtualSystemService.Dispose();
    }

    public static ManagementObject GetVirtualSystemSetting(string vmName, ManagementScope scope)
    {
        ManagementObject virtualSystem = Utility.GetTargetComputer(vmName, scope);

        ManagementObjectCollection virtualSystemSettings = virtualSystem.GetRelated
         (
             "Msvm_VirtualSystemSettingData",
             "Msvm_SettingsDefineState",
             null,
             null,
             "SettingData",
             "ManagedElement",
             false,
             null
         );

        ManagementObject virtualSystemSetting = null;

        foreach (ManagementObject instance in virtualSystemSettings)
        {
            virtualSystemSetting = instance;
            break;
        }

        return virtualSystemSetting;

    }
}
```

--------------------------------

### Remove Planned Virtual Machine in C#

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/destroysystem-msvm-virtualsystemmanagementservice

Example demonstrating how to remove a planned virtual machine using the DestroySystem method. Requires execution on the host server with Administrator privileges.

```csharp
/// <summary>
/// Finds the first Planned VM matching pvmName and removes it.
/// </summary>
/// <param name="pvmName">The name of the PVM to be removed.</param>
internal static void
RemovePvm(
    string pvmName
    )
{
    ManagementScope scope = new ManagementScope(@"root\virtualization\v2");

    using (ManagementObject pvm = WmiUtilities.GetPlannedVirtualMachine(pvmName, scope))
    using (ManagementObject managementService = WmiUtilities.GetVirtualMachineManagementService(scope))
    using (ManagementBaseObject inParams =
        managementService.GetMethodParameters("DestroySystem"))
    {
        inParams["AffectedSystem"] = pvm.Path;

        Console.WriteLine("Removing Planned Virtual Machine \"{0}\" ({1})...",
                pvm["ElementName"], pvm["Name"]);

        using (ManagementBaseObject outParams =
            managementService.InvokeMethod("DestroySystem", inParams, null))
        {
            WmiUtilities.ValidateOutput(outParams, scope);
        }
    }
}
```

--------------------------------

### Execute sample entry point

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/querying-networking-objects

Entry point for the EnumerateSwitch sample, handling command line arguments and basic error reporting.

```csharp
        internal static void
        ExecuteSample(
            string[] args)
        {
            if (args.Length == 0 || args[0] == "/?")
            {
                Console.WriteLine("Usage: EnumerateSwitch SwitchName\n");
                Console.WriteLine("Example: EnumerateSwitch MySwitch");
                return;
            }

            try
            {
                EnumerateSwitch(args[0]);
            }
            catch (Exception ex)
            {
                Console.WriteLine("Failed to enumerate the switch. Error message details:\n");
                Console.WriteLine(ex.Message);
            }
        }
    }
}
```

--------------------------------

### StartReplication(CIM_ComputerSystem, uint16, string, datetime, CIM_ConcreteJob)

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/startreplication-msvm-replicationservice

Initiates the replication process for a specified virtual machine.

```APIDOC
## Method: StartReplication

### Description
Starts the replication of a virtual machine. When called for a replica virtual machine, it initiates replication with the extended replica.

### Parameters
- **ComputerSystem** (CIM_ComputerSystem) - Required - A reference to the virtual machine for which replication should be started.
- **InitialReplicationType** (uint16) - Required - The type of transfer: 1 (Network Transfer), 2 (Export), or 3 (Seeded Network Transfer).
- **InitialReplicationExportLocation** (string) - Optional - The fully qualified path for export if InitialReplicationType is 2.
- **StartTime** (datetime) - Optional - The scheduled start time for initial replication. If Null, it starts immediately.

### Return Values
- **Job** (CIM_ConcreteJob) - Output parameter containing a reference to the job if the operation is asynchronous.
- **Return Code** (uint32) - Returns 0 for success, 4096 if the job started, or various error codes (32768-32779) for failures.
```

--------------------------------

### DefineSystem(string SystemSettings, string ResourceSettings[], CIM_VirtualSystemSettingData ReferenceConfiguration, CIM_ComputerSystem ResultingSystem, CIM_ConcreteJob Job)

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/definesystem-msvm-virtualsystemmanagementservice

Creates a new virtual machine instance. Properties that are not specified will be populated with default values.

```APIDOC
## DefineSystem

### Description
Creates a new virtual machine instance. Properties that are not specified will be populated with default values.

### Syntax
```
uint32 DefineSystem(
  [in]  string                           SystemSettings,
  [in]  string                           ResourceSettings[],
  [in]  CIM_VirtualSystemSettingData REF ReferenceConfiguration,
  [out] CIM_ComputerSystem           REF ResultingSystem,
  [out] CIM_ConcreteJob              REF Job
);
```

### Parameters
- **SystemSettings** (string) - [in] An embedded instance of the Msvm_VirtualSystemSettingData class that is used to define the attributes of the virtual machine to be created. This parameter is required.
- **ResourceSettings** (string[]) - [in] A number of embedded instances of the Msvm_ResourceAllocationSettingData class (or derived classes thereof). Together these instances describe the virtual resources of the virtual machine.
- **ReferenceConfiguration** (CIM_VirtualSystemSettingData) - [in] A reference to an instance of the Msvm_VirtualSystemSettingData class that is the top level object of a reference virtual machine configuration.
- **ResultingSystem** (CIM_ComputerSystem) - [out] A reference to an instance of the CIM_ComputerSystem class that represents the newly created virtual machine.
- **Job** (CIM_ConcreteJob) - [out] If the operation is performed asynchronously, this method will return 4096, and this parameter will contain a reference to an object derived from CIM_ConcreteJob.

### Return Value
- **uint32** - Returns 0 if successful (synchronous). Returns 4096 if the operation is performed asynchronously. Any other value indicates an error.
```

--------------------------------

### RemoveResourcesFromResourcePool

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/cim-resourcepoolconfigurationservice-removeresourcesfromresourcepool

Starts a job to remove resources from a resource pool.

```APIDOC
## RemoveResourcesFromResourcePool

### Description
Starts a job to remove resources from a resource pool.

### Syntax
`uint32 RemoveResourcesFromResourcePool(CIM_LogicalDevice REF HostResources[], CIM_ResourcePool REF Pool, CIM_ConcreteJob REF Job);`

### Parameters
- **HostResources** (CIM_LogicalDevice[]) - Input - Array of CIM_LogicalDevice instances to remove from the pool.
- **Pool** (CIM_ResourcePool) - Input - A CIM_ResourcePool representing the pool to remove the resources from.
- **Job** (CIM_ConcreteJob) - Output - A CIM_ConcreteJob that references the job (may be null if job completed).

### Return Values
- **0**: Job Completed with No Error
- **1**: Not Supported
- **2**: Unknown
- **3**: Timeout
- **4**: Failed
- **5**: Invalid Parameter
- **6**: In Use
- **7**: Incorrect ResourceType for the Pool
- **4096**: Method Parameters Checked - Job Started
- **4097**: Size Not Supported
```

--------------------------------

### AddResourcesToResourcePool

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/cim-resourcepoolconfigurationservice-addresourcestoresourcepool

Starts a job to add resources to a resource pool.

```APIDOC
## AddResourcesToResourcePool

### Description
Starts a job to add resources to a resource pool.

### Syntax
```
uint32 AddResourcesToResourcePool(
  [in]  CIM_LogicalDevice REF HostResources[],
  [in]  CIM_ResourcePool  REF Pool,
  [out] CIM_ConcreteJob   REF Job
);
```

### Parameters
- **HostResources** (CIM_LogicalDevice[]) - Input - Array of CIM_LogicalDevice instances to add to the pool.
- **Pool** (CIM_ResourcePool) - Input - A CIM_ResourcePool that represents the pool to add the resources to.
- **Job** (CIM_ConcreteJob) - Output - A CIM_ConcreteJob that references the job (may be null if job completed).

### Return Values
- **0**: Job Completed with No Error
- **1**: Not Supported
- **2**: Unknown
- **3**: Timeout
- **4**: Failed
- **5**: Invalid Parameter
- **6**: In Use
- **7**: Incorrect ResourceType for the Pool
- **4096**: Method Parameters Checked - Job Started
- **4097**: Size Not Supported
```

--------------------------------

### Get Migration Setting Data

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/importing-virtual-machines

Creates and returns a new instance of Msvm_VirtualSystemMigrationSettingData.

```csharp
    public
    ManagementObject
    GetMigrationSettingData(
        ManagementScope scope
        )
    {
        ManagementObject migrationSettingData = null;
        ManagementPath settingPath =
            new ManagementPath("Msvm_VirtualSystemMigrationSettingData");

        using (ManagementClass migrationSettingDataClass = new ManagementClass(scope, settingPath, null))
        {
            migrationSettingData = migrationSettingDataClass.CreateInstance();
        }

        return migrationSettingData;
    }
```

--------------------------------

### CreateResourcePool

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/cim-resourcepoolconfigurationservice-createresourcepool

Starts a job to create a root ResourcePool. The ResourcePool will be scoped to the same System as this Service.

```APIDOC
## uint32 CreateResourcePool(string ElementName, CIM_LogicalDevice REF HostResources[], string ResourceType, CIM_ResourcePool REF Pool, CIM_ConcreteJob REF Job)

### Description
Starts a job to create a root ResourcePool. The ResourcePool will be scoped to the same System as this Service.

### Parameters
- **ElementName** (string) - [in] A end user relevant name for the pool being created. If NULL, then a system supplied default name can be used.
- **HostResources** (CIM_LogicalDevice[]) - [in] Array of zero or more CIM_LogicalDevice devices that are used to create the Pool or modify the source extents.
- **ResourceType** (string) - [in] The type of resources the created pool will manage.
- **Pool** (CIM_ResourcePool) - [out] On success, returns a reference to the resulting CIM_ResourcePool.
- **Job** (CIM_ConcreteJob) - [out] Reference to a CIM_ConcreteJob that represents the job (may be null if job completed).

### Return Values
- **0** - Job Completed with No Error
- **1** - Not Supported
- **2** - Unknown
- **3** - Timeout
- **4** - Failed
- **5** - Invalid Parameter
- **6** - In Use
- **7** - Incorrect ResourceType for the Pool
- **4096** - Method Parameters Checked - Job Started
- **4097** - Size Not Supported
```

--------------------------------

### CreateChildResourcePool

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/cim-resourcepoolconfigurationservice-createchildresourcepool

Starts a job to create a sub-pool from a parent pool using the specified allocation settings.

```APIDOC
## CreateChildResourcePool

### Description
Starts a job to create a sub-pool from a parent pool using the specified allocation settings.

### Syntax
```
uint32 CreateChildResourcePool(
  [in]  string               ElementName,
  [in]  string               Settings[],
  [in]  CIM_ResourcePool REF ParentPool[],
  [out] CIM_ResourcePool REF Pool,
  [out] CIM_ConcreteJob  REF Job
);
```

### Parameters
- **ElementName** (string) - [in] An end user relevant name for the pool being created. If NULL, a system supplied default name can be used.
- **Settings** (string[]) - [in] String containing a representation of a CIM_SettingData instance that is used to specify the settings for the child Pool.
- **ParentPool** (CIM_ResourcePool) - [in] A CIM_ResourcePool from which to create the new Pool.
- **Pool** (CIM_ResourcePool) - [out] A CIM_ResourcePool that references the resulting pool.
- **Job** (CIM_ConcreteJob) - [out] Reference to the job (may be null if job completed).

### Return Values
- **0** - Job Completed with No Error
- **1** - Not Supported
- **2** - Unknown
- **3** - Timeout
- **4** - Failed
- **5** - Invalid Parameter
- **6** - In Use
- **7** - Incorrect ResourceType for the Pool
- **8** - Insufficient Resources
- **4096** - Method Parameters Checked - Job Started
- **4097** - Size Not Supported
```

--------------------------------

### ImportSystemDefinition(string SystemDefinitionFile, string SnapshotFolder, boolean GenerateNewSystemIdentifier, Msvm_PlannedComputerSystem REF ImportedSystem, CIM_ConcreteJob REF Job)

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/importsystemdefinition-msvm-virtualsystemmanagementservice

Creates a new planned computer system based on the specified virtual machine definition file.

```APIDOC
## ImportSystemDefinition

### Description
Creates a new planned computer system based on the specified virtual machine definition file (.xml or .exp).

### Parameters
- **SystemDefinitionFile** (string) - [in] The fully qualified path to the system definition file.
- **SnapshotFolder** (string) - [in] The fully qualified path to the folder where snapshot configurations are located.
- **GenerateNewSystemIdentifier** (boolean) - [in] Indicates whether to generate a new unique identifier for the virtual machine.
- **ImportedSystem** (Msvm_PlannedComputerSystem) - [out] A reference to the imported virtual machine if the operation completes synchronously.
- **Job** (CIM_ConcreteJob) - [out] A reference to a job object if the operation is performed asynchronously.

### Return Values
- **0**: Completed with No Error
- **4096**: Method Parameters Checked - Job Started
- **32768**: Failed
- **32769**: Access Denied
- **32770**: Not Supported
- **32771**: Status is unknown
- **32772**: Timeout
- **32773**: Invalid parameter
- **32774**: System is in use
- **32775**: Invalid state for this operation
- **32776**: Incorrect data type
- **32777**: System is not available
- **32778**: Out of memory
- **32779**: File in Use
```

--------------------------------

### InitiateReboot Method Syntax

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/msvm-shutdowncomponent-initiatereboot

The method signature defined in Managed Object Format (MOF).

```mof
uint32 InitiateReboot(
  [in] boolean Force,
  [in] string  Reason
);
```

--------------------------------

### Get Msvm_VirtualSystemMigrationServiceSettingData

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/importing-virtual-machines

Retrieves the migration service setting data instance associated with the provided migration service.

```csharp
    public
    ManagementObject
    GetMigrationServiceSettings(
        ManagementObject service
        )
    {
        ManagementObject serviceSetting = null;
        using (ManagementObjectCollection settingCollection =
            service.GetRelated("Msvm_VirtualSystemMigrationServiceSettingData"))
        {
            foreach (ManagementObject mgmtObj in settingCollection)
            {
                serviceSetting = mgmtObj;
                break;
            }
        }

        return serviceSetting;
    }
```

--------------------------------

### InitiateFailover MOF Syntax

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/initiatefailover-msvm-replicationservice

The Managed Object Format (MOF) definition for the InitiateFailover method.

```MOF
uint32 InitiateFailover(
  [in]  CIM_ComputerSystem           REF ComputerSystem,
  [in]  CIM_VirtualSystemSettingData REF SnapshotSettingData,
  [out] CIM_ConcreteJob              REF Job
);
```

--------------------------------

### Validate a Virtual Hard Disk in C#

Source: https://learn.microsoft.com/en-us/windows/win32/hyperv_v2/validatevirtualharddisk-msvm-imagemanagementservice

Example demonstrating how to invoke the ValidateVirtualHardDisk method using WMI in C#.

```CSharp
public static void ValidateVirtualHardDisk(string vhdPath)
{
    ManagementScope scope = new ManagementScope(@"root\virtualization\v2", null);
    ManagementObject imageService = Utility.GetServiceObject(scope, "Msvm_ImageManagementService");

    ManagementBaseObject inParams = imageService.GetMethodParameters("ValidateVirtualHardDisk");
    inParams["Path"] = vhdPath;
    ManagementBaseObject outParams = imageService.InvokeMethod("ValidateVirtualHardDisk", inParams, null);
    if ((UInt32)outParams["ReturnValue"] == ReturnCode.Started)
    {
        if (Utility.JobCompleted(outParams, scope))
        {
            Console.WriteLine("{0} is a valid virtual hard disk.", inParams["Path"]);
        }
        else
        {
            Console.WriteLine("Unable to validate {0}", inParams["Path"]);
        }
    }

    outParams.Dispose();
    inParams.Dispose();
    imageService.Dispose();
}
```
Tokens:
Raw