
/*
 *  DO NOT EDIT! This is a generated file.
 *
 *  MS IDL (MIDL) definition for VirualBox Main API (COM interfaces)
 *  generated from XIDL (XML interface definition).
 *
 *  Source    : src/VBox/Main/idl/VirtualBox.xidl
 *  Generator : src/VBox/Main/idl/midl.xsl
 */
  
import "unknwn.idl";

cpp_quote("enum {")

cpp_quote("    kTypeLibraryMajorVersion = 1,")

cpp_quote("    kTypeLibraryMinorVersion = 0")

cpp_quote("};")

[
    uuid(46137EEC-703B-4fe5-AFD4-7C9BBBBA0259),
    version(1.3),
    helpstring("VirtualBox Type Library")
]
library VirtualBox
{

importlib("stdole2.tlb");

interface IVirtualBoxErrorInfo;
interface IVirtualBoxCallback;
interface IVirtualBox;
interface IMachineEnumerator;
interface IMachineCollection;
interface IInternalMachineControl;
interface IBIOSSettings;
interface IMachine;
interface IConsoleCallback;
interface IRemoteDisplayInfo;
interface IConsole;
interface IHostDVDDrive;
interface IHostDVDDriveEnumerator;
interface IHostDVDDriveCollection;
interface IHostFloppyDrive;
interface IHostFloppyDriveEnumerator;
interface IHostFloppyDriveCollection;
interface IHostNetworkInterface;
interface IHostNetworkInterfaceEnumerator;
interface IHostNetworkInterfaceCollection;
interface IHost;
interface ISystemProperties;
interface IGuestOSType;
interface IGuestOSTypeEnumerator;
interface IGuestOSTypeCollection;
interface IGuest;
interface IProgressEnumerator;
interface IProgressCollection;
interface IProgress;
interface ISnapshotEnumerator;
interface ISnapshotCollection;
interface ISnapshot;
interface IHardDiskAttachment;
interface IHardDiskAttachmentEnumerator;
interface IHardDiskAttachmentCollection;
interface IHardDiskEnumerator;
interface IHardDiskCollection;
interface IHardDisk;
interface IVirtualDiskImage;
interface IISCSIHardDisk;
interface IVMDKImage;
interface ICustomHardDisk;
interface IVHDImage;
interface IDVDImageEnumerator;
interface IDVDImageCollection;
interface IDVDImage;
interface IDVDDrive;
interface IFloppyImageEnumerator;
interface IFloppyImageCollection;
interface IFloppyImage;
interface IFloppyDrive;
interface IKeyboard;
interface IMouse;
interface IFramebuffer;
interface IFramebufferOverlay;
interface IDisplay;
interface INetworkAdapter;
interface ISerialPort;
interface IParallelPort;
interface IMachineDebugger;
interface IUSBController;
interface IUSBDeviceEnumerator;
interface IUSBDeviceCollection;
interface IUSBDevice;
interface IUSBDeviceFilterEnumerator;
interface IUSBDeviceFilterCollection;
interface IUSBDeviceFilter;
interface IHostUSBDeviceEnumerator;
interface IHostUSBDeviceCollection;
interface IHostUSBDevice;
interface IHostUSBDeviceFilterEnumerator;
interface IHostUSBDeviceFilterCollection;
interface IHostUSBDeviceFilter;
interface IAudioAdapter;
interface IVRDPServer;
interface ISharedFolderEnumerator;
interface ISharedFolderCollection;
interface ISharedFolder;
interface IInternalSessionControl;
interface ISession;
interface ISATAController;
interface IPerformanceMetric;
interface IPerformanceCollector;

[
    uuid(523ff64d-842a-4b1a-80e7-c311b028cb3a),
    v1_enum
]
typedef enum 
{
    TSBool_False = 0,
    TSBool_True = 1,
    TSBool_Default = 2
} TSBool;

/* cross-platform type name for TSBool */
cpp_quote("#define TSBool_T TSBool")



[
    uuid(73bf04d0-7c4f-4684-9abf-d65a9ad74343),
    v1_enum
]
typedef enum 
{
    MachineState_Null = 0,
    MachineState_PoweredOff = 1,
    MachineState_Saved = 2,
    MachineState_Aborted = 3,
    MachineState_Running = 4,
    MachineState_Paused = 5,
    MachineState_Stuck = 6,
    MachineState_Starting = 7,
    MachineState_Stopping = 8,
    MachineState_Saving = 9,
    MachineState_Restoring = 10,
    MachineState_Discarding = 11
} MachineState;

/* cross-platform type name for MachineState */
cpp_quote("#define MachineState_T MachineState")



[
    uuid(CF2700C0-EA4B-47ae-9725-7810114B94D8),
    v1_enum
]
typedef enum 
{
    SessionState_Null = 0,
    SessionState_Closed = 1,
    SessionState_Open = 2,
    SessionState_Spawning = 3,
    SessionState_Closing = 4
} SessionState;

/* cross-platform type name for SessionState */
cpp_quote("#define SessionState_T SessionState")



[
    uuid(A13C02CB-0C2C-421E-8317-AC0E8AAA153A),
    v1_enum
]
typedef enum 
{
    SessionType_Null = 0,
    SessionType_Direct = 1,
    SessionType_Remote = 2,
    SessionType_Existing = 3
} SessionType;

/* cross-platform type name for SessionType */
cpp_quote("#define SessionType_T SessionType")



[
    uuid(6d9420f7-0b56-4636-99f9-7346f1b01e57),
    v1_enum
]
typedef enum 
{
    DeviceType_Null = 0,
    DeviceType_Floppy = 1,
    DeviceType_DVD = 2,
    DeviceType_HardDisk = 3,
    DeviceType_Network = 4,
    DeviceType_USB = 5,
    DeviceType_SharedFolder = 6
} DeviceType;

/* cross-platform type name for DeviceType */
cpp_quote("#define DeviceType_T DeviceType")



[
    uuid(6FC8AEAA-130A-4eb5-8954-3F921422D707),
    v1_enum
]
typedef enum 
{
    DeviceActivity_Null = 0,
    DeviceActivity_Idle = 1,
    DeviceActivity_Reading = 2,
    DeviceActivity_Writing = 3
} DeviceActivity;

/* cross-platform type name for DeviceActivity */
cpp_quote("#define DeviceActivity_T DeviceActivity")



[
    uuid(FC56E4B6-B195-48e2-A5E1-A667B0D9F809),
    v1_enum
]
typedef enum 
{
    ResourceUsage_Null = 0,
    ResourceUsage_Permanent = 1,
    ResourceUsage_Temporary = 2,
    ResourceUsage_All = 3
} ResourceUsage;

/* cross-platform type name for ResourceUsage */
cpp_quote("#define ResourceUsage_T ResourceUsage")



[
    uuid(715984a5-093c-43bb-aa42-a16ed16828dd),
    v1_enum
]
typedef enum 
{
    StorageBus_Null = 0,
    StorageBus_IDE = 1,
    StorageBus_SATA = 2
} StorageBus;

/* cross-platform type name for StorageBus */
cpp_quote("#define StorageBus_T StorageBus")



[
    uuid(33364716-4008-4701-8f14-be0fa3d62950),
    v1_enum
]
typedef enum 
{
    ClipboardMode_Disabled = 0,
    ClipboardMode_HostToGuest = 1,
    ClipboardMode_GuestToHost = 2,
    ClipboardMode_Bidirectional = 3
} ClipboardMode;

/* cross-platform type name for ClipboardMode */
cpp_quote("#define ClipboardMode_T ClipboardMode")



[
    uuid(7c91096e-499e-4eca-9f9b-9001438d7855),
    v1_enum
]
typedef enum 
{
    Scope_Global = 0,
    Scope_Machine = 1,
    Scope_Session = 2
} Scope;

/* cross-platform type name for Scope */
cpp_quote("#define Scope_T Scope")



[
    uuid(aa7c1d71-aafe-47a8-9608-27d2d337cf55),
    v1_enum
]
typedef enum 
{
    GuestStatisticType_CPULoad_Idle = 0,
    GuestStatisticType_CPULoad_Kernel = 1,
    GuestStatisticType_CPULoad_User = 2,
    GuestStatisticType_Threads = 3,
    GuestStatisticType_Processes = 4,
    GuestStatisticType_Handles = 5,
    GuestStatisticType_MemoryLoad = 6,
    GuestStatisticType_PhysMemTotal = 7,
    GuestStatisticType_PhysMemAvailable = 8,
    GuestStatisticType_PhysMemBalloon = 9,
    GuestStatisticType_MemCommitTotal = 10,
    GuestStatisticType_MemKernelTotal = 11,
    GuestStatisticType_MemKernelPaged = 12,
    GuestStatisticType_MemKernelNonpaged = 13,
    GuestStatisticType_MemSystemCache = 14,
    GuestStatisticType_PageFileSize = 15,
    GuestStatisticType_SampleNumber = 16,
    GuestStatisticType_MaxVal = 17
} GuestStatisticType;

/* cross-platform type name for GuestStatisticType */
cpp_quote("#define GuestStatisticType_T GuestStatisticType")



[
    uuid(ae4fb9f7-29d2-45b4-b2c7-d579603135d5),
    v1_enum
]
typedef enum 
{
    BIOSBootMenuMode_Disabled = 0,
    BIOSBootMenuMode_MenuOnly = 1,
    BIOSBootMenuMode_MessageAndMenu = 2
} BIOSBootMenuMode;

/* cross-platform type name for BIOSBootMenuMode */
cpp_quote("#define BIOSBootMenuMode_T BIOSBootMenuMode")



[
    uuid(445330e3-202a-4dab-854f-ce22e6cb9715),
    v1_enum
]
typedef enum 
{
    IDEControllerType_Null = 0,
    IDEControllerType_PIIX3 = 1,
    IDEControllerType_PIIX4 = 2
} IDEControllerType;

/* cross-platform type name for IDEControllerType */
cpp_quote("#define IDEControllerType_T IDEControllerType")



[
    uuid(cb7233b7-c519-42a5-8310-1830953cacbc),
    v1_enum
]
typedef enum 
{
    DriveState_Null = 0,
    DriveState_NotMounted = 1,
    DriveState_ImageMounted = 2,
    DriveState_HostDriveCaptured = 3
} DriveState;

/* cross-platform type name for DriveState */
cpp_quote("#define DriveState_T DriveState")



[
    uuid(48138584-ad99-479d-a36f-eb82a7663685),
    v1_enum
]
typedef enum 
{
    HardDiskStorageType_VirtualDiskImage = 0,
    HardDiskStorageType_ISCSIHardDisk = 1,
    HardDiskStorageType_VMDKImage = 2,
    HardDiskStorageType_CustomHardDisk = 3,
    HardDiskStorageType_VHDImage = 4
} HardDiskStorageType;

/* cross-platform type name for HardDiskStorageType */
cpp_quote("#define HardDiskStorageType_T HardDiskStorageType")



[
    uuid(a348fafd-a64e-4643-ba65-eb3896bd7e0a),
    v1_enum
]
typedef enum 
{
    HardDiskType_Normal = 0,
    HardDiskType_Immutable = 1,
    HardDiskType_Writethrough = 2
} HardDiskType;

/* cross-platform type name for HardDiskType */
cpp_quote("#define HardDiskType_T HardDiskType")



[
    uuid(03131722-2EC5-4173-9794-0DACA46673EF),
    v1_enum
]
typedef enum 
{
    MouseButtonState_LeftButton = 0x01,
    MouseButtonState_RightButton = 0x02,
    MouseButtonState_MiddleButton = 0x04,
    MouseButtonState_WheelUp = 0x08,
    MouseButtonState_WheelDown = 0x10,
    MouseButtonState_MouseStateMask = 0x1F
} MouseButtonState;

/* cross-platform type name for MouseButtonState */
cpp_quote("#define MouseButtonState_T MouseButtonState")



[
    uuid(f0e5ebbe-dc8e-4e2d-916e-53baa3844df8),
    v1_enum
]
typedef enum 
{
    FramebufferAccelerationOperation_SolidFillAcceleration = 1,
    FramebufferAccelerationOperation_ScreenCopyAcceleration = 2
} FramebufferAccelerationOperation;

/* cross-platform type name for FramebufferAccelerationOperation */
cpp_quote("#define FramebufferAccelerationOperation_T FramebufferAccelerationOperation")



[
    uuid(6b27d1fc-4f2c-4e9c-a166-01d06540305d),
    v1_enum
]
typedef enum 
{
    FramebufferPixelFormat_Opaque = 0xFFFFFFFF,
    FramebufferPixelFormat_FOURCC_RGB = 0x32424752
} FramebufferPixelFormat;

/* cross-platform type name for FramebufferPixelFormat */
cpp_quote("#define FramebufferPixelFormat_T FramebufferPixelFormat")



[
    uuid(8730d899-d036-4925-bc63-e58f3486f4bf),
    v1_enum
]
typedef enum 
{
    NetworkAttachmentType_Null = 0,
    NetworkAttachmentType_NAT = 1,
    NetworkAttachmentType_HostInterface = 2,
    NetworkAttachmentType_Internal = 3
} NetworkAttachmentType;

/* cross-platform type name for NetworkAttachmentType */
cpp_quote("#define NetworkAttachmentType_T NetworkAttachmentType")



[
    uuid(156b17b9-5d61-4d54-be90-62e37dda848d),
    v1_enum
]
typedef enum 
{
    NetworkAdapterType_Null = 0,
    NetworkAdapterType_Am79C970A = 1,
    NetworkAdapterType_Am79C973 = 2,
    NetworkAdapterType_I82540EM = 3,
    NetworkAdapterType_I82543GC = 4
} NetworkAdapterType;

/* cross-platform type name for NetworkAdapterType */
cpp_quote("#define NetworkAdapterType_T NetworkAdapterType")



[
    uuid(b266f43c-2e93-46b3-812b-c20e600e867b),
    v1_enum
]
typedef enum 
{
    PortMode_Disconnected = 0,
    PortMode_HostPipe = 1,
    PortMode_HostDevice = 2
} PortMode;

/* cross-platform type name for PortMode */
cpp_quote("#define PortMode_T PortMode")



[
    uuid(b99a2e65-67fb-4882-82fd-f3e5e8193ab4),
    v1_enum
]
typedef enum 
{
    USBDeviceState_NotSupported = 0,
    USBDeviceState_Unavailable = 1,
    USBDeviceState_Busy = 2,
    USBDeviceState_Available = 3,
    USBDeviceState_Held = 4,
    USBDeviceState_Captured = 5
} USBDeviceState;

/* cross-platform type name for USBDeviceState */
cpp_quote("#define USBDeviceState_T USBDeviceState")



[
    uuid(cbc30a49-2f4e-43b5-9da6-121320475933),
    v1_enum
]
typedef enum 
{
    USBDeviceFilterAction_Null = 0,
    USBDeviceFilterAction_Ignore = 1,
    USBDeviceFilterAction_Hold = 2
} USBDeviceFilterAction;

/* cross-platform type name for USBDeviceFilterAction */
cpp_quote("#define USBDeviceFilterAction_T USBDeviceFilterAction")



[
    uuid(4bcc3d73-c2fe-40db-b72f-0c2ca9d68496),
    v1_enum
]
typedef enum 
{
    AudioDriverType_Null = 0,
    AudioDriverType_WinMM = 1,
    AudioDriverType_OSS = 2,
    AudioDriverType_ALSA = 3,
    AudioDriverType_DirectSound = 4,
    AudioDriverType_CoreAudio = 5,
    AudioDriverType_MMPM = 6,
    AudioDriverType_Pulse = 7,
    AudioDriverType_SolAudio = 8
} AudioDriverType;

/* cross-platform type name for AudioDriverType */
cpp_quote("#define AudioDriverType_T AudioDriverType")



[
    uuid(7afd395c-42c3-444e-8788-3ce80292f36c),
    v1_enum
]
typedef enum 
{
    AudioControllerType_AC97 = 0,
    AudioControllerType_SB16 = 1
} AudioControllerType;

/* cross-platform type name for AudioControllerType */
cpp_quote("#define AudioControllerType_T AudioControllerType")



[
    uuid(3d91887a-b67f-4b33-85bf-2da7ab1ea83a),
    v1_enum
]
typedef enum 
{
    VRDPAuthType_Null = 0,
    VRDPAuthType_External = 1,
    VRDPAuthType_Guest = 2
} VRDPAuthType;

/* cross-platform type name for VRDPAuthType */
cpp_quote("#define VRDPAuthType_T VRDPAuthType")



[
    uuid(e98b5376-8eb4-4eea-812a-3964bf3bb26f),
    object,
    dual
]
interface IVirtualBoxErrorInfo : IErrorInfo
{
    [propget] HRESULT ResultCode ([out, retval] HRESULT * aResultCode);

    [propget] HRESULT InterfaceID ([out, retval] GUID * aInterfaceID);

    [propget] HRESULT Component ([out, retval] BSTR * aComponent);

    [propget] HRESULT Text ([out, retval] BSTR * aText);

    [propget] HRESULT Next ([out, retval] IVirtualBoxErrorInfo * * aNext);

}; /* interface IVirtualBoxErrorInfo */

[
    uuid(5516cc08-fb81-47a6-b184-031e7bbd2997),
    object,
    dual
]
interface IVirtualBoxCallback : IUnknown
{
    HRESULT OnMachineStateChange (
        [in] GUID aMachineId,
        [in] MachineState aState
    );

    HRESULT OnMachineDataChange (
        [in] GUID aMachineId
    );

    HRESULT OnExtraDataCanChange (
        [in] GUID aMachineId,
        [in] BSTR aKey,
        [in] BSTR aValue,
        [out] BSTR * aError,
        [out, retval] BOOL * aAllowChange
    );

    HRESULT OnExtraDataChange (
        [in] GUID aMachineId,
        [in] BSTR aKey,
        [in] BSTR aValue
    );

    HRESULT OnMediaRegistered (
        [in] GUID aMediaId,
        [in] DeviceType aMediaType,
        [in] BOOL aRegistered
    );

    HRESULT OnMachineRegistered (
        [in] GUID aMachineId,
        [in] BOOL aRegistered
    );

    HRESULT OnSessionStateChange (
        [in] GUID aMachineId,
        [in] SessionState aState
    );

    HRESULT OnSnapshotTaken (
        [in] GUID aMachineId,
        [in] GUID aSnapshotId
    );

    HRESULT OnSnapshotDiscarded (
        [in] GUID aMachineId,
        [in] GUID aSnapshotId
    );

    HRESULT OnSnapshotChange (
        [in] GUID aMachineId,
        [in] GUID aSnapshotId
    );

    HRESULT OnGuestPropertyChange (
        [in] GUID aMachineId,
        [in] BSTR aName,
        [in] BSTR aValue,
        [in] BSTR aFlags
    );

}; /* interface IVirtualBoxCallback */

[
    uuid(557a07bc-e6ae-4520-a361-4a8493199137),
    object,
    dual
]
interface IVirtualBox : IDispatch
{
    [propget] HRESULT Version ([out, retval] BSTR * aVersion);

    [propget] HRESULT Revision ([out, retval] ULONG * aRevision);

    [propget] HRESULT PackageType ([out, retval] BSTR * aPackageType);

    [propget] HRESULT HomeFolder ([out, retval] BSTR * aHomeFolder);

    [propget] HRESULT SettingsFilePath ([out, retval] BSTR * aSettingsFilePath);

    [propget] HRESULT SettingsFileVersion ([out, retval] BSTR * aSettingsFileVersion);

    [propget] HRESULT SettingsFormatVersion ([out, retval] BSTR * aSettingsFormatVersion);

    [propget] HRESULT Host ([out, retval] IHost * * aHost);

    [propget] HRESULT SystemProperties ([out, retval] ISystemProperties * * aSystemProperties);

    [propget] HRESULT Machines ([out, retval] IMachineCollection * * aMachines);

    [propget] HRESULT Machines2 ([out, retval] SAFEARRAY(IMachine *) * aMachines2);

    [propget] HRESULT HardDisks ([out, retval] IHardDiskCollection * * aHardDisks);

    [propget] HRESULT DVDImages ([out, retval] IDVDImageCollection * * aDVDImages);

    [propget] HRESULT FloppyImages ([out, retval] IFloppyImageCollection * * aFloppyImages);

    [propget] HRESULT ProgressOperations ([out, retval] IProgressCollection * * aProgressOperations);

    [propget] HRESULT GuestOSTypes ([out, retval] IGuestOSTypeCollection * * aGuestOSTypes);

    [propget] HRESULT SharedFolders ([out, retval] ISharedFolderCollection * * aSharedFolders);

    [propget] HRESULT PerformanceCollector ([out, retval] IPerformanceCollector * * aPerformanceCollector);

    HRESULT CreateMachine (
        [in] BSTR aBaseFolder,
        [in] BSTR aName,
        [in] GUID aId,
        [out, retval] IMachine * * aMachine
    );

    HRESULT CreateLegacyMachine (
        [in] BSTR aSettingsFile,
        [in] BSTR aName,
        [in] GUID aId,
        [out, retval] IMachine * * aMachine
    );

    HRESULT OpenMachine (
        [in] BSTR aSettingsFile,
        [out, retval] IMachine * * aMachine
    );

    HRESULT RegisterMachine (
        [in] IMachine * aMachine
    );

    HRESULT GetMachine (
        [in] GUID aId,
        [out, retval] IMachine * * aMachine
    );

    HRESULT FindMachine (
        [in] BSTR aName,
        [out, retval] IMachine * * aMachine
    );

    HRESULT UnregisterMachine (
        [in] GUID aId,
        [out, retval] IMachine * * aMachine
    );

    HRESULT CreateHardDisk (
        [in] HardDiskStorageType aStorageType,
        [out, retval] IHardDisk * * aHardDisk
    );

    HRESULT OpenHardDisk (
        [in] BSTR aLocation,
        [out, retval] IHardDisk * * aHardDisk
    );

    HRESULT OpenVirtualDiskImage (
        [in] BSTR aFilePath,
        [out, retval] IVirtualDiskImage * * aImage
    );

    HRESULT RegisterHardDisk (
        [in] IHardDisk * aHardDisk
    );

    HRESULT GetHardDisk (
        [in] GUID aId,
        [out, retval] IHardDisk * * aHardDisk
    );

    HRESULT FindHardDisk (
        [in] BSTR aLocation,
        [out, retval] IHardDisk * * aHardDisk
    );

    HRESULT FindVirtualDiskImage (
        [in] BSTR aFilePath,
        [out, retval] IVirtualDiskImage * * aImage
    );

    HRESULT UnregisterHardDisk (
        [in] GUID aId,
        [out, retval] IHardDisk * * aHardDisk
    );

    HRESULT OpenDVDImage (
        [in] BSTR aFilePath,
        [in] GUID aId,
        [out, retval] IDVDImage * * aImage
    );

    HRESULT RegisterDVDImage (
        [in] IDVDImage * aImage
    );

    HRESULT GetDVDImage (
        [in] GUID aId,
        [out, retval] IDVDImage * * aImage
    );

    HRESULT FindDVDImage (
        [in] BSTR aFilePath,
        [out, retval] IDVDImage * * aImage
    );

    HRESULT GetDVDImageUsage (
        [in] GUID aId,
        [in] ResourceUsage aUsage,
        [out, retval] BSTR * aMachineIDs
    );

    HRESULT UnregisterDVDImage (
        [in] GUID aId,
        [out, retval] IDVDImage * * aImage
    );

    HRESULT OpenFloppyImage (
        [in] BSTR aFilePath,
        [in] GUID aId,
        [out, retval] IFloppyImage * * aImage
    );

    HRESULT RegisterFloppyImage (
        [in] IFloppyImage * aImage
    );

    HRESULT GetFloppyImage (
        [in] GUID aId,
        [out, retval] IFloppyImage * * aImage
    );

    HRESULT FindFloppyImage (
        [in] BSTR aFilePath,
        [out, retval] IFloppyImage * * aImage
    );

    HRESULT GetFloppyImageUsage (
        [in] GUID aId,
        [in] ResourceUsage aUsage,
        [out, retval] BSTR * aMachineIDs
    );

    HRESULT UnregisterFloppyImage (
        [in] GUID aId,
        [out, retval] IFloppyImage * * aImage
    );

    HRESULT GetGuestOSType (
        [in] BSTR aId,
        [out, retval] IGuestOSType * * aType
    );

    HRESULT CreateSharedFolder (
        [in] BSTR aName,
        [in] BSTR aHostPath,
        [in] BOOL aWritable
    );

    HRESULT RemoveSharedFolder (
        [in] BSTR aName
    );

    HRESULT GetNextExtraDataKey (
        [in] BSTR aKey,
        [out] BSTR * aNextKey,
        [out] BSTR * aNextValue
    );

    HRESULT GetExtraData (
        [in] BSTR aKey,
        [out, retval] BSTR * aValue
    );

    HRESULT SetExtraData (
        [in] BSTR aKey,
        [in] BSTR aValue
    );

    HRESULT OpenSession (
        [in] ISession * aSession,
        [in] GUID aMachineId
    );

    HRESULT OpenRemoteSession (
        [in] ISession * aSession,
        [in] GUID aMachineId,
        [in] BSTR aType,
        [in] BSTR aEnvironment,
        [out, retval] IProgress * * aProgress
    );

    HRESULT OpenExistingSession (
        [in] ISession * aSession,
        [in] GUID aMachineId
    );

    HRESULT RegisterCallback (
        [in] IVirtualBoxCallback * aCallback
    );

    HRESULT UnregisterCallback (
        [in] IVirtualBoxCallback * aCallback
    );

    HRESULT WaitForPropertyChange (
        [in] BSTR aWhat,
        [in] ULONG aTimeout,
        [out] BSTR * aChanged,
        [out] BSTR * aValues
    );

    HRESULT SaveSettings();

    HRESULT SaveSettingsWithBackup (
        [out, retval] BSTR * aBakFileName
    );

}; /* interface IVirtualBox */

[
    uuid(1b554149-be0a-4465-9252-9ff8f420af55),
    object,
    dual
]
interface IMachineEnumerator : IUnknown
{
    HRESULT HasMore ([out, retval] BOOL * more);

    HRESULT GetNext ([out, retval] IMachine * * next);


}; /* interface IMachineEnumerator */

[
    uuid(FD443EC1-3007-4F5B-9282-D72760A66916),
    object,
    dual
]
interface IMachineCollection : IUnknown
{
    [propget] HRESULT Count ([out, retval] ULONG * count);

    HRESULT GetItemAt ([in] ULONG index, [out, retval] IMachine * * item);

    HRESULT Enumerate ([out, retval] IMachineEnumerator * * enumerator);


}; /* interface IMachineCollection */

[
    uuid(de04566a-7125-444b-949e-34e9f3ec3676),
    object,
    dual
]
interface IInternalMachineControl : IUnknown
{
    HRESULT UpdateState (
        [in] MachineState aState
    );

    HRESULT GetIPCId (
        [out, retval] BSTR * aId
    );

    HRESULT RunUSBDeviceFilters (
        [in] IUSBDevice * aDevice,
        [out] BOOL * aMatched,
        [out] ULONG * aMaskedInterfaces
    );

    HRESULT CaptureUSBDevice (
        [in] GUID aId
    );

    HRESULT DetachUSBDevice (
        [in] GUID aId,
        [in] BOOL aDone
    );

    HRESULT AutoCaptureUSBDevices();

    HRESULT DetachAllUSBDevices (
        [in] BOOL aDone
    );

    HRESULT OnSessionEnd (
        [in] ISession * aSession,
        [out, retval] IProgress * * aProgress
    );

    HRESULT BeginSavingState (
        [in] IProgress * aProgress,
        [out] BSTR * aStateFilePath
    );

    HRESULT EndSavingState (
        [in] BOOL aSuccess
    );

    HRESULT AdoptSavedState (
        [in] BSTR aSavedStateFile
    );

    HRESULT BeginTakingSnapshot (
        [in] IConsole * aInitiator,
        [in] BSTR aName,
        [in] BSTR aDescription,
        [in] IProgress * aProgress,
        [out] BSTR * aStateFilePath,
        [out] IProgress * * aServerProgress
    );

    HRESULT EndTakingSnapshot (
        [in] BOOL aSuccess
    );

    HRESULT DiscardSnapshot (
        [in] IConsole * aInitiator,
        [in] GUID aId,
        [out] MachineState * aMachineState,
        [out, retval] IProgress * * aProgress
    );

    HRESULT DiscardCurrentState (
        [in] IConsole * aInitiator,
        [out] MachineState * aMachineState,
        [out, retval] IProgress * * aProgress
    );

    HRESULT DiscardCurrentSnapshotAndState (
        [in] IConsole * aInitiator,
        [out] MachineState * aMachineState,
        [out, retval] IProgress * * aProgress
    );

    HRESULT PullGuestProperties (
        [out] SAFEARRAY(BSTR) * aName,
        [out] SAFEARRAY(BSTR) * aValue,
        [out] SAFEARRAY(ULONG64) * aTimestamp,
        [out] SAFEARRAY(BSTR) * aFlags
    );

    HRESULT PushGuestProperties (
        [in, out] SAFEARRAY(BSTR) * aName,
        [in, out] SAFEARRAY(BSTR) * aValue,
        [in, out] SAFEARRAY(ULONG64) * aTimestamp,
        [in, out] SAFEARRAY(BSTR) * aFlags
    );

}; /* interface IInternalMachineControl */

[
    uuid(38b54279-dc35-4f5e-a431-835b867c6b5e),
    object,
    dual
]
interface IBIOSSettings : IUnknown
{
    [propget] HRESULT LogoFadeIn ([out, retval] BOOL * aLogoFadeIn);
    [propput] HRESULT LogoFadeIn ([in] BOOL aLogoFadeIn);

    [propget] HRESULT LogoFadeOut ([out, retval] BOOL * aLogoFadeOut);
    [propput] HRESULT LogoFadeOut ([in] BOOL aLogoFadeOut);

    [propget] HRESULT LogoDisplayTime ([out, retval] ULONG * aLogoDisplayTime);
    [propput] HRESULT LogoDisplayTime ([in] ULONG aLogoDisplayTime);

    [propget] HRESULT LogoImagePath ([out, retval] BSTR * aLogoImagePath);
    [propput] HRESULT LogoImagePath ([in] BSTR aLogoImagePath);

    [propget] HRESULT BootMenuMode ([out, retval] BIOSBootMenuMode * aBootMenuMode);
    [propput] HRESULT BootMenuMode ([in] BIOSBootMenuMode aBootMenuMode);

    [propget] HRESULT ACPIEnabled ([out, retval] BOOL * aACPIEnabled);
    [propput] HRESULT ACPIEnabled ([in] BOOL aACPIEnabled);

    [propget] HRESULT IOAPICEnabled ([out, retval] BOOL * aIOAPICEnabled);
    [propput] HRESULT IOAPICEnabled ([in] BOOL aIOAPICEnabled);

    [propget] HRESULT TimeOffset ([out, retval] LONG64 * aTimeOffset);
    [propput] HRESULT TimeOffset ([in] LONG64 aTimeOffset);

    [propget] HRESULT PXEDebugEnabled ([out, retval] BOOL * aPXEDebugEnabled);
    [propput] HRESULT PXEDebugEnabled ([in] BOOL aPXEDebugEnabled);

    [propget] HRESULT IDEControllerType ([out, retval] IDEControllerType * aIDEControllerType);
    [propput] HRESULT IDEControllerType ([in] IDEControllerType aIDEControllerType);

}; /* interface IBIOSSettings */

[
    uuid(1e509de4-d96c-4f44-8b94-860194f710ac),
    object,
    dual
]
interface IMachine : IUnknown
{
    [propget] HRESULT Parent ([out, retval] IVirtualBox * * aParent);

    [propget] HRESULT Accessible ([out, retval] BOOL * aAccessible);

    [propget] HRESULT AccessError ([out, retval] IVirtualBoxErrorInfo * * aAccessError);

    [propget] HRESULT Name ([out, retval] BSTR * aName);
    [propput] HRESULT Name ([in] BSTR aName);

    [propget] HRESULT Description ([out, retval] BSTR * aDescription);
    [propput] HRESULT Description ([in] BSTR aDescription);

    [propget] HRESULT Id ([out, retval] GUID * aId);

    [propget] HRESULT OSTypeId ([out, retval] BSTR * aOSTypeId);
    [propput] HRESULT OSTypeId ([in] BSTR aOSTypeId);

    [propget] HRESULT MemorySize ([out, retval] ULONG * aMemorySize);
    [propput] HRESULT MemorySize ([in] ULONG aMemorySize);

    [propget] HRESULT MemoryBalloonSize ([out, retval] ULONG * aMemoryBalloonSize);
    [propput] HRESULT MemoryBalloonSize ([in] ULONG aMemoryBalloonSize);

    [propget] HRESULT StatisticsUpdateInterval ([out, retval] ULONG * aStatisticsUpdateInterval);
    [propput] HRESULT StatisticsUpdateInterval ([in] ULONG aStatisticsUpdateInterval);

    [propget] HRESULT VRAMSize ([out, retval] ULONG * aVRAMSize);
    [propput] HRESULT VRAMSize ([in] ULONG aVRAMSize);

    [propget] HRESULT MonitorCount ([out, retval] ULONG * aMonitorCount);
    [propput] HRESULT MonitorCount ([in] ULONG aMonitorCount);

    [propget] HRESULT BIOSSettings ([out, retval] IBIOSSettings * * aBIOSSettings);

    [propget] HRESULT HWVirtExEnabled ([out, retval] TSBool * aHWVirtExEnabled);
    [propput] HRESULT HWVirtExEnabled ([in] TSBool aHWVirtExEnabled);

    [propget] HRESULT HWVirtExNestedPagingEnabled ([out, retval] BOOL * aHWVirtExNestedPagingEnabled);
    [propput] HRESULT HWVirtExNestedPagingEnabled ([in] BOOL aHWVirtExNestedPagingEnabled);

    [propget] HRESULT PAEEnabled ([out, retval] BOOL * aPAEEnabled);
    [propput] HRESULT PAEEnabled ([in] BOOL aPAEEnabled);

    [propget] HRESULT SnapshotFolder ([out, retval] BSTR * aSnapshotFolder);
    [propput] HRESULT SnapshotFolder ([in] BSTR aSnapshotFolder);

    [propget] HRESULT VRDPServer ([out, retval] IVRDPServer * * aVRDPServer);

    [propget] HRESULT HardDiskAttachments ([out, retval] IHardDiskAttachmentCollection * * aHardDiskAttachments);

    [propget] HRESULT DVDDrive ([out, retval] IDVDDrive * * aDVDDrive);

    [propget] HRESULT FloppyDrive ([out, retval] IFloppyDrive * * aFloppyDrive);

    [propget] HRESULT USBController ([out, retval] IUSBController * * aUSBController);

    [propget] HRESULT AudioAdapter ([out, retval] IAudioAdapter * * aAudioAdapter);

    [propget] HRESULT SATAController ([out, retval] ISATAController * * aSATAController);

    [propget] HRESULT SettingsFilePath ([out, retval] BSTR * aSettingsFilePath);

    [propget] HRESULT SettingsFileVersion ([out, retval] BSTR * aSettingsFileVersion);

    [propget] HRESULT SettingsModified ([out, retval] BOOL * aSettingsModified);

    [propget] HRESULT SessionState ([out, retval] SessionState * aSessionState);

    [propget] HRESULT SessionType ([out, retval] BSTR * aSessionType);

    [propget] HRESULT SessionPid ([out, retval] ULONG * aSessionPid);

    [propget] HRESULT State ([out, retval] MachineState * aState);

    [propget] HRESULT LastStateChange ([out, retval] LONG64 * aLastStateChange);

    [propget] HRESULT StateFilePath ([out, retval] BSTR * aStateFilePath);

    [propget] HRESULT LogFolder ([out, retval] BSTR * aLogFolder);

    [propget] HRESULT CurrentSnapshot ([out, retval] ISnapshot * * aCurrentSnapshot);

    [propget] HRESULT SnapshotCount ([out, retval] ULONG * aSnapshotCount);

    [propget] HRESULT CurrentStateModified ([out, retval] BOOL * aCurrentStateModified);

    [propget] HRESULT SharedFolders ([out, retval] ISharedFolderCollection * * aSharedFolders);

    [propget] HRESULT ClipboardMode ([out, retval] ClipboardMode * aClipboardMode);
    [propput] HRESULT ClipboardMode ([in] ClipboardMode aClipboardMode);

    HRESULT SetBootOrder (
        [in] ULONG aPosition,
        [in] DeviceType aDevice
    );

    HRESULT GetBootOrder (
        [in] ULONG aOrder,
        [out, retval] DeviceType * aDevice
    );

    HRESULT AttachHardDisk (
        [in] GUID aId,
        [in] StorageBus aBus,
        [in] LONG aChannel,
        [in] LONG aDevice
    );

    HRESULT GetHardDisk (
        [in] StorageBus aBus,
        [in] LONG aChannel,
        [in] LONG aDevice,
        [out, retval] IHardDisk * * aHardDisk
    );

    HRESULT DetachHardDisk (
        [in] StorageBus aBus,
        [in] LONG aChannel,
        [in] LONG aDevice
    );

    HRESULT GetNetworkAdapter (
        [in] ULONG aSlot,
        [out, retval] INetworkAdapter * * aAdapter
    );

    HRESULT GetSerialPort (
        [in] ULONG aSlot,
        [out, retval] ISerialPort * * aPort
    );

    HRESULT GetParallelPort (
        [in] ULONG aSlot,
        [out, retval] IParallelPort * * aPort
    );

    HRESULT GetNextExtraDataKey (
        [in] BSTR aKey,
        [out] BSTR * aNextKey,
        [out] BSTR * aNextValue
    );

    HRESULT GetExtraData (
        [in] BSTR aKey,
        [out, retval] BSTR * aValue
    );

    HRESULT SetExtraData (
        [in] BSTR aKey,
        [in] BSTR aValue
    );

    HRESULT SaveSettings();

    HRESULT SaveSettingsWithBackup (
        [out, retval] BSTR * aBakFileName
    );

    HRESULT DiscardSettings();

    HRESULT DeleteSettings();

    HRESULT GetSnapshot (
        [in] GUID aId,
        [out, retval] ISnapshot * * aSnapshot
    );

    HRESULT FindSnapshot (
        [in] BSTR aName,
        [out, retval] ISnapshot * * aSnapshot
    );

    HRESULT SetCurrentSnapshot (
        [in] GUID aId
    );

    HRESULT CreateSharedFolder (
        [in] BSTR aName,
        [in] BSTR aHostPath,
        [in] BOOL aWritable
    );

    HRESULT RemoveSharedFolder (
        [in] BSTR aName
    );

    HRESULT CanShowConsoleWindow (
        [out, retval] BOOL * aCanShow
    );

    HRESULT ShowConsoleWindow (
        [out, retval] ULONG64 * aWinId
    );

    HRESULT GetGuestProperty (
        [in] BSTR aName,
        [out] BSTR * aValue,
        [out] ULONG64 * aTimestamp,
        [out] BSTR * aFlags
    );

    HRESULT GetGuestPropertyValue (
        [in] BSTR aProperty,
        [out, retval] BSTR * aValue
    );

    HRESULT GetGuestPropertyTimestamp (
        [in] BSTR aProperty,
        [out, retval] ULONG64 * aValue
    );

    HRESULT SetGuestProperty (
        [in] BSTR aProperty,
        [in] BSTR aValue,
        [in] BSTR aFlags
    );

    HRESULT SetGuestPropertyValue (
        [in] BSTR aProperty,
        [in] BSTR aValue
    );

    HRESULT EnumerateGuestProperties (
        [in] BSTR aPatterns,
        [out] SAFEARRAY(BSTR) * aName,
        [out] SAFEARRAY(BSTR) * aValue,
        [out] SAFEARRAY(ULONG64) * aTimestamp,
        [out] SAFEARRAY(BSTR) * aFlags
    );

}; /* interface IMachine */

[
    uuid(13dfbef3-b74d-487d-bada-2304529aefa6),
    object,
    dual
]
interface IConsoleCallback : IUnknown
{
    HRESULT OnMousePointerShapeChange (
        [in] BOOL aVisible,
        [in] BOOL aAlpha,
        [in] ULONG aXHot,
        [in] ULONG aYHot,
        [in] ULONG aWidth,
        [in] ULONG aHeight,
        [in] BYTE * aShape
    );

    HRESULT OnMouseCapabilityChange (
        [in] BOOL aSupportsAbsolute,
        [in] BOOL aNeedsHostCursor
    );

    HRESULT OnKeyboardLedsChange (
        [in] BOOL aNumLock,
        [in] BOOL aCapsLock,
        [in] BOOL aScrollLock
    );

    HRESULT OnStateChange (
        [in] MachineState aState
    );

    HRESULT OnAdditionsStateChange();

    HRESULT OnDVDDriveChange();

    HRESULT OnFloppyDriveChange();

    HRESULT OnNetworkAdapterChange (
        [in] INetworkAdapter * aNetworkAdapter
    );

    HRESULT OnSerialPortChange (
        [in] ISerialPort * aSerialPort
    );

    HRESULT OnParallelPortChange (
        [in] IParallelPort * aParallelPort
    );

    HRESULT OnVRDPServerChange();

    HRESULT OnUSBControllerChange();

    HRESULT OnUSBDeviceStateChange (
        [in] IUSBDevice * aDevice,
        [in] BOOL aAttached,
        [in] IVirtualBoxErrorInfo * aError
    );

    HRESULT OnSharedFolderChange (
        [in] Scope aScope
    );

    HRESULT OnRuntimeError (
        [in] BOOL aFatal,
        [in] BSTR aId,
        [in] BSTR aMessage
    );

    HRESULT OnCanShowWindow (
        [out, retval] BOOL * aCanShow
    );

    HRESULT OnShowWindow (
        [out, retval] ULONG64 * aWinId
    );

}; /* interface IConsoleCallback */

[
    uuid(550104cd-2dfd-4a6c-857d-f6f8e088e62c),
    object,
    dual
]
interface IRemoteDisplayInfo : IUnknown
{
    [propget] HRESULT Active ([out, retval] BOOL * aActive);

    [propget] HRESULT NumberOfClients ([out, retval] ULONG * aNumberOfClients);

    [propget] HRESULT BeginTime ([out, retval] LONG64 * aBeginTime);

    [propget] HRESULT EndTime ([out, retval] LONG64 * aEndTime);

    [propget] HRESULT BytesSent ([out, retval] ULONG64 * aBytesSent);

    [propget] HRESULT BytesSentTotal ([out, retval] ULONG64 * aBytesSentTotal);

    [propget] HRESULT BytesReceived ([out, retval] ULONG64 * aBytesReceived);

    [propget] HRESULT BytesReceivedTotal ([out, retval] ULONG64 * aBytesReceivedTotal);

    [propget] HRESULT User ([out, retval] BSTR * aUser);

    [propget] HRESULT Domain ([out, retval] BSTR * aDomain);

    [propget] HRESULT ClientName ([out, retval] BSTR * aClientName);

    [propget] HRESULT ClientIP ([out, retval] BSTR * aClientIP);

    [propget] HRESULT ClientVersion ([out, retval] ULONG * aClientVersion);

    [propget] HRESULT EncryptionStyle ([out, retval] ULONG * aEncryptionStyle);

}; /* interface IRemoteDisplayInfo */

[
    uuid(e3c6d4a1-a935-47ca-b16d-f9e9c496e53e),
    object,
    dual
]
interface IConsole : IUnknown
{
    [propget] HRESULT Machine ([out, retval] IMachine * * aMachine);

    [propget] HRESULT State ([out, retval] MachineState * aState);

    [propget] HRESULT Guest ([out, retval] IGuest * * aGuest);

    [propget] HRESULT Keyboard ([out, retval] IKeyboard * * aKeyboard);

    [propget] HRESULT Mouse ([out, retval] IMouse * * aMouse);

    [propget] HRESULT Display ([out, retval] IDisplay * * aDisplay);

    [propget] HRESULT Debugger ([out, retval] IMachineDebugger * * aDebugger);

    [propget] HRESULT USBDevices ([out, retval] IUSBDeviceCollection * * aUSBDevices);

    [propget] HRESULT RemoteUSBDevices ([out, retval] IHostUSBDeviceCollection * * aRemoteUSBDevices);

    [propget] HRESULT SharedFolders ([out, retval] ISharedFolderCollection * * aSharedFolders);

    [propget] HRESULT RemoteDisplayInfo ([out, retval] IRemoteDisplayInfo * * aRemoteDisplayInfo);

    HRESULT PowerUp (
        [out, retval] IProgress * * aProgress
    );

    HRESULT PowerDown();

    HRESULT PowerDownAsync (
        [out, retval] IProgress * * aProgress
    );

    HRESULT Reset();

    HRESULT Pause();

    HRESULT Resume();

    HRESULT PowerButton();

    HRESULT SleepButton();

    HRESULT GetPowerButtonHandled (
        [out, retval] BOOL * aHandled
    );

    HRESULT SaveState (
        [out, retval] IProgress * * aProgress
    );

    HRESULT AdoptSavedState (
        [in] BSTR aSavedStateFile
    );

    HRESULT DiscardSavedState();

    HRESULT GetDeviceActivity (
        [in] DeviceType aType,
        [out, retval] DeviceActivity * aActivity
    );

    HRESULT AttachUSBDevice (
        [in] GUID aId
    );

    HRESULT DetachUSBDevice (
        [in] GUID aId,
        [out, retval] IUSBDevice * * aDevice
    );

    HRESULT CreateSharedFolder (
        [in] BSTR aName,
        [in] BSTR aHostPath,
        [in] BOOL aWritable
    );

    HRESULT RemoveSharedFolder (
        [in] BSTR aName
    );

    HRESULT TakeSnapshot (
        [in] BSTR aName,
        [in] BSTR aDescription,
        [out, retval] IProgress * * aProgress
    );

    HRESULT DiscardSnapshot (
        [in] GUID aId,
        [out, retval] IProgress * * aProgress
    );

    HRESULT DiscardCurrentState (
        [out, retval] IProgress * * aProgress
    );

    HRESULT DiscardCurrentSnapshotAndState (
        [out, retval] IProgress * * aProgress
    );

    HRESULT RegisterCallback (
        [in] IConsoleCallback * aCallback
    );

    HRESULT UnregisterCallback (
        [in] IConsoleCallback * aCallback
    );

}; /* interface IConsole */

[
    uuid(21f86694-202d-4ce4-8b05-a63ff82dbf4c),
    object,
    dual
]
interface IHostDVDDrive : IUnknown
{
    [propget] HRESULT Name ([out, retval] BSTR * aName);

    [propget] HRESULT Description ([out, retval] BSTR * aDescription);

    [propget] HRESULT Udi ([out, retval] BSTR * aUdi);

}; /* interface IHostDVDDrive */

[
    uuid(1ed7cfaf-c363-40df-aa4e-89c1afb7d96b),
    object,
    dual
]
interface IHostDVDDriveEnumerator : IUnknown
{
    HRESULT HasMore ([out, retval] BOOL * more);

    HRESULT GetNext ([out, retval] IHostDVDDrive * * next);


}; /* interface IHostDVDDriveEnumerator */

[
    uuid(1909c533-1a1e-445f-a4e1-a267cffc30ed),
    object,
    dual
]
interface IHostDVDDriveCollection : IUnknown
{
    [propget] HRESULT Count ([out, retval] ULONG * count);

    HRESULT GetItemAt ([in] ULONG index, [out, retval] IHostDVDDrive * * item);

    HRESULT Enumerate ([out, retval] IHostDVDDriveEnumerator * * enumerator);

    HRESULT FindByName (
        [in] BSTR aName,
        [out, retval] IHostDVDDrive * * aDrive
    );


}; /* interface IHostDVDDriveCollection */

[
    uuid(b6a4d1a9-4221-43c3-bd52-021a5daa9ed2),
    object,
    dual
]
interface IHostFloppyDrive : IUnknown
{
    [propget] HRESULT Name ([out, retval] BSTR * aName);

    [propget] HRESULT Description ([out, retval] BSTR * aDescription);

    [propget] HRESULT Udi ([out, retval] BSTR * aUdi);

}; /* interface IHostFloppyDrive */

[
    uuid(ce04c924-4f54-432a-9dec-11fddc3ea875),
    object,
    dual
]
interface IHostFloppyDriveEnumerator : IUnknown
{
    HRESULT HasMore ([out, retval] BOOL * more);

    HRESULT GetNext ([out, retval] IHostFloppyDrive * * next);


}; /* interface IHostFloppyDriveEnumerator */

[
    uuid(fd84bb86-c59a-4037-a557-755ff263a460),
    object,
    dual
]
interface IHostFloppyDriveCollection : IUnknown
{
    [propget] HRESULT Count ([out, retval] ULONG * count);

    HRESULT GetItemAt ([in] ULONG index, [out, retval] IHostFloppyDrive * * item);

    HRESULT Enumerate ([out, retval] IHostFloppyDriveEnumerator * * enumerator);

    HRESULT FindByName (
        [in] BSTR aName,
        [out, retval] IHostFloppyDrive * * aDrive
    );


}; /* interface IHostFloppyDriveCollection */

[
    uuid(F4512D7C-B074-4e97-99B8-6D2BD27C3F5A),
    object,
    dual
]
interface IHostNetworkInterface : IUnknown
{
    [propget] HRESULT Name ([out, retval] BSTR * aName);

    [propget] HRESULT Id ([out, retval] GUID * aId);

}; /* interface IHostNetworkInterface */

[
    uuid(7B52FEF7-56E8-4aec-92F5-15E6D11EC630),
    object,
    dual
]
interface IHostNetworkInterfaceEnumerator : IUnknown
{
    HRESULT HasMore ([out, retval] BOOL * more);

    HRESULT GetNext ([out, retval] IHostNetworkInterface * * next);


}; /* interface IHostNetworkInterfaceEnumerator */

[
    uuid(BF1D41F2-B97B-4314-A0FB-D4823AF42FB5),
    object,
    dual
]
interface IHostNetworkInterfaceCollection : IUnknown
{
    [propget] HRESULT Count ([out, retval] ULONG * count);

    HRESULT GetItemAt ([in] ULONG index, [out, retval] IHostNetworkInterface * * item);

    HRESULT Enumerate ([out, retval] IHostNetworkInterfaceEnumerator * * enumerator);

    HRESULT FindByName (
        [in] BSTR aName,
        [out, retval] IHostNetworkInterface * * aNetworkInterface
    );

    HRESULT FindById (
        [in] GUID aId,
        [out, retval] IHostNetworkInterface * * aNetworkInterface
    );


}; /* interface IHostNetworkInterfaceCollection */

[
    uuid(489fb370-c227-4d43-9761-ceb28484fd9f),
    object,
    dual
]
interface IHost : IUnknown
{
    [propget] HRESULT DVDDrives ([out, retval] IHostDVDDriveCollection * * aDVDDrives);

    [propget] HRESULT FloppyDrives ([out, retval] IHostFloppyDriveCollection * * aFloppyDrives);

    [propget] HRESULT USBDevices ([out, retval] IHostUSBDeviceCollection * * aUSBDevices);

    [propget] HRESULT USBDeviceFilters ([out, retval] IHostUSBDeviceFilterCollection * * aUSBDeviceFilters);

    [propget] HRESULT NetworkInterfaces ([out, retval] IHostNetworkInterfaceCollection * * aNetworkInterfaces);

    [propget] HRESULT ProcessorCount ([out, retval] ULONG * aProcessorCount);

    [propget] HRESULT ProcessorOnlineCount ([out, retval] ULONG * aProcessorOnlineCount);

    [propget] HRESULT MemorySize ([out, retval] ULONG * aMemorySize);

    [propget] HRESULT MemoryAvailable ([out, retval] ULONG * aMemoryAvailable);

    [propget] HRESULT OperatingSystem ([out, retval] BSTR * aOperatingSystem);

    [propget] HRESULT OSVersion ([out, retval] BSTR * aOSVersion);

    [propget] HRESULT UTCTime ([out, retval] LONG64 * aUTCTime);

    HRESULT GetProcessorSpeed (
        [in] ULONG aCpuId,
        [out, retval] ULONG * aSpeed
    );

    HRESULT GetProcessorDescription (
        [in] ULONG aCpuId,
        [out, retval] BSTR * aDescription
    );

    HRESULT CreateUSBDeviceFilter (
        [in] BSTR aName,
        [out, retval] IHostUSBDeviceFilter * * aFilter
    );

    HRESULT InsertUSBDeviceFilter (
        [in] ULONG aPosition,
        [in] IHostUSBDeviceFilter * aFilter
    );

    HRESULT RemoveUSBDeviceFilter (
        [in] ULONG aPosition,
        [out, retval] IHostUSBDeviceFilter * * aFilter
    );

    HRESULT CreateHostNetworkInterface (
        [in] BSTR aName,
        [out] IHostNetworkInterface * * aHostInterface,
        [out, retval] IProgress * * aProgress
    );

    HRESULT RemoveHostNetworkInterface (
        [in] GUID aId,
        [out] IHostNetworkInterface * * aHostInterface,
        [out, retval] IProgress * * aProgress
    );

}; /* interface IHost */

[
    uuid(12c2e31e-247f-4d51-82e5-5b9d4a6c7d5b),
    object,
    dual
]
interface ISystemProperties : IUnknown
{
    [propget] HRESULT MinGuestRAM ([out, retval] ULONG * aMinGuestRAM);

    [propget] HRESULT MaxGuestRAM ([out, retval] ULONG * aMaxGuestRAM);

    [propget] HRESULT MinGuestVRAM ([out, retval] ULONG * aMinGuestVRAM);

    [propget] HRESULT MaxGuestVRAM ([out, retval] ULONG * aMaxGuestVRAM);

    [propget] HRESULT MaxVDISize ([out, retval] ULONG64 * aMaxVDISize);

    [propget] HRESULT NetworkAdapterCount ([out, retval] ULONG * aNetworkAdapterCount);

    [propget] HRESULT SerialPortCount ([out, retval] ULONG * aSerialPortCount);

    [propget] HRESULT ParallelPortCount ([out, retval] ULONG * aParallelPortCount);

    [propget] HRESULT MaxBootPosition ([out, retval] ULONG * aMaxBootPosition);

    [propget] HRESULT DefaultVDIFolder ([out, retval] BSTR * aDefaultVDIFolder);
    [propput] HRESULT DefaultVDIFolder ([in] BSTR aDefaultVDIFolder);

    [propget] HRESULT DefaultMachineFolder ([out, retval] BSTR * aDefaultMachineFolder);
    [propput] HRESULT DefaultMachineFolder ([in] BSTR aDefaultMachineFolder);

    [propget] HRESULT RemoteDisplayAuthLibrary ([out, retval] BSTR * aRemoteDisplayAuthLibrary);
    [propput] HRESULT RemoteDisplayAuthLibrary ([in] BSTR aRemoteDisplayAuthLibrary);

    [propget] HRESULT WebServiceAuthLibrary ([out, retval] BSTR * aWebServiceAuthLibrary);
    [propput] HRESULT WebServiceAuthLibrary ([in] BSTR aWebServiceAuthLibrary);

    [propget] HRESULT HWVirtExEnabled ([out, retval] BOOL * aHWVirtExEnabled);
    [propput] HRESULT HWVirtExEnabled ([in] BOOL aHWVirtExEnabled);

    [propget] HRESULT LogHistoryCount ([out, retval] ULONG * aLogHistoryCount);
    [propput] HRESULT LogHistoryCount ([in] ULONG aLogHistoryCount);

}; /* interface ISystemProperties */

[
    uuid(da94f478-1f37-4726-b750-2235950dc2fe),
    object,
    dual
]
interface IGuestOSType : IUnknown
{
    [propget] HRESULT Id ([out, retval] BSTR * aId);

    [propget] HRESULT Description ([out, retval] BSTR * aDescription);

    [propget] HRESULT RecommendedRAM ([out, retval] ULONG * aRecommendedRAM);

    [propget] HRESULT RecommendedVRAM ([out, retval] ULONG * aRecommendedVRAM);

    [propget] HRESULT RecommendedHDD ([out, retval] ULONG * aRecommendedHDD);

}; /* interface IGuestOSType */

[
    uuid(a3335e02-4669-4e3c-80c7-c4dc7056a07c),
    object,
    dual
]
interface IGuestOSTypeEnumerator : IUnknown
{
    HRESULT HasMore ([out, retval] BOOL * more);

    HRESULT GetNext ([out, retval] IGuestOSType * * next);


}; /* interface IGuestOSTypeEnumerator */

[
    uuid(a5e36749-a610-498b-9f29-2e36c1042d65),
    object,
    dual
]
interface IGuestOSTypeCollection : IUnknown
{
    [propget] HRESULT Count ([out, retval] ULONG * count);

    HRESULT GetItemAt ([in] ULONG index, [out, retval] IGuestOSType * * item);

    HRESULT Enumerate ([out, retval] IGuestOSTypeEnumerator * * enumerator);


}; /* interface IGuestOSTypeCollection */

[
    uuid(d8556fca-81bc-12af-fca3-365528fa38ca),
    object,
    dual
]
interface IGuest : IUnknown
{
    [propget] HRESULT OSTypeId ([out, retval] BSTR * aOSTypeId);

    [propget] HRESULT AdditionsActive ([out, retval] BOOL * aAdditionsActive);

    [propget] HRESULT AdditionsVersion ([out, retval] BSTR * aAdditionsVersion);

    [propget] HRESULT SupportsSeamless ([out, retval] BOOL * aSupportsSeamless);

    [propget] HRESULT SupportsGraphics ([out, retval] BOOL * aSupportsGraphics);

    [propget] HRESULT MemoryBalloonSize ([out, retval] ULONG * aMemoryBalloonSize);
    [propput] HRESULT MemoryBalloonSize ([in] ULONG aMemoryBalloonSize);

    [propget] HRESULT StatisticsUpdateInterval ([out, retval] ULONG * aStatisticsUpdateInterval);
    [propput] HRESULT StatisticsUpdateInterval ([in] ULONG aStatisticsUpdateInterval);

    HRESULT SetCredentials (
        [in] BSTR aUserName,
        [in] BSTR aPassword,
        [in] BSTR aDomain,
        [in] BOOL aAllowInteractiveLogon
    );

    HRESULT GetStatistic (
        [in] ULONG aCpuId,
        [in] GuestStatisticType aStatistic,
        [out] ULONG * aStatVal
    );

}; /* interface IGuest */

[
    uuid(e0380522-4ef1-48f4-856c-e455177ccb2d),
    object,
    dual
]
interface IProgressEnumerator : IUnknown
{
    HRESULT HasMore ([out, retval] BOOL * more);

    HRESULT GetNext ([out, retval] IProgress * * next);


}; /* interface IProgressEnumerator */

[
    uuid(78B76A7C-F0F2-467c-9F0E-F089A54EE957),
    object,
    dual
]
interface IProgressCollection : IUnknown
{
    [propget] HRESULT Count ([out, retval] ULONG * count);

    HRESULT GetItemAt ([in] ULONG index, [out, retval] IProgress * * item);

    HRESULT Enumerate ([out, retval] IProgressEnumerator * * enumerator);


}; /* interface IProgressCollection */

[
    uuid(10CC03A1-717E-429b-992D-C67B56175A51),
    object,
    dual
]
interface IProgress : IUnknown
{
    [propget] HRESULT Id ([out, retval] GUID * aId);

    [propget] HRESULT Description ([out, retval] BSTR * aDescription);

    [propget] HRESULT Initiator ([out, retval] IUnknown * * aInitiator);

    [propget] HRESULT Cancelable ([out, retval] BOOL * aCancelable);

    [propget] HRESULT Percent ([out, retval] LONG * aPercent);

    [propget] HRESULT Completed ([out, retval] BOOL * aCompleted);

    [propget] HRESULT Canceled ([out, retval] BOOL * aCanceled);

    [propget] HRESULT ResultCode ([out, retval] HRESULT * aResultCode);

    [propget] HRESULT ErrorInfo ([out, retval] IVirtualBoxErrorInfo * * aErrorInfo);

    [propget] HRESULT OperationCount ([out, retval] ULONG * aOperationCount);

    [propget] HRESULT Operation ([out, retval] ULONG * aOperation);

    [propget] HRESULT OperationDescription ([out, retval] BSTR * aOperationDescription);

    [propget] HRESULT OperationPercent ([out, retval] LONG * aOperationPercent);

    HRESULT WaitForCompletion (
        [in] LONG aTimeout
    );

    HRESULT WaitForOperationCompletion (
        [in] ULONG aOperation,
        [in] LONG aTimeout
    );

    HRESULT Cancel();

}; /* interface IProgress */

[
    uuid(25cfa2a4-1f1d-4f05-9658-b7a5894ef1a3),
    object,
    dual
]
interface ISnapshotEnumerator : IUnknown
{
    HRESULT HasMore ([out, retval] BOOL * more);

    HRESULT GetNext ([out, retval] ISnapshot * * next);


}; /* interface ISnapshotEnumerator */

[
    uuid(23852e3c-94cd-4801-ab05-ed35675b3894),
    object,
    dual
]
interface ISnapshotCollection : IUnknown
{
    [propget] HRESULT Count ([out, retval] ULONG * count);

    HRESULT GetItemAt ([in] ULONG index, [out, retval] ISnapshot * * item);

    HRESULT Enumerate ([out, retval] ISnapshotEnumerator * * enumerator);


}; /* interface ISnapshotCollection */

[
    uuid(9f1bbf79-13b0-4da2-abba-4a992c65c083),
    object,
    dual
]
interface ISnapshot : IUnknown
{
    [propget] HRESULT Id ([out, retval] GUID * aId);

    [propget] HRESULT Name ([out, retval] BSTR * aName);
    [propput] HRESULT Name ([in] BSTR aName);

    [propget] HRESULT Description ([out, retval] BSTR * aDescription);
    [propput] HRESULT Description ([in] BSTR aDescription);

    [propget] HRESULT TimeStamp ([out, retval] LONG64 * aTimeStamp);

    [propget] HRESULT Online ([out, retval] BOOL * aOnline);

    [propget] HRESULT Machine ([out, retval] IMachine * * aMachine);

    [propget] HRESULT Parent ([out, retval] ISnapshot * * aParent);

    [propget] HRESULT Children ([out, retval] ISnapshotCollection * * aChildren);

}; /* interface ISnapshot */

[
    uuid(c0ffe596-21c6-4797-8d8a-b47b66881e7a),
    object,
    dual
]
interface IHardDiskAttachment : IUnknown
{
    [propget] HRESULT HardDisk ([out, retval] IHardDisk * * aHardDisk);

    [propget] HRESULT Bus ([out, retval] StorageBus * aBus);

    [propget] HRESULT Channel ([out, retval] LONG * aChannel);

    [propget] HRESULT Device ([out, retval] LONG * aDevice);

}; /* interface IHardDiskAttachment */

[
    uuid(9955e486-2f0b-432a-99e4-0ebbd338875e),
    object,
    dual
]
interface IHardDiskAttachmentEnumerator : IUnknown
{
    HRESULT HasMore ([out, retval] BOOL * more);

    HRESULT GetNext ([out, retval] IHardDiskAttachment * * next);


}; /* interface IHardDiskAttachmentEnumerator */

[
    uuid(8f727842-bb77-45d4-92de-4ec14bf613c9),
    object,
    dual
]
interface IHardDiskAttachmentCollection : IUnknown
{
    [propget] HRESULT Count ([out, retval] ULONG * count);

    HRESULT GetItemAt ([in] ULONG index, [out, retval] IHardDiskAttachment * * item);

    HRESULT Enumerate ([out, retval] IHardDiskAttachmentEnumerator * * enumerator);


}; /* interface IHardDiskAttachmentCollection */

[
    uuid(b976f97b-cdb8-47e3-9860-084031cbd533),
    object,
    dual
]
interface IHardDiskEnumerator : IUnknown
{
    HRESULT HasMore ([out, retval] BOOL * more);

    HRESULT GetNext ([out, retval] IHardDisk * * next);


}; /* interface IHardDiskEnumerator */

[
    uuid(43EAC2BC-5C61-40fa-BC38-46DE2C7DB6BB),
    object,
    dual
]
interface IHardDiskCollection : IUnknown
{
    [propget] HRESULT Count ([out, retval] ULONG * count);

    HRESULT GetItemAt ([in] ULONG index, [out, retval] IHardDisk * * item);

    HRESULT Enumerate ([out, retval] IHardDiskEnumerator * * enumerator);


}; /* interface IHardDiskCollection */

[
    uuid(FD443EC1-000F-4F5B-9282-D72760A66916),
    object,
    dual
]
interface IHardDisk : IUnknown
{
    [propget] HRESULT Id ([out, retval] GUID * aId);

    [propget] HRESULT Description ([out, retval] BSTR * aDescription);
    [propput] HRESULT Description ([in] BSTR aDescription);

    [propget] HRESULT StorageType ([out, retval] HardDiskStorageType * aStorageType);

    [propget] HRESULT Location ([out, retval] BSTR * aLocation);

    [propget] HRESULT Type ([out, retval] HardDiskType * aType);
    [propput] HRESULT Type ([in] HardDiskType aType);

    [propget] HRESULT Parent ([out, retval] IHardDisk * * aParent);

    [propget] HRESULT Children ([out, retval] IHardDiskCollection * * aChildren);

    [propget] HRESULT Root ([out, retval] IHardDisk * * aRoot);

    [propget] HRESULT Accessible ([out, retval] BOOL * aAccessible);

    [propget] HRESULT AllAccessible ([out, retval] BOOL * aAllAccessible);

    [propget] HRESULT LastAccessError ([out, retval] BSTR * aLastAccessError);

    [propget] HRESULT Size ([out, retval] ULONG64 * aSize);

    [propget] HRESULT ActualSize ([out, retval] ULONG64 * aActualSize);

    [propget] HRESULT MachineId ([out, retval] GUID * aMachineId);

    [propget] HRESULT SnapshotId ([out, retval] GUID * aSnapshotId);

    HRESULT CloneToImage (
        [in] BSTR aFilePath,
        [out] IVirtualDiskImage * * aImage,
        [out, retval] IProgress * * aProgress
    );

}; /* interface IHardDisk */

[
    uuid(a8265b5a-0d20-4a46-a02f-65693a4e8239),
    object,
    dual
]
interface IVirtualDiskImage : IUnknown
{
    [propget] HRESULT FilePath ([out, retval] BSTR * aFilePath);
    [propput] HRESULT FilePath ([in] BSTR aFilePath);

    [propget] HRESULT Created ([out, retval] BOOL * aCreated);

    HRESULT CreateDynamicImage (
        [in] ULONG64 aSize,
        [out, retval] IProgress * * aProgress
    );

    HRESULT CreateFixedImage (
        [in] ULONG64 aSize,
        [out, retval] IProgress * * aProgress
    );

    HRESULT DeleteImage();

}; /* interface IVirtualDiskImage */

[
    uuid(003f6ca9-3257-4ef9-99c9-c66ce44576cb),
    object,
    dual
]
interface IISCSIHardDisk : IUnknown
{
    [propget] HRESULT Server ([out, retval] BSTR * aServer);
    [propput] HRESULT Server ([in] BSTR aServer);

    [propget] HRESULT Port ([out, retval] USHORT * aPort);
    [propput] HRESULT Port ([in] USHORT aPort);

    [propget] HRESULT Target ([out, retval] BSTR * aTarget);
    [propput] HRESULT Target ([in] BSTR aTarget);

    [propget] HRESULT Lun ([out, retval] ULONG64 * aLun);
    [propput] HRESULT Lun ([in] ULONG64 aLun);

    [propget] HRESULT UserName ([out, retval] BSTR * aUserName);
    [propput] HRESULT UserName ([in] BSTR aUserName);

    [propget] HRESULT Password ([out, retval] BSTR * aPassword);
    [propput] HRESULT Password ([in] BSTR aPassword);

}; /* interface IISCSIHardDisk */

[
    uuid(178398f5-8559-4fee-979e-420af5b53eef),
    object,
    dual
]
interface IVMDKImage : IUnknown
{
    [propget] HRESULT FilePath ([out, retval] BSTR * aFilePath);
    [propput] HRESULT FilePath ([in] BSTR aFilePath);

    [propget] HRESULT Created ([out, retval] BOOL * aCreated);

    HRESULT CreateDynamicImage (
        [in] ULONG64 aSize,
        [out, retval] IProgress * * aProgress
    );

    HRESULT CreateFixedImage (
        [in] ULONG64 aSize,
        [out, retval] IProgress * * aProgress
    );

    HRESULT DeleteImage();

}; /* interface IVMDKImage */

[
    uuid(a7b0236d-3ff4-47c0-a4aa-ddc4ddc1141a),
    object,
    dual
]
interface ICustomHardDisk : IUnknown
{
    [propget] HRESULT Location ([out, retval] BSTR * aLocation);
    [propput] HRESULT Location ([in] BSTR aLocation);

    [propget] HRESULT Format ([out, retval] BSTR * aFormat);

    [propget] HRESULT Created ([out, retval] BOOL * aCreated);

    HRESULT CreateDynamicImage (
        [in] ULONG64 aSize,
        [out, retval] IProgress * * aProgress
    );

    HRESULT CreateFixedImage (
        [in] ULONG64 aSize,
        [out, retval] IProgress * * aProgress
    );

    HRESULT DeleteImage();

}; /* interface ICustomHardDisk */

[
    uuid(163b88c3-7552-424a-8205-daf17a004747),
    object,
    dual
]
interface IVHDImage : IUnknown
{
    [propget] HRESULT FilePath ([out, retval] BSTR * aFilePath);
    [propput] HRESULT FilePath ([in] BSTR aFilePath);

    [propget] HRESULT Created ([out, retval] BOOL * aCreated);

    HRESULT CreateDynamicImage (
        [in] ULONG64 aSize,
        [out, retval] IProgress * * aProgress
    );

    HRESULT CreateFixedImage (
        [in] ULONG64 aSize,
        [out, retval] IProgress * * aProgress
    );

    HRESULT DeleteImage();

}; /* interface IVHDImage */

[
    uuid(9BE77C8D-E1BE-4bf2-A67B-B4DD3D2B0F28),
    object,
    dual
]
interface IDVDImageEnumerator : IUnknown
{
    HRESULT HasMore ([out, retval] BOOL * more);

    HRESULT GetNext ([out, retval] IDVDImage * * next);


}; /* interface IDVDImageEnumerator */

[
    uuid(AE7053FA-ADD2-4ea4-AFCF-24D5F8DDED64),
    object,
    dual
]
interface IDVDImageCollection : IUnknown
{
    [propget] HRESULT Count ([out, retval] ULONG * count);

    HRESULT GetItemAt ([in] ULONG index, [out, retval] IDVDImage * * item);

    HRESULT Enumerate ([out, retval] IDVDImageEnumerator * * enumerator);

    HRESULT FindByPath (
        [in] BSTR aPath,
        [out, retval] IDVDImage * * aImage
    );


}; /* interface IDVDImageCollection */

[
    uuid(140FFF03-E479-4194-8562-ABC4F8171009),
    object,
    dual
]
interface IDVDImage : IUnknown
{
    [propget] HRESULT Id ([out, retval] GUID * aId);

    [propget] HRESULT FilePath ([out, retval] BSTR * aFilePath);

    [propget] HRESULT Accessible ([out, retval] BOOL * aAccessible);

    [propget] HRESULT Size ([out, retval] ULONG64 * aSize);

}; /* interface IDVDImage */

[
    uuid(d9bd101a-8079-4fb9-bad1-31bf32482b75),
    object,
    dual
]
interface IDVDDrive : IUnknown
{
    [propget] HRESULT State ([out, retval] DriveState * aState);

    [propget] HRESULT Passthrough ([out, retval] BOOL * aPassthrough);
    [propput] HRESULT Passthrough ([in] BOOL aPassthrough);

    HRESULT MountImage (
        [in] GUID aImageId
    );

    HRESULT CaptureHostDrive (
        [in] IHostDVDDrive * aDrive
    );

    HRESULT Unmount();

    HRESULT GetImage (
        [out, retval] IDVDImage * * aImage
    );

    HRESULT GetHostDrive (
        [out, retval] IHostDVDDrive * * aDrive
    );

}; /* interface IDVDDrive */

[
    uuid(902C4089-76B7-41f1-91E8-49A261A28A2C),
    object,
    dual
]
interface IFloppyImageEnumerator : IUnknown
{
    HRESULT HasMore ([out, retval] BOOL * more);

    HRESULT GetNext ([out, retval] IFloppyImage * * next);


}; /* interface IFloppyImageEnumerator */

[
    uuid(327A8928-8572-446e-AD9A-18FE30E81F3F),
    object,
    dual
]
interface IFloppyImageCollection : IUnknown
{
    [propget] HRESULT Count ([out, retval] ULONG * count);

    HRESULT GetItemAt ([in] ULONG index, [out, retval] IFloppyImage * * item);

    HRESULT Enumerate ([out, retval] IFloppyImageEnumerator * * enumerator);

    HRESULT FindByPath (
        [in] BSTR aPath,
        [out, retval] IFloppyImage * * aImage
    );


}; /* interface IFloppyImageCollection */

[
    uuid(CC696755-EA98-4ffe-9DC5-C003047034AB),
    object,
    dual
]
interface IFloppyImage : IUnknown
{
    [propget] HRESULT Id ([out, retval] GUID * aId);

    [propget] HRESULT FilePath ([out, retval] BSTR * aFilePath);

    [propget] HRESULT Accessible ([out, retval] BOOL * aAccessible);

    [propget] HRESULT Size ([out, retval] ULONG * aSize);

}; /* interface IFloppyImage */

[
    uuid(E9318F71-78D2-4b00-863C-B7CB0030A2D9),
    object,
    dual
]
interface IFloppyDrive : IUnknown
{
    [propget] HRESULT Enabled ([out, retval] BOOL * aEnabled);
    [propput] HRESULT Enabled ([in] BOOL aEnabled);

    [propget] HRESULT State ([out, retval] DriveState * aState);

    HRESULT MountImage (
        [in] GUID aImageId
    );

    HRESULT CaptureHostDrive (
        [in] IHostFloppyDrive * aDrive
    );

    HRESULT Unmount();

    HRESULT GetImage (
        [out, retval] IFloppyImage * * aImage
    );

    HRESULT GetHostDrive (
        [out, retval] IHostFloppyDrive * * aDrive
    );

}; /* interface IFloppyDrive */

[
    uuid(2d1a531b-4c6e-49cc-8af6-5c857b78b5d7),
    object,
    dual
]
interface IKeyboard : IUnknown
{
    HRESULT PutScancode (
        [in] LONG aScancode
    );

    HRESULT PutScancodes (
        [in, out] SAFEARRAY(LONG) * aScancodes,
        [out, retval] ULONG * aCodesStored
    );

    HRESULT PutCAD();

}; /* interface IKeyboard */

[
    uuid(FD443EC1-0006-4F5B-9282-D72760A66916),
    object,
    dual
]
interface IMouse : IUnknown
{
    [propget] HRESULT AbsoluteSupported ([out, retval] BOOL * aAbsoluteSupported);

    HRESULT PutMouseEvent (
        [in] LONG aDx,
        [in] LONG aDy,
        [in] LONG aDz,
        [in] LONG aButtonState
    );

    HRESULT PutMouseEventAbsolute (
        [in] LONG aX,
        [in] LONG aY,
        [in] LONG aDz,
        [in] LONG aButtonState
    );

}; /* interface IMouse */

[
    uuid(af431304-5b09-40e2-94da-3c3cb03822c1),
    object,
    dual
]
interface IFramebuffer : IUnknown
{
    [propget] HRESULT Address ([out, retval] BYTE * * aAddress);

    [propget] HRESULT Width ([out, retval] ULONG * aWidth);

    [propget] HRESULT Height ([out, retval] ULONG * aHeight);

    [propget] HRESULT BitsPerPixel ([out, retval] ULONG * aBitsPerPixel);

    [propget] HRESULT BytesPerLine ([out, retval] ULONG * aBytesPerLine);

    [propget] HRESULT PixelFormat ([out, retval] ULONG * aPixelFormat);

    [propget] HRESULT UsesGuestVRAM ([out, retval] BOOL * aUsesGuestVRAM);

    [propget] HRESULT HeightReduction ([out, retval] ULONG * aHeightReduction);

    [propget] HRESULT Overlay ([out, retval] IFramebufferOverlay * * aOverlay);

    HRESULT Lock();

    HRESULT Unlock();

    HRESULT NotifyUpdate (
        [in] ULONG aX,
        [in] ULONG aY,
        [in] ULONG aWidth,
        [in] ULONG aHeight,
        [out, retval] BOOL * aFinished
    );

    HRESULT RequestResize (
        [in] ULONG aScreenId,
        [in] ULONG aPixelFormat,
        [in] BYTE * aVRAM,
        [in] ULONG aBitsPerPixel,
        [in] ULONG aBytesPerLine,
        [in] ULONG aWidth,
        [in] ULONG aHeight,
        [out, retval] BOOL * aFinished
    );

    HRESULT OperationSupported (
        [in] FramebufferAccelerationOperation aOperation,
        [out, retval] BOOL * aSupported
    );

    HRESULT VideoModeSupported (
        [in] ULONG aWidth,
        [in] ULONG aHeight,
        [in] ULONG aBpp,
        [out, retval] BOOL * aSupported
    );

    HRESULT SolidFill (
        [in] ULONG aX,
        [in] ULONG aY,
        [in] ULONG aWidth,
        [in] ULONG aHeight,
        [in] ULONG aColor,
        [out, retval] BOOL * aHandled
    );

    HRESULT CopyScreenBits (
        [in] ULONG aXDst,
        [in] ULONG aYDst,
        [in] ULONG aXSrc,
        [in] ULONG aYSrc,
        [in] ULONG aWidth,
        [in] ULONG aHeight,
        [out, retval] BOOL * aHandled
    );

    HRESULT GetVisibleRegion (
        [in] BYTE * aRectangles,
        [in] ULONG aCount,
        [out, retval] ULONG * aCountCopied
    );

    HRESULT SetVisibleRegion (
        [in] BYTE * aRectangles,
        [in] ULONG aCount
    );

}; /* interface IFramebuffer */

[
    uuid(0bcc1c7e-e415-47d2-bfdb-e4c705fb0f47),
    object,
    dual
]
interface IFramebufferOverlay : IFrameBuffer
{
    [propget] HRESULT X ([out, retval] ULONG * aX);

    [propget] HRESULT Y ([out, retval] ULONG * aY);

    [propget] HRESULT Visible ([out, retval] BOOL * aVisible);
    [propput] HRESULT Visible ([in] BOOL aVisible);

    [propget] HRESULT Alpha ([out, retval] ULONG * aAlpha);
    [propput] HRESULT Alpha ([in] ULONG aAlpha);

    HRESULT Move (
        [in] ULONG aX,
        [in] ULONG aY
    );

}; /* interface IFramebufferOverlay */

[
    uuid(09789f63-4525-48e5-a5e4-1080453b0eab),
    object,
    dual
]
interface IDisplay : IUnknown
{
    [propget] HRESULT Width ([out, retval] ULONG * aWidth);

    [propget] HRESULT Height ([out, retval] ULONG * aHeight);

    [propget] HRESULT BitsPerPixel ([out, retval] ULONG * aBitsPerPixel);

    HRESULT SetupInternalFramebuffer (
        [in] ULONG aDepth
    );

    HRESULT LockFramebuffer (
        [out, retval] BYTE * * aAddress
    );

    HRESULT UnlockFramebuffer();

    HRESULT RegisterExternalFramebuffer (
        [in] IFramebuffer * aFramebuffer
    );

    HRESULT SetFramebuffer (
        [in] ULONG aScreenId,
        [in] IFramebuffer * aFramebuffer
    );

    HRESULT GetFramebuffer (
        [in] ULONG aScreenId,
        [out] IFramebuffer * * aFramebuffer,
        [out] LONG * aXOrigin,
        [out] LONG * aYOrigin
    );

    HRESULT SetVideoModeHint (
        [in] ULONG aWidth,
        [in] ULONG aHeight,
        [in] ULONG aBitsPerPixel,
        [in] ULONG aDisplay
    );

    HRESULT SetSeamlessMode (
        [in] BOOL aEnabled
    );

    HRESULT TakeScreenShot (
        [in] BYTE * aAddress,
        [in] ULONG aWidth,
        [in] ULONG aHeight
    );

    HRESULT DrawToScreen (
        [in] BYTE * aAddress,
        [in] ULONG aX,
        [in] ULONG aY,
        [in] ULONG aWidth,
        [in] ULONG aHeight
    );

    HRESULT InvalidateAndUpdate();

    HRESULT ResizeCompleted (
        [in] ULONG aScreenId
    );

    HRESULT UpdateCompleted();

}; /* interface IDisplay */

[
    uuid(a876d9b1-68d9-43b1-9c68-ddea0a473663),
    object,
    dual
]
interface INetworkAdapter : IUnknown
{
    [propget] HRESULT AdapterType ([out, retval] NetworkAdapterType * aAdapterType);
    [propput] HRESULT AdapterType ([in] NetworkAdapterType aAdapterType);

    [propget] HRESULT Slot ([out, retval] ULONG * aSlot);

    [propget] HRESULT Enabled ([out, retval] BOOL * aEnabled);
    [propput] HRESULT Enabled ([in] BOOL aEnabled);

    [propget] HRESULT MACAddress ([out, retval] BSTR * aMACAddress);
    [propput] HRESULT MACAddress ([in] BSTR aMACAddress);

    [propget] HRESULT AttachmentType ([out, retval] NetworkAttachmentType * aAttachmentType);

    [propget] HRESULT HostInterface ([out, retval] BSTR * aHostInterface);
    [propput] HRESULT HostInterface ([in] BSTR aHostInterface);

    [propget] HRESULT InternalNetwork ([out, retval] BSTR * aInternalNetwork);
    [propput] HRESULT InternalNetwork ([in] BSTR aInternalNetwork);

    [propget] HRESULT NATNetwork ([out, retval] BSTR * aNATNetwork);
    [propput] HRESULT NATNetwork ([in] BSTR aNATNetwork);

    [propget] HRESULT CableConnected ([out, retval] BOOL * aCableConnected);
    [propput] HRESULT CableConnected ([in] BOOL aCableConnected);

    [propget] HRESULT LineSpeed ([out, retval] ULONG * aLineSpeed);
    [propput] HRESULT LineSpeed ([in] ULONG aLineSpeed);

    [propget] HRESULT TraceEnabled ([out, retval] BOOL * aTraceEnabled);
    [propput] HRESULT TraceEnabled ([in] BOOL aTraceEnabled);

    [propget] HRESULT TraceFile ([out, retval] BSTR * aTraceFile);
    [propput] HRESULT TraceFile ([in] BSTR aTraceFile);

    HRESULT AttachToNAT();

    HRESULT AttachToHostInterface();

    HRESULT AttachToInternalNetwork();

    HRESULT Detach();

}; /* interface INetworkAdapter */

[
    uuid(937f6970-5103-4745-b78e-d28dcf1479a8),
    object,
    dual
]
interface ISerialPort : IUnknown
{
    [propget] HRESULT Slot ([out, retval] ULONG * aSlot);

    [propget] HRESULT Enabled ([out, retval] BOOL * aEnabled);
    [propput] HRESULT Enabled ([in] BOOL aEnabled);

    [propget] HRESULT IOBase ([out, retval] ULONG * aIOBase);
    [propput] HRESULT IOBase ([in] ULONG aIOBase);

    [propget] HRESULT IRQ ([out, retval] ULONG * aIRQ);
    [propput] HRESULT IRQ ([in] ULONG aIRQ);

    [propget] HRESULT HostMode ([out, retval] PortMode * aHostMode);
    [propput] HRESULT HostMode ([in] PortMode aHostMode);

    [propget] HRESULT Server ([out, retval] BOOL * aServer);
    [propput] HRESULT Server ([in] BOOL aServer);

    [propget] HRESULT Path ([out, retval] BSTR * aPath);
    [propput] HRESULT Path ([in] BSTR aPath);

}; /* interface ISerialPort */

[
    uuid(0c925f06-dd10-4b77-8de8-294d738c3214),
    object,
    dual
]
interface IParallelPort : IUnknown
{
    [propget] HRESULT Slot ([out, retval] ULONG * aSlot);

    [propget] HRESULT Enabled ([out, retval] BOOL * aEnabled);
    [propput] HRESULT Enabled ([in] BOOL aEnabled);

    [propget] HRESULT IOBase ([out, retval] ULONG * aIOBase);
    [propput] HRESULT IOBase ([in] ULONG aIOBase);

    [propget] HRESULT IRQ ([out, retval] ULONG * aIRQ);
    [propput] HRESULT IRQ ([in] ULONG aIRQ);

    [propget] HRESULT Path ([out, retval] BSTR * aPath);
    [propput] HRESULT Path ([in] BSTR aPath);

}; /* interface IParallelPort */

[
    uuid(54ebce96-fa7d-4a4d-bc81-a7db41c29637),
    object,
    dual
]
interface IMachineDebugger : IUnknown
{
    [propget] HRESULT Singlestep ([out, retval] BOOL * aSinglestep);
    [propput] HRESULT Singlestep ([in] BOOL aSinglestep);

    [propget] HRESULT RecompileUser ([out, retval] BOOL * aRecompileUser);
    [propput] HRESULT RecompileUser ([in] BOOL aRecompileUser);

    [propget] HRESULT RecompileSupervisor ([out, retval] BOOL * aRecompileSupervisor);
    [propput] HRESULT RecompileSupervisor ([in] BOOL aRecompileSupervisor);

    [propget] HRESULT PATMEnabled ([out, retval] BOOL * aPATMEnabled);
    [propput] HRESULT PATMEnabled ([in] BOOL aPATMEnabled);

    [propget] HRESULT CSAMEnabled ([out, retval] BOOL * aCSAMEnabled);
    [propput] HRESULT CSAMEnabled ([in] BOOL aCSAMEnabled);

    [propget] HRESULT LogEnabled ([out, retval] BOOL * aLogEnabled);
    [propput] HRESULT LogEnabled ([in] BOOL aLogEnabled);

    [propget] HRESULT HWVirtExEnabled ([out, retval] BOOL * aHWVirtExEnabled);

    [propget] HRESULT HWVirtExNestedPagingEnabled ([out, retval] BOOL * aHWVirtExNestedPagingEnabled);

    [propget] HRESULT PAEEnabled ([out, retval] BOOL * aPAEEnabled);

    [propget] HRESULT VirtualTimeRate ([out, retval] ULONG * aVirtualTimeRate);
    [propput] HRESULT VirtualTimeRate ([in] ULONG aVirtualTimeRate);

    [propget] HRESULT VM ([out, retval] ULONG64 * aVM);

    HRESULT ResetStats (
        [in] BSTR aPattern
    );

    HRESULT DumpStats (
        [in] BSTR aPattern
    );

    HRESULT GetStats (
        [in] BSTR aPattern,
        [in] BOOL aWithDescriptions,
        [out] BSTR * aStats
    );

}; /* interface IMachineDebugger */

[
    uuid(f4c2d3dc-f109-4da7-93b1-ec28973ac89f),
    object,
    dual
]
interface IUSBController : IUnknown
{
    [propget] HRESULT Enabled ([out, retval] BOOL * aEnabled);
    [propput] HRESULT Enabled ([in] BOOL aEnabled);

    [propget] HRESULT EnabledEhci ([out, retval] BOOL * aEnabledEhci);
    [propput] HRESULT EnabledEhci ([in] BOOL aEnabledEhci);

    [propget] HRESULT USBStandard ([out, retval] USHORT * aUSBStandard);

    [propget] HRESULT DeviceFilters ([out, retval] IUSBDeviceFilterCollection * * aDeviceFilters);

    HRESULT CreateDeviceFilter (
        [in] BSTR aName,
        [out, retval] IUSBDeviceFilter * * aFilter
    );

    HRESULT InsertDeviceFilter (
        [in] ULONG aPosition,
        [in] IUSBDeviceFilter * aFilter
    );

    HRESULT RemoveDeviceFilter (
        [in] ULONG aPosition,
        [out, retval] IUSBDeviceFilter * * aFilter
    );

}; /* interface IUSBController */

[
    uuid(aefe00f7-eb8a-454b-9ea4-fd5ad93c0e99),
    object,
    dual
]
interface IUSBDeviceEnumerator : IUnknown
{
    HRESULT HasMore ([out, retval] BOOL * more);

    HRESULT GetNext ([out, retval] IUSBDevice * * next);


}; /* interface IUSBDeviceEnumerator */

[
    uuid(e31f3248-90dd-4ca2-95f0-6b36042d96a2),
    object,
    dual
]
interface IUSBDeviceCollection : IUnknown
{
    [propget] HRESULT Count ([out, retval] ULONG * count);

    HRESULT GetItemAt ([in] ULONG index, [out, retval] IUSBDevice * * item);

    HRESULT Enumerate ([out, retval] IUSBDeviceEnumerator * * enumerator);

    HRESULT FindById (
        [in] GUID aId,
        [out, retval] IUSBDevice * * aDevice
    );

    HRESULT FindByAddress (
        [in] BSTR aName,
        [out, retval] IUSBDevice * * aDevice
    );


}; /* interface IUSBDeviceCollection */

[
    uuid(850af07b-9ee8-48c2-b6b0-f6d0acbf63c3),
    object,
    dual
]
interface IUSBDevice : IUnknown
{
    [propget] HRESULT Id ([out, retval] GUID * aId);

    [propget] HRESULT VendorId ([out, retval] USHORT * aVendorId);

    [propget] HRESULT ProductId ([out, retval] USHORT * aProductId);

    [propget] HRESULT Revision ([out, retval] USHORT * aRevision);

    [propget] HRESULT Manufacturer ([out, retval] BSTR * aManufacturer);

    [propget] HRESULT Product ([out, retval] BSTR * aProduct);

    [propget] HRESULT SerialNumber ([out, retval] BSTR * aSerialNumber);

    [propget] HRESULT Address ([out, retval] BSTR * aAddress);

    [propget] HRESULT Port ([out, retval] USHORT * aPort);

    [propget] HRESULT Version ([out, retval] USHORT * aVersion);

    [propget] HRESULT PortVersion ([out, retval] USHORT * aPortVersion);

    [propget] HRESULT Remote ([out, retval] BOOL * aRemote);

}; /* interface IUSBDevice */

[
    uuid(d5109c61-93e7-4726-926b-0dee1020da56),
    object,
    dual
]
interface IUSBDeviceFilterEnumerator : IUnknown
{
    HRESULT HasMore ([out, retval] BOOL * more);

    HRESULT GetNext ([out, retval] IUSBDeviceFilter * * next);


}; /* interface IUSBDeviceFilterEnumerator */

[
    uuid(4fa3fc99-ceb1-4bf5-a9cb-e962d825c1ef),
    object,
    dual
]
interface IUSBDeviceFilterCollection : IUnknown
{
    [propget] HRESULT Count ([out, retval] ULONG * count);

    HRESULT GetItemAt ([in] ULONG index, [out, retval] IUSBDeviceFilter * * item);

    HRESULT Enumerate ([out, retval] IUSBDeviceFilterEnumerator * * enumerator);


}; /* interface IUSBDeviceFilterCollection */

[
    uuid(d6831fb4-1a94-4c2c-96ef-8d0d6192066d),
    object,
    dual
]
interface IUSBDeviceFilter : IUnknown
{
    [propget] HRESULT Name ([out, retval] BSTR * aName);
    [propput] HRESULT Name ([in] BSTR aName);

    [propget] HRESULT Active ([out, retval] BOOL * aActive);
    [propput] HRESULT Active ([in] BOOL aActive);

    [propget] HRESULT VendorId ([out, retval] BSTR * aVendorId);
    [propput] HRESULT VendorId ([in] BSTR aVendorId);

    [propget] HRESULT ProductId ([out, retval] BSTR * aProductId);
    [propput] HRESULT ProductId ([in] BSTR aProductId);

    [propget] HRESULT Revision ([out, retval] BSTR * aRevision);
    [propput] HRESULT Revision ([in] BSTR aRevision);

    [propget] HRESULT Manufacturer ([out, retval] BSTR * aManufacturer);
    [propput] HRESULT Manufacturer ([in] BSTR aManufacturer);

    [propget] HRESULT Product ([out, retval] BSTR * aProduct);
    [propput] HRESULT Product ([in] BSTR aProduct);

    [propget] HRESULT SerialNumber ([out, retval] BSTR * aSerialNumber);
    [propput] HRESULT SerialNumber ([in] BSTR aSerialNumber);

    [propget] HRESULT Port ([out, retval] BSTR * aPort);
    [propput] HRESULT Port ([in] BSTR aPort);

    [propget] HRESULT Remote ([out, retval] BSTR * aRemote);
    [propput] HRESULT Remote ([in] BSTR aRemote);

    [propget] HRESULT MaskedInterfaces ([out, retval] ULONG * aMaskedInterfaces);
    [propput] HRESULT MaskedInterfaces ([in] ULONG aMaskedInterfaces);

}; /* interface IUSBDeviceFilter */

[
    uuid(a0c55136-939f-4d20-b9d3-4d406f08bfa5),
    object,
    dual
]
interface IHostUSBDeviceEnumerator : IUnknown
{
    HRESULT HasMore ([out, retval] BOOL * more);

    HRESULT GetNext ([out, retval] IHostUSBDevice * * next);


}; /* interface IHostUSBDeviceEnumerator */

[
    uuid(f9d3f96d-b027-4994-b589-70bb9ee0d364),
    object,
    dual
]
interface IHostUSBDeviceCollection : IUnknown
{
    [propget] HRESULT Count ([out, retval] ULONG * count);

    HRESULT GetItemAt ([in] ULONG index, [out, retval] IHostUSBDevice * * item);

    HRESULT Enumerate ([out, retval] IHostUSBDeviceEnumerator * * enumerator);

    HRESULT FindById (
        [in] GUID aId,
        [out, retval] IHostUSBDevice * * aDevice
    );

    HRESULT FindByAddress (
        [in] BSTR aName,
        [out, retval] IHostUSBDevice * * aDevice
    );


}; /* interface IHostUSBDeviceCollection */

[
    uuid(173b4b44-d268-4334-a00d-b6521c9a740a),
    object,
    dual
]
interface IHostUSBDevice : IUSBDevice
{
    [propget] HRESULT State ([out, retval] USBDeviceState * aState);

}; /* interface IHostUSBDevice */

[
    uuid(ff735211-903e-4642-9c37-189eb44579fe),
    object,
    dual
]
interface IHostUSBDeviceFilterEnumerator : IUnknown
{
    HRESULT HasMore ([out, retval] BOOL * more);

    HRESULT GetNext ([out, retval] IHostUSBDeviceFilter * * next);


}; /* interface IHostUSBDeviceFilterEnumerator */

[
    uuid(1a80458b-87f1-4a74-995d-04e2330119e0),
    object,
    dual
]
interface IHostUSBDeviceFilterCollection : IUnknown
{
    [propget] HRESULT Count ([out, retval] ULONG * count);

    HRESULT GetItemAt ([in] ULONG index, [out, retval] IHostUSBDeviceFilter * * item);

    HRESULT Enumerate ([out, retval] IHostUSBDeviceFilterEnumerator * * enumerator);


}; /* interface IHostUSBDeviceFilterCollection */

[
    uuid(4cc70246-d74a-400f-8222-3900489c0374),
    object,
    dual
]
interface IHostUSBDeviceFilter : IUSBDeviceFilter
{
    [propget] HRESULT Action ([out, retval] USBDeviceFilterAction * aAction);
    [propput] HRESULT Action ([in] USBDeviceFilterAction aAction);

}; /* interface IHostUSBDeviceFilter */

[
    uuid(921873db-5f3f-4b69-91f9-7be9e535a2cb),
    object,
    dual
]
interface IAudioAdapter : IUnknown
{
    [propget] HRESULT Enabled ([out, retval] BOOL * aEnabled);
    [propput] HRESULT Enabled ([in] BOOL aEnabled);

    [propget] HRESULT AudioController ([out, retval] AudioControllerType * aAudioController);
    [propput] HRESULT AudioController ([in] AudioControllerType aAudioController);

    [propget] HRESULT AudioDriver ([out, retval] AudioDriverType * aAudioDriver);
    [propput] HRESULT AudioDriver ([in] AudioDriverType aAudioDriver);

}; /* interface IAudioAdapter */

[
    uuid(f4584ae7-6bce-474b-83d6-17d235e6aa89),
    object,
    dual
]
interface IVRDPServer : IUnknown
{
    [propget] HRESULT Enabled ([out, retval] BOOL * aEnabled);
    [propput] HRESULT Enabled ([in] BOOL aEnabled);

    [propget] HRESULT Port ([out, retval] ULONG * aPort);
    [propput] HRESULT Port ([in] ULONG aPort);

    [propget] HRESULT NetAddress ([out, retval] BSTR * aNetAddress);
    [propput] HRESULT NetAddress ([in] BSTR aNetAddress);

    [propget] HRESULT AuthType ([out, retval] VRDPAuthType * aAuthType);
    [propput] HRESULT AuthType ([in] VRDPAuthType aAuthType);

    [propget] HRESULT AuthTimeout ([out, retval] ULONG * aAuthTimeout);
    [propput] HRESULT AuthTimeout ([in] ULONG aAuthTimeout);

    [propget] HRESULT AllowMultiConnection ([out, retval] BOOL * aAllowMultiConnection);
    [propput] HRESULT AllowMultiConnection ([in] BOOL aAllowMultiConnection);

    [propget] HRESULT ReuseSingleConnection ([out, retval] BOOL * aReuseSingleConnection);
    [propput] HRESULT ReuseSingleConnection ([in] BOOL aReuseSingleConnection);

}; /* interface IVRDPServer */

[
    uuid(1d420fd8-e7c1-4511-abf4-a504dc6d0cbf),
    object,
    dual
]
interface ISharedFolderEnumerator : IUnknown
{
    HRESULT HasMore ([out, retval] BOOL * more);

    HRESULT GetNext ([out, retval] ISharedFolder * * next);


}; /* interface ISharedFolderEnumerator */

[
    uuid(9c7e2282-bb16-4fa7-9138-f383c5e02353),
    object,
    dual
]
interface ISharedFolderCollection : IUnknown
{
    [propget] HRESULT Count ([out, retval] ULONG * count);

    HRESULT GetItemAt ([in] ULONG index, [out, retval] ISharedFolder * * item);

    HRESULT Enumerate ([out, retval] ISharedFolderEnumerator * * enumerator);

    HRESULT FindByName (
        [in] BSTR aName,
        [out, retval] ISharedFolder * * aSharedFolder
    );


}; /* interface ISharedFolderCollection */

[
    uuid(8b0c5f70-9139-4f97-a421-64d5e9c335d5),
    object,
    dual
]
interface ISharedFolder : IUnknown
{
    [propget] HRESULT Name ([out, retval] BSTR * aName);

    [propget] HRESULT HostPath ([out, retval] BSTR * aHostPath);

    [propget] HRESULT Accessible ([out, retval] BOOL * aAccessible);

    [propget] HRESULT Writable ([out, retval] BOOL * aWritable);

}; /* interface ISharedFolder */

[
    uuid(2581845a-5a9d-45fb-bc3b-2476552dd970),
    object,
    dual
]
interface IInternalSessionControl : IUnknown
{
    HRESULT GetPID (
        [out, retval] ULONG * aPid
    );

    HRESULT GetRemoteConsole (
        [out, retval] IConsole * * aConsole
    );

    HRESULT AssignMachine (
        [in] IMachine * aMachine
    );

    HRESULT AssignRemoteMachine (
        [in] IMachine * aMachine,
        [in] IConsole * aConsole
    );

    HRESULT UpdateMachineState (
        [in] MachineState aAMachineState
    );

    HRESULT Uninitialize();

    HRESULT OnDVDDriveChange();

    HRESULT OnFloppyDriveChange();

    HRESULT OnNetworkAdapterChange (
        [in] INetworkAdapter * aNetworkAdapter
    );

    HRESULT OnSerialPortChange (
        [in] ISerialPort * aSerialPort
    );

    HRESULT OnParallelPortChange (
        [in] IParallelPort * aParallelPort
    );

    HRESULT OnVRDPServerChange();

    HRESULT OnUSBControllerChange();

    HRESULT OnSharedFolderChange (
        [in] BOOL aGlobal
    );

    HRESULT OnUSBDeviceAttach (
        [in] IUSBDevice * aDevice,
        [in] IVirtualBoxErrorInfo * aError,
        [in] ULONG aMaskedInterfaces
    );

    HRESULT OnUSBDeviceDetach (
        [in] GUID aId,
        [in] IVirtualBoxErrorInfo * aError
    );

    HRESULT OnShowWindow (
        [in] BOOL aCheck,
        [out] BOOL * aCanShow,
        [out] ULONG64 * aWinId
    );

    HRESULT AccessGuestProperty (
        [in] BSTR aName,
        [in] BSTR aValue,
        [in] BSTR aFlags,
        [in] BOOL aIsSetter,
        [out] BSTR * aRetValue,
        [out] ULONG64 * aRetTimestamp,
        [out] BSTR * aRetFlags
    );

    HRESULT EnumerateGuestProperties (
        [in] BSTR aPatterns,
        [out] SAFEARRAY(BSTR) * aKey,
        [out] SAFEARRAY(BSTR) * aValue,
        [out] SAFEARRAY(ULONG64) * aTimestamp,
        [out] SAFEARRAY(BSTR) * aFlags
    );

}; /* interface IInternalSessionControl */

[
    uuid(12F4DCDB-12B2-4ec1-B7CD-DDD9F6C5BF4D),
    object,
    dual
]
interface ISession : IDispatch
{
    [propget] HRESULT State ([out, retval] SessionState * aState);

    [propget] HRESULT Type ([out, retval] SessionType * aType);

    [propget] HRESULT Machine ([out, retval] IMachine * * aMachine);

    [propget] HRESULT Console ([out, retval] IConsole * * aConsole);

    HRESULT Close();

}; /* interface ISession */

[
    uuid(9a4b868b-1376-4533-8ef5-065b8e8cedff),
    object,
    dual
]
interface ISATAController : IUnknown
{
    [propget] HRESULT Enabled ([out, retval] BOOL * aEnabled);
    [propput] HRESULT Enabled ([in] BOOL aEnabled);

    [propget] HRESULT PortCount ([out, retval] ULONG * aPortCount);
    [propput] HRESULT PortCount ([in] ULONG aPortCount);

    HRESULT GetIDEEmulationPort (
        [in] LONG aDevicePosition,
        [out, retval] LONG * aPortNumber
    );

    HRESULT SetIDEEmulationPort (
        [in] LONG aDevicePosition,
        [in] LONG aPortNumber
    );

}; /* interface ISATAController */

[
    uuid(2a1a60ae-9345-4019-ad53-d34ba41cbfe9),
    object,
    dual
]
interface IPerformanceMetric : IUnknown
{
    [propget] HRESULT MetricName ([out, retval] BSTR * aMetricName);

    [propget] HRESULT Object ([out, retval] IUnknown * * aObject);

    [propget] HRESULT Description ([out, retval] BSTR * aDescription);

    [propget] HRESULT Period ([out, retval] ULONG * aPeriod);

    [propget] HRESULT Count ([out, retval] ULONG * aCount);

    [propget] HRESULT Unit ([out, retval] BSTR * aUnit);

    [propget] HRESULT MinimumValue ([out, retval] LONG * aMinimumValue);

    [propget] HRESULT MaximumValue ([out, retval] LONG * aMaximumValue);

}; /* interface IPerformanceMetric */

[
    uuid(dcd37e5a-3964-43d1-be30-0f3c7234e347),
    object,
    dual
]
interface IPerformanceCollector : IUnknown
{
    [propget] HRESULT MetricNames ([out, retval] SAFEARRAY(BSTR) * aMetricNames);

    HRESULT GetMetrics (
        [in, out] SAFEARRAY(BSTR) * aMetricNames,
        [in, out] SAFEARRAY(IUnknown *) * aObjects,
        [out, retval] SAFEARRAY(IPerformanceMetric *) * aMetrics
    );

    HRESULT SetupMetrics (
        [in, out] SAFEARRAY(BSTR) * aMetricNames,
        [in, out] SAFEARRAY(IUnknown *) * aObjects,
        [in] ULONG aPeriod,
        [in] ULONG aCount
    );

    HRESULT EnableMetrics (
        [in, out] SAFEARRAY(BSTR) * aMetricNames,
        [in, out] SAFEARRAY(IUnknown *) * aObjects
    );

    HRESULT DisableMetrics (
        [in, out] SAFEARRAY(BSTR) * aMetricNames,
        [in, out] SAFEARRAY(IUnknown *) * aObjects
    );

    HRESULT QueryMetricsData (
        [in, out] SAFEARRAY(BSTR) * aMetricNames,
        [in, out] SAFEARRAY(IUnknown *) * aObjects,
        [out] SAFEARRAY(BSTR) * aReturnMetricNames,
        [out] SAFEARRAY(IUnknown *) * aReturnObjects,
        [out] SAFEARRAY(ULONG) * aReturnDataIndices,
        [out] SAFEARRAY(ULONG) * aReturnDataLengths,
        [out, retval] SAFEARRAY(LONG) * aReturnData
    );

}; /* interface IPerformanceCollector */

[
    uuid(B1A7A4F2-47B9-4A1E-82B2-07CCD5323C3F)
]
coclass VirtualBox
{
    [default] interface IVirtualBox;

}; /* coclass VirtualBox */

[
    uuid(3C02F46D-C9D2-4f11-A384-53F0CF917214)
]
coclass Session
{
    [default] interface ISession;

}; /* coclass Session */

}; /* library VirtualBox */

