
/*
 *  DO NOT EDIT! This is a generated file.
 *
 *  XPCOM IDL (XPIDL) 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/xpidl.xsl
 */

#include "nsISupports.idl"
#include "nsIException.idl"

[ptr] native booeanPtr  (PRBool);
[ptr] native octetPtr   (PRUint8);
[ptr] native shortPtr   (PRInt16);
[ptr] native ushortPtr  (PRUint16);
[ptr] native longPtr    (PRInt32);
[ptr] native llongPtr   (PRInt64);
[ptr] native ulongPtr   (PRUint32);
[ptr] native ullongPtr  (PRUint64);


[ptr] native stringPtr  (string);
[ptr] native wcharPtr   (wchar);
[ptr] native wstringPtr (wstring);

%{C++
// currenty, nsISupportsImpl.h lacks the below-like macros
#ifndef NS_IMPL_THREADSAFE_ISUPPORTS1_CI
#define NS_IMPL_THREADSAFE_ISUPPORTS1_CI(_class, _interface)                  \
  NS_IMPL_THREADSAFE_ADDREF(_class)                                           \
  NS_IMPL_THREADSAFE_RELEASE(_class)                                          \
  NS_IMPL_QUERY_INTERFACE1_CI(_class, _interface)                             \
  NS_IMPL_CI_INTERFACE_GETTER1(_class, _interface)
#endif
#ifndef NS_IMPL_THREADSAFE_ISUPPORTS2_CI
#define NS_IMPL_THREADSAFE_ISUPPORTS2_CI(_class, _i1, _i2)                    \
  NS_IMPL_THREADSAFE_ADDREF(_class)                                           \
  NS_IMPL_THREADSAFE_RELEASE(_class)                                          \
  NS_IMPL_QUERY_INTERFACE2_CI(_class, _i1, _i2)                               \
  NS_IMPL_CI_INTERFACE_GETTER2(_class, _i1, _i2)
#endif
  
%}

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 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;

[
    uuid(523ff64d-842a-4b1a-80e7-c311b028cb3a),
    scriptable
]
interface TSBool
{
    const PRUint32 False = 0;
    const PRUint32 True = 1;
    const PRUint32 Default = 2;
};

/* cross-platform type name for TSBool */
%{C++
#define TSBool_T PRUint32
%}

/* cross-platform constants for TSBool */
%{C++
#define TSBool_False TSBool::False
#define TSBool_True TSBool::True
#define TSBool_Default TSBool::Default
%}

[
    uuid(73bf04d0-7c4f-4684-9abf-d65a9ad74343),
    scriptable
]
interface MachineState
{
    const PRUint32 Null = 0;
    const PRUint32 PoweredOff = 1;
    const PRUint32 Saved = 2;
    const PRUint32 Aborted = 3;
    const PRUint32 Running = 4;
    const PRUint32 Paused = 5;
    const PRUint32 Stuck = 6;
    const PRUint32 Starting = 7;
    const PRUint32 Stopping = 8;
    const PRUint32 Saving = 9;
    const PRUint32 Restoring = 10;
    const PRUint32 Discarding = 11;
};

/* cross-platform type name for MachineState */
%{C++
#define MachineState_T PRUint32
%}

/* cross-platform constants for MachineState */
%{C++
#define MachineState_Null MachineState::Null
#define MachineState_PoweredOff MachineState::PoweredOff
#define MachineState_Saved MachineState::Saved
#define MachineState_Aborted MachineState::Aborted
#define MachineState_Running MachineState::Running
#define MachineState_Paused MachineState::Paused
#define MachineState_Stuck MachineState::Stuck
#define MachineState_Starting MachineState::Starting
#define MachineState_Stopping MachineState::Stopping
#define MachineState_Saving MachineState::Saving
#define MachineState_Restoring MachineState::Restoring
#define MachineState_Discarding MachineState::Discarding
%}

[
    uuid(CF2700C0-EA4B-47ae-9725-7810114B94D8),
    scriptable
]
interface SessionState
{
    const PRUint32 Null = 0;
    const PRUint32 Closed = 1;
    const PRUint32 Open = 2;
    const PRUint32 Spawning = 3;
    const PRUint32 Closing = 4;
};

/* cross-platform type name for SessionState */
%{C++
#define SessionState_T PRUint32
%}

/* cross-platform constants for SessionState */
%{C++
#define SessionState_Null SessionState::Null
#define SessionState_Closed SessionState::Closed
#define SessionState_Open SessionState::Open
#define SessionState_Spawning SessionState::Spawning
#define SessionState_Closing SessionState::Closing
%}

[
    uuid(A13C02CB-0C2C-421E-8317-AC0E8AAA153A),
    scriptable
]
interface SessionType
{
    const PRUint32 Null = 0;
    const PRUint32 Direct = 1;
    const PRUint32 Remote = 2;
    const PRUint32 Existing = 3;
};

/* cross-platform type name for SessionType */
%{C++
#define SessionType_T PRUint32
%}

/* cross-platform constants for SessionType */
%{C++
#define SessionType_Null SessionType::Null
#define SessionType_Direct SessionType::Direct
#define SessionType_Remote SessionType::Remote
#define SessionType_Existing SessionType::Existing
%}

[
    uuid(6d9420f7-0b56-4636-99f9-7346f1b01e57),
    scriptable
]
interface DeviceType
{
    const PRUint32 Null = 0;
    const PRUint32 Floppy = 1;
    const PRUint32 DVD = 2;
    const PRUint32 HardDisk = 3;
    const PRUint32 Network = 4;
    const PRUint32 USB = 5;
    const PRUint32 SharedFolder = 6;
};

/* cross-platform type name for DeviceType */
%{C++
#define DeviceType_T PRUint32
%}

/* cross-platform constants for DeviceType */
%{C++
#define DeviceType_Null DeviceType::Null
#define DeviceType_Floppy DeviceType::Floppy
#define DeviceType_DVD DeviceType::DVD
#define DeviceType_HardDisk DeviceType::HardDisk
#define DeviceType_Network DeviceType::Network
#define DeviceType_USB DeviceType::USB
#define DeviceType_SharedFolder DeviceType::SharedFolder
%}

[
    uuid(6FC8AEAA-130A-4eb5-8954-3F921422D707),
    scriptable
]
interface DeviceActivity
{
    const PRUint32 Null = 0;
    const PRUint32 Idle = 1;
    const PRUint32 Reading = 2;
    const PRUint32 Writing = 3;
};

/* cross-platform type name for DeviceActivity */
%{C++
#define DeviceActivity_T PRUint32
%}

/* cross-platform constants for DeviceActivity */
%{C++
#define DeviceActivity_Null DeviceActivity::Null
#define DeviceActivity_Idle DeviceActivity::Idle
#define DeviceActivity_Reading DeviceActivity::Reading
#define DeviceActivity_Writing DeviceActivity::Writing
%}

[
    uuid(FC56E4B6-B195-48e2-A5E1-A667B0D9F809),
    scriptable
]
interface ResourceUsage
{
    const PRUint32 Null = 0;
    const PRUint32 Permanent = 1;
    const PRUint32 Temporary = 2;
    const PRUint32 All = 3;
};

/* cross-platform type name for ResourceUsage */
%{C++
#define ResourceUsage_T PRUint32
%}

/* cross-platform constants for ResourceUsage */
%{C++
#define ResourceUsage_Null ResourceUsage::Null
#define ResourceUsage_Permanent ResourceUsage::Permanent
#define ResourceUsage_Temporary ResourceUsage::Temporary
#define ResourceUsage_All ResourceUsage::All
%}

[
    uuid(715984a5-093c-43bb-aa42-a16ed16828dd),
    scriptable
]
interface StorageBus
{
    const PRUint32 Null = 0;
    const PRUint32 IDE = 1;
    const PRUint32 SATA = 2;
};

/* cross-platform type name for StorageBus */
%{C++
#define StorageBus_T PRUint32
%}

/* cross-platform constants for StorageBus */
%{C++
#define StorageBus_Null StorageBus::Null
#define StorageBus_IDE StorageBus::IDE
#define StorageBus_SATA StorageBus::SATA
%}

[
    uuid(33364716-4008-4701-8f14-be0fa3d62950),
    scriptable
]
interface ClipboardMode
{
    const PRUint32 Disabled = 0;
    const PRUint32 HostToGuest = 1;
    const PRUint32 GuestToHost = 2;
    const PRUint32 Bidirectional = 3;
};

/* cross-platform type name for ClipboardMode */
%{C++
#define ClipboardMode_T PRUint32
%}

/* cross-platform constants for ClipboardMode */
%{C++
#define ClipboardMode_Disabled ClipboardMode::Disabled
#define ClipboardMode_HostToGuest ClipboardMode::HostToGuest
#define ClipboardMode_GuestToHost ClipboardMode::GuestToHost
#define ClipboardMode_Bidirectional ClipboardMode::Bidirectional
%}

[
    uuid(7c91096e-499e-4eca-9f9b-9001438d7855),
    scriptable
]
interface Scope
{
    const PRUint32 Global = 0;
    const PRUint32 Machine = 1;
    const PRUint32 Session = 2;
};

/* cross-platform type name for Scope */
%{C++
#define Scope_T PRUint32
%}

/* cross-platform constants for Scope */
%{C++
#define Scope_Global Scope::Global
#define Scope_Machine Scope::Machine
#define Scope_Session Scope::Session
%}

[
    uuid(aa7c1d71-aafe-47a8-9608-27d2d337cf55),
    scriptable
]
interface GuestStatisticType
{
    const PRUint32 CPULoad_Idle = 0;
    const PRUint32 CPULoad_Kernel = 1;
    const PRUint32 CPULoad_User = 2;
    const PRUint32 Threads = 3;
    const PRUint32 Processes = 4;
    const PRUint32 Handles = 5;
    const PRUint32 MemoryLoad = 6;
    const PRUint32 PhysMemTotal = 7;
    const PRUint32 PhysMemAvailable = 8;
    const PRUint32 PhysMemBalloon = 9;
    const PRUint32 MemCommitTotal = 10;
    const PRUint32 MemKernelTotal = 11;
    const PRUint32 MemKernelPaged = 12;
    const PRUint32 MemKernelNonpaged = 13;
    const PRUint32 MemSystemCache = 14;
    const PRUint32 PageFileSize = 15;
    const PRUint32 SampleNumber = 16;
    const PRUint32 MaxVal = 17;
};

/* cross-platform type name for GuestStatisticType */
%{C++
#define GuestStatisticType_T PRUint32
%}

/* cross-platform constants for GuestStatisticType */
%{C++
#define GuestStatisticType_CPULoad_Idle GuestStatisticType::CPULoad_Idle
#define GuestStatisticType_CPULoad_Kernel GuestStatisticType::CPULoad_Kernel
#define GuestStatisticType_CPULoad_User GuestStatisticType::CPULoad_User
#define GuestStatisticType_Threads GuestStatisticType::Threads
#define GuestStatisticType_Processes GuestStatisticType::Processes
#define GuestStatisticType_Handles GuestStatisticType::Handles
#define GuestStatisticType_MemoryLoad GuestStatisticType::MemoryLoad
#define GuestStatisticType_PhysMemTotal GuestStatisticType::PhysMemTotal
#define GuestStatisticType_PhysMemAvailable GuestStatisticType::PhysMemAvailable
#define GuestStatisticType_PhysMemBalloon GuestStatisticType::PhysMemBalloon
#define GuestStatisticType_MemCommitTotal GuestStatisticType::MemCommitTotal
#define GuestStatisticType_MemKernelTotal GuestStatisticType::MemKernelTotal
#define GuestStatisticType_MemKernelPaged GuestStatisticType::MemKernelPaged
#define GuestStatisticType_MemKernelNonpaged GuestStatisticType::MemKernelNonpaged
#define GuestStatisticType_MemSystemCache GuestStatisticType::MemSystemCache
#define GuestStatisticType_PageFileSize GuestStatisticType::PageFileSize
#define GuestStatisticType_SampleNumber GuestStatisticType::SampleNumber
#define GuestStatisticType_MaxVal GuestStatisticType::MaxVal
%}

[
    uuid(ae4fb9f7-29d2-45b4-b2c7-d579603135d5),
    scriptable
]
interface BIOSBootMenuMode
{
    const PRUint32 Disabled = 0;
    const PRUint32 MenuOnly = 1;
    const PRUint32 MessageAndMenu = 2;
};

/* cross-platform type name for BIOSBootMenuMode */
%{C++
#define BIOSBootMenuMode_T PRUint32
%}

/* cross-platform constants for BIOSBootMenuMode */
%{C++
#define BIOSBootMenuMode_Disabled BIOSBootMenuMode::Disabled
#define BIOSBootMenuMode_MenuOnly BIOSBootMenuMode::MenuOnly
#define BIOSBootMenuMode_MessageAndMenu BIOSBootMenuMode::MessageAndMenu
%}

[
    uuid(445330e3-202a-4dab-854f-ce22e6cb9715),
    scriptable
]
interface IDEControllerType
{
    const PRUint32 Null = 0;
    const PRUint32 PIIX3 = 1;
    const PRUint32 PIIX4 = 2;
};

/* cross-platform type name for IDEControllerType */
%{C++
#define IDEControllerType_T PRUint32
%}

/* cross-platform constants for IDEControllerType */
%{C++
#define IDEControllerType_Null IDEControllerType::Null
#define IDEControllerType_PIIX3 IDEControllerType::PIIX3
#define IDEControllerType_PIIX4 IDEControllerType::PIIX4
%}

[
    uuid(cb7233b7-c519-42a5-8310-1830953cacbc),
    scriptable
]
interface DriveState
{
    const PRUint32 Null = 0;
    const PRUint32 NotMounted = 1;
    const PRUint32 ImageMounted = 2;
    const PRUint32 HostDriveCaptured = 3;
};

/* cross-platform type name for DriveState */
%{C++
#define DriveState_T PRUint32
%}

/* cross-platform constants for DriveState */
%{C++
#define DriveState_Null DriveState::Null
#define DriveState_NotMounted DriveState::NotMounted
#define DriveState_ImageMounted DriveState::ImageMounted
#define DriveState_HostDriveCaptured DriveState::HostDriveCaptured
%}

[
    uuid(48138584-ad99-479d-a36f-eb82a7663685),
    scriptable
]
interface HardDiskStorageType
{
    const PRUint32 VirtualDiskImage = 0;
    const PRUint32 ISCSIHardDisk = 1;
    const PRUint32 VMDKImage = 2;
    const PRUint32 CustomHardDisk = 3;
    const PRUint32 VHDImage = 4;
};

/* cross-platform type name for HardDiskStorageType */
%{C++
#define HardDiskStorageType_T PRUint32
%}

/* cross-platform constants for HardDiskStorageType */
%{C++
#define HardDiskStorageType_VirtualDiskImage HardDiskStorageType::VirtualDiskImage
#define HardDiskStorageType_ISCSIHardDisk HardDiskStorageType::ISCSIHardDisk
#define HardDiskStorageType_VMDKImage HardDiskStorageType::VMDKImage
#define HardDiskStorageType_CustomHardDisk HardDiskStorageType::CustomHardDisk
#define HardDiskStorageType_VHDImage HardDiskStorageType::VHDImage
%}

[
    uuid(a348fafd-a64e-4643-ba65-eb3896bd7e0a),
    scriptable
]
interface HardDiskType
{
    const PRUint32 Normal = 0;
    const PRUint32 Immutable = 1;
    const PRUint32 Writethrough = 2;
};

/* cross-platform type name for HardDiskType */
%{C++
#define HardDiskType_T PRUint32
%}

/* cross-platform constants for HardDiskType */
%{C++
#define HardDiskType_Normal HardDiskType::Normal
#define HardDiskType_Immutable HardDiskType::Immutable
#define HardDiskType_Writethrough HardDiskType::Writethrough
%}

[
    uuid(03131722-2EC5-4173-9794-0DACA46673EF),
    scriptable
]
interface MouseButtonState
{
    const PRUint32 LeftButton = 0x01;
    const PRUint32 RightButton = 0x02;
    const PRUint32 MiddleButton = 0x04;
    const PRUint32 WheelUp = 0x08;
    const PRUint32 WheelDown = 0x10;
    const PRUint32 MouseStateMask = 0x1F;
};

/* cross-platform type name for MouseButtonState */
%{C++
#define MouseButtonState_T PRUint32
%}

/* cross-platform constants for MouseButtonState */
%{C++
#define MouseButtonState_LeftButton MouseButtonState::LeftButton
#define MouseButtonState_RightButton MouseButtonState::RightButton
#define MouseButtonState_MiddleButton MouseButtonState::MiddleButton
#define MouseButtonState_WheelUp MouseButtonState::WheelUp
#define MouseButtonState_WheelDown MouseButtonState::WheelDown
#define MouseButtonState_MouseStateMask MouseButtonState::MouseStateMask
%}

[
    uuid(f0e5ebbe-dc8e-4e2d-916e-53baa3844df8),
    scriptable
]
interface FramebufferAccelerationOperation
{
    const PRUint32 SolidFillAcceleration = 1;
    const PRUint32 ScreenCopyAcceleration = 2;
};

/* cross-platform type name for FramebufferAccelerationOperation */
%{C++
#define FramebufferAccelerationOperation_T PRUint32
%}

/* cross-platform constants for FramebufferAccelerationOperation */
%{C++
#define FramebufferAccelerationOperation_SolidFillAcceleration FramebufferAccelerationOperation::SolidFillAcceleration
#define FramebufferAccelerationOperation_ScreenCopyAcceleration FramebufferAccelerationOperation::ScreenCopyAcceleration
%}

[
    uuid(6b27d1fc-4f2c-4e9c-a166-01d06540305d),
    scriptable
]
interface FramebufferPixelFormat
{
    const PRUint32 Opaque = 0xFFFFFFFF;
    const PRUint32 FOURCC_RGB = 0x32424752;
};

/* cross-platform type name for FramebufferPixelFormat */
%{C++
#define FramebufferPixelFormat_T PRUint32
%}

/* cross-platform constants for FramebufferPixelFormat */
%{C++
#define FramebufferPixelFormat_Opaque FramebufferPixelFormat::Opaque
#define FramebufferPixelFormat_FOURCC_RGB FramebufferPixelFormat::FOURCC_RGB
%}

[
    uuid(8730d899-d036-4925-bc63-e58f3486f4bf),
    scriptable
]
interface NetworkAttachmentType
{
    const PRUint32 Null = 0;
    const PRUint32 NAT = 1;
    const PRUint32 HostInterface = 2;
    const PRUint32 Internal = 3;
};

/* cross-platform type name for NetworkAttachmentType */
%{C++
#define NetworkAttachmentType_T PRUint32
%}

/* cross-platform constants for NetworkAttachmentType */
%{C++
#define NetworkAttachmentType_Null NetworkAttachmentType::Null
#define NetworkAttachmentType_NAT NetworkAttachmentType::NAT
#define NetworkAttachmentType_HostInterface NetworkAttachmentType::HostInterface
#define NetworkAttachmentType_Internal NetworkAttachmentType::Internal
%}

[
    uuid(156b17b9-5d61-4d54-be90-62e37dda848d),
    scriptable
]
interface NetworkAdapterType
{
    const PRUint32 Null = 0;
    const PRUint32 Am79C970A = 1;
    const PRUint32 Am79C973 = 2;
    const PRUint32 I82540EM = 3;
    const PRUint32 I82543GC = 4;
};

/* cross-platform type name for NetworkAdapterType */
%{C++
#define NetworkAdapterType_T PRUint32
%}

/* cross-platform constants for NetworkAdapterType */
%{C++
#define NetworkAdapterType_Null NetworkAdapterType::Null
#define NetworkAdapterType_Am79C970A NetworkAdapterType::Am79C970A
#define NetworkAdapterType_Am79C973 NetworkAdapterType::Am79C973
#define NetworkAdapterType_I82540EM NetworkAdapterType::I82540EM
#define NetworkAdapterType_I82543GC NetworkAdapterType::I82543GC
%}

[
    uuid(b266f43c-2e93-46b3-812b-c20e600e867b),
    scriptable
]
interface PortMode
{
    const PRUint32 Disconnected = 0;
    const PRUint32 HostPipe = 1;
    const PRUint32 HostDevice = 2;
};

/* cross-platform type name for PortMode */
%{C++
#define PortMode_T PRUint32
%}

/* cross-platform constants for PortMode */
%{C++
#define PortMode_Disconnected PortMode::Disconnected
#define PortMode_HostPipe PortMode::HostPipe
#define PortMode_HostDevice PortMode::HostDevice
%}

[
    uuid(b99a2e65-67fb-4882-82fd-f3e5e8193ab4),
    scriptable
]
interface USBDeviceState
{
    const PRUint32 NotSupported = 0;
    const PRUint32 Unavailable = 1;
    const PRUint32 Busy = 2;
    const PRUint32 Available = 3;
    const PRUint32 Held = 4;
    const PRUint32 Captured = 5;
};

/* cross-platform type name for USBDeviceState */
%{C++
#define USBDeviceState_T PRUint32
%}

/* cross-platform constants for USBDeviceState */
%{C++
#define USBDeviceState_NotSupported USBDeviceState::NotSupported
#define USBDeviceState_Unavailable USBDeviceState::Unavailable
#define USBDeviceState_Busy USBDeviceState::Busy
#define USBDeviceState_Available USBDeviceState::Available
#define USBDeviceState_Held USBDeviceState::Held
#define USBDeviceState_Captured USBDeviceState::Captured
%}

[
    uuid(cbc30a49-2f4e-43b5-9da6-121320475933),
    scriptable
]
interface USBDeviceFilterAction
{
    const PRUint32 Null = 0;
    const PRUint32 Ignore = 1;
    const PRUint32 Hold = 2;
};

/* cross-platform type name for USBDeviceFilterAction */
%{C++
#define USBDeviceFilterAction_T PRUint32
%}

/* cross-platform constants for USBDeviceFilterAction */
%{C++
#define USBDeviceFilterAction_Null USBDeviceFilterAction::Null
#define USBDeviceFilterAction_Ignore USBDeviceFilterAction::Ignore
#define USBDeviceFilterAction_Hold USBDeviceFilterAction::Hold
%}

[
    uuid(4bcc3d73-c2fe-40db-b72f-0c2ca9d68496),
    scriptable
]
interface AudioDriverType
{
    const PRUint32 Null = 0;
    const PRUint32 WinMM = 1;
    const PRUint32 OSS = 2;
    const PRUint32 ALSA = 3;
    const PRUint32 DirectSound = 4;
    const PRUint32 CoreAudio = 5;
    const PRUint32 MMPM = 6;
    const PRUint32 Pulse = 7;
    const PRUint32 SolAudio = 8;
};

/* cross-platform type name for AudioDriverType */
%{C++
#define AudioDriverType_T PRUint32
%}

/* cross-platform constants for AudioDriverType */
%{C++
#define AudioDriverType_Null AudioDriverType::Null
#define AudioDriverType_WinMM AudioDriverType::WinMM
#define AudioDriverType_OSS AudioDriverType::OSS
#define AudioDriverType_ALSA AudioDriverType::ALSA
#define AudioDriverType_DirectSound AudioDriverType::DirectSound
#define AudioDriverType_CoreAudio AudioDriverType::CoreAudio
#define AudioDriverType_MMPM AudioDriverType::MMPM
#define AudioDriverType_Pulse AudioDriverType::Pulse
#define AudioDriverType_SolAudio AudioDriverType::SolAudio
%}

[
    uuid(7afd395c-42c3-444e-8788-3ce80292f36c),
    scriptable
]
interface AudioControllerType
{
    const PRUint32 AC97 = 0;
    const PRUint32 SB16 = 1;
};

/* cross-platform type name for AudioControllerType */
%{C++
#define AudioControllerType_T PRUint32
%}

/* cross-platform constants for AudioControllerType */
%{C++
#define AudioControllerType_AC97 AudioControllerType::AC97
#define AudioControllerType_SB16 AudioControllerType::SB16
%}

[
    uuid(3d91887a-b67f-4b33-85bf-2da7ab1ea83a),
    scriptable
]
interface VRDPAuthType
{
    const PRUint32 Null = 0;
    const PRUint32 External = 1;
    const PRUint32 Guest = 2;
};

/* cross-platform type name for VRDPAuthType */
%{C++
#define VRDPAuthType_T PRUint32
%}

/* cross-platform constants for VRDPAuthType */
%{C++
#define VRDPAuthType_Null VRDPAuthType::Null
#define VRDPAuthType_External VRDPAuthType::External
#define VRDPAuthType_Guest VRDPAuthType::Guest
%}

[
    uuid(e98b5376-8eb4-4eea-812a-3964bf3bb26f),
    scriptable
]
interface IVirtualBoxErrorInfo : nsIException
{
    readonly attribute nsresult resultCode;

    readonly attribute nsIDPtr interfaceID;

    readonly attribute wstring component;

    readonly attribute wstring text;

    readonly attribute IVirtualBoxErrorInfo next;

}; /* interface IVirtualBoxErrorInfo */

[
    uuid(ee95ffc2-b6c6-4ce8-9e9e-ceadbb5019fe),
    scriptable
]
interface IVirtualBoxCallback : nsISupports
{
    void onMachineStateChange (
        in nsIDRef machineId,
        in PRUint32 state
    );

    void onMachineDataChange (
        in nsIDRef machineId
    );

    void onExtraDataCanChange (
        in nsIDRef machineId,
        in wstring key,
        in wstring value,
        out wstring error,
        [retval] out boolean allowChange
    );

    void onExtraDataChange (
        in nsIDRef machineId,
        in wstring key,
        in wstring value
    );

    void onMediaRegistered (
        in nsIDRef mediaId,
        in PRUint32 mediaType,
        in boolean registered
    );

    void onMachineRegistered (
        in nsIDRef machineId,
        in boolean registered
    );

    void onSessionStateChange (
        in nsIDRef machineId,
        in PRUint32 state
    );

    void onSnapshotTaken (
        in nsIDRef machineId,
        in nsIDRef snapshotId
    );

    void onSnapshotDiscarded (
        in nsIDRef machineId,
        in nsIDRef snapshotId
    );

    void onSnapshotChange (
        in nsIDRef machineId,
        in nsIDRef snapshotId
    );

}; /* interface IVirtualBoxCallback */

[
    uuid(2d3b9ea7-25f5-4f07-a8e1-7dd7e0dcf667),
    scriptable
]
interface IVirtualBox : nsISupports
{
    readonly attribute wstring version;

    readonly attribute wstring homeFolder;

    readonly attribute wstring settingsFilePath;

    readonly attribute wstring settingsFileVersion;

    readonly attribute wstring settingsFormatVersion;

    readonly attribute IHost host;

    readonly attribute ISystemProperties systemProperties;

    readonly attribute IMachineCollection machines;

    void getMachines2 (
        out unsigned long machines2Size,
        [array, size_is(machines2Size), retval] out IMachine machines2
    );

    readonly attribute IHardDiskCollection hardDisks;

    readonly attribute IDVDImageCollection DVDImages;

    readonly attribute IFloppyImageCollection FloppyImages;

    readonly attribute IProgressCollection progressOperations;

    readonly attribute IGuestOSTypeCollection guestOSTypes;

    readonly attribute ISharedFolderCollection sharedFolders;

    void createMachine (
        in wstring baseFolder,
        in wstring name,
        in nsIDRef id,
        [retval] out IMachine machine
    );

    void createLegacyMachine (
        in wstring settingsFile,
        in wstring name,
        in nsIDRef id,
        [retval] out IMachine machine
    );

    void openMachine (
        in wstring settingsFile,
        [retval] out IMachine machine
    );

    void registerMachine (
        in IMachine machine
    );

    void getMachine (
        in nsIDRef id,
        [retval] out IMachine machine
    );

    void findMachine (
        in wstring name,
        [retval] out IMachine machine
    );

    void unregisterMachine (
        in nsIDRef id,
        [retval] out IMachine machine
    );

    void createHardDisk (
        in PRUint32 storageType,
        [retval] out IHardDisk hardDisk
    );

    void openHardDisk (
        in wstring location,
        [retval] out IHardDisk hardDisk
    );

    void openVirtualDiskImage (
        in wstring filePath,
        [retval] out IVirtualDiskImage image
    );

    void registerHardDisk (
        in IHardDisk hardDisk
    );

    void getHardDisk (
        in nsIDRef id,
        [retval] out IHardDisk hardDisk
    );

    void findHardDisk (
        in wstring location,
        [retval] out IHardDisk hardDisk
    );

    void findVirtualDiskImage (
        in wstring filePath,
        [retval] out IVirtualDiskImage image
    );

    void unregisterHardDisk (
        in nsIDRef id,
        [retval] out IHardDisk hardDisk
    );

    void openDVDImage (
        in wstring filePath,
        in nsIDRef id,
        [retval] out IDVDImage image
    );

    void registerDVDImage (
        in IDVDImage image
    );

    void getDVDImage (
        in nsIDRef id,
        [retval] out IDVDImage image
    );

    void findDVDImage (
        in wstring filePath,
        [retval] out IDVDImage image
    );

    void getDVDImageUsage (
        in nsIDRef id,
        in PRUint32 usage,
        [retval] out wstring machineIDs
    );

    void unregisterDVDImage (
        in nsIDRef id,
        [retval] out IDVDImage image
    );

    void openFloppyImage (
        in wstring filePath,
        in nsIDRef id,
        [retval] out IFloppyImage image
    );

    void registerFloppyImage (
        in IFloppyImage image
    );

    void getFloppyImage (
        in nsIDRef id,
        [retval] out IFloppyImage image
    );

    void findFloppyImage (
        in wstring filePath,
        [retval] out IFloppyImage image
    );

    void getFloppyImageUsage (
        in nsIDRef id,
        in PRUint32 usage,
        [retval] out wstring machineIDs
    );

    void unregisterFloppyImage (
        in nsIDRef id,
        [retval] out IFloppyImage image
    );

    void getGuestOSType (
        in wstring id,
        [retval] out IGuestOSType type
    );

    void createSharedFolder (
        in wstring name,
        in wstring hostPath,
        in boolean writable
    );

    void removeSharedFolder (
        in wstring name
    );

    void getNextExtraDataKey (
        in wstring key,
        out wstring nextKey,
        out wstring nextValue
    );

    void getExtraData (
        in wstring key,
        [retval] out wstring value
    );

    void setExtraData (
        in wstring key,
        in wstring value
    );

    void openSession (
        in ISession session,
        in nsIDRef machineId
    );

    void openRemoteSession (
        in ISession session,
        in nsIDRef machineId,
        in wstring type,
        in wstring environment,
        [retval] out IProgress progress
    );

    void openExistingSession (
        in ISession session,
        in nsIDRef machineId
    );

    void registerCallback (
        in IVirtualBoxCallback callback
    );

    void unregisterCallback (
        in IVirtualBoxCallback callback
    );

    void waitForPropertyChange (
        in wstring what,
        in unsigned long timeout,
        out wstring changed,
        out wstring values
    );

    void saveSettings();

    void saveSettingsWithBackup (
        [retval] out wstring bakFileName
    );

}; /* interface IVirtualBox */

[
    uuid(1b554149-be0a-4465-9252-9ff8f420af55),
    scriptable
]
interface IMachineEnumerator : nsISupports
{
    void hasMore ([retval] out boolean more);

    void getNext ([retval] out IMachine next);

}; /* interface IMachineEnumerator */

[
    uuid(FD443EC1-3007-4F5B-9282-D72760A66916),
    scriptable
]
interface IMachineCollection : nsISupports
{
    readonly attribute unsigned long count;

    void getItemAt (in unsigned long index, [retval] out IMachine item);

    void enumerate ([retval] out IMachineEnumerator enumerator);

}; /* interface IMachineCollection */

[
    uuid(1063893c-4c38-4304-aee9-73e072c181cc),
    scriptable
]
interface IInternalMachineControl : nsISupports
{
    void updateState (
        in PRUint32 state
    );

    void getIPCId (
        [retval] out wstring id
    );

    void runUSBDeviceFilters (
        in IUSBDevice device,
        out boolean matched,
        out unsigned long maskedInterfaces
    );

    void captureUSBDevice (
        in nsIDRef id
    );

    void detachUSBDevice (
        in nsIDRef id,
        in boolean done
    );

    void autoCaptureUSBDevices();

    void detachAllUSBDevices (
        in boolean done
    );

    void onSessionEnd (
        in ISession session,
        [retval] out IProgress progress
    );

    void beginSavingState (
        in IProgress progress,
        out wstring stateFilePath
    );

    void endSavingState (
        in boolean success
    );

    void adoptSavedState (
        in wstring savedStateFile
    );

    void beginTakingSnapshot (
        in IConsole initiator,
        in wstring name,
        in wstring description,
        in IProgress progress,
        out wstring stateFilePath,
        out IProgress serverProgress
    );

    void endTakingSnapshot (
        in boolean success
    );

    void discardSnapshot (
        in IConsole initiator,
        in nsIDRef id,
        out PRUint32 machineState,
        [retval] out IProgress progress
    );

    void discardCurrentState (
        in IConsole initiator,
        out PRUint32 machineState,
        [retval] out IProgress progress
    );

    void discardCurrentSnapshotAndState (
        in IConsole initiator,
        out PRUint32 machineState,
        [retval] out IProgress progress
    );

}; /* interface IInternalMachineControl */

[
    uuid(38b54279-dc35-4f5e-a431-835b867c6b5e),
    scriptable
]
interface IBIOSSettings : nsISupports
{
    attribute boolean logoFadeIn;

    attribute boolean logoFadeOut;

    attribute unsigned long logoDisplayTime;

    attribute wstring logoImagePath;

    attribute PRUint32 bootMenuMode;

    attribute boolean ACPIEnabled;

    attribute boolean IOAPICEnabled;

    attribute long long timeOffset;

    attribute boolean PXEDebugEnabled;

    attribute PRUint32 IDEControllerType;

}; /* interface IBIOSSettings */

[
    uuid(f95c0793-7737-49a1-85d9-6da81097173b),
    scriptable
]
interface IMachine : nsISupports
{
    readonly attribute IVirtualBox parent;

    readonly attribute boolean accessible;

    readonly attribute IVirtualBoxErrorInfo accessError;

    attribute wstring name;

    attribute wstring description;

    readonly attribute nsIDPtr id;

    attribute wstring OSTypeId;

    attribute unsigned long memorySize;

    attribute unsigned long memoryBalloonSize;

    attribute unsigned long statisticsUpdateInterval;

    attribute unsigned long VRAMSize;

    attribute unsigned long MonitorCount;

    readonly attribute IBIOSSettings BIOSSettings;

    attribute PRUint32 HWVirtExEnabled;

    attribute boolean PAEEnabled;

    attribute wstring snapshotFolder;

    readonly attribute IVRDPServer VRDPServer;

    readonly attribute IHardDiskAttachmentCollection hardDiskAttachments;

    readonly attribute IDVDDrive DVDDrive;

    readonly attribute IFloppyDrive FloppyDrive;

    readonly attribute IUSBController USBController;

    readonly attribute IAudioAdapter audioAdapter;

    readonly attribute ISATAController SATAController;

    readonly attribute wstring settingsFilePath;

    readonly attribute wstring settingsFileVersion;

    readonly attribute boolean settingsModified;

    readonly attribute PRUint32 sessionState;

    readonly attribute wstring sessionType;

    readonly attribute unsigned long sessionPid;

    readonly attribute PRUint32 state;

    readonly attribute long long lastStateChange;

    readonly attribute wstring stateFilePath;

    readonly attribute wstring logFolder;

    readonly attribute ISnapshot currentSnapshot;

    readonly attribute unsigned long snapshotCount;

    readonly attribute boolean currentStateModified;

    readonly attribute ISharedFolderCollection sharedFolders;

    attribute PRUint32 clipboardMode;

    void setBootOrder (
        in unsigned long position,
        in PRUint32 device
    );

    void getBootOrder (
        in unsigned long order,
        [retval] out PRUint32 device
    );

    void attachHardDisk (
        in nsIDRef id,
        in PRUint32 bus,
        in long channel,
        in long device
    );

    void getHardDisk (
        in PRUint32 bus,
        in long channel,
        in long device,
        [retval] out IHardDisk hardDisk
    );

    void detachHardDisk (
        in PRUint32 bus,
        in long channel,
        in long device
    );

    void getNetworkAdapter (
        in unsigned long slot,
        [retval] out INetworkAdapter adapter
    );

    void getSerialPort (
        in unsigned long slot,
        [retval] out ISerialPort port
    );

    void getParallelPort (
        in unsigned long slot,
        [retval] out IParallelPort port
    );

    void getNextExtraDataKey (
        in wstring key,
        out wstring nextKey,
        out wstring nextValue
    );

    void getExtraData (
        in wstring key,
        [retval] out wstring value
    );

    void setExtraData (
        in wstring key,
        in wstring value
    );

    void saveSettings();

    void saveSettingsWithBackup (
        [retval] out wstring bakFileName
    );

    void discardSettings();

    void deleteSettings();

    void getSnapshot (
        in nsIDRef id,
        [retval] out ISnapshot snapshot
    );

    void findSnapshot (
        in wstring name,
        [retval] out ISnapshot snapshot
    );

    void setCurrentSnapshot (
        in nsIDRef id
    );

    void createSharedFolder (
        in wstring name,
        in wstring hostPath,
        in boolean writable
    );

    void removeSharedFolder (
        in wstring name
    );

    void canShowConsoleWindow (
        [retval] out boolean canShow
    );

    void showConsoleWindow (
        [retval] out unsigned long long winId
    );

}; /* interface IMachine */

[
    uuid(13dfbef3-b74d-487d-bada-2304529aefa6),
    scriptable
]
interface IConsoleCallback : nsISupports
{
    [noscript]
    void onMousePointerShapeChange (
        in boolean visible,
        in boolean alpha,
        in unsigned long xHot,
        in unsigned long yHot,
        in unsigned long width,
        in unsigned long height,
        in octetPtr shape
    );

    void onMouseCapabilityChange (
        in boolean supportsAbsolute,
        in boolean needsHostCursor
    );

    void onKeyboardLedsChange (
        in boolean numLock,
        in boolean capsLock,
        in boolean scrollLock
    );

    void onStateChange (
        in PRUint32 state
    );

    void onAdditionsStateChange();

    void onDVDDriveChange();

    void onFloppyDriveChange();

    void onNetworkAdapterChange (
        in INetworkAdapter networkAdapter
    );

    void onSerialPortChange (
        in ISerialPort serialPort
    );

    void onParallelPortChange (
        in IParallelPort parallelPort
    );

    void onVRDPServerChange();

    void onUSBControllerChange();

    void onUSBDeviceStateChange (
        in IUSBDevice device,
        in boolean attached,
        in IVirtualBoxErrorInfo error
    );

    void onSharedFolderChange (
        in PRUint32 scope
    );

    void onRuntimeError (
        in boolean fatal,
        in wstring id,
        in wstring message
    );

    void onCanShowWindow (
        [retval] out boolean canShow
    );

    void onShowWindow (
        [retval] out unsigned long long winId
    );

}; /* interface IConsoleCallback */

[
    uuid(550104cd-2dfd-4a6c-857d-f6f8e088e62c),
    scriptable
]
interface IRemoteDisplayInfo : nsISupports
{
    readonly attribute boolean active;

    readonly attribute unsigned long numberOfClients;

    readonly attribute long long beginTime;

    readonly attribute long long endTime;

    readonly attribute unsigned long long bytesSent;

    readonly attribute unsigned long long bytesSentTotal;

    readonly attribute unsigned long long bytesReceived;

    readonly attribute unsigned long long bytesReceivedTotal;

    readonly attribute wstring user;

    readonly attribute wstring domain;

    readonly attribute wstring clientName;

    readonly attribute wstring clientIP;

    readonly attribute unsigned long clientVersion;

    readonly attribute unsigned long encryptionStyle;

}; /* interface IRemoteDisplayInfo */

[
    uuid(d5a1cbda-f5d7-4824-9afe-d640c94c7dcf),
    scriptable
]
interface IConsole : nsISupports
{
    readonly attribute IMachine machine;

    readonly attribute PRUint32 state;

    readonly attribute IGuest guest;

    readonly attribute IKeyboard keyboard;

    readonly attribute IMouse mouse;

    readonly attribute IDisplay display;

    readonly attribute IMachineDebugger debugger;

    readonly attribute IUSBDeviceCollection USBDevices;

    readonly attribute IHostUSBDeviceCollection remoteUSBDevices;

    readonly attribute ISharedFolderCollection sharedFolders;

    readonly attribute IRemoteDisplayInfo remoteDisplayInfo;

    void powerUp (
        [retval] out IProgress progress
    );

    void powerDown();

    void reset();

    void pause();

    void resume();

    void powerButton();

    void sleepButton();

    void getPowerButtonHandled (
        [retval] out boolean handled
    );

    void saveState (
        [retval] out IProgress progress
    );

    void adoptSavedState (
        in wstring savedStateFile
    );

    void discardSavedState();

    void getDeviceActivity (
        in PRUint32 type,
        [retval] out PRUint32 activity
    );

    void attachUSBDevice (
        in nsIDRef id
    );

    void detachUSBDevice (
        in nsIDRef id,
        [retval] out IUSBDevice device
    );

    void createSharedFolder (
        in wstring name,
        in wstring hostPath,
        in boolean writable
    );

    void removeSharedFolder (
        in wstring name
    );

    void takeSnapshot (
        in wstring name,
        in wstring description,
        [retval] out IProgress progress
    );

    void discardSnapshot (
        in nsIDRef id,
        [retval] out IProgress progress
    );

    void discardCurrentState (
        [retval] out IProgress progress
    );

    void discardCurrentSnapshotAndState (
        [retval] out IProgress progress
    );

    void registerCallback (
        in IConsoleCallback callback
    );

    void unregisterCallback (
        in IConsoleCallback callback
    );

}; /* interface IConsole */

[
    uuid(21f86694-202d-4ce4-8b05-a63ff82dbf4c),
    scriptable
]
interface IHostDVDDrive : nsISupports
{
    readonly attribute wstring name;

    readonly attribute wstring description;

    readonly attribute wstring udi;

}; /* interface IHostDVDDrive */

[
    uuid(1ed7cfaf-c363-40df-aa4e-89c1afb7d96b),
    scriptable
]
interface IHostDVDDriveEnumerator : nsISupports
{
    void hasMore ([retval] out boolean more);

    void getNext ([retval] out IHostDVDDrive next);

}; /* interface IHostDVDDriveEnumerator */

[
    uuid(1909c533-1a1e-445f-a4e1-a267cffc30ed),
    scriptable
]
interface IHostDVDDriveCollection : nsISupports
{
    readonly attribute unsigned long count;

    void getItemAt (in unsigned long index, [retval] out IHostDVDDrive item);

    void enumerate ([retval] out IHostDVDDriveEnumerator enumerator);

    void findByName (
        in wstring name,
        [retval] out IHostDVDDrive drive
    );

}; /* interface IHostDVDDriveCollection */

[
    uuid(b6a4d1a9-4221-43c3-bd52-021a5daa9ed2),
    scriptable
]
interface IHostFloppyDrive : nsISupports
{
    readonly attribute wstring name;

    readonly attribute wstring description;

    readonly attribute wstring udi;

}; /* interface IHostFloppyDrive */

[
    uuid(ce04c924-4f54-432a-9dec-11fddc3ea875),
    scriptable
]
interface IHostFloppyDriveEnumerator : nsISupports
{
    void hasMore ([retval] out boolean more);

    void getNext ([retval] out IHostFloppyDrive next);

}; /* interface IHostFloppyDriveEnumerator */

[
    uuid(fd84bb86-c59a-4037-a557-755ff263a460),
    scriptable
]
interface IHostFloppyDriveCollection : nsISupports
{
    readonly attribute unsigned long count;

    void getItemAt (in unsigned long index, [retval] out IHostFloppyDrive item);

    void enumerate ([retval] out IHostFloppyDriveEnumerator enumerator);

    void findByName (
        in wstring name,
        [retval] out IHostFloppyDrive drive
    );

}; /* interface IHostFloppyDriveCollection */

[
    uuid(81729c26-1aec-46f5-b7c0-cc7364738fdb),
    scriptable
]
interface IHost : nsISupports
{
    readonly attribute IHostDVDDriveCollection DVDDrives;

    readonly attribute IHostFloppyDriveCollection floppyDrives;

    readonly attribute IHostUSBDeviceCollection USBDevices;

    readonly attribute IHostUSBDeviceFilterCollection USBDeviceFilters;

    readonly attribute unsigned long processorCount;

    readonly attribute unsigned long processorSpeed;

    readonly attribute wstring processorDescription;

    readonly attribute unsigned long memorySize;

    readonly attribute unsigned long memoryAvailable;

    readonly attribute wstring operatingSystem;

    readonly attribute wstring OSVersion;

    readonly attribute long long UTCTime;

    void createUSBDeviceFilter (
        in wstring name,
        [retval] out IHostUSBDeviceFilter filter
    );

    void insertUSBDeviceFilter (
        in unsigned long position,
        in IHostUSBDeviceFilter filter
    );

    void removeUSBDeviceFilter (
        in unsigned long position,
        [retval] out IHostUSBDeviceFilter filter
    );

}; /* interface IHost */

[
    uuid(12c2e31e-247f-4d51-82e5-5b9d4a6c7d5b),
    scriptable
]
interface ISystemProperties : nsISupports
{
    readonly attribute unsigned long minGuestRAM;

    readonly attribute unsigned long maxGuestRAM;

    readonly attribute unsigned long minGuestVRAM;

    readonly attribute unsigned long maxGuestVRAM;

    readonly attribute unsigned long long maxVDISize;

    readonly attribute unsigned long networkAdapterCount;

    readonly attribute unsigned long serialPortCount;

    readonly attribute unsigned long parallelPortCount;

    readonly attribute unsigned long maxBootPosition;

    attribute wstring defaultVDIFolder;

    attribute wstring defaultMachineFolder;

    attribute wstring remoteDisplayAuthLibrary;

    attribute wstring webServiceAuthLibrary;

    attribute boolean HWVirtExEnabled;

    attribute unsigned long LogHistoryCount;

}; /* interface ISystemProperties */

[
    uuid(da94f478-1f37-4726-b750-2235950dc2fe),
    scriptable
]
interface IGuestOSType : nsISupports
{
    readonly attribute wstring id;

    readonly attribute wstring description;

    readonly attribute unsigned long recommendedRAM;

    readonly attribute unsigned long recommendedVRAM;

    readonly attribute unsigned long recommendedHDD;

}; /* interface IGuestOSType */

[
    uuid(a3335e02-4669-4e3c-80c7-c4dc7056a07c),
    scriptable
]
interface IGuestOSTypeEnumerator : nsISupports
{
    void hasMore ([retval] out boolean more);

    void getNext ([retval] out IGuestOSType next);

}; /* interface IGuestOSTypeEnumerator */

[
    uuid(a5e36749-a610-498b-9f29-2e36c1042d65),
    scriptable
]
interface IGuestOSTypeCollection : nsISupports
{
    readonly attribute unsigned long count;

    void getItemAt (in unsigned long index, [retval] out IGuestOSType item);

    void enumerate ([retval] out IGuestOSTypeEnumerator enumerator);

}; /* interface IGuestOSTypeCollection */

[
    uuid(d8556fca-81bc-12af-fca3-365528fa38ca),
    scriptable
]
interface IGuest : nsISupports
{
    readonly attribute wstring OSTypeId;

    readonly attribute boolean additionsActive;

    readonly attribute wstring additionsVersion;

    readonly attribute boolean supportsSeamless;

    readonly attribute boolean supportsGraphics;

    attribute unsigned long memoryBalloonSize;

    attribute unsigned long statisticsUpdateInterval;

    void setCredentials (
        in wstring userName,
        in wstring password,
        in wstring domain,
        in boolean allowInteractiveLogon
    );

    void getStatistic (
        in unsigned long cpuId,
        in PRUint32 statistic,
        out unsigned long statVal
    );

}; /* interface IGuest */

[
    uuid(e0380522-4ef1-48f4-856c-e455177ccb2d),
    scriptable
]
interface IProgressEnumerator : nsISupports
{
    void hasMore ([retval] out boolean more);

    void getNext ([retval] out IProgress next);

}; /* interface IProgressEnumerator */

[
    uuid(78B76A7C-F0F2-467c-9F0E-F089A54EE957),
    scriptable
]
interface IProgressCollection : nsISupports
{
    readonly attribute unsigned long count;

    void getItemAt (in unsigned long index, [retval] out IProgress item);

    void enumerate ([retval] out IProgressEnumerator enumerator);

}; /* interface IProgressCollection */

[
    uuid(10CC03A1-717E-429b-992D-C67B56175A51),
    scriptable
]
interface IProgress : nsISupports
{
    readonly attribute nsIDPtr id;

    readonly attribute wstring description;

    readonly attribute nsISupports initiator;

    readonly attribute boolean cancelable;

    readonly attribute long percent;

    readonly attribute boolean completed;

    readonly attribute boolean canceled;

    readonly attribute nsresult resultCode;

    readonly attribute IVirtualBoxErrorInfo errorInfo;

    readonly attribute unsigned long operationCount;

    readonly attribute unsigned long operation;

    readonly attribute wstring operationDescription;

    readonly attribute long operationPercent;

    void waitForCompletion (
        in long timeout
    );

    void waitForOperationCompletion (
        in unsigned long operation,
        in long timeout
    );

    void cancel();

}; /* interface IProgress */

[
    uuid(25cfa2a4-1f1d-4f05-9658-b7a5894ef1a3),
    scriptable
]
interface ISnapshotEnumerator : nsISupports
{
    void hasMore ([retval] out boolean more);

    void getNext ([retval] out ISnapshot next);

}; /* interface ISnapshotEnumerator */

[
    uuid(23852e3c-94cd-4801-ab05-ed35675b3894),
    scriptable
]
interface ISnapshotCollection : nsISupports
{
    readonly attribute unsigned long count;

    void getItemAt (in unsigned long index, [retval] out ISnapshot item);

    void enumerate ([retval] out ISnapshotEnumerator enumerator);

}; /* interface ISnapshotCollection */

[
    uuid(9f1bbf79-13b0-4da2-abba-4a992c65c083),
    scriptable
]
interface ISnapshot : nsISupports
{
    readonly attribute nsIDPtr id;

    attribute wstring name;

    attribute wstring description;

    readonly attribute long long timeStamp;

    readonly attribute boolean online;

    readonly attribute IMachine machine;

    readonly attribute ISnapshot parent;

    readonly attribute ISnapshotCollection children;

}; /* interface ISnapshot */

[
    uuid(c0ffe596-21c6-4797-8d8a-b47b66881e7a),
    scriptable
]
interface IHardDiskAttachment : nsISupports
{
    readonly attribute IHardDisk hardDisk;

    readonly attribute PRUint32 bus;

    readonly attribute long channel;

    readonly attribute long device;

}; /* interface IHardDiskAttachment */

[
    uuid(9955e486-2f0b-432a-99e4-0ebbd338875e),
    scriptable
]
interface IHardDiskAttachmentEnumerator : nsISupports
{
    void hasMore ([retval] out boolean more);

    void getNext ([retval] out IHardDiskAttachment next);

}; /* interface IHardDiskAttachmentEnumerator */

[
    uuid(8f727842-bb77-45d4-92de-4ec14bf613c9),
    scriptable
]
interface IHardDiskAttachmentCollection : nsISupports
{
    readonly attribute unsigned long count;

    void getItemAt (in unsigned long index, [retval] out IHardDiskAttachment item);

    void enumerate ([retval] out IHardDiskAttachmentEnumerator enumerator);

}; /* interface IHardDiskAttachmentCollection */

[
    uuid(b976f97b-cdb8-47e3-9860-084031cbd533),
    scriptable
]
interface IHardDiskEnumerator : nsISupports
{
    void hasMore ([retval] out boolean more);

    void getNext ([retval] out IHardDisk next);

}; /* interface IHardDiskEnumerator */

[
    uuid(43EAC2BC-5C61-40fa-BC38-46DE2C7DB6BB),
    scriptable
]
interface IHardDiskCollection : nsISupports
{
    readonly attribute unsigned long count;

    void getItemAt (in unsigned long index, [retval] out IHardDisk item);

    void enumerate ([retval] out IHardDiskEnumerator enumerator);

}; /* interface IHardDiskCollection */

[
    uuid(FD443EC1-000F-4F5B-9282-D72760A66916),
    scriptable
]
interface IHardDisk : nsISupports
{
    readonly attribute nsIDPtr id;

    attribute wstring description;

    readonly attribute PRUint32 storageType;

    readonly attribute wstring location;

    attribute PRUint32 type;

    readonly attribute IHardDisk parent;

    readonly attribute IHardDiskCollection children;

    readonly attribute IHardDisk root;

    readonly attribute boolean accessible;

    readonly attribute boolean allAccessible;

    readonly attribute wstring lastAccessError;

    readonly attribute unsigned long long size;

    readonly attribute unsigned long long actualSize;

    readonly attribute nsIDPtr machineId;

    readonly attribute nsIDPtr snapshotId;

    void cloneToImage (
        in wstring filePath,
        out IVirtualDiskImage image,
        [retval] out IProgress progress
    );

}; /* interface IHardDisk */

[
    uuid(a8265b5a-0d20-4a46-a02f-65693a4e8239),
    scriptable
]
interface IVirtualDiskImage : nsISupports
{
    attribute wstring filePath;

    readonly attribute boolean created;

    void createDynamicImage (
        in unsigned long long size,
        [retval] out IProgress progress
    );

    void createFixedImage (
        in unsigned long long size,
        [retval] out IProgress progress
    );

    void deleteImage();

}; /* interface IVirtualDiskImage */

[
    uuid(003f6ca9-3257-4ef9-99c9-c66ce44576cb),
    scriptable
]
interface IISCSIHardDisk : nsISupports
{
    attribute wstring server;

    attribute unsigned short port;

    attribute wstring target;

    attribute unsigned long long lun;

    attribute wstring userName;

    attribute wstring password;

}; /* interface IISCSIHardDisk */

[
    uuid(178398f5-8559-4fee-979e-420af5b53eef),
    scriptable
]
interface IVMDKImage : nsISupports
{
    attribute wstring filePath;

    readonly attribute boolean created;

    void createDynamicImage (
        in unsigned long long size,
        [retval] out IProgress progress
    );

    void createFixedImage (
        in unsigned long long size,
        [retval] out IProgress progress
    );

    void deleteImage();

}; /* interface IVMDKImage */

[
    uuid(a7b0236d-3ff4-47c0-a4aa-ddc4ddc1141a),
    scriptable
]
interface ICustomHardDisk : nsISupports
{
    attribute wstring location;

    readonly attribute wstring format;

    readonly attribute boolean created;

    void createDynamicImage (
        in unsigned long long size,
        [retval] out IProgress progress
    );

    void createFixedImage (
        in unsigned long long size,
        [retval] out IProgress progress
    );

    void deleteImage();

}; /* interface ICustomHardDisk */

[
    uuid(163b88c3-7552-424a-8205-daf17a004747),
    scriptable
]
interface IVHDImage : nsISupports
{
    attribute wstring filePath;

    readonly attribute boolean created;

    void createDynamicImage (
        in unsigned long long size,
        [retval] out IProgress progress
    );

    void createFixedImage (
        in unsigned long long size,
        [retval] out IProgress progress
    );

    void deleteImage();

}; /* interface IVHDImage */

[
    uuid(9BE77C8D-E1BE-4bf2-A67B-B4DD3D2B0F28),
    scriptable
]
interface IDVDImageEnumerator : nsISupports
{
    void hasMore ([retval] out boolean more);

    void getNext ([retval] out IDVDImage next);

}; /* interface IDVDImageEnumerator */

[
    uuid(AE7053FA-ADD2-4ea4-AFCF-24D5F8DDED64),
    scriptable
]
interface IDVDImageCollection : nsISupports
{
    readonly attribute unsigned long count;

    void getItemAt (in unsigned long index, [retval] out IDVDImage item);

    void enumerate ([retval] out IDVDImageEnumerator enumerator);

    void findByPath (
        in wstring path,
        [retval] out IDVDImage image
    );

}; /* interface IDVDImageCollection */

[
    uuid(140FFF03-E479-4194-8562-ABC4F8171009),
    scriptable
]
interface IDVDImage : nsISupports
{
    readonly attribute nsIDPtr id;

    readonly attribute wstring filePath;

    readonly attribute boolean accessible;

    readonly attribute unsigned long long size;

}; /* interface IDVDImage */

[
    uuid(d9bd101a-8079-4fb9-bad1-31bf32482b75),
    scriptable
]
interface IDVDDrive : nsISupports
{
    readonly attribute PRUint32 state;

    attribute boolean passthrough;

    void mountImage (
        in nsIDRef imageId
    );

    void captureHostDrive (
        in IHostDVDDrive drive
    );

    void unmount();

    void getImage (
        [retval] out IDVDImage image
    );

    void getHostDrive (
        [retval] out IHostDVDDrive drive
    );

}; /* interface IDVDDrive */

[
    uuid(902C4089-76B7-41f1-91E8-49A261A28A2C),
    scriptable
]
interface IFloppyImageEnumerator : nsISupports
{
    void hasMore ([retval] out boolean more);

    void getNext ([retval] out IFloppyImage next);

}; /* interface IFloppyImageEnumerator */

[
    uuid(327A8928-8572-446e-AD9A-18FE30E81F3F),
    scriptable
]
interface IFloppyImageCollection : nsISupports
{
    readonly attribute unsigned long count;

    void getItemAt (in unsigned long index, [retval] out IFloppyImage item);

    void enumerate ([retval] out IFloppyImageEnumerator enumerator);

    void findByPath (
        in wstring path,
        [retval] out IFloppyImage image
    );

}; /* interface IFloppyImageCollection */

[
    uuid(CC696755-EA98-4ffe-9DC5-C003047034AB),
    scriptable
]
interface IFloppyImage : nsISupports
{
    readonly attribute nsIDPtr id;

    readonly attribute wstring filePath;

    readonly attribute boolean accessible;

    readonly attribute unsigned long size;

}; /* interface IFloppyImage */

[
    uuid(E9318F71-78D2-4b00-863C-B7CB0030A2D9),
    scriptable
]
interface IFloppyDrive : nsISupports
{
    attribute boolean enabled;

    readonly attribute PRUint32 state;

    void mountImage (
        in nsIDRef imageId
    );

    void captureHostDrive (
        in IHostFloppyDrive drive
    );

    void unmount();

    void getImage (
        [retval] out IFloppyImage image
    );

    void getHostDrive (
        [retval] out IHostFloppyDrive drive
    );

}; /* interface IFloppyDrive */

[
    uuid(FD443EC1-000A-4F5B-9282-D72760A66916),
    scriptable
]
interface IKeyboard : nsISupports
{
    void putScancode (
        in long scancode
    );

    void putScancodes (
        [array, size_is(count)] in long scancodes,
        in unsigned long count,
        [retval] out unsigned long codesStored
    );

    void putCAD();

}; /* interface IKeyboard */

[
    uuid(FD443EC1-0006-4F5B-9282-D72760A66916),
    scriptable
]
interface IMouse : nsISupports
{
    readonly attribute boolean absoluteSupported;

    void putMouseEvent (
        in long dx,
        in long dy,
        in long dz,
        in long buttonState
    );

    void putMouseEventAbsolute (
        in long x,
        in long y,
        in long dz,
        in long buttonState
    );

}; /* interface IMouse */

[
    uuid(af431304-5b09-40e2-94da-3c3cb03822c1),
    scriptable
]
interface IFramebuffer : nsISupports
{
    [noscript]
    readonly attribute octetPtr address;

    readonly attribute unsigned long width;

    readonly attribute unsigned long height;

    readonly attribute unsigned long bitsPerPixel;

    readonly attribute unsigned long bytesPerLine;

    readonly attribute unsigned long pixelFormat;

    readonly attribute boolean usesGuestVRAM;

    readonly attribute unsigned long heightReduction;

    readonly attribute IFramebufferOverlay overlay;

    void lock();

    void unlock();

    void notifyUpdate (
        in unsigned long x,
        in unsigned long y,
        in unsigned long width,
        in unsigned long height,
        [retval] out boolean finished
    );

    [noscript]
    void requestResize (
        in unsigned long screenId,
        in unsigned long pixelFormat,
        in octetPtr VRAM,
        in unsigned long bitsPerPixel,
        in unsigned long bytesPerLine,
        in unsigned long width,
        in unsigned long height,
        [retval] out boolean finished
    );

    void operationSupported (
        in PRUint32 operation,
        [retval] out boolean supported
    );

    void videoModeSupported (
        in unsigned long width,
        in unsigned long height,
        in unsigned long bpp,
        [retval] out boolean supported
    );

    void solidFill (
        in unsigned long x,
        in unsigned long y,
        in unsigned long width,
        in unsigned long height,
        in unsigned long color,
        [retval] out boolean handled
    );

    void copyScreenBits (
        in unsigned long xDst,
        in unsigned long yDst,
        in unsigned long xSrc,
        in unsigned long ySrc,
        in unsigned long width,
        in unsigned long height,
        [retval] out boolean handled
    );

    [noscript]
    void getVisibleRegion (
        in octetPtr rectangles,
        in unsigned long count,
        [retval] out unsigned long countCopied
    );

    [noscript]
    void setVisibleRegion (
        in octetPtr rectangles,
        in unsigned long count
    );

}; /* interface IFramebuffer */

[
    uuid(0bcc1c7e-e415-47d2-bfdb-e4c705fb0f47),
    scriptable
]
interface IFramebufferOverlay : IFrameBuffer
{
    readonly attribute unsigned long x;

    readonly attribute unsigned long y;

    attribute boolean visible;

    attribute unsigned long alpha;

    void move (
        in unsigned long x,
        in unsigned long y
    );

}; /* interface IFramebufferOverlay */

[
    uuid(09789f63-4525-48e5-a5e4-1080453b0eab),
    scriptable
]
interface IDisplay : nsISupports
{
    readonly attribute unsigned long width;

    readonly attribute unsigned long height;

    readonly attribute unsigned long bitsPerPixel;

    void setupInternalFramebuffer (
        in unsigned long depth
    );

    [noscript]
    void lockFramebuffer (
        [retval] out octetPtr address
    );

    void unlockFramebuffer();

    void registerExternalFramebuffer (
        in IFramebuffer framebuffer
    );

    void setFramebuffer (
        in unsigned long screenId,
        in IFramebuffer framebuffer
    );

    void getFramebuffer (
        in unsigned long screenId,
        out IFramebuffer framebuffer,
        out long xOrigin,
        out long yOrigin
    );

    void setVideoModeHint (
        in unsigned long width,
        in unsigned long height,
        in unsigned long bitsPerPixel,
        in unsigned long display
    );

    void setSeamlessMode (
        in boolean enabled
    );

    [noscript]
    void takeScreenShot (
        in octetPtr address,
        in unsigned long width,
        in unsigned long height
    );

    [noscript]
    void drawToScreen (
        in octetPtr address,
        in unsigned long x,
        in unsigned long y,
        in unsigned long width,
        in unsigned long height
    );

    void invalidateAndUpdate();

    void resizeCompleted (
        in unsigned long screenId
    );

    void updateCompleted();

}; /* interface IDisplay */

[
    uuid(a876d9b1-68d9-43b1-9c68-ddea0a473663),
    scriptable
]
interface INetworkAdapter : nsISupports
{
    attribute PRUint32 adapterType;

    readonly attribute unsigned long slot;

    attribute boolean enabled;

    attribute wstring MACAddress;

    readonly attribute PRUint32 attachmentType;

    attribute wstring hostInterface;

    attribute wstring internalNetwork;

    attribute wstring NATNetwork;

    attribute boolean cableConnected;

    attribute unsigned long lineSpeed;

    attribute boolean traceEnabled;

    attribute wstring traceFile;

    void attachToNAT();

    void attachToHostInterface();

    void attachToInternalNetwork();

    void detach();

    attribute long TAPFileDescriptor;

    attribute wstring TAPBridge;

    attribute wstring TAPSetupApplication;

    attribute wstring TAPTerminateApplication;

}; /* interface INetworkAdapter */

[
    uuid(937f6970-5103-4745-b78e-d28dcf1479a8),
    scriptable
]
interface ISerialPort : nsISupports
{
    readonly attribute unsigned long slot;

    attribute boolean enabled;

    attribute unsigned long IOBase;

    attribute unsigned long IRQ;

    attribute PRUint32 hostMode;

    attribute boolean server;

    attribute wstring path;

}; /* interface ISerialPort */

[
    uuid(0c925f06-dd10-4b77-8de8-294d738c3214),
    scriptable
]
interface IParallelPort : nsISupports
{
    readonly attribute unsigned long slot;

    attribute boolean enabled;

    attribute unsigned long IOBase;

    attribute unsigned long IRQ;

    attribute wstring path;

}; /* interface IParallelPort */

[
    uuid(b3a02721-556a-4481-9d47-052a3f8cff90),
    scriptable
]
interface IMachineDebugger : nsISupports
{
    attribute boolean singlestep;

    attribute boolean recompileUser;

    attribute boolean recompileSupervisor;

    attribute boolean PATMEnabled;

    attribute boolean CSAMEnabled;

    attribute boolean logEnabled;

    readonly attribute boolean HWVirtExEnabled;

    readonly attribute boolean PAEEnabled;

    attribute unsigned long virtualTimeRate;

    readonly attribute unsigned long long VM;

    void resetStats (
        in wstring pattern
    );

    void dumpStats (
        in wstring pattern
    );

    void getStats (
        in wstring pattern,
        in boolean withDescriptions,
        out wstring stats
    );

}; /* interface IMachineDebugger */

[
    uuid(f4c2d3dc-f109-4da7-93b1-ec28973ac89f),
    scriptable
]
interface IUSBController : nsISupports
{
    attribute boolean enabled;

    attribute boolean enabledEhci;

    readonly attribute unsigned short USBStandard;

    readonly attribute IUSBDeviceFilterCollection deviceFilters;

    void createDeviceFilter (
        in wstring name,
        [retval] out IUSBDeviceFilter filter
    );

    void insertDeviceFilter (
        in unsigned long position,
        in IUSBDeviceFilter filter
    );

    void removeDeviceFilter (
        in unsigned long position,
        [retval] out IUSBDeviceFilter filter
    );

}; /* interface IUSBController */

[
    uuid(aefe00f7-eb8a-454b-9ea4-fd5ad93c0e99),
    scriptable
]
interface IUSBDeviceEnumerator : nsISupports
{
    void hasMore ([retval] out boolean more);

    void getNext ([retval] out IUSBDevice next);

}; /* interface IUSBDeviceEnumerator */

[
    uuid(e31f3248-90dd-4ca2-95f0-6b36042d96a2),
    scriptable
]
interface IUSBDeviceCollection : nsISupports
{
    readonly attribute unsigned long count;

    void getItemAt (in unsigned long index, [retval] out IUSBDevice item);

    void enumerate ([retval] out IUSBDeviceEnumerator enumerator);

    void findById (
        in nsIDRef id,
        [retval] out IUSBDevice device
    );

    void findByAddress (
        in wstring name,
        [retval] out IUSBDevice device
    );

}; /* interface IUSBDeviceCollection */

[
    uuid(850af07b-9ee8-48c2-b6b0-f6d0acbf63c3),
    scriptable
]
interface IUSBDevice : nsISupports
{
    readonly attribute nsIDPtr id;

    readonly attribute unsigned short vendorId;

    readonly attribute unsigned short productId;

    readonly attribute unsigned short revision;

    readonly attribute wstring manufacturer;

    readonly attribute wstring product;

    readonly attribute wstring serialNumber;

    readonly attribute wstring address;

    readonly attribute unsigned short port;

    readonly attribute unsigned short version;

    readonly attribute unsigned short portVersion;

    readonly attribute boolean remote;

}; /* interface IUSBDevice */

[
    uuid(d5109c61-93e7-4726-926b-0dee1020da56),
    scriptable
]
interface IUSBDeviceFilterEnumerator : nsISupports
{
    void hasMore ([retval] out boolean more);

    void getNext ([retval] out IUSBDeviceFilter next);

}; /* interface IUSBDeviceFilterEnumerator */

[
    uuid(4fa3fc99-ceb1-4bf5-a9cb-e962d825c1ef),
    scriptable
]
interface IUSBDeviceFilterCollection : nsISupports
{
    readonly attribute unsigned long count;

    void getItemAt (in unsigned long index, [retval] out IUSBDeviceFilter item);

    void enumerate ([retval] out IUSBDeviceFilterEnumerator enumerator);

}; /* interface IUSBDeviceFilterCollection */

[
    uuid(d6831fb4-1a94-4c2c-96ef-8d0d6192066d),
    scriptable
]
interface IUSBDeviceFilter : nsISupports
{
    attribute wstring name;

    attribute boolean active;

    attribute wstring vendorId;

    attribute wstring productId;

    attribute wstring revision;

    attribute wstring manufacturer;

    attribute wstring product;

    attribute wstring serialNumber;

    attribute wstring port;

    attribute wstring remote;

    attribute unsigned long maskedInterfaces;

}; /* interface IUSBDeviceFilter */

[
    uuid(a0c55136-939f-4d20-b9d3-4d406f08bfa5),
    scriptable
]
interface IHostUSBDeviceEnumerator : nsISupports
{
    void hasMore ([retval] out boolean more);

    void getNext ([retval] out IHostUSBDevice next);

}; /* interface IHostUSBDeviceEnumerator */

[
    uuid(f9d3f96d-b027-4994-b589-70bb9ee0d364),
    scriptable
]
interface IHostUSBDeviceCollection : nsISupports
{
    readonly attribute unsigned long count;

    void getItemAt (in unsigned long index, [retval] out IHostUSBDevice item);

    void enumerate ([retval] out IHostUSBDeviceEnumerator enumerator);

    void findById (
        in nsIDRef id,
        [retval] out IHostUSBDevice device
    );

    void findByAddress (
        in wstring name,
        [retval] out IHostUSBDevice device
    );

}; /* interface IHostUSBDeviceCollection */

[
    uuid(173b4b44-d268-4334-a00d-b6521c9a740a),
    scriptable
]
interface IHostUSBDevice : IUSBDevice
{
    readonly attribute PRUint32 state;

}; /* interface IHostUSBDevice */

[
    uuid(ff735211-903e-4642-9c37-189eb44579fe),
    scriptable
]
interface IHostUSBDeviceFilterEnumerator : nsISupports
{
    void hasMore ([retval] out boolean more);

    void getNext ([retval] out IHostUSBDeviceFilter next);

}; /* interface IHostUSBDeviceFilterEnumerator */

[
    uuid(1a80458b-87f1-4a74-995d-04e2330119e0),
    scriptable
]
interface IHostUSBDeviceFilterCollection : nsISupports
{
    readonly attribute unsigned long count;

    void getItemAt (in unsigned long index, [retval] out IHostUSBDeviceFilter item);

    void enumerate ([retval] out IHostUSBDeviceFilterEnumerator enumerator);

}; /* interface IHostUSBDeviceFilterCollection */

[
    uuid(4cc70246-d74a-400f-8222-3900489c0374),
    scriptable
]
interface IHostUSBDeviceFilter : IUSBDeviceFilter
{
    attribute PRUint32 action;

}; /* interface IHostUSBDeviceFilter */

[
    uuid(921873db-5f3f-4b69-91f9-7be9e535a2cb),
    scriptable
]
interface IAudioAdapter : nsISupports
{
    attribute boolean enabled;

    attribute PRUint32 audioController;

    attribute PRUint32 audioDriver;

}; /* interface IAudioAdapter */

[
    uuid(ed9d31ae-867f-45fc-b727-6740084d1883),
    scriptable
]
interface IVRDPServer : nsISupports
{
    attribute boolean enabled;

    attribute unsigned long port;

    attribute wstring netAddress;

    attribute PRUint32 authType;

    attribute unsigned long authTimeout;

    attribute boolean allowMultiConnection;

}; /* interface IVRDPServer */

[
    uuid(1d420fd8-e7c1-4511-abf4-a504dc6d0cbf),
    scriptable
]
interface ISharedFolderEnumerator : nsISupports
{
    void hasMore ([retval] out boolean more);

    void getNext ([retval] out ISharedFolder next);

}; /* interface ISharedFolderEnumerator */

[
    uuid(9c7e2282-bb16-4fa7-9138-f383c5e02353),
    scriptable
]
interface ISharedFolderCollection : nsISupports
{
    readonly attribute unsigned long count;

    void getItemAt (in unsigned long index, [retval] out ISharedFolder item);

    void enumerate ([retval] out ISharedFolderEnumerator enumerator);

    void findByName (
        in wstring name,
        [retval] out ISharedFolder sharedFolder
    );

}; /* interface ISharedFolderCollection */

[
    uuid(8b0c5f70-9139-4f97-a421-64d5e9c335d5),
    scriptable
]
interface ISharedFolder : nsISupports
{
    readonly attribute wstring name;

    readonly attribute wstring hostPath;

    readonly attribute boolean accessible;

    readonly attribute boolean writable;

}; /* interface ISharedFolder */

[
    uuid(37838967-2430-4bb1-8acc-1b5b2c383d44),
    scriptable
]
interface IInternalSessionControl : nsISupports
{
    void getPID (
        [retval] out unsigned long pid
    );

    void getRemoteConsole (
        [retval] out IConsole console
    );

    void assignMachine (
        in IMachine machine
    );

    void assignRemoteMachine (
        in IMachine machine,
        in IConsole console
    );

    void updateMachineState (
        in PRUint32 aMachineState
    );

    void uninitialize();

    void onDVDDriveChange();

    void onFloppyDriveChange();

    void onNetworkAdapterChange (
        in INetworkAdapter networkAdapter
    );

    void onSerialPortChange (
        in ISerialPort serialPort
    );

    void onParallelPortChange (
        in IParallelPort parallelPort
    );

    void onVRDPServerChange();

    void onUSBControllerChange();

    void onSharedFolderChange (
        in boolean global
    );

    void onUSBDeviceAttach (
        in IUSBDevice device,
        in IVirtualBoxErrorInfo error,
        in unsigned long maskedInterfaces
    );

    void onUSBDeviceDetach (
        in nsIDRef id,
        in IVirtualBoxErrorInfo error
    );

    void onShowWindow (
        in boolean check,
        out boolean canShow,
        out unsigned long long winId
    );

}; /* interface IInternalSessionControl */

[
    uuid(12F4DCDB-12B2-4ec1-B7CD-DDD9F6C5BF4D),
    scriptable
]
interface ISession : nsISupports
{
    readonly attribute PRUint32 state;

    readonly attribute PRUint32 type;

    readonly attribute IMachine machine;

    readonly attribute IConsole console;

    void close();

}; /* interface ISession */

[
    uuid(9a4b868b-1376-4533-8ef5-065b8e8cedff),
    scriptable
]
interface ISATAController : nsISupports
{
    attribute boolean enabled;

    attribute unsigned long portCount;

    void GetIDEEmulationPort (
        in long devicePosition,
        [retval] out long portNumber
    );

    void SetIDEEmulationPort (
        in long devicePosition,
        in long portNumber
    );

}; /* interface ISATAController */

%{C++
#define NS_VIRTUALBOX_CID { \
    0xB1A7A4F2, 0x47B9, 0x4A1E, \
    { 0x82, 0xB2, 0x07, 0xCC, 0xD5, 0x32, 0x3C, 0x3F } \
}
#define NS_VIRTUALBOX_CONTRACTID "@virtualbox.org/VirtualBox;1"
// for compatibility with Win32
#define CLSID_VirtualBox (nsCID) NS_VIRTUALBOX_CID
%}

%{C++
#define NS_SESSION_CID { \
    0x3C02F46D, 0xC9D2, 0x4f11, \
    { 0xA3, 0x84, 0x53, 0xF0, 0xCF, 0x91, 0x72, 0x14 } \
}
#define NS_SESSION_CONTRACTID "@virtualbox.org/Session;1"
// for compatibility with Win32
#define CLSID_Session (nsCID) NS_SESSION_CID
%}

