

// ##### BEGINFILE "NATNetworkWrap.h"
/** @file
 * VirtualBox API class wrapper header for INATNetwork.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef NATNetworkWrap_H_
#define NATNetworkWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE NATNetworkWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(INATNetwork)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(NATNetworkWrap, INATNetwork)
    DECLARE_NOT_AGGREGATABLE(NATNetworkWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(NATNetworkWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(INATNetwork)
        COM_INTERFACE_ENTRY2(IDispatch, INATNetwork)
        VBOX_TWEAK_INTERFACE_ENTRY(INATNetwork)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(NATNetworkWrap)

    /** @name Public INATNetwork properties
     * @{ */
    STDMETHOD(COMGETTER(NetworkName))(BSTR *aNetworkName);
    STDMETHOD(COMSETTER(NetworkName))(IN_BSTR aNetworkName);
    STDMETHOD(COMGETTER(Enabled))(BOOL *aEnabled);
    STDMETHOD(COMSETTER(Enabled))(BOOL aEnabled);
    STDMETHOD(COMGETTER(Network))(BSTR *aNetwork);
    STDMETHOD(COMSETTER(Network))(IN_BSTR aNetwork);
    STDMETHOD(COMGETTER(Gateway))(BSTR *aGateway);
    STDMETHOD(COMGETTER(IPv6Enabled))(BOOL *aIPv6Enabled);
    STDMETHOD(COMSETTER(IPv6Enabled))(BOOL aIPv6Enabled);
    STDMETHOD(COMGETTER(IPv6Prefix))(BSTR *aIPv6Prefix);
    STDMETHOD(COMSETTER(IPv6Prefix))(IN_BSTR aIPv6Prefix);
    STDMETHOD(COMGETTER(AdvertiseDefaultIPv6RouteEnabled))(BOOL *aAdvertiseDefaultIPv6RouteEnabled);
    STDMETHOD(COMSETTER(AdvertiseDefaultIPv6RouteEnabled))(BOOL aAdvertiseDefaultIPv6RouteEnabled);
    STDMETHOD(COMGETTER(NeedDhcpServer))(BOOL *aNeedDhcpServer);
    STDMETHOD(COMSETTER(NeedDhcpServer))(BOOL aNeedDhcpServer);
    STDMETHOD(COMGETTER(EventSource))(IEventSource **aEventSource);
    STDMETHOD(COMGETTER(PortForwardRules4))(ComSafeArrayOut(BSTR, aPortForwardRules4));
    STDMETHOD(COMGETTER(LocalMappings))(ComSafeArrayOut(BSTR, aLocalMappings));
    STDMETHOD(COMGETTER(LoopbackIp6))(LONG *aLoopbackIp6);
    STDMETHOD(COMSETTER(LoopbackIp6))(LONG aLoopbackIp6);
    STDMETHOD(COMGETTER(PortForwardRules6))(ComSafeArrayOut(BSTR, aPortForwardRules6));
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1INATNetwork))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2INATNetwork))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3INATNetwork))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4INATNetwork))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5INATNetwork))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6INATNetwork))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7INATNetwork))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8INATNetwork))(ULONG *aReserved);
    /** @} */

    /** @name Public INATNetwork methods
     * @{ */
    STDMETHOD(AddLocalMapping)(IN_BSTR aHostid,
                               LONG aOffset);
    STDMETHOD(AddPortForwardRule)(BOOL aIsIpv6,
                                  IN_BSTR aRuleName,
                                  NATProtocol_T aProto,
                                  IN_BSTR aHostIP,
                                  USHORT aHostPort,
                                  IN_BSTR aGuestIP,
                                  USHORT aGuestPort);
    STDMETHOD(RemovePortForwardRule)(BOOL aISipv6,
                                     IN_BSTR aRuleName);
    STDMETHOD(Start)();
    STDMETHOD(Stop)();
    STDMETHOD(InternalAndReservedMethod1INATNetwork)();
    STDMETHOD(InternalAndReservedMethod2INATNetwork)();
    /** @} */

private:
    /** @name Wrapped INATNetwork properties
     * @{ */
    virtual HRESULT getNetworkName(com::Utf8Str &aNetworkName) = 0;
    virtual HRESULT setNetworkName(const com::Utf8Str &aNetworkName) = 0;
    virtual HRESULT getEnabled(BOOL *aEnabled) = 0;
    virtual HRESULT setEnabled(BOOL aEnabled) = 0;
    virtual HRESULT getNetwork(com::Utf8Str &aNetwork) = 0;
    virtual HRESULT setNetwork(const com::Utf8Str &aNetwork) = 0;
    virtual HRESULT getGateway(com::Utf8Str &aGateway) = 0;
    virtual HRESULT getIPv6Enabled(BOOL *aIPv6Enabled) = 0;
    virtual HRESULT setIPv6Enabled(BOOL aIPv6Enabled) = 0;
    virtual HRESULT getIPv6Prefix(com::Utf8Str &aIPv6Prefix) = 0;
    virtual HRESULT setIPv6Prefix(const com::Utf8Str &aIPv6Prefix) = 0;
    virtual HRESULT getAdvertiseDefaultIPv6RouteEnabled(BOOL *aAdvertiseDefaultIPv6RouteEnabled) = 0;
    virtual HRESULT setAdvertiseDefaultIPv6RouteEnabled(BOOL aAdvertiseDefaultIPv6RouteEnabled) = 0;
    virtual HRESULT getNeedDhcpServer(BOOL *aNeedDhcpServer) = 0;
    virtual HRESULT setNeedDhcpServer(BOOL aNeedDhcpServer) = 0;
    virtual HRESULT getEventSource(ComPtr<IEventSource> &aEventSource) = 0;
    virtual HRESULT getPortForwardRules4(std::vector<com::Utf8Str> &aPortForwardRules4) = 0;
    virtual HRESULT getLocalMappings(std::vector<com::Utf8Str> &aLocalMappings) = 0;
    virtual HRESULT getLoopbackIp6(LONG *aLoopbackIp6) = 0;
    virtual HRESULT setLoopbackIp6(LONG aLoopbackIp6) = 0;
    virtual HRESULT getPortForwardRules6(std::vector<com::Utf8Str> &aPortForwardRules6) = 0;
    /** @} */

    /** @name Wrapped INATNetwork methods
     * @{ */
    virtual HRESULT addLocalMapping(const com::Utf8Str &aHostid,
                                    LONG aOffset) = 0;
    virtual HRESULT addPortForwardRule(BOOL aIsIpv6,
                                       const com::Utf8Str &aRuleName,
                                       NATProtocol_T aProto,
                                       const com::Utf8Str &aHostIP,
                                       USHORT aHostPort,
                                       const com::Utf8Str &aGuestIP,
                                       USHORT aGuestPort) = 0;
    virtual HRESULT removePortForwardRule(BOOL aISipv6,
                                          const com::Utf8Str &aRuleName) = 0;
    virtual HRESULT start() = 0;
    virtual HRESULT stop() = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(NATNetworkWrap); /* Shuts up MSC warning C4625. */

};

#endif // !NATNetworkWrap_H_

// ##### ENDFILE "NATNetworkWrap.h"


// ##### BEGINFILE "CloudNetworkWrap.h"
/** @file
 * VirtualBox API class wrapper header for ICloudNetwork.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef CloudNetworkWrap_H_
#define CloudNetworkWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE CloudNetworkWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(ICloudNetwork)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(CloudNetworkWrap, ICloudNetwork)
    DECLARE_NOT_AGGREGATABLE(CloudNetworkWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(CloudNetworkWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(ICloudNetwork)
        COM_INTERFACE_ENTRY2(IDispatch, ICloudNetwork)
        VBOX_TWEAK_INTERFACE_ENTRY(ICloudNetwork)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(CloudNetworkWrap)

    /** @name Public ICloudNetwork properties
     * @{ */
    STDMETHOD(COMGETTER(NetworkName))(BSTR *aNetworkName);
    STDMETHOD(COMSETTER(NetworkName))(IN_BSTR aNetworkName);
    STDMETHOD(COMGETTER(Enabled))(BOOL *aEnabled);
    STDMETHOD(COMSETTER(Enabled))(BOOL aEnabled);
    STDMETHOD(COMGETTER(Provider))(BSTR *aProvider);
    STDMETHOD(COMSETTER(Provider))(IN_BSTR aProvider);
    STDMETHOD(COMGETTER(Profile))(BSTR *aProfile);
    STDMETHOD(COMSETTER(Profile))(IN_BSTR aProfile);
    STDMETHOD(COMGETTER(NetworkId))(BSTR *aNetworkId);
    STDMETHOD(COMSETTER(NetworkId))(IN_BSTR aNetworkId);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1ICloudNetwork))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2ICloudNetwork))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3ICloudNetwork))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4ICloudNetwork))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5ICloudNetwork))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6ICloudNetwork))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7ICloudNetwork))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8ICloudNetwork))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute9ICloudNetwork))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute10ICloudNetwork))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute11ICloudNetwork))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute12ICloudNetwork))(ULONG *aReserved);
    /** @} */

    /** @name Public ICloudNetwork methods
     * @{ */
    STDMETHOD(InternalAndReservedMethod1ICloudNetwork)();
    STDMETHOD(InternalAndReservedMethod2ICloudNetwork)();
    STDMETHOD(InternalAndReservedMethod3ICloudNetwork)();
    STDMETHOD(InternalAndReservedMethod4ICloudNetwork)();
    /** @} */

private:
    /** @name Wrapped ICloudNetwork properties
     * @{ */
    virtual HRESULT getNetworkName(com::Utf8Str &aNetworkName) = 0;
    virtual HRESULT setNetworkName(const com::Utf8Str &aNetworkName) = 0;
    virtual HRESULT getEnabled(BOOL *aEnabled) = 0;
    virtual HRESULT setEnabled(BOOL aEnabled) = 0;
    virtual HRESULT getProvider(com::Utf8Str &aProvider) = 0;
    virtual HRESULT setProvider(const com::Utf8Str &aProvider) = 0;
    virtual HRESULT getProfile(com::Utf8Str &aProfile) = 0;
    virtual HRESULT setProfile(const com::Utf8Str &aProfile) = 0;
    virtual HRESULT getNetworkId(com::Utf8Str &aNetworkId) = 0;
    virtual HRESULT setNetworkId(const com::Utf8Str &aNetworkId) = 0;
    /** @} */

    /** @name Wrapped ICloudNetwork methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(CloudNetworkWrap); /* Shuts up MSC warning C4625. */

};

#endif // !CloudNetworkWrap_H_

// ##### ENDFILE "CloudNetworkWrap.h"


// ##### BEGINFILE "DHCPServerWrap.h"
/** @file
 * VirtualBox API class wrapper header for IDHCPServer.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef DHCPServerWrap_H_
#define DHCPServerWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE DHCPServerWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IDHCPServer)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(DHCPServerWrap, IDHCPServer)
    DECLARE_NOT_AGGREGATABLE(DHCPServerWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(DHCPServerWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IDHCPServer)
        COM_INTERFACE_ENTRY2(IDispatch, IDHCPServer)
        VBOX_TWEAK_INTERFACE_ENTRY(IDHCPServer)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(DHCPServerWrap)

    /** @name Public IDHCPServer properties
     * @{ */
    STDMETHOD(COMGETTER(EventSource))(IEventSource **aEventSource);
    STDMETHOD(COMGETTER(Enabled))(BOOL *aEnabled);
    STDMETHOD(COMSETTER(Enabled))(BOOL aEnabled);
    STDMETHOD(COMGETTER(IPAddress))(BSTR *aIPAddress);
    STDMETHOD(COMGETTER(NetworkMask))(BSTR *aNetworkMask);
    STDMETHOD(COMGETTER(NetworkName))(BSTR *aNetworkName);
    STDMETHOD(COMGETTER(LowerIP))(BSTR *aLowerIP);
    STDMETHOD(COMGETTER(UpperIP))(BSTR *aUpperIP);
    STDMETHOD(COMGETTER(GlobalConfig))(IDHCPGlobalConfig **aGlobalConfig);
    STDMETHOD(COMGETTER(GroupConfigs))(ComSafeArrayOut(IDHCPGroupConfig *, aGroupConfigs));
    STDMETHOD(COMGETTER(IndividualConfigs))(ComSafeArrayOut(IDHCPIndividualConfig *, aIndividualConfigs));
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IDHCPServer))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IDHCPServer))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IDHCPServer))(ULONG *aReserved);
    /** @} */

    /** @name Public IDHCPServer methods
     * @{ */
    STDMETHOD(SetConfiguration)(IN_BSTR aIPAddress,
                                IN_BSTR aNetworkMask,
                                IN_BSTR aFromIPAddress,
                                IN_BSTR aToIPAddress);
    STDMETHOD(Start)(IN_BSTR aTrunkName,
                     IN_BSTR aTrunkType);
    STDMETHOD(Stop)();
    STDMETHOD(Restart)();
    STDMETHOD(FindLeaseByMAC)(IN_BSTR aMac,
                              LONG aType,
                              BSTR *aAddress,
                              BSTR *aState,
                              LONG64 *aIssued,
                              LONG64 *aExpire);
    STDMETHOD(GetConfig)(DHCPConfigScope_T aScope,
                         IN_BSTR aName,
                         ULONG aSlot,
                         BOOL aMayAdd,
                         IDHCPConfig **aConfig);
    /** @} */

private:
    /** @name Wrapped IDHCPServer properties
     * @{ */
    virtual HRESULT getEventSource(ComPtr<IEventSource> &aEventSource) = 0;
    virtual HRESULT getEnabled(BOOL *aEnabled) = 0;
    virtual HRESULT setEnabled(BOOL aEnabled) = 0;
    virtual HRESULT getIPAddress(com::Utf8Str &aIPAddress) = 0;
    virtual HRESULT getNetworkMask(com::Utf8Str &aNetworkMask) = 0;
    virtual HRESULT getNetworkName(com::Utf8Str &aNetworkName) = 0;
    virtual HRESULT getLowerIP(com::Utf8Str &aLowerIP) = 0;
    virtual HRESULT getUpperIP(com::Utf8Str &aUpperIP) = 0;
    virtual HRESULT getGlobalConfig(ComPtr<IDHCPGlobalConfig> &aGlobalConfig) = 0;
    virtual HRESULT getGroupConfigs(std::vector<ComPtr<IDHCPGroupConfig> > &aGroupConfigs) = 0;
    virtual HRESULT getIndividualConfigs(std::vector<ComPtr<IDHCPIndividualConfig> > &aIndividualConfigs) = 0;
    /** @} */

    /** @name Wrapped IDHCPServer methods
     * @{ */
    virtual HRESULT setConfiguration(const com::Utf8Str &aIPAddress,
                                     const com::Utf8Str &aNetworkMask,
                                     const com::Utf8Str &aFromIPAddress,
                                     const com::Utf8Str &aToIPAddress) = 0;
    virtual HRESULT start(const com::Utf8Str &aTrunkName,
                          const com::Utf8Str &aTrunkType) = 0;
    virtual HRESULT stop() = 0;
    virtual HRESULT restart() = 0;
    virtual HRESULT findLeaseByMAC(const com::Utf8Str &aMac,
                                   LONG aType,
                                   com::Utf8Str &aAddress,
                                   com::Utf8Str &aState,
                                   LONG64 *aIssued,
                                   LONG64 *aExpire) = 0;
    virtual HRESULT getConfig(DHCPConfigScope_T aScope,
                              const com::Utf8Str &aName,
                              ULONG aSlot,
                              BOOL aMayAdd,
                              ComPtr<IDHCPConfig> &aConfig) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(DHCPServerWrap); /* Shuts up MSC warning C4625. */

};

#endif // !DHCPServerWrap_H_

// ##### ENDFILE "DHCPServerWrap.h"


// ##### BEGINFILE "DHCPConfigWrap.h"
/** @file
 * VirtualBox API class wrapper header for IDHCPConfig.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef DHCPConfigWrap_H_
#define DHCPConfigWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE DHCPConfigWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IDHCPConfig)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(DHCPConfigWrap, IDHCPConfig)
    DECLARE_NOT_AGGREGATABLE(DHCPConfigWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(DHCPConfigWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IDHCPConfig)
        COM_INTERFACE_ENTRY2(IDispatch, IDHCPConfig)
        VBOX_TWEAK_INTERFACE_ENTRY(IDHCPConfig)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(DHCPConfigWrap)

    /** @name Public IDHCPConfig properties
     * @{ */
    STDMETHOD(COMGETTER(Scope))(DHCPConfigScope_T *aScope);
    STDMETHOD(COMGETTER(MinLeaseTime))(ULONG *aMinLeaseTime);
    STDMETHOD(COMSETTER(MinLeaseTime))(ULONG aMinLeaseTime);
    STDMETHOD(COMGETTER(DefaultLeaseTime))(ULONG *aDefaultLeaseTime);
    STDMETHOD(COMSETTER(DefaultLeaseTime))(ULONG aDefaultLeaseTime);
    STDMETHOD(COMGETTER(MaxLeaseTime))(ULONG *aMaxLeaseTime);
    STDMETHOD(COMSETTER(MaxLeaseTime))(ULONG aMaxLeaseTime);
    STDMETHOD(COMGETTER(ForcedOptions))(ComSafeArrayOut(DHCPOption_T, aForcedOptions));
    STDMETHOD(COMSETTER(ForcedOptions))(ComSafeArrayIn(DHCPOption_T, aForcedOptions));
    STDMETHOD(COMGETTER(SuppressedOptions))(ComSafeArrayOut(DHCPOption_T, aSuppressedOptions));
    STDMETHOD(COMSETTER(SuppressedOptions))(ComSafeArrayIn(DHCPOption_T, aSuppressedOptions));
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute9IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute10IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute11IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute12IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute13IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute14IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute15IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute16IDHCPConfig))(ULONG *aReserved);
    /** @} */

    /** @name Public IDHCPConfig methods
     * @{ */
    STDMETHOD(SetOption)(DHCPOption_T aOption,
                         DHCPOptionEncoding_T aEncoding,
                         IN_BSTR aValue);
    STDMETHOD(RemoveOption)(DHCPOption_T aOption);
    STDMETHOD(RemoveAllOptions)();
    STDMETHOD(GetOption)(DHCPOption_T aOption,
                         DHCPOptionEncoding_T *aEncoding,
                         BSTR *aValue);
    STDMETHOD(GetAllOptions)(ComSafeArrayOut(DHCPOption_T, aOptions),
                             ComSafeArrayOut(DHCPOptionEncoding_T, aEncodings),
                             ComSafeArrayOut(BSTR, aValues));
    STDMETHOD(Remove)();
    STDMETHOD(InternalAndReservedMethod1IDHCPConfig)();
    STDMETHOD(InternalAndReservedMethod2IDHCPConfig)();
    STDMETHOD(InternalAndReservedMethod3IDHCPConfig)();
    STDMETHOD(InternalAndReservedMethod4IDHCPConfig)();
    STDMETHOD(InternalAndReservedMethod5IDHCPConfig)();
    STDMETHOD(InternalAndReservedMethod6IDHCPConfig)();
    STDMETHOD(InternalAndReservedMethod7IDHCPConfig)();
    STDMETHOD(InternalAndReservedMethod8IDHCPConfig)();
    /** @} */

private:
    /** @name Wrapped IDHCPConfig properties
     * @{ */
    virtual HRESULT getScope(DHCPConfigScope_T *aScope) = 0;
    virtual HRESULT getMinLeaseTime(ULONG *aMinLeaseTime) = 0;
    virtual HRESULT setMinLeaseTime(ULONG aMinLeaseTime) = 0;
    virtual HRESULT getDefaultLeaseTime(ULONG *aDefaultLeaseTime) = 0;
    virtual HRESULT setDefaultLeaseTime(ULONG aDefaultLeaseTime) = 0;
    virtual HRESULT getMaxLeaseTime(ULONG *aMaxLeaseTime) = 0;
    virtual HRESULT setMaxLeaseTime(ULONG aMaxLeaseTime) = 0;
    virtual HRESULT getForcedOptions(std::vector<DHCPOption_T> &aForcedOptions) = 0;
    virtual HRESULT setForcedOptions(const std::vector<DHCPOption_T> &aForcedOptions) = 0;
    virtual HRESULT getSuppressedOptions(std::vector<DHCPOption_T> &aSuppressedOptions) = 0;
    virtual HRESULT setSuppressedOptions(const std::vector<DHCPOption_T> &aSuppressedOptions) = 0;
    /** @} */

    /** @name Wrapped IDHCPConfig methods
     * @{ */
    virtual HRESULT setOption(DHCPOption_T aOption,
                              DHCPOptionEncoding_T aEncoding,
                              const com::Utf8Str &aValue) = 0;
    virtual HRESULT removeOption(DHCPOption_T aOption) = 0;
    virtual HRESULT removeAllOptions() = 0;
    virtual HRESULT getOption(DHCPOption_T aOption,
                              DHCPOptionEncoding_T *aEncoding,
                              com::Utf8Str &aValue) = 0;
    virtual HRESULT getAllOptions(std::vector<DHCPOption_T> &aOptions,
                                  std::vector<DHCPOptionEncoding_T> &aEncodings,
                                  std::vector<com::Utf8Str> &aValues) = 0;
    virtual HRESULT remove() = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(DHCPConfigWrap); /* Shuts up MSC warning C4625. */

};

#endif // !DHCPConfigWrap_H_

// ##### ENDFILE "DHCPConfigWrap.h"


// ##### BEGINFILE "DHCPGlobalConfigWrap.h"
/** @file
 * VirtualBox API class wrapper header for IDHCPGlobalConfig.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef DHCPGlobalConfigWrap_H_
#define DHCPGlobalConfigWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE DHCPGlobalConfigWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IDHCPGlobalConfig)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(DHCPGlobalConfigWrap, IDHCPGlobalConfig)
    DECLARE_NOT_AGGREGATABLE(DHCPGlobalConfigWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(DHCPGlobalConfigWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IDHCPGlobalConfig)
        COM_INTERFACE_ENTRY(IDHCPConfig)
        COM_INTERFACE_ENTRY2(IDispatch, IDHCPGlobalConfig)
        VBOX_TWEAK_INTERFACE_ENTRY(IDHCPGlobalConfig)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(DHCPGlobalConfigWrap)

    /** @name Public IDHCPConfig properties
     * @{ */
    STDMETHOD(COMGETTER(Scope))(DHCPConfigScope_T *aScope);
    STDMETHOD(COMGETTER(MinLeaseTime))(ULONG *aMinLeaseTime);
    STDMETHOD(COMSETTER(MinLeaseTime))(ULONG aMinLeaseTime);
    STDMETHOD(COMGETTER(DefaultLeaseTime))(ULONG *aDefaultLeaseTime);
    STDMETHOD(COMSETTER(DefaultLeaseTime))(ULONG aDefaultLeaseTime);
    STDMETHOD(COMGETTER(MaxLeaseTime))(ULONG *aMaxLeaseTime);
    STDMETHOD(COMSETTER(MaxLeaseTime))(ULONG aMaxLeaseTime);
    STDMETHOD(COMGETTER(ForcedOptions))(ComSafeArrayOut(DHCPOption_T, aForcedOptions));
    STDMETHOD(COMSETTER(ForcedOptions))(ComSafeArrayIn(DHCPOption_T, aForcedOptions));
    STDMETHOD(COMGETTER(SuppressedOptions))(ComSafeArrayOut(DHCPOption_T, aSuppressedOptions));
    STDMETHOD(COMSETTER(SuppressedOptions))(ComSafeArrayIn(DHCPOption_T, aSuppressedOptions));
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute9IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute10IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute11IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute12IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute13IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute14IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute15IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute16IDHCPConfig))(ULONG *aReserved);
    /** @} */

    /** @name Public IDHCPGlobalConfig properties
     * @{ */
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IDHCPGlobalConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IDHCPGlobalConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IDHCPGlobalConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IDHCPGlobalConfig))(ULONG *aReserved);
    /** @} */

    /** @name Public IDHCPConfig methods
     * @{ */
    STDMETHOD(SetOption)(DHCPOption_T aOption,
                         DHCPOptionEncoding_T aEncoding,
                         IN_BSTR aValue);
    STDMETHOD(RemoveOption)(DHCPOption_T aOption);
    STDMETHOD(RemoveAllOptions)();
    STDMETHOD(GetOption)(DHCPOption_T aOption,
                         DHCPOptionEncoding_T *aEncoding,
                         BSTR *aValue);
    STDMETHOD(GetAllOptions)(ComSafeArrayOut(DHCPOption_T, aOptions),
                             ComSafeArrayOut(DHCPOptionEncoding_T, aEncodings),
                             ComSafeArrayOut(BSTR, aValues));
    STDMETHOD(Remove)();
    STDMETHOD(InternalAndReservedMethod1IDHCPConfig)();
    STDMETHOD(InternalAndReservedMethod2IDHCPConfig)();
    STDMETHOD(InternalAndReservedMethod3IDHCPConfig)();
    STDMETHOD(InternalAndReservedMethod4IDHCPConfig)();
    STDMETHOD(InternalAndReservedMethod5IDHCPConfig)();
    STDMETHOD(InternalAndReservedMethod6IDHCPConfig)();
    STDMETHOD(InternalAndReservedMethod7IDHCPConfig)();
    STDMETHOD(InternalAndReservedMethod8IDHCPConfig)();
    /** @} */

    /** @name Public IDHCPGlobalConfig methods
     * @{ */
    STDMETHOD(InternalAndReservedMethod1IDHCPGlobalConfig)();
    STDMETHOD(InternalAndReservedMethod2IDHCPGlobalConfig)();
    STDMETHOD(InternalAndReservedMethod3IDHCPGlobalConfig)();
    STDMETHOD(InternalAndReservedMethod4IDHCPGlobalConfig)();
    /** @} */

private:
    /** @name Wrapped IDHCPConfig properties
     * @{ */
    virtual HRESULT getScope(DHCPConfigScope_T *aScope) = 0;
    virtual HRESULT getMinLeaseTime(ULONG *aMinLeaseTime) = 0;
    virtual HRESULT setMinLeaseTime(ULONG aMinLeaseTime) = 0;
    virtual HRESULT getDefaultLeaseTime(ULONG *aDefaultLeaseTime) = 0;
    virtual HRESULT setDefaultLeaseTime(ULONG aDefaultLeaseTime) = 0;
    virtual HRESULT getMaxLeaseTime(ULONG *aMaxLeaseTime) = 0;
    virtual HRESULT setMaxLeaseTime(ULONG aMaxLeaseTime) = 0;
    virtual HRESULT getForcedOptions(std::vector<DHCPOption_T> &aForcedOptions) = 0;
    virtual HRESULT setForcedOptions(const std::vector<DHCPOption_T> &aForcedOptions) = 0;
    virtual HRESULT getSuppressedOptions(std::vector<DHCPOption_T> &aSuppressedOptions) = 0;
    virtual HRESULT setSuppressedOptions(const std::vector<DHCPOption_T> &aSuppressedOptions) = 0;
    /** @} */

    /** @name Wrapped IDHCPGlobalConfig properties
     * @{ */
    /** @} */

    /** @name Wrapped IDHCPConfig methods
     * @{ */
    virtual HRESULT setOption(DHCPOption_T aOption,
                              DHCPOptionEncoding_T aEncoding,
                              const com::Utf8Str &aValue) = 0;
    virtual HRESULT removeOption(DHCPOption_T aOption) = 0;
    virtual HRESULT removeAllOptions() = 0;
    virtual HRESULT getOption(DHCPOption_T aOption,
                              DHCPOptionEncoding_T *aEncoding,
                              com::Utf8Str &aValue) = 0;
    virtual HRESULT getAllOptions(std::vector<DHCPOption_T> &aOptions,
                                  std::vector<DHCPOptionEncoding_T> &aEncodings,
                                  std::vector<com::Utf8Str> &aValues) = 0;
    virtual HRESULT remove() = 0;
    /** @} */

    /** @name Wrapped IDHCPGlobalConfig methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(DHCPGlobalConfigWrap); /* Shuts up MSC warning C4625. */

};

#endif // !DHCPGlobalConfigWrap_H_

// ##### ENDFILE "DHCPGlobalConfigWrap.h"


// ##### BEGINFILE "DHCPGroupConditionWrap.h"
/** @file
 * VirtualBox API class wrapper header for IDHCPGroupCondition.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef DHCPGroupConditionWrap_H_
#define DHCPGroupConditionWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE DHCPGroupConditionWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IDHCPGroupCondition)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(DHCPGroupConditionWrap, IDHCPGroupCondition)
    DECLARE_NOT_AGGREGATABLE(DHCPGroupConditionWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(DHCPGroupConditionWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IDHCPGroupCondition)
        COM_INTERFACE_ENTRY2(IDispatch, IDHCPGroupCondition)
        VBOX_TWEAK_INTERFACE_ENTRY(IDHCPGroupCondition)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(DHCPGroupConditionWrap)

    /** @name Public IDHCPGroupCondition properties
     * @{ */
    STDMETHOD(COMGETTER(Inclusive))(BOOL *aInclusive);
    STDMETHOD(COMSETTER(Inclusive))(BOOL aInclusive);
    STDMETHOD(COMGETTER(Type))(DHCPGroupConditionType_T *aType);
    STDMETHOD(COMSETTER(Type))(DHCPGroupConditionType_T aType);
    STDMETHOD(COMGETTER(Value))(BSTR *aValue);
    STDMETHOD(COMSETTER(Value))(IN_BSTR aValue);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IDHCPGroupCondition))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IDHCPGroupCondition))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IDHCPGroupCondition))(ULONG *aReserved);
    /** @} */

    /** @name Public IDHCPGroupCondition methods
     * @{ */
    STDMETHOD(Remove)();
    STDMETHOD(InternalAndReservedMethod1IDHCPGroupCondition)();
    STDMETHOD(InternalAndReservedMethod2IDHCPGroupCondition)();
    STDMETHOD(InternalAndReservedMethod3IDHCPGroupCondition)();
    /** @} */

private:
    /** @name Wrapped IDHCPGroupCondition properties
     * @{ */
    virtual HRESULT getInclusive(BOOL *aInclusive) = 0;
    virtual HRESULT setInclusive(BOOL aInclusive) = 0;
    virtual HRESULT getType(DHCPGroupConditionType_T *aType) = 0;
    virtual HRESULT setType(DHCPGroupConditionType_T aType) = 0;
    virtual HRESULT getValue(com::Utf8Str &aValue) = 0;
    virtual HRESULT setValue(const com::Utf8Str &aValue) = 0;
    /** @} */

    /** @name Wrapped IDHCPGroupCondition methods
     * @{ */
    virtual HRESULT remove() = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(DHCPGroupConditionWrap); /* Shuts up MSC warning C4625. */

};

#endif // !DHCPGroupConditionWrap_H_

// ##### ENDFILE "DHCPGroupConditionWrap.h"


// ##### BEGINFILE "DHCPGroupConfigWrap.h"
/** @file
 * VirtualBox API class wrapper header for IDHCPGroupConfig.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef DHCPGroupConfigWrap_H_
#define DHCPGroupConfigWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE DHCPGroupConfigWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IDHCPGroupConfig)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(DHCPGroupConfigWrap, IDHCPGroupConfig)
    DECLARE_NOT_AGGREGATABLE(DHCPGroupConfigWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(DHCPGroupConfigWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IDHCPGroupConfig)
        COM_INTERFACE_ENTRY(IDHCPConfig)
        COM_INTERFACE_ENTRY2(IDispatch, IDHCPGroupConfig)
        VBOX_TWEAK_INTERFACE_ENTRY(IDHCPGroupConfig)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(DHCPGroupConfigWrap)

    /** @name Public IDHCPConfig properties
     * @{ */
    STDMETHOD(COMGETTER(Scope))(DHCPConfigScope_T *aScope);
    STDMETHOD(COMGETTER(MinLeaseTime))(ULONG *aMinLeaseTime);
    STDMETHOD(COMSETTER(MinLeaseTime))(ULONG aMinLeaseTime);
    STDMETHOD(COMGETTER(DefaultLeaseTime))(ULONG *aDefaultLeaseTime);
    STDMETHOD(COMSETTER(DefaultLeaseTime))(ULONG aDefaultLeaseTime);
    STDMETHOD(COMGETTER(MaxLeaseTime))(ULONG *aMaxLeaseTime);
    STDMETHOD(COMSETTER(MaxLeaseTime))(ULONG aMaxLeaseTime);
    STDMETHOD(COMGETTER(ForcedOptions))(ComSafeArrayOut(DHCPOption_T, aForcedOptions));
    STDMETHOD(COMSETTER(ForcedOptions))(ComSafeArrayIn(DHCPOption_T, aForcedOptions));
    STDMETHOD(COMGETTER(SuppressedOptions))(ComSafeArrayOut(DHCPOption_T, aSuppressedOptions));
    STDMETHOD(COMSETTER(SuppressedOptions))(ComSafeArrayIn(DHCPOption_T, aSuppressedOptions));
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute9IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute10IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute11IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute12IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute13IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute14IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute15IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute16IDHCPConfig))(ULONG *aReserved);
    /** @} */

    /** @name Public IDHCPGroupConfig properties
     * @{ */
    STDMETHOD(COMGETTER(Name))(BSTR *aName);
    STDMETHOD(COMSETTER(Name))(IN_BSTR aName);
    STDMETHOD(COMGETTER(Conditions))(ComSafeArrayOut(IDHCPGroupCondition *, aConditions));
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IDHCPGroupConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IDHCPGroupConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IDHCPGroupConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IDHCPGroupConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IDHCPGroupConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IDHCPGroupConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IDHCPGroupConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IDHCPGroupConfig))(ULONG *aReserved);
    /** @} */

    /** @name Public IDHCPConfig methods
     * @{ */
    STDMETHOD(SetOption)(DHCPOption_T aOption,
                         DHCPOptionEncoding_T aEncoding,
                         IN_BSTR aValue);
    STDMETHOD(RemoveOption)(DHCPOption_T aOption);
    STDMETHOD(RemoveAllOptions)();
    STDMETHOD(GetOption)(DHCPOption_T aOption,
                         DHCPOptionEncoding_T *aEncoding,
                         BSTR *aValue);
    STDMETHOD(GetAllOptions)(ComSafeArrayOut(DHCPOption_T, aOptions),
                             ComSafeArrayOut(DHCPOptionEncoding_T, aEncodings),
                             ComSafeArrayOut(BSTR, aValues));
    STDMETHOD(Remove)();
    STDMETHOD(InternalAndReservedMethod1IDHCPConfig)();
    STDMETHOD(InternalAndReservedMethod2IDHCPConfig)();
    STDMETHOD(InternalAndReservedMethod3IDHCPConfig)();
    STDMETHOD(InternalAndReservedMethod4IDHCPConfig)();
    STDMETHOD(InternalAndReservedMethod5IDHCPConfig)();
    STDMETHOD(InternalAndReservedMethod6IDHCPConfig)();
    STDMETHOD(InternalAndReservedMethod7IDHCPConfig)();
    STDMETHOD(InternalAndReservedMethod8IDHCPConfig)();
    /** @} */

    /** @name Public IDHCPGroupConfig methods
     * @{ */
    STDMETHOD(AddCondition)(BOOL aInclusive,
                            DHCPGroupConditionType_T aType,
                            IN_BSTR aValue,
                            IDHCPGroupCondition **aCondition);
    STDMETHOD(RemoveAllConditions)();
    STDMETHOD(InternalAndReservedMethod1IDHCPGroupConfig)();
    STDMETHOD(InternalAndReservedMethod2IDHCPGroupConfig)();
    STDMETHOD(InternalAndReservedMethod3IDHCPGroupConfig)();
    STDMETHOD(InternalAndReservedMethod4IDHCPGroupConfig)();
    STDMETHOD(InternalAndReservedMethod5IDHCPGroupConfig)();
    STDMETHOD(InternalAndReservedMethod6IDHCPGroupConfig)();
    STDMETHOD(InternalAndReservedMethod7IDHCPGroupConfig)();
    STDMETHOD(InternalAndReservedMethod8IDHCPGroupConfig)();
    /** @} */

private:
    /** @name Wrapped IDHCPConfig properties
     * @{ */
    virtual HRESULT getScope(DHCPConfigScope_T *aScope) = 0;
    virtual HRESULT getMinLeaseTime(ULONG *aMinLeaseTime) = 0;
    virtual HRESULT setMinLeaseTime(ULONG aMinLeaseTime) = 0;
    virtual HRESULT getDefaultLeaseTime(ULONG *aDefaultLeaseTime) = 0;
    virtual HRESULT setDefaultLeaseTime(ULONG aDefaultLeaseTime) = 0;
    virtual HRESULT getMaxLeaseTime(ULONG *aMaxLeaseTime) = 0;
    virtual HRESULT setMaxLeaseTime(ULONG aMaxLeaseTime) = 0;
    virtual HRESULT getForcedOptions(std::vector<DHCPOption_T> &aForcedOptions) = 0;
    virtual HRESULT setForcedOptions(const std::vector<DHCPOption_T> &aForcedOptions) = 0;
    virtual HRESULT getSuppressedOptions(std::vector<DHCPOption_T> &aSuppressedOptions) = 0;
    virtual HRESULT setSuppressedOptions(const std::vector<DHCPOption_T> &aSuppressedOptions) = 0;
    /** @} */

    /** @name Wrapped IDHCPGroupConfig properties
     * @{ */
    virtual HRESULT getName(com::Utf8Str &aName) = 0;
    virtual HRESULT setName(const com::Utf8Str &aName) = 0;
    virtual HRESULT getConditions(std::vector<ComPtr<IDHCPGroupCondition> > &aConditions) = 0;
    /** @} */

    /** @name Wrapped IDHCPConfig methods
     * @{ */
    virtual HRESULT setOption(DHCPOption_T aOption,
                              DHCPOptionEncoding_T aEncoding,
                              const com::Utf8Str &aValue) = 0;
    virtual HRESULT removeOption(DHCPOption_T aOption) = 0;
    virtual HRESULT removeAllOptions() = 0;
    virtual HRESULT getOption(DHCPOption_T aOption,
                              DHCPOptionEncoding_T *aEncoding,
                              com::Utf8Str &aValue) = 0;
    virtual HRESULT getAllOptions(std::vector<DHCPOption_T> &aOptions,
                                  std::vector<DHCPOptionEncoding_T> &aEncodings,
                                  std::vector<com::Utf8Str> &aValues) = 0;
    virtual HRESULT remove() = 0;
    /** @} */

    /** @name Wrapped IDHCPGroupConfig methods
     * @{ */
    virtual HRESULT addCondition(BOOL aInclusive,
                                 DHCPGroupConditionType_T aType,
                                 const com::Utf8Str &aValue,
                                 ComPtr<IDHCPGroupCondition> &aCondition) = 0;
    virtual HRESULT removeAllConditions() = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(DHCPGroupConfigWrap); /* Shuts up MSC warning C4625. */

};

#endif // !DHCPGroupConfigWrap_H_

// ##### ENDFILE "DHCPGroupConfigWrap.h"


// ##### BEGINFILE "DHCPIndividualConfigWrap.h"
/** @file
 * VirtualBox API class wrapper header for IDHCPIndividualConfig.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef DHCPIndividualConfigWrap_H_
#define DHCPIndividualConfigWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE DHCPIndividualConfigWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IDHCPIndividualConfig)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(DHCPIndividualConfigWrap, IDHCPIndividualConfig)
    DECLARE_NOT_AGGREGATABLE(DHCPIndividualConfigWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(DHCPIndividualConfigWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IDHCPIndividualConfig)
        COM_INTERFACE_ENTRY(IDHCPConfig)
        COM_INTERFACE_ENTRY2(IDispatch, IDHCPIndividualConfig)
        VBOX_TWEAK_INTERFACE_ENTRY(IDHCPIndividualConfig)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(DHCPIndividualConfigWrap)

    /** @name Public IDHCPConfig properties
     * @{ */
    STDMETHOD(COMGETTER(Scope))(DHCPConfigScope_T *aScope);
    STDMETHOD(COMGETTER(MinLeaseTime))(ULONG *aMinLeaseTime);
    STDMETHOD(COMSETTER(MinLeaseTime))(ULONG aMinLeaseTime);
    STDMETHOD(COMGETTER(DefaultLeaseTime))(ULONG *aDefaultLeaseTime);
    STDMETHOD(COMSETTER(DefaultLeaseTime))(ULONG aDefaultLeaseTime);
    STDMETHOD(COMGETTER(MaxLeaseTime))(ULONG *aMaxLeaseTime);
    STDMETHOD(COMSETTER(MaxLeaseTime))(ULONG aMaxLeaseTime);
    STDMETHOD(COMGETTER(ForcedOptions))(ComSafeArrayOut(DHCPOption_T, aForcedOptions));
    STDMETHOD(COMSETTER(ForcedOptions))(ComSafeArrayIn(DHCPOption_T, aForcedOptions));
    STDMETHOD(COMGETTER(SuppressedOptions))(ComSafeArrayOut(DHCPOption_T, aSuppressedOptions));
    STDMETHOD(COMSETTER(SuppressedOptions))(ComSafeArrayIn(DHCPOption_T, aSuppressedOptions));
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute9IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute10IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute11IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute12IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute13IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute14IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute15IDHCPConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute16IDHCPConfig))(ULONG *aReserved);
    /** @} */

    /** @name Public IDHCPIndividualConfig properties
     * @{ */
    STDMETHOD(COMGETTER(MACAddress))(BSTR *aMACAddress);
    STDMETHOD(COMGETTER(MachineId))(BSTR *aMachineId);
    STDMETHOD(COMGETTER(Slot))(ULONG *aSlot);
    STDMETHOD(COMGETTER(FixedAddress))(BSTR *aFixedAddress);
    STDMETHOD(COMSETTER(FixedAddress))(IN_BSTR aFixedAddress);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IDHCPIndividualConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IDHCPIndividualConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IDHCPIndividualConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IDHCPIndividualConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IDHCPIndividualConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IDHCPIndividualConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IDHCPIndividualConfig))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IDHCPIndividualConfig))(ULONG *aReserved);
    /** @} */

    /** @name Public IDHCPConfig methods
     * @{ */
    STDMETHOD(SetOption)(DHCPOption_T aOption,
                         DHCPOptionEncoding_T aEncoding,
                         IN_BSTR aValue);
    STDMETHOD(RemoveOption)(DHCPOption_T aOption);
    STDMETHOD(RemoveAllOptions)();
    STDMETHOD(GetOption)(DHCPOption_T aOption,
                         DHCPOptionEncoding_T *aEncoding,
                         BSTR *aValue);
    STDMETHOD(GetAllOptions)(ComSafeArrayOut(DHCPOption_T, aOptions),
                             ComSafeArrayOut(DHCPOptionEncoding_T, aEncodings),
                             ComSafeArrayOut(BSTR, aValues));
    STDMETHOD(Remove)();
    STDMETHOD(InternalAndReservedMethod1IDHCPConfig)();
    STDMETHOD(InternalAndReservedMethod2IDHCPConfig)();
    STDMETHOD(InternalAndReservedMethod3IDHCPConfig)();
    STDMETHOD(InternalAndReservedMethod4IDHCPConfig)();
    STDMETHOD(InternalAndReservedMethod5IDHCPConfig)();
    STDMETHOD(InternalAndReservedMethod6IDHCPConfig)();
    STDMETHOD(InternalAndReservedMethod7IDHCPConfig)();
    STDMETHOD(InternalAndReservedMethod8IDHCPConfig)();
    /** @} */

    /** @name Public IDHCPIndividualConfig methods
     * @{ */
    STDMETHOD(InternalAndReservedMethod1IDHCPIndividualConfig)();
    STDMETHOD(InternalAndReservedMethod2IDHCPIndividualConfig)();
    STDMETHOD(InternalAndReservedMethod3IDHCPIndividualConfig)();
    STDMETHOD(InternalAndReservedMethod4IDHCPIndividualConfig)();
    STDMETHOD(InternalAndReservedMethod5IDHCPIndividualConfig)();
    STDMETHOD(InternalAndReservedMethod6IDHCPIndividualConfig)();
    STDMETHOD(InternalAndReservedMethod7IDHCPIndividualConfig)();
    STDMETHOD(InternalAndReservedMethod8IDHCPIndividualConfig)();
    /** @} */

private:
    /** @name Wrapped IDHCPConfig properties
     * @{ */
    virtual HRESULT getScope(DHCPConfigScope_T *aScope) = 0;
    virtual HRESULT getMinLeaseTime(ULONG *aMinLeaseTime) = 0;
    virtual HRESULT setMinLeaseTime(ULONG aMinLeaseTime) = 0;
    virtual HRESULT getDefaultLeaseTime(ULONG *aDefaultLeaseTime) = 0;
    virtual HRESULT setDefaultLeaseTime(ULONG aDefaultLeaseTime) = 0;
    virtual HRESULT getMaxLeaseTime(ULONG *aMaxLeaseTime) = 0;
    virtual HRESULT setMaxLeaseTime(ULONG aMaxLeaseTime) = 0;
    virtual HRESULT getForcedOptions(std::vector<DHCPOption_T> &aForcedOptions) = 0;
    virtual HRESULT setForcedOptions(const std::vector<DHCPOption_T> &aForcedOptions) = 0;
    virtual HRESULT getSuppressedOptions(std::vector<DHCPOption_T> &aSuppressedOptions) = 0;
    virtual HRESULT setSuppressedOptions(const std::vector<DHCPOption_T> &aSuppressedOptions) = 0;
    /** @} */

    /** @name Wrapped IDHCPIndividualConfig properties
     * @{ */
    virtual HRESULT getMACAddress(com::Utf8Str &aMACAddress) = 0;
    virtual HRESULT getMachineId(com::Guid &aMachineId) = 0;
    virtual HRESULT getSlot(ULONG *aSlot) = 0;
    virtual HRESULT getFixedAddress(com::Utf8Str &aFixedAddress) = 0;
    virtual HRESULT setFixedAddress(const com::Utf8Str &aFixedAddress) = 0;
    /** @} */

    /** @name Wrapped IDHCPConfig methods
     * @{ */
    virtual HRESULT setOption(DHCPOption_T aOption,
                              DHCPOptionEncoding_T aEncoding,
                              const com::Utf8Str &aValue) = 0;
    virtual HRESULT removeOption(DHCPOption_T aOption) = 0;
    virtual HRESULT removeAllOptions() = 0;
    virtual HRESULT getOption(DHCPOption_T aOption,
                              DHCPOptionEncoding_T *aEncoding,
                              com::Utf8Str &aValue) = 0;
    virtual HRESULT getAllOptions(std::vector<DHCPOption_T> &aOptions,
                                  std::vector<DHCPOptionEncoding_T> &aEncodings,
                                  std::vector<com::Utf8Str> &aValues) = 0;
    virtual HRESULT remove() = 0;
    /** @} */

    /** @name Wrapped IDHCPIndividualConfig methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(DHCPIndividualConfigWrap); /* Shuts up MSC warning C4625. */

};

#endif // !DHCPIndividualConfigWrap_H_

// ##### ENDFILE "DHCPIndividualConfigWrap.h"


// ##### BEGINFILE "VirtualBoxWrap.h"
/** @file
 * VirtualBox API class wrapper header for IVirtualBox.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef VirtualBoxWrap_H_
#define VirtualBoxWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE VirtualBoxWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IVirtualBox)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(VirtualBoxWrap, IVirtualBox)
    DECLARE_NOT_AGGREGATABLE(VirtualBoxWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(VirtualBoxWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IVirtualBox)
        COM_INTERFACE_ENTRY2(IDispatch, IVirtualBox)
        VBOX_TWEAK_INTERFACE_ENTRY(IVirtualBox)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(VirtualBoxWrap)

    /** @name Public IVirtualBox properties
     * @{ */
    STDMETHOD(COMGETTER(Version))(BSTR *aVersion);
    STDMETHOD(COMGETTER(VersionNormalized))(BSTR *aVersionNormalized);
    STDMETHOD(COMGETTER(Revision))(ULONG *aRevision);
    STDMETHOD(COMGETTER(PackageType))(BSTR *aPackageType);
    STDMETHOD(COMGETTER(APIVersion))(BSTR *aAPIVersion);
    STDMETHOD(COMGETTER(APIRevision))(LONG64 *aAPIRevision);
    STDMETHOD(COMGETTER(HomeFolder))(BSTR *aHomeFolder);
    STDMETHOD(COMGETTER(SettingsFilePath))(BSTR *aSettingsFilePath);
    STDMETHOD(COMGETTER(Host))(IHost **aHost);
    STDMETHOD(COMGETTER(SystemProperties))(ISystemProperties **aSystemProperties);
    STDMETHOD(COMGETTER(Machines))(ComSafeArrayOut(IMachine *, aMachines));
    STDMETHOD(COMGETTER(MachineGroups))(ComSafeArrayOut(BSTR, aMachineGroups));
    STDMETHOD(COMGETTER(HardDisks))(ComSafeArrayOut(IMedium *, aHardDisks));
    STDMETHOD(COMGETTER(DVDImages))(ComSafeArrayOut(IMedium *, aDVDImages));
    STDMETHOD(COMGETTER(FloppyImages))(ComSafeArrayOut(IMedium *, aFloppyImages));
    STDMETHOD(COMGETTER(ProgressOperations))(ComSafeArrayOut(IProgress *, aProgressOperations));
    STDMETHOD(COMGETTER(GuestOSTypes))(ComSafeArrayOut(IGuestOSType *, aGuestOSTypes));
    STDMETHOD(COMGETTER(SharedFolders))(ComSafeArrayOut(ISharedFolder *, aSharedFolders));
    STDMETHOD(COMGETTER(PerformanceCollector))(IPerformanceCollector **aPerformanceCollector);
    STDMETHOD(COMGETTER(DHCPServers))(ComSafeArrayOut(IDHCPServer *, aDHCPServers));
    STDMETHOD(COMGETTER(NATNetworks))(ComSafeArrayOut(INATNetwork *, aNATNetworks));
    STDMETHOD(COMGETTER(EventSource))(IEventSource **aEventSource);
    STDMETHOD(COMGETTER(ExtensionPackManager))(IExtPackManager **aExtensionPackManager);
    STDMETHOD(COMGETTER(InternalNetworks))(ComSafeArrayOut(BSTR, aInternalNetworks));
    STDMETHOD(COMGETTER(GenericNetworkDrivers))(ComSafeArrayOut(BSTR, aGenericNetworkDrivers));
    STDMETHOD(COMGETTER(CloudNetworks))(ComSafeArrayOut(ICloudNetwork *, aCloudNetworks));
    STDMETHOD(COMGETTER(CloudProviderManager))(ICloudProviderManager **aCloudProviderManager);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IVirtualBox))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IVirtualBox))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IVirtualBox))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IVirtualBox))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IVirtualBox))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IVirtualBox))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IVirtualBox))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IVirtualBox))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute9IVirtualBox))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute10IVirtualBox))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute11IVirtualBox))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute12IVirtualBox))(ULONG *aReserved);
    /** @} */

    /** @name Public IVirtualBox methods
     * @{ */
    STDMETHOD(ComposeMachineFilename)(IN_BSTR aName,
                                      IN_BSTR aGroup,
                                      IN_BSTR aCreateFlags,
                                      IN_BSTR aBaseFolder,
                                      BSTR *aFile);
    STDMETHOD(CreateMachine)(IN_BSTR aSettingsFile,
                             IN_BSTR aName,
                             ComSafeArrayIn(IN_BSTR, aGroups),
                             IN_BSTR aOsTypeId,
                             IN_BSTR aFlags,
                             IMachine **aMachine);
    STDMETHOD(OpenMachine)(IN_BSTR aSettingsFile,
                           IMachine **aMachine);
    STDMETHOD(RegisterMachine)(IMachine *aMachine);
    STDMETHOD(FindMachine)(IN_BSTR aNameOrId,
                           IMachine **aMachine);
    STDMETHOD(GetMachinesByGroups)(ComSafeArrayIn(IN_BSTR, aGroups),
                                   ComSafeArrayOut(IMachine *, aMachines));
    STDMETHOD(GetMachineStates)(ComSafeArrayIn(IMachine *, aMachines),
                                ComSafeArrayOut(MachineState_T, aStates));
    STDMETHOD(CreateAppliance)(IAppliance **aAppliance);
    STDMETHOD(CreateUnattendedInstaller)(IUnattended **aUnattended);
    STDMETHOD(CreateMedium)(IN_BSTR aFormat,
                            IN_BSTR aLocation,
                            AccessMode_T aAccessMode,
                            DeviceType_T aADeviceTypeType,
                            IMedium **aMedium);
    STDMETHOD(OpenMedium)(IN_BSTR aLocation,
                          DeviceType_T aDeviceType,
                          AccessMode_T aAccessMode,
                          BOOL aForceNewUuid,
                          IMedium **aMedium);
    STDMETHOD(GetGuestOSType)(IN_BSTR aId,
                              IGuestOSType **aType);
    STDMETHOD(CreateSharedFolder)(IN_BSTR aName,
                                  IN_BSTR aHostPath,
                                  BOOL aWritable,
                                  BOOL aAutomount,
                                  IN_BSTR aAutoMountPoint);
    STDMETHOD(RemoveSharedFolder)(IN_BSTR aName);
    STDMETHOD(GetExtraDataKeys)(ComSafeArrayOut(BSTR, aKeys));
    STDMETHOD(GetExtraData)(IN_BSTR aKey,
                            BSTR *aValue);
    STDMETHOD(SetExtraData)(IN_BSTR aKey,
                            IN_BSTR aValue);
    STDMETHOD(SetSettingsSecret)(IN_BSTR aPassword);
    STDMETHOD(CreateDHCPServer)(IN_BSTR aName,
                                IDHCPServer **aServer);
    STDMETHOD(FindDHCPServerByNetworkName)(IN_BSTR aName,
                                           IDHCPServer **aServer);
    STDMETHOD(RemoveDHCPServer)(IDHCPServer *aServer);
    STDMETHOD(CreateNATNetwork)(IN_BSTR aNetworkName,
                                INATNetwork **aNetwork);
    STDMETHOD(FindNATNetworkByName)(IN_BSTR aNetworkName,
                                    INATNetwork **aNetwork);
    STDMETHOD(RemoveNATNetwork)(INATNetwork *aNetwork);
    STDMETHOD(CreateCloudNetwork)(IN_BSTR aNetworkName,
                                  ICloudNetwork **aNetwork);
    STDMETHOD(FindCloudNetworkByName)(IN_BSTR aNetworkName,
                                      ICloudNetwork **aNetwork);
    STDMETHOD(RemoveCloudNetwork)(ICloudNetwork *aNetwork);
    STDMETHOD(CheckFirmwarePresent)(FirmwareType_T aFirmwareType,
                                    IN_BSTR aVersion,
                                    BSTR *aUrl,
                                    BSTR *aFile,
                                    BOOL *aResult);
    STDMETHOD(InternalAndReservedMethod1IVirtualBox)();
    STDMETHOD(InternalAndReservedMethod2IVirtualBox)();
    STDMETHOD(InternalAndReservedMethod3IVirtualBox)();
    STDMETHOD(InternalAndReservedMethod4IVirtualBox)();
    STDMETHOD(InternalAndReservedMethod5IVirtualBox)();
    STDMETHOD(InternalAndReservedMethod6IVirtualBox)();
    STDMETHOD(InternalAndReservedMethod7IVirtualBox)();
    STDMETHOD(InternalAndReservedMethod8IVirtualBox)();
    /** @} */

private:
    /** @name Wrapped IVirtualBox properties
     * @{ */
    virtual HRESULT getVersion(com::Utf8Str &aVersion) = 0;
    virtual HRESULT getVersionNormalized(com::Utf8Str &aVersionNormalized) = 0;
    virtual HRESULT getRevision(ULONG *aRevision) = 0;
    virtual HRESULT getPackageType(com::Utf8Str &aPackageType) = 0;
    virtual HRESULT getAPIVersion(com::Utf8Str &aAPIVersion) = 0;
    virtual HRESULT getAPIRevision(LONG64 *aAPIRevision) = 0;
    virtual HRESULT getHomeFolder(com::Utf8Str &aHomeFolder) = 0;
    virtual HRESULT getSettingsFilePath(com::Utf8Str &aSettingsFilePath) = 0;
    virtual HRESULT getHost(ComPtr<IHost> &aHost) = 0;
    virtual HRESULT getSystemProperties(ComPtr<ISystemProperties> &aSystemProperties) = 0;
    virtual HRESULT getMachines(std::vector<ComPtr<IMachine> > &aMachines) = 0;
    virtual HRESULT getMachineGroups(std::vector<com::Utf8Str> &aMachineGroups) = 0;
    virtual HRESULT getHardDisks(std::vector<ComPtr<IMedium> > &aHardDisks) = 0;
    virtual HRESULT getDVDImages(std::vector<ComPtr<IMedium> > &aDVDImages) = 0;
    virtual HRESULT getFloppyImages(std::vector<ComPtr<IMedium> > &aFloppyImages) = 0;
    virtual HRESULT getProgressOperations(std::vector<ComPtr<IProgress> > &aProgressOperations) = 0;
    virtual HRESULT getGuestOSTypes(std::vector<ComPtr<IGuestOSType> > &aGuestOSTypes) = 0;
    virtual HRESULT getSharedFolders(std::vector<ComPtr<ISharedFolder> > &aSharedFolders) = 0;
    virtual HRESULT getPerformanceCollector(ComPtr<IPerformanceCollector> &aPerformanceCollector) = 0;
    virtual HRESULT getDHCPServers(std::vector<ComPtr<IDHCPServer> > &aDHCPServers) = 0;
    virtual HRESULT getNATNetworks(std::vector<ComPtr<INATNetwork> > &aNATNetworks) = 0;
    virtual HRESULT getEventSource(ComPtr<IEventSource> &aEventSource) = 0;
    virtual HRESULT getExtensionPackManager(ComPtr<IExtPackManager> &aExtensionPackManager) = 0;
    virtual HRESULT getInternalNetworks(std::vector<com::Utf8Str> &aInternalNetworks) = 0;
    virtual HRESULT getGenericNetworkDrivers(std::vector<com::Utf8Str> &aGenericNetworkDrivers) = 0;
    virtual HRESULT getCloudNetworks(std::vector<ComPtr<ICloudNetwork> > &aCloudNetworks) = 0;
    virtual HRESULT getCloudProviderManager(ComPtr<ICloudProviderManager> &aCloudProviderManager) = 0;
    /** @} */

    /** @name Wrapped IVirtualBox methods
     * @{ */
    virtual HRESULT composeMachineFilename(const com::Utf8Str &aName,
                                           const com::Utf8Str &aGroup,
                                           const com::Utf8Str &aCreateFlags,
                                           const com::Utf8Str &aBaseFolder,
                                           com::Utf8Str &aFile) = 0;
    virtual HRESULT createMachine(const com::Utf8Str &aSettingsFile,
                                  const com::Utf8Str &aName,
                                  const std::vector<com::Utf8Str> &aGroups,
                                  const com::Utf8Str &aOsTypeId,
                                  const com::Utf8Str &aFlags,
                                  ComPtr<IMachine> &aMachine) = 0;
    virtual HRESULT openMachine(const com::Utf8Str &aSettingsFile,
                                ComPtr<IMachine> &aMachine) = 0;
    virtual HRESULT registerMachine(const ComPtr<IMachine> &aMachine) = 0;
    virtual HRESULT findMachine(const com::Utf8Str &aNameOrId,
                                ComPtr<IMachine> &aMachine) = 0;
    virtual HRESULT getMachinesByGroups(const std::vector<com::Utf8Str> &aGroups,
                                        std::vector<ComPtr<IMachine> > &aMachines) = 0;
    virtual HRESULT getMachineStates(const std::vector<ComPtr<IMachine> > &aMachines,
                                     std::vector<MachineState_T> &aStates) = 0;
    virtual HRESULT createAppliance(ComPtr<IAppliance> &aAppliance) = 0;
    virtual HRESULT createUnattendedInstaller(ComPtr<IUnattended> &aUnattended) = 0;
    virtual HRESULT createMedium(const com::Utf8Str &aFormat,
                                 const com::Utf8Str &aLocation,
                                 AccessMode_T aAccessMode,
                                 DeviceType_T aADeviceTypeType,
                                 ComPtr<IMedium> &aMedium) = 0;
    virtual HRESULT openMedium(const com::Utf8Str &aLocation,
                               DeviceType_T aDeviceType,
                               AccessMode_T aAccessMode,
                               BOOL aForceNewUuid,
                               ComPtr<IMedium> &aMedium) = 0;
    virtual HRESULT getGuestOSType(const com::Utf8Str &aId,
                                   ComPtr<IGuestOSType> &aType) = 0;
    virtual HRESULT createSharedFolder(const com::Utf8Str &aName,
                                       const com::Utf8Str &aHostPath,
                                       BOOL aWritable,
                                       BOOL aAutomount,
                                       const com::Utf8Str &aAutoMountPoint) = 0;
    virtual HRESULT removeSharedFolder(const com::Utf8Str &aName) = 0;
    virtual HRESULT getExtraDataKeys(std::vector<com::Utf8Str> &aKeys) = 0;
    virtual HRESULT getExtraData(const com::Utf8Str &aKey,
                                 com::Utf8Str &aValue) = 0;
    virtual HRESULT setExtraData(const com::Utf8Str &aKey,
                                 const com::Utf8Str &aValue) = 0;
    virtual HRESULT setSettingsSecret(const com::Utf8Str &aPassword) = 0;
    virtual HRESULT createDHCPServer(const com::Utf8Str &aName,
                                     ComPtr<IDHCPServer> &aServer) = 0;
    virtual HRESULT findDHCPServerByNetworkName(const com::Utf8Str &aName,
                                                ComPtr<IDHCPServer> &aServer) = 0;
    virtual HRESULT removeDHCPServer(const ComPtr<IDHCPServer> &aServer) = 0;
    virtual HRESULT createNATNetwork(const com::Utf8Str &aNetworkName,
                                     ComPtr<INATNetwork> &aNetwork) = 0;
    virtual HRESULT findNATNetworkByName(const com::Utf8Str &aNetworkName,
                                         ComPtr<INATNetwork> &aNetwork) = 0;
    virtual HRESULT removeNATNetwork(const ComPtr<INATNetwork> &aNetwork) = 0;
    virtual HRESULT createCloudNetwork(const com::Utf8Str &aNetworkName,
                                       ComPtr<ICloudNetwork> &aNetwork) = 0;
    virtual HRESULT findCloudNetworkByName(const com::Utf8Str &aNetworkName,
                                           ComPtr<ICloudNetwork> &aNetwork) = 0;
    virtual HRESULT removeCloudNetwork(const ComPtr<ICloudNetwork> &aNetwork) = 0;
    virtual HRESULT checkFirmwarePresent(FirmwareType_T aFirmwareType,
                                         const com::Utf8Str &aVersion,
                                         com::Utf8Str &aUrl,
                                         com::Utf8Str &aFile,
                                         BOOL *aResult) = 0;
    /** @} */

public:
    virtual void i_callHook(const char *a_pszFunction) { RT_NOREF_PV(a_pszFunction); }

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(VirtualBoxWrap); /* Shuts up MSC warning C4625. */

};

#endif // !VirtualBoxWrap_H_

// ##### ENDFILE "VirtualBoxWrap.h"


// ##### BEGINFILE "VFSExplorerWrap.h"
/** @file
 * VirtualBox API class wrapper header for IVFSExplorer.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef VFSExplorerWrap_H_
#define VFSExplorerWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE VFSExplorerWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IVFSExplorer)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(VFSExplorerWrap, IVFSExplorer)
    DECLARE_NOT_AGGREGATABLE(VFSExplorerWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(VFSExplorerWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IVFSExplorer)
        COM_INTERFACE_ENTRY2(IDispatch, IVFSExplorer)
        VBOX_TWEAK_INTERFACE_ENTRY(IVFSExplorer)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(VFSExplorerWrap)

    /** @name Public IVFSExplorer properties
     * @{ */
    STDMETHOD(COMGETTER(Path))(BSTR *aPath);
    STDMETHOD(COMGETTER(Type))(VFSType_T *aType);
    /** @} */

    /** @name Public IVFSExplorer methods
     * @{ */
    STDMETHOD(Update)(IProgress **aProgress);
    STDMETHOD(Cd)(IN_BSTR aDir,
                  IProgress **aProgress);
    STDMETHOD(CdUp)(IProgress **aProgress);
    STDMETHOD(EntryList)(ComSafeArrayOut(BSTR, aNames),
                         ComSafeArrayOut(ULONG, aTypes),
                         ComSafeArrayOut(LONG64, aSizes),
                         ComSafeArrayOut(ULONG, aModes));
    STDMETHOD(Exists)(ComSafeArrayIn(IN_BSTR, aNames),
                      ComSafeArrayOut(BSTR, aExists));
    STDMETHOD(Remove)(ComSafeArrayIn(IN_BSTR, aNames),
                      IProgress **aProgress);
    /** @} */

private:
    /** @name Wrapped IVFSExplorer properties
     * @{ */
    virtual HRESULT getPath(com::Utf8Str &aPath) = 0;
    virtual HRESULT getType(VFSType_T *aType) = 0;
    /** @} */

    /** @name Wrapped IVFSExplorer methods
     * @{ */
    virtual HRESULT update(ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT cd(const com::Utf8Str &aDir,
                       ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT cdUp(ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT entryList(std::vector<com::Utf8Str> &aNames,
                              std::vector<ULONG> &aTypes,
                              std::vector<LONG64> &aSizes,
                              std::vector<ULONG> &aModes) = 0;
    virtual HRESULT exists(const std::vector<com::Utf8Str> &aNames,
                           std::vector<com::Utf8Str> &aExists) = 0;
    virtual HRESULT remove(const std::vector<com::Utf8Str> &aNames,
                           ComPtr<IProgress> &aProgress) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(VFSExplorerWrap); /* Shuts up MSC warning C4625. */

};

#endif // !VFSExplorerWrap_H_

// ##### ENDFILE "VFSExplorerWrap.h"


// ##### BEGINFILE "CertificateWrap.h"
/** @file
 * VirtualBox API class wrapper header for ICertificate.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef CertificateWrap_H_
#define CertificateWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE CertificateWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(ICertificate)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(CertificateWrap, ICertificate)
    DECLARE_NOT_AGGREGATABLE(CertificateWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(CertificateWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(ICertificate)
        COM_INTERFACE_ENTRY2(IDispatch, ICertificate)
        VBOX_TWEAK_INTERFACE_ENTRY(ICertificate)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(CertificateWrap)

    /** @name Public ICertificate properties
     * @{ */
    STDMETHOD(COMGETTER(VersionNumber))(CertificateVersion_T *aVersionNumber);
    STDMETHOD(COMGETTER(SerialNumber))(BSTR *aSerialNumber);
    STDMETHOD(COMGETTER(SignatureAlgorithmOID))(BSTR *aSignatureAlgorithmOID);
    STDMETHOD(COMGETTER(SignatureAlgorithmName))(BSTR *aSignatureAlgorithmName);
    STDMETHOD(COMGETTER(IssuerName))(ComSafeArrayOut(BSTR, aIssuerName));
    STDMETHOD(COMGETTER(SubjectName))(ComSafeArrayOut(BSTR, aSubjectName));
    STDMETHOD(COMGETTER(FriendlyName))(BSTR *aFriendlyName);
    STDMETHOD(COMGETTER(ValidityPeriodNotBefore))(BSTR *aValidityPeriodNotBefore);
    STDMETHOD(COMGETTER(ValidityPeriodNotAfter))(BSTR *aValidityPeriodNotAfter);
    STDMETHOD(COMGETTER(PublicKeyAlgorithmOID))(BSTR *aPublicKeyAlgorithmOID);
    STDMETHOD(COMGETTER(PublicKeyAlgorithm))(BSTR *aPublicKeyAlgorithm);
    STDMETHOD(COMGETTER(SubjectPublicKey))(ComSafeArrayOut(BYTE, aSubjectPublicKey));
    STDMETHOD(COMGETTER(IssuerUniqueIdentifier))(BSTR *aIssuerUniqueIdentifier);
    STDMETHOD(COMGETTER(SubjectUniqueIdentifier))(BSTR *aSubjectUniqueIdentifier);
    STDMETHOD(COMGETTER(CertificateAuthority))(BOOL *aCertificateAuthority);
    STDMETHOD(COMGETTER(KeyUsage))(ULONG *aKeyUsage);
    STDMETHOD(COMGETTER(ExtendedKeyUsage))(ComSafeArrayOut(BSTR, aExtendedKeyUsage));
    STDMETHOD(COMGETTER(RawCertData))(ComSafeArrayOut(BYTE, aRawCertData));
    STDMETHOD(COMGETTER(SelfSigned))(BOOL *aSelfSigned);
    STDMETHOD(COMGETTER(Trusted))(BOOL *aTrusted);
    STDMETHOD(COMGETTER(Expired))(BOOL *aExpired);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1ICertificate))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2ICertificate))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3ICertificate))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4ICertificate))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5ICertificate))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6ICertificate))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7ICertificate))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8ICertificate))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute9ICertificate))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute10ICertificate))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute11ICertificate))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute12ICertificate))(ULONG *aReserved);
    /** @} */

    /** @name Public ICertificate methods
     * @{ */
    STDMETHOD(IsCurrentlyExpired)(BOOL *aResult);
    STDMETHOD(QueryInfo)(LONG aWhat,
                         BSTR *aResult);
    STDMETHOD(InternalAndReservedMethod1ICertificate)();
    STDMETHOD(InternalAndReservedMethod2ICertificate)();
    /** @} */

private:
    /** @name Wrapped ICertificate properties
     * @{ */
    virtual HRESULT getVersionNumber(CertificateVersion_T *aVersionNumber) = 0;
    virtual HRESULT getSerialNumber(com::Utf8Str &aSerialNumber) = 0;
    virtual HRESULT getSignatureAlgorithmOID(com::Utf8Str &aSignatureAlgorithmOID) = 0;
    virtual HRESULT getSignatureAlgorithmName(com::Utf8Str &aSignatureAlgorithmName) = 0;
    virtual HRESULT getIssuerName(std::vector<com::Utf8Str> &aIssuerName) = 0;
    virtual HRESULT getSubjectName(std::vector<com::Utf8Str> &aSubjectName) = 0;
    virtual HRESULT getFriendlyName(com::Utf8Str &aFriendlyName) = 0;
    virtual HRESULT getValidityPeriodNotBefore(com::Utf8Str &aValidityPeriodNotBefore) = 0;
    virtual HRESULT getValidityPeriodNotAfter(com::Utf8Str &aValidityPeriodNotAfter) = 0;
    virtual HRESULT getPublicKeyAlgorithmOID(com::Utf8Str &aPublicKeyAlgorithmOID) = 0;
    virtual HRESULT getPublicKeyAlgorithm(com::Utf8Str &aPublicKeyAlgorithm) = 0;
    virtual HRESULT getSubjectPublicKey(std::vector<BYTE> &aSubjectPublicKey) = 0;
    virtual HRESULT getIssuerUniqueIdentifier(com::Utf8Str &aIssuerUniqueIdentifier) = 0;
    virtual HRESULT getSubjectUniqueIdentifier(com::Utf8Str &aSubjectUniqueIdentifier) = 0;
    virtual HRESULT getCertificateAuthority(BOOL *aCertificateAuthority) = 0;
    virtual HRESULT getKeyUsage(ULONG *aKeyUsage) = 0;
    virtual HRESULT getExtendedKeyUsage(std::vector<com::Utf8Str> &aExtendedKeyUsage) = 0;
    virtual HRESULT getRawCertData(std::vector<BYTE> &aRawCertData) = 0;
    virtual HRESULT getSelfSigned(BOOL *aSelfSigned) = 0;
    virtual HRESULT getTrusted(BOOL *aTrusted) = 0;
    virtual HRESULT getExpired(BOOL *aExpired) = 0;
    /** @} */

    /** @name Wrapped ICertificate methods
     * @{ */
    virtual HRESULT isCurrentlyExpired(BOOL *aResult) = 0;
    virtual HRESULT queryInfo(LONG aWhat,
                              com::Utf8Str &aResult) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(CertificateWrap); /* Shuts up MSC warning C4625. */

};

#endif // !CertificateWrap_H_

// ##### ENDFILE "CertificateWrap.h"


// ##### BEGINFILE "ApplianceWrap.h"
/** @file
 * VirtualBox API class wrapper header for IAppliance.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef ApplianceWrap_H_
#define ApplianceWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE ApplianceWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IAppliance)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(ApplianceWrap, IAppliance)
    DECLARE_NOT_AGGREGATABLE(ApplianceWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(ApplianceWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IAppliance)
        COM_INTERFACE_ENTRY2(IDispatch, IAppliance)
        VBOX_TWEAK_INTERFACE_ENTRY(IAppliance)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(ApplianceWrap)

    /** @name Public IAppliance properties
     * @{ */
    STDMETHOD(COMGETTER(Path))(BSTR *aPath);
    STDMETHOD(COMGETTER(Disks))(ComSafeArrayOut(BSTR, aDisks));
    STDMETHOD(COMGETTER(VirtualSystemDescriptions))(ComSafeArrayOut(IVirtualSystemDescription *, aVirtualSystemDescriptions));
    STDMETHOD(COMGETTER(Machines))(ComSafeArrayOut(BSTR, aMachines));
    STDMETHOD(COMGETTER(Certificate))(ICertificate **aCertificate);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IAppliance))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IAppliance))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IAppliance))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IAppliance))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IAppliance))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IAppliance))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IAppliance))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IAppliance))(ULONG *aReserved);
    /** @} */

    /** @name Public IAppliance methods
     * @{ */
    STDMETHOD(Read)(IN_BSTR aFile,
                    IProgress **aProgress);
    STDMETHOD(Interpret)();
    STDMETHOD(ImportMachines)(ComSafeArrayIn(ImportOptions_T, aOptions),
                              IProgress **aProgress);
    STDMETHOD(CreateVFSExplorer)(IN_BSTR aURI,
                                 IVFSExplorer **aExplorer);
    STDMETHOD(Write)(IN_BSTR aFormat,
                     ComSafeArrayIn(ExportOptions_T, aOptions),
                     IN_BSTR aPath,
                     IProgress **aProgress);
    STDMETHOD(GetWarnings)(ComSafeArrayOut(BSTR, aWarnings));
    STDMETHOD(GetPasswordIds)(ComSafeArrayOut(BSTR, aIdentifiers));
    STDMETHOD(GetMediumIdsForPasswordId)(IN_BSTR aPasswordId,
                                         ComSafeArrayOut(BSTR, aIdentifiers));
    STDMETHOD(AddPasswords)(ComSafeArrayIn(IN_BSTR, aIdentifiers),
                            ComSafeArrayIn(IN_BSTR, aPasswords));
    STDMETHOD(CreateVirtualSystemDescriptions)(ULONG aRequested,
                                               ULONG *aCreated);
    STDMETHOD(InternalAndReservedMethod1IAppliance)();
    STDMETHOD(InternalAndReservedMethod2IAppliance)();
    STDMETHOD(InternalAndReservedMethod3IAppliance)();
    STDMETHOD(InternalAndReservedMethod4IAppliance)();
    STDMETHOD(InternalAndReservedMethod5IAppliance)();
    STDMETHOD(InternalAndReservedMethod6IAppliance)();
    STDMETHOD(InternalAndReservedMethod7IAppliance)();
    /** @} */

private:
    /** @name Wrapped IAppliance properties
     * @{ */
    virtual HRESULT getPath(com::Utf8Str &aPath) = 0;
    virtual HRESULT getDisks(std::vector<com::Utf8Str> &aDisks) = 0;
    virtual HRESULT getVirtualSystemDescriptions(std::vector<ComPtr<IVirtualSystemDescription> > &aVirtualSystemDescriptions) = 0;
    virtual HRESULT getMachines(std::vector<com::Utf8Str> &aMachines) = 0;
    virtual HRESULT getCertificate(ComPtr<ICertificate> &aCertificate) = 0;
    /** @} */

    /** @name Wrapped IAppliance methods
     * @{ */
    virtual HRESULT read(const com::Utf8Str &aFile,
                         ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT interpret() = 0;
    virtual HRESULT importMachines(const std::vector<ImportOptions_T> &aOptions,
                                   ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT createVFSExplorer(const com::Utf8Str &aURI,
                                      ComPtr<IVFSExplorer> &aExplorer) = 0;
    virtual HRESULT write(const com::Utf8Str &aFormat,
                          const std::vector<ExportOptions_T> &aOptions,
                          const com::Utf8Str &aPath,
                          ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT getWarnings(std::vector<com::Utf8Str> &aWarnings) = 0;
    virtual HRESULT getPasswordIds(std::vector<com::Utf8Str> &aIdentifiers) = 0;
    virtual HRESULT getMediumIdsForPasswordId(const com::Utf8Str &aPasswordId,
                                              std::vector<com::Guid> &aIdentifiers) = 0;
    virtual HRESULT addPasswords(const std::vector<com::Utf8Str> &aIdentifiers,
                                 const std::vector<com::Utf8Str> &aPasswords) = 0;
    virtual HRESULT createVirtualSystemDescriptions(ULONG aRequested,
                                                    ULONG *aCreated) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(ApplianceWrap); /* Shuts up MSC warning C4625. */

};

#endif // !ApplianceWrap_H_

// ##### ENDFILE "ApplianceWrap.h"


// ##### BEGINFILE "VirtualSystemDescriptionWrap.h"
/** @file
 * VirtualBox API class wrapper header for IVirtualSystemDescription.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef VirtualSystemDescriptionWrap_H_
#define VirtualSystemDescriptionWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE VirtualSystemDescriptionWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IVirtualSystemDescription)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(VirtualSystemDescriptionWrap, IVirtualSystemDescription)
    DECLARE_NOT_AGGREGATABLE(VirtualSystemDescriptionWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(VirtualSystemDescriptionWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IVirtualSystemDescription)
        COM_INTERFACE_ENTRY2(IDispatch, IVirtualSystemDescription)
        VBOX_TWEAK_INTERFACE_ENTRY(IVirtualSystemDescription)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(VirtualSystemDescriptionWrap)

    /** @name Public IVirtualSystemDescription properties
     * @{ */
    STDMETHOD(COMGETTER(Count))(ULONG *aCount);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IVirtualSystemDescription))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IVirtualSystemDescription))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IVirtualSystemDescription))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IVirtualSystemDescription))(ULONG *aReserved);
    /** @} */

    /** @name Public IVirtualSystemDescription methods
     * @{ */
    STDMETHOD(GetDescription)(ComSafeArrayOut(VirtualSystemDescriptionType_T, aTypes),
                              ComSafeArrayOut(BSTR, aRefs),
                              ComSafeArrayOut(BSTR, aOVFValues),
                              ComSafeArrayOut(BSTR, aVBoxValues),
                              ComSafeArrayOut(BSTR, aExtraConfigValues));
    STDMETHOD(GetDescriptionByType)(VirtualSystemDescriptionType_T aType,
                                    ComSafeArrayOut(VirtualSystemDescriptionType_T, aTypes),
                                    ComSafeArrayOut(BSTR, aRefs),
                                    ComSafeArrayOut(BSTR, aOVFValues),
                                    ComSafeArrayOut(BSTR, aVBoxValues),
                                    ComSafeArrayOut(BSTR, aExtraConfigValues));
    STDMETHOD(RemoveDescriptionByType)(VirtualSystemDescriptionType_T aType);
    STDMETHOD(GetValuesByType)(VirtualSystemDescriptionType_T aType,
                               VirtualSystemDescriptionValueType_T aWhich,
                               ComSafeArrayOut(BSTR, aValues));
    STDMETHOD(SetFinalValues)(ComSafeArrayIn(BOOL, aEnabled),
                              ComSafeArrayIn(IN_BSTR, aVBoxValues),
                              ComSafeArrayIn(IN_BSTR, aExtraConfigValues));
    STDMETHOD(AddDescription)(VirtualSystemDescriptionType_T aType,
                              IN_BSTR aVBoxValue,
                              IN_BSTR aExtraConfigValue);
    STDMETHOD(InternalAndReservedMethod1IVirtualSystemDescription)();
    STDMETHOD(InternalAndReservedMethod2IVirtualSystemDescription)();
    STDMETHOD(InternalAndReservedMethod3IVirtualSystemDescription)();
    STDMETHOD(InternalAndReservedMethod4IVirtualSystemDescription)();
    /** @} */

private:
    /** @name Wrapped IVirtualSystemDescription properties
     * @{ */
    virtual HRESULT getCount(ULONG *aCount) = 0;
    /** @} */

    /** @name Wrapped IVirtualSystemDescription methods
     * @{ */
    virtual HRESULT getDescription(std::vector<VirtualSystemDescriptionType_T> &aTypes,
                                   std::vector<com::Utf8Str> &aRefs,
                                   std::vector<com::Utf8Str> &aOVFValues,
                                   std::vector<com::Utf8Str> &aVBoxValues,
                                   std::vector<com::Utf8Str> &aExtraConfigValues) = 0;
    virtual HRESULT getDescriptionByType(VirtualSystemDescriptionType_T aType,
                                         std::vector<VirtualSystemDescriptionType_T> &aTypes,
                                         std::vector<com::Utf8Str> &aRefs,
                                         std::vector<com::Utf8Str> &aOVFValues,
                                         std::vector<com::Utf8Str> &aVBoxValues,
                                         std::vector<com::Utf8Str> &aExtraConfigValues) = 0;
    virtual HRESULT removeDescriptionByType(VirtualSystemDescriptionType_T aType) = 0;
    virtual HRESULT getValuesByType(VirtualSystemDescriptionType_T aType,
                                    VirtualSystemDescriptionValueType_T aWhich,
                                    std::vector<com::Utf8Str> &aValues) = 0;
    virtual HRESULT setFinalValues(const std::vector<BOOL> &aEnabled,
                                   const std::vector<com::Utf8Str> &aVBoxValues,
                                   const std::vector<com::Utf8Str> &aExtraConfigValues) = 0;
    virtual HRESULT addDescription(VirtualSystemDescriptionType_T aType,
                                   const com::Utf8Str &aVBoxValue,
                                   const com::Utf8Str &aExtraConfigValue) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(VirtualSystemDescriptionWrap); /* Shuts up MSC warning C4625. */

};

#endif // !VirtualSystemDescriptionWrap_H_

// ##### ENDFILE "VirtualSystemDescriptionWrap.h"


// ##### BEGINFILE "UnattendedWrap.h"
/** @file
 * VirtualBox API class wrapper header for IUnattended.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef UnattendedWrap_H_
#define UnattendedWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE UnattendedWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IUnattended)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(UnattendedWrap, IUnattended)
    DECLARE_NOT_AGGREGATABLE(UnattendedWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(UnattendedWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IUnattended)
        COM_INTERFACE_ENTRY2(IDispatch, IUnattended)
        VBOX_TWEAK_INTERFACE_ENTRY(IUnattended)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(UnattendedWrap)

    /** @name Public IUnattended properties
     * @{ */
    STDMETHOD(COMGETTER(IsoPath))(BSTR *aIsoPath);
    STDMETHOD(COMSETTER(IsoPath))(IN_BSTR aIsoPath);
    STDMETHOD(COMGETTER(Machine))(IMachine **aMachine);
    STDMETHOD(COMSETTER(Machine))(IMachine *aMachine);
    STDMETHOD(COMGETTER(User))(BSTR *aUser);
    STDMETHOD(COMSETTER(User))(IN_BSTR aUser);
    STDMETHOD(COMGETTER(Password))(BSTR *aPassword);
    STDMETHOD(COMSETTER(Password))(IN_BSTR aPassword);
    STDMETHOD(COMGETTER(FullUserName))(BSTR *aFullUserName);
    STDMETHOD(COMSETTER(FullUserName))(IN_BSTR aFullUserName);
    STDMETHOD(COMGETTER(ProductKey))(BSTR *aProductKey);
    STDMETHOD(COMSETTER(ProductKey))(IN_BSTR aProductKey);
    STDMETHOD(COMGETTER(AdditionsIsoPath))(BSTR *aAdditionsIsoPath);
    STDMETHOD(COMSETTER(AdditionsIsoPath))(IN_BSTR aAdditionsIsoPath);
    STDMETHOD(COMGETTER(InstallGuestAdditions))(BOOL *aInstallGuestAdditions);
    STDMETHOD(COMSETTER(InstallGuestAdditions))(BOOL aInstallGuestAdditions);
    STDMETHOD(COMGETTER(ValidationKitIsoPath))(BSTR *aValidationKitIsoPath);
    STDMETHOD(COMSETTER(ValidationKitIsoPath))(IN_BSTR aValidationKitIsoPath);
    STDMETHOD(COMGETTER(InstallTestExecService))(BOOL *aInstallTestExecService);
    STDMETHOD(COMSETTER(InstallTestExecService))(BOOL aInstallTestExecService);
    STDMETHOD(COMGETTER(TimeZone))(BSTR *aTimeZone);
    STDMETHOD(COMSETTER(TimeZone))(IN_BSTR aTimeZone);
    STDMETHOD(COMGETTER(Locale))(BSTR *aLocale);
    STDMETHOD(COMSETTER(Locale))(IN_BSTR aLocale);
    STDMETHOD(COMGETTER(Language))(BSTR *aLanguage);
    STDMETHOD(COMSETTER(Language))(IN_BSTR aLanguage);
    STDMETHOD(COMGETTER(Country))(BSTR *aCountry);
    STDMETHOD(COMSETTER(Country))(IN_BSTR aCountry);
    STDMETHOD(COMGETTER(Proxy))(BSTR *aProxy);
    STDMETHOD(COMSETTER(Proxy))(IN_BSTR aProxy);
    STDMETHOD(COMGETTER(PackageSelectionAdjustments))(BSTR *aPackageSelectionAdjustments);
    STDMETHOD(COMSETTER(PackageSelectionAdjustments))(IN_BSTR aPackageSelectionAdjustments);
    STDMETHOD(COMGETTER(Hostname))(BSTR *aHostname);
    STDMETHOD(COMSETTER(Hostname))(IN_BSTR aHostname);
    STDMETHOD(COMGETTER(AuxiliaryBasePath))(BSTR *aAuxiliaryBasePath);
    STDMETHOD(COMSETTER(AuxiliaryBasePath))(IN_BSTR aAuxiliaryBasePath);
    STDMETHOD(COMGETTER(ImageIndex))(ULONG *aImageIndex);
    STDMETHOD(COMSETTER(ImageIndex))(ULONG aImageIndex);
    STDMETHOD(COMGETTER(ScriptTemplatePath))(BSTR *aScriptTemplatePath);
    STDMETHOD(COMSETTER(ScriptTemplatePath))(IN_BSTR aScriptTemplatePath);
    STDMETHOD(COMGETTER(PostInstallScriptTemplatePath))(BSTR *aPostInstallScriptTemplatePath);
    STDMETHOD(COMSETTER(PostInstallScriptTemplatePath))(IN_BSTR aPostInstallScriptTemplatePath);
    STDMETHOD(COMGETTER(PostInstallCommand))(BSTR *aPostInstallCommand);
    STDMETHOD(COMSETTER(PostInstallCommand))(IN_BSTR aPostInstallCommand);
    STDMETHOD(COMGETTER(ExtraInstallKernelParameters))(BSTR *aExtraInstallKernelParameters);
    STDMETHOD(COMSETTER(ExtraInstallKernelParameters))(IN_BSTR aExtraInstallKernelParameters);
    STDMETHOD(COMGETTER(DetectedOSTypeId))(BSTR *aDetectedOSTypeId);
    STDMETHOD(COMGETTER(DetectedOSVersion))(BSTR *aDetectedOSVersion);
    STDMETHOD(COMGETTER(DetectedOSFlavor))(BSTR *aDetectedOSFlavor);
    STDMETHOD(COMGETTER(DetectedOSLanguages))(BSTR *aDetectedOSLanguages);
    STDMETHOD(COMGETTER(DetectedOSHints))(BSTR *aDetectedOSHints);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IUnattended))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IUnattended))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IUnattended))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IUnattended))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IUnattended))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IUnattended))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IUnattended))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IUnattended))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute9IUnattended))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute10IUnattended))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute11IUnattended))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute12IUnattended))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute13IUnattended))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute14IUnattended))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute15IUnattended))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute16IUnattended))(ULONG *aReserved);
    /** @} */

    /** @name Public IUnattended methods
     * @{ */
    STDMETHOD(DetectIsoOS)();
    STDMETHOD(Prepare)();
    STDMETHOD(ConstructMedia)();
    STDMETHOD(ReconfigureVM)();
    STDMETHOD(Done)();
    STDMETHOD(InternalAndReservedMethod1IUnattended)();
    STDMETHOD(InternalAndReservedMethod2IUnattended)();
    STDMETHOD(InternalAndReservedMethod3IUnattended)();
    STDMETHOD(InternalAndReservedMethod4IUnattended)();
    /** @} */

private:
    /** @name Wrapped IUnattended properties
     * @{ */
    virtual HRESULT getIsoPath(com::Utf8Str &aIsoPath) = 0;
    virtual HRESULT setIsoPath(const com::Utf8Str &aIsoPath) = 0;
    virtual HRESULT getMachine(ComPtr<IMachine> &aMachine) = 0;
    virtual HRESULT setMachine(const ComPtr<IMachine> &aMachine) = 0;
    virtual HRESULT getUser(com::Utf8Str &aUser) = 0;
    virtual HRESULT setUser(const com::Utf8Str &aUser) = 0;
    virtual HRESULT getPassword(com::Utf8Str &aPassword) = 0;
    virtual HRESULT setPassword(const com::Utf8Str &aPassword) = 0;
    virtual HRESULT getFullUserName(com::Utf8Str &aFullUserName) = 0;
    virtual HRESULT setFullUserName(const com::Utf8Str &aFullUserName) = 0;
    virtual HRESULT getProductKey(com::Utf8Str &aProductKey) = 0;
    virtual HRESULT setProductKey(const com::Utf8Str &aProductKey) = 0;
    virtual HRESULT getAdditionsIsoPath(com::Utf8Str &aAdditionsIsoPath) = 0;
    virtual HRESULT setAdditionsIsoPath(const com::Utf8Str &aAdditionsIsoPath) = 0;
    virtual HRESULT getInstallGuestAdditions(BOOL *aInstallGuestAdditions) = 0;
    virtual HRESULT setInstallGuestAdditions(BOOL aInstallGuestAdditions) = 0;
    virtual HRESULT getValidationKitIsoPath(com::Utf8Str &aValidationKitIsoPath) = 0;
    virtual HRESULT setValidationKitIsoPath(const com::Utf8Str &aValidationKitIsoPath) = 0;
    virtual HRESULT getInstallTestExecService(BOOL *aInstallTestExecService) = 0;
    virtual HRESULT setInstallTestExecService(BOOL aInstallTestExecService) = 0;
    virtual HRESULT getTimeZone(com::Utf8Str &aTimeZone) = 0;
    virtual HRESULT setTimeZone(const com::Utf8Str &aTimeZone) = 0;
    virtual HRESULT getLocale(com::Utf8Str &aLocale) = 0;
    virtual HRESULT setLocale(const com::Utf8Str &aLocale) = 0;
    virtual HRESULT getLanguage(com::Utf8Str &aLanguage) = 0;
    virtual HRESULT setLanguage(const com::Utf8Str &aLanguage) = 0;
    virtual HRESULT getCountry(com::Utf8Str &aCountry) = 0;
    virtual HRESULT setCountry(const com::Utf8Str &aCountry) = 0;
    virtual HRESULT getProxy(com::Utf8Str &aProxy) = 0;
    virtual HRESULT setProxy(const com::Utf8Str &aProxy) = 0;
    virtual HRESULT getPackageSelectionAdjustments(com::Utf8Str &aPackageSelectionAdjustments) = 0;
    virtual HRESULT setPackageSelectionAdjustments(const com::Utf8Str &aPackageSelectionAdjustments) = 0;
    virtual HRESULT getHostname(com::Utf8Str &aHostname) = 0;
    virtual HRESULT setHostname(const com::Utf8Str &aHostname) = 0;
    virtual HRESULT getAuxiliaryBasePath(com::Utf8Str &aAuxiliaryBasePath) = 0;
    virtual HRESULT setAuxiliaryBasePath(const com::Utf8Str &aAuxiliaryBasePath) = 0;
    virtual HRESULT getImageIndex(ULONG *aImageIndex) = 0;
    virtual HRESULT setImageIndex(ULONG aImageIndex) = 0;
    virtual HRESULT getScriptTemplatePath(com::Utf8Str &aScriptTemplatePath) = 0;
    virtual HRESULT setScriptTemplatePath(const com::Utf8Str &aScriptTemplatePath) = 0;
    virtual HRESULT getPostInstallScriptTemplatePath(com::Utf8Str &aPostInstallScriptTemplatePath) = 0;
    virtual HRESULT setPostInstallScriptTemplatePath(const com::Utf8Str &aPostInstallScriptTemplatePath) = 0;
    virtual HRESULT getPostInstallCommand(com::Utf8Str &aPostInstallCommand) = 0;
    virtual HRESULT setPostInstallCommand(const com::Utf8Str &aPostInstallCommand) = 0;
    virtual HRESULT getExtraInstallKernelParameters(com::Utf8Str &aExtraInstallKernelParameters) = 0;
    virtual HRESULT setExtraInstallKernelParameters(const com::Utf8Str &aExtraInstallKernelParameters) = 0;
    virtual HRESULT getDetectedOSTypeId(com::Utf8Str &aDetectedOSTypeId) = 0;
    virtual HRESULT getDetectedOSVersion(com::Utf8Str &aDetectedOSVersion) = 0;
    virtual HRESULT getDetectedOSFlavor(com::Utf8Str &aDetectedOSFlavor) = 0;
    virtual HRESULT getDetectedOSLanguages(com::Utf8Str &aDetectedOSLanguages) = 0;
    virtual HRESULT getDetectedOSHints(com::Utf8Str &aDetectedOSHints) = 0;
    /** @} */

    /** @name Wrapped IUnattended methods
     * @{ */
    virtual HRESULT detectIsoOS() = 0;
    virtual HRESULT prepare() = 0;
    virtual HRESULT constructMedia() = 0;
    virtual HRESULT reconfigureVM() = 0;
    virtual HRESULT done() = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(UnattendedWrap); /* Shuts up MSC warning C4625. */

};

#endif // !UnattendedWrap_H_

// ##### ENDFILE "UnattendedWrap.h"


// ##### BEGINFILE "GraphicsAdapterWrap.h"
/** @file
 * VirtualBox API class wrapper header for IGraphicsAdapter.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef GraphicsAdapterWrap_H_
#define GraphicsAdapterWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE GraphicsAdapterWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IGraphicsAdapter)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(GraphicsAdapterWrap, IGraphicsAdapter)
    DECLARE_NOT_AGGREGATABLE(GraphicsAdapterWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(GraphicsAdapterWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IGraphicsAdapter)
        COM_INTERFACE_ENTRY2(IDispatch, IGraphicsAdapter)
        VBOX_TWEAK_INTERFACE_ENTRY(IGraphicsAdapter)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(GraphicsAdapterWrap)

    /** @name Public IGraphicsAdapter properties
     * @{ */
    STDMETHOD(COMGETTER(GraphicsControllerType))(GraphicsControllerType_T *aGraphicsControllerType);
    STDMETHOD(COMSETTER(GraphicsControllerType))(GraphicsControllerType_T aGraphicsControllerType);
    STDMETHOD(COMGETTER(VRAMSize))(ULONG *aVRAMSize);
    STDMETHOD(COMSETTER(VRAMSize))(ULONG aVRAMSize);
    STDMETHOD(COMGETTER(Accelerate3DEnabled))(BOOL *aAccelerate3DEnabled);
    STDMETHOD(COMSETTER(Accelerate3DEnabled))(BOOL aAccelerate3DEnabled);
    STDMETHOD(COMGETTER(Accelerate2DVideoEnabled))(BOOL *aAccelerate2DVideoEnabled);
    STDMETHOD(COMSETTER(Accelerate2DVideoEnabled))(BOOL aAccelerate2DVideoEnabled);
    STDMETHOD(COMGETTER(MonitorCount))(ULONG *aMonitorCount);
    STDMETHOD(COMSETTER(MonitorCount))(ULONG aMonitorCount);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IGraphicsAdapter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IGraphicsAdapter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IGraphicsAdapter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IGraphicsAdapter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IGraphicsAdapter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IGraphicsAdapter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IGraphicsAdapter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IGraphicsAdapter))(ULONG *aReserved);
    /** @} */

    /** @name Public IGraphicsAdapter methods
     * @{ */
    STDMETHOD(InternalAndReservedMethod1IGraphicsAdapter)();
    STDMETHOD(InternalAndReservedMethod2IGraphicsAdapter)();
    STDMETHOD(InternalAndReservedMethod3IGraphicsAdapter)();
    STDMETHOD(InternalAndReservedMethod4IGraphicsAdapter)();
    /** @} */

private:
    /** @name Wrapped IGraphicsAdapter properties
     * @{ */
    virtual HRESULT getGraphicsControllerType(GraphicsControllerType_T *aGraphicsControllerType) = 0;
    virtual HRESULT setGraphicsControllerType(GraphicsControllerType_T aGraphicsControllerType) = 0;
    virtual HRESULT getVRAMSize(ULONG *aVRAMSize) = 0;
    virtual HRESULT setVRAMSize(ULONG aVRAMSize) = 0;
    virtual HRESULT getAccelerate3DEnabled(BOOL *aAccelerate3DEnabled) = 0;
    virtual HRESULT setAccelerate3DEnabled(BOOL aAccelerate3DEnabled) = 0;
    virtual HRESULT getAccelerate2DVideoEnabled(BOOL *aAccelerate2DVideoEnabled) = 0;
    virtual HRESULT setAccelerate2DVideoEnabled(BOOL aAccelerate2DVideoEnabled) = 0;
    virtual HRESULT getMonitorCount(ULONG *aMonitorCount) = 0;
    virtual HRESULT setMonitorCount(ULONG aMonitorCount) = 0;
    /** @} */

    /** @name Wrapped IGraphicsAdapter methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(GraphicsAdapterWrap); /* Shuts up MSC warning C4625. */

};

#endif // !GraphicsAdapterWrap_H_

// ##### ENDFILE "GraphicsAdapterWrap.h"


// ##### BEGINFILE "BIOSSettingsWrap.h"
/** @file
 * VirtualBox API class wrapper header for IBIOSSettings.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef BIOSSettingsWrap_H_
#define BIOSSettingsWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE BIOSSettingsWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IBIOSSettings)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(BIOSSettingsWrap, IBIOSSettings)
    DECLARE_NOT_AGGREGATABLE(BIOSSettingsWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(BIOSSettingsWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IBIOSSettings)
        COM_INTERFACE_ENTRY2(IDispatch, IBIOSSettings)
        VBOX_TWEAK_INTERFACE_ENTRY(IBIOSSettings)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(BIOSSettingsWrap)

    /** @name Public IBIOSSettings properties
     * @{ */
    STDMETHOD(COMGETTER(LogoFadeIn))(BOOL *aLogoFadeIn);
    STDMETHOD(COMSETTER(LogoFadeIn))(BOOL aLogoFadeIn);
    STDMETHOD(COMGETTER(LogoFadeOut))(BOOL *aLogoFadeOut);
    STDMETHOD(COMSETTER(LogoFadeOut))(BOOL aLogoFadeOut);
    STDMETHOD(COMGETTER(LogoDisplayTime))(ULONG *aLogoDisplayTime);
    STDMETHOD(COMSETTER(LogoDisplayTime))(ULONG aLogoDisplayTime);
    STDMETHOD(COMGETTER(LogoImagePath))(BSTR *aLogoImagePath);
    STDMETHOD(COMSETTER(LogoImagePath))(IN_BSTR aLogoImagePath);
    STDMETHOD(COMGETTER(BootMenuMode))(BIOSBootMenuMode_T *aBootMenuMode);
    STDMETHOD(COMSETTER(BootMenuMode))(BIOSBootMenuMode_T aBootMenuMode);
    STDMETHOD(COMGETTER(ACPIEnabled))(BOOL *aACPIEnabled);
    STDMETHOD(COMSETTER(ACPIEnabled))(BOOL aACPIEnabled);
    STDMETHOD(COMGETTER(IOAPICEnabled))(BOOL *aIOAPICEnabled);
    STDMETHOD(COMSETTER(IOAPICEnabled))(BOOL aIOAPICEnabled);
    STDMETHOD(COMGETTER(APICMode))(APICMode_T *aAPICMode);
    STDMETHOD(COMSETTER(APICMode))(APICMode_T aAPICMode);
    STDMETHOD(COMGETTER(TimeOffset))(LONG64 *aTimeOffset);
    STDMETHOD(COMSETTER(TimeOffset))(LONG64 aTimeOffset);
    STDMETHOD(COMGETTER(PXEDebugEnabled))(BOOL *aPXEDebugEnabled);
    STDMETHOD(COMSETTER(PXEDebugEnabled))(BOOL aPXEDebugEnabled);
    STDMETHOD(COMGETTER(NonVolatileStorageFile))(BSTR *aNonVolatileStorageFile);
    STDMETHOD(COMGETTER(SMBIOSUuidLittleEndian))(BOOL *aSMBIOSUuidLittleEndian);
    STDMETHOD(COMSETTER(SMBIOSUuidLittleEndian))(BOOL aSMBIOSUuidLittleEndian);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IBIOSSettings))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IBIOSSettings))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IBIOSSettings))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IBIOSSettings))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IBIOSSettings))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IBIOSSettings))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IBIOSSettings))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IBIOSSettings))(ULONG *aReserved);
    /** @} */

    /** @name Public IBIOSSettings methods
     * @{ */
    STDMETHOD(InternalAndReservedMethod1IBIOSSettings)();
    STDMETHOD(InternalAndReservedMethod2IBIOSSettings)();
    /** @} */

private:
    /** @name Wrapped IBIOSSettings properties
     * @{ */
    virtual HRESULT getLogoFadeIn(BOOL *aLogoFadeIn) = 0;
    virtual HRESULT setLogoFadeIn(BOOL aLogoFadeIn) = 0;
    virtual HRESULT getLogoFadeOut(BOOL *aLogoFadeOut) = 0;
    virtual HRESULT setLogoFadeOut(BOOL aLogoFadeOut) = 0;
    virtual HRESULT getLogoDisplayTime(ULONG *aLogoDisplayTime) = 0;
    virtual HRESULT setLogoDisplayTime(ULONG aLogoDisplayTime) = 0;
    virtual HRESULT getLogoImagePath(com::Utf8Str &aLogoImagePath) = 0;
    virtual HRESULT setLogoImagePath(const com::Utf8Str &aLogoImagePath) = 0;
    virtual HRESULT getBootMenuMode(BIOSBootMenuMode_T *aBootMenuMode) = 0;
    virtual HRESULT setBootMenuMode(BIOSBootMenuMode_T aBootMenuMode) = 0;
    virtual HRESULT getACPIEnabled(BOOL *aACPIEnabled) = 0;
    virtual HRESULT setACPIEnabled(BOOL aACPIEnabled) = 0;
    virtual HRESULT getIOAPICEnabled(BOOL *aIOAPICEnabled) = 0;
    virtual HRESULT setIOAPICEnabled(BOOL aIOAPICEnabled) = 0;
    virtual HRESULT getAPICMode(APICMode_T *aAPICMode) = 0;
    virtual HRESULT setAPICMode(APICMode_T aAPICMode) = 0;
    virtual HRESULT getTimeOffset(LONG64 *aTimeOffset) = 0;
    virtual HRESULT setTimeOffset(LONG64 aTimeOffset) = 0;
    virtual HRESULT getPXEDebugEnabled(BOOL *aPXEDebugEnabled) = 0;
    virtual HRESULT setPXEDebugEnabled(BOOL aPXEDebugEnabled) = 0;
    virtual HRESULT getNonVolatileStorageFile(com::Utf8Str &aNonVolatileStorageFile) = 0;
    virtual HRESULT getSMBIOSUuidLittleEndian(BOOL *aSMBIOSUuidLittleEndian) = 0;
    virtual HRESULT setSMBIOSUuidLittleEndian(BOOL aSMBIOSUuidLittleEndian) = 0;
    /** @} */

    /** @name Wrapped IBIOSSettings methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(BIOSSettingsWrap); /* Shuts up MSC warning C4625. */

};

#endif // !BIOSSettingsWrap_H_

// ##### ENDFILE "BIOSSettingsWrap.h"


// ##### BEGINFILE "RecordingScreenSettingsWrap.h"
/** @file
 * VirtualBox API class wrapper header for IRecordingScreenSettings.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef RecordingScreenSettingsWrap_H_
#define RecordingScreenSettingsWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE RecordingScreenSettingsWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IRecordingScreenSettings)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(RecordingScreenSettingsWrap, IRecordingScreenSettings)
    DECLARE_NOT_AGGREGATABLE(RecordingScreenSettingsWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(RecordingScreenSettingsWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IRecordingScreenSettings)
        COM_INTERFACE_ENTRY2(IDispatch, IRecordingScreenSettings)
        VBOX_TWEAK_INTERFACE_ENTRY(IRecordingScreenSettings)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(RecordingScreenSettingsWrap)

    /** @name Public IRecordingScreenSettings properties
     * @{ */
    STDMETHOD(COMGETTER(Id))(ULONG *aId);
    STDMETHOD(COMGETTER(Enabled))(BOOL *aEnabled);
    STDMETHOD(COMSETTER(Enabled))(BOOL aEnabled);
    STDMETHOD(COMGETTER(Features))(ULONG *aFeatures);
    STDMETHOD(COMSETTER(Features))(ULONG aFeatures);
    STDMETHOD(COMGETTER(Destination))(RecordingDestination_T *aDestination);
    STDMETHOD(COMSETTER(Destination))(RecordingDestination_T aDestination);
    STDMETHOD(COMGETTER(Filename))(BSTR *aFilename);
    STDMETHOD(COMSETTER(Filename))(IN_BSTR aFilename);
    STDMETHOD(COMGETTER(MaxTime))(ULONG *aMaxTime);
    STDMETHOD(COMSETTER(MaxTime))(ULONG aMaxTime);
    STDMETHOD(COMGETTER(MaxFileSize))(ULONG *aMaxFileSize);
    STDMETHOD(COMSETTER(MaxFileSize))(ULONG aMaxFileSize);
    STDMETHOD(COMGETTER(Options))(BSTR *aOptions);
    STDMETHOD(COMSETTER(Options))(IN_BSTR aOptions);
    STDMETHOD(COMGETTER(AudioCodec))(RecordingAudioCodec_T *aAudioCodec);
    STDMETHOD(COMSETTER(AudioCodec))(RecordingAudioCodec_T aAudioCodec);
    STDMETHOD(COMGETTER(AudioHz))(ULONG *aAudioHz);
    STDMETHOD(COMSETTER(AudioHz))(ULONG aAudioHz);
    STDMETHOD(COMGETTER(AudioBits))(ULONG *aAudioBits);
    STDMETHOD(COMSETTER(AudioBits))(ULONG aAudioBits);
    STDMETHOD(COMGETTER(AudioChannels))(ULONG *aAudioChannels);
    STDMETHOD(COMSETTER(AudioChannels))(ULONG aAudioChannels);
    STDMETHOD(COMGETTER(VideoCodec))(RecordingVideoCodec_T *aVideoCodec);
    STDMETHOD(COMSETTER(VideoCodec))(RecordingVideoCodec_T aVideoCodec);
    STDMETHOD(COMGETTER(VideoWidth))(ULONG *aVideoWidth);
    STDMETHOD(COMSETTER(VideoWidth))(ULONG aVideoWidth);
    STDMETHOD(COMGETTER(VideoHeight))(ULONG *aVideoHeight);
    STDMETHOD(COMSETTER(VideoHeight))(ULONG aVideoHeight);
    STDMETHOD(COMGETTER(VideoRate))(ULONG *aVideoRate);
    STDMETHOD(COMSETTER(VideoRate))(ULONG aVideoRate);
    STDMETHOD(COMGETTER(VideoRateControlMode))(RecordingVideoRateControlMode_T *aVideoRateControlMode);
    STDMETHOD(COMSETTER(VideoRateControlMode))(RecordingVideoRateControlMode_T aVideoRateControlMode);
    STDMETHOD(COMGETTER(VideoFPS))(ULONG *aVideoFPS);
    STDMETHOD(COMSETTER(VideoFPS))(ULONG aVideoFPS);
    STDMETHOD(COMGETTER(VideoScalingMethod))(RecordingVideoScalingMethod_T *aVideoScalingMethod);
    STDMETHOD(COMSETTER(VideoScalingMethod))(RecordingVideoScalingMethod_T aVideoScalingMethod);
    /** @} */

    /** @name Public IRecordingScreenSettings methods
     * @{ */
    STDMETHOD(IsFeatureEnabled)(RecordingFeature_T aFeature,
                                BOOL *aEnabled);
    /** @} */

private:
    /** @name Wrapped IRecordingScreenSettings properties
     * @{ */
    virtual HRESULT getId(ULONG *aId) = 0;
    virtual HRESULT getEnabled(BOOL *aEnabled) = 0;
    virtual HRESULT setEnabled(BOOL aEnabled) = 0;
    virtual HRESULT getFeatures(ULONG *aFeatures) = 0;
    virtual HRESULT setFeatures(ULONG aFeatures) = 0;
    virtual HRESULT getDestination(RecordingDestination_T *aDestination) = 0;
    virtual HRESULT setDestination(RecordingDestination_T aDestination) = 0;
    virtual HRESULT getFilename(com::Utf8Str &aFilename) = 0;
    virtual HRESULT setFilename(const com::Utf8Str &aFilename) = 0;
    virtual HRESULT getMaxTime(ULONG *aMaxTime) = 0;
    virtual HRESULT setMaxTime(ULONG aMaxTime) = 0;
    virtual HRESULT getMaxFileSize(ULONG *aMaxFileSize) = 0;
    virtual HRESULT setMaxFileSize(ULONG aMaxFileSize) = 0;
    virtual HRESULT getOptions(com::Utf8Str &aOptions) = 0;
    virtual HRESULT setOptions(const com::Utf8Str &aOptions) = 0;
    virtual HRESULT getAudioCodec(RecordingAudioCodec_T *aAudioCodec) = 0;
    virtual HRESULT setAudioCodec(RecordingAudioCodec_T aAudioCodec) = 0;
    virtual HRESULT getAudioHz(ULONG *aAudioHz) = 0;
    virtual HRESULT setAudioHz(ULONG aAudioHz) = 0;
    virtual HRESULT getAudioBits(ULONG *aAudioBits) = 0;
    virtual HRESULT setAudioBits(ULONG aAudioBits) = 0;
    virtual HRESULT getAudioChannels(ULONG *aAudioChannels) = 0;
    virtual HRESULT setAudioChannels(ULONG aAudioChannels) = 0;
    virtual HRESULT getVideoCodec(RecordingVideoCodec_T *aVideoCodec) = 0;
    virtual HRESULT setVideoCodec(RecordingVideoCodec_T aVideoCodec) = 0;
    virtual HRESULT getVideoWidth(ULONG *aVideoWidth) = 0;
    virtual HRESULT setVideoWidth(ULONG aVideoWidth) = 0;
    virtual HRESULT getVideoHeight(ULONG *aVideoHeight) = 0;
    virtual HRESULT setVideoHeight(ULONG aVideoHeight) = 0;
    virtual HRESULT getVideoRate(ULONG *aVideoRate) = 0;
    virtual HRESULT setVideoRate(ULONG aVideoRate) = 0;
    virtual HRESULT getVideoRateControlMode(RecordingVideoRateControlMode_T *aVideoRateControlMode) = 0;
    virtual HRESULT setVideoRateControlMode(RecordingVideoRateControlMode_T aVideoRateControlMode) = 0;
    virtual HRESULT getVideoFPS(ULONG *aVideoFPS) = 0;
    virtual HRESULT setVideoFPS(ULONG aVideoFPS) = 0;
    virtual HRESULT getVideoScalingMethod(RecordingVideoScalingMethod_T *aVideoScalingMethod) = 0;
    virtual HRESULT setVideoScalingMethod(RecordingVideoScalingMethod_T aVideoScalingMethod) = 0;
    /** @} */

    /** @name Wrapped IRecordingScreenSettings methods
     * @{ */
    virtual HRESULT isFeatureEnabled(RecordingFeature_T aFeature,
                                     BOOL *aEnabled) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(RecordingScreenSettingsWrap); /* Shuts up MSC warning C4625. */

};

#endif // !RecordingScreenSettingsWrap_H_

// ##### ENDFILE "RecordingScreenSettingsWrap.h"


// ##### BEGINFILE "RecordingSettingsWrap.h"
/** @file
 * VirtualBox API class wrapper header for IRecordingSettings.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef RecordingSettingsWrap_H_
#define RecordingSettingsWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE RecordingSettingsWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IRecordingSettings)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(RecordingSettingsWrap, IRecordingSettings)
    DECLARE_NOT_AGGREGATABLE(RecordingSettingsWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(RecordingSettingsWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IRecordingSettings)
        COM_INTERFACE_ENTRY2(IDispatch, IRecordingSettings)
        VBOX_TWEAK_INTERFACE_ENTRY(IRecordingSettings)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(RecordingSettingsWrap)

    /** @name Public IRecordingSettings properties
     * @{ */
    STDMETHOD(COMGETTER(Enabled))(BOOL *aEnabled);
    STDMETHOD(COMSETTER(Enabled))(BOOL aEnabled);
    STDMETHOD(COMGETTER(Screens))(ComSafeArrayOut(IRecordingScreenSettings *, aScreens));
    /** @} */

    /** @name Public IRecordingSettings methods
     * @{ */
    STDMETHOD(GetScreenSettings)(ULONG aScreenId,
                                 IRecordingScreenSettings **aRecordScreenSettings);
    /** @} */

private:
    /** @name Wrapped IRecordingSettings properties
     * @{ */
    virtual HRESULT getEnabled(BOOL *aEnabled) = 0;
    virtual HRESULT setEnabled(BOOL aEnabled) = 0;
    virtual HRESULT getScreens(std::vector<ComPtr<IRecordingScreenSettings> > &aScreens) = 0;
    /** @} */

    /** @name Wrapped IRecordingSettings methods
     * @{ */
    virtual HRESULT getScreenSettings(ULONG aScreenId,
                                      ComPtr<IRecordingScreenSettings> &aRecordScreenSettings) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(RecordingSettingsWrap); /* Shuts up MSC warning C4625. */

};

#endif // !RecordingSettingsWrap_H_

// ##### ENDFILE "RecordingSettingsWrap.h"


// ##### BEGINFILE "PCIAddressWrap.h"
/** @file
 * VirtualBox API class wrapper header for IPCIAddress.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef PCIAddressWrap_H_
#define PCIAddressWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE PCIAddressWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IPCIAddress)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(PCIAddressWrap, IPCIAddress)
    DECLARE_NOT_AGGREGATABLE(PCIAddressWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(PCIAddressWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IPCIAddress)
        COM_INTERFACE_ENTRY2(IDispatch, IPCIAddress)
        VBOX_TWEAK_INTERFACE_ENTRY(IPCIAddress)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(PCIAddressWrap)

    /** @name Public IPCIAddress properties
     * @{ */
    STDMETHOD(COMGETTER(Bus))(SHORT *aBus);
    STDMETHOD(COMSETTER(Bus))(SHORT aBus);
    STDMETHOD(COMGETTER(Device))(SHORT *aDevice);
    STDMETHOD(COMSETTER(Device))(SHORT aDevice);
    STDMETHOD(COMGETTER(DevFunction))(SHORT *aDevFunction);
    STDMETHOD(COMSETTER(DevFunction))(SHORT aDevFunction);
    /** @} */

    /** @name Public IPCIAddress methods
     * @{ */
    STDMETHOD(AsLong)(LONG *aResult);
    STDMETHOD(FromLong)(LONG aNumber);
    /** @} */

private:
    /** @name Wrapped IPCIAddress properties
     * @{ */
    virtual HRESULT getBus(SHORT *aBus) = 0;
    virtual HRESULT setBus(SHORT aBus) = 0;
    virtual HRESULT getDevice(SHORT *aDevice) = 0;
    virtual HRESULT setDevice(SHORT aDevice) = 0;
    virtual HRESULT getDevFunction(SHORT *aDevFunction) = 0;
    virtual HRESULT setDevFunction(SHORT aDevFunction) = 0;
    /** @} */

    /** @name Wrapped IPCIAddress methods
     * @{ */
    virtual HRESULT asLong(LONG *aResult) = 0;
    virtual HRESULT fromLong(LONG aNumber) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(PCIAddressWrap); /* Shuts up MSC warning C4625. */

};

#endif // !PCIAddressWrap_H_

// ##### ENDFILE "PCIAddressWrap.h"


// ##### BEGINFILE "PCIDeviceAttachmentWrap.h"
/** @file
 * VirtualBox API class wrapper header for IPCIDeviceAttachment.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef PCIDeviceAttachmentWrap_H_
#define PCIDeviceAttachmentWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE PCIDeviceAttachmentWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IPCIDeviceAttachment)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(PCIDeviceAttachmentWrap, IPCIDeviceAttachment)
    DECLARE_NOT_AGGREGATABLE(PCIDeviceAttachmentWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(PCIDeviceAttachmentWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IPCIDeviceAttachment)
        COM_INTERFACE_ENTRY2(IDispatch, IPCIDeviceAttachment)
        VBOX_TWEAK_INTERFACE_ENTRY(IPCIDeviceAttachment)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(PCIDeviceAttachmentWrap)

    /** @name Public IPCIDeviceAttachment properties
     * @{ */
    STDMETHOD(COMGETTER(Name))(BSTR *aName);
    STDMETHOD(COMGETTER(IsPhysicalDevice))(BOOL *aIsPhysicalDevice);
    STDMETHOD(COMGETTER(HostAddress))(LONG *aHostAddress);
    STDMETHOD(COMGETTER(GuestAddress))(LONG *aGuestAddress);
    /** @} */

    /** @name Public IPCIDeviceAttachment methods
     * @{ */
    /** @} */

private:
    /** @name Wrapped IPCIDeviceAttachment properties
     * @{ */
    virtual HRESULT getName(com::Utf8Str &aName) = 0;
    virtual HRESULT getIsPhysicalDevice(BOOL *aIsPhysicalDevice) = 0;
    virtual HRESULT getHostAddress(LONG *aHostAddress) = 0;
    virtual HRESULT getGuestAddress(LONG *aGuestAddress) = 0;
    /** @} */

    /** @name Wrapped IPCIDeviceAttachment methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(PCIDeviceAttachmentWrap); /* Shuts up MSC warning C4625. */

};

#endif // !PCIDeviceAttachmentWrap_H_

// ##### ENDFILE "PCIDeviceAttachmentWrap.h"


// ##### BEGINFILE "MachineWrap.h"
/** @file
 * VirtualBox API class wrapper header for IMachine.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef MachineWrap_H_
#define MachineWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE MachineWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IMachine)
    , VBOX_SCRIPTABLE_IMPL(IInternalMachineControl)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(MachineWrap, IMachine)
    DECLARE_NOT_AGGREGATABLE(MachineWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(MachineWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IMachine)
        COM_INTERFACE_ENTRY2(IDispatch, IMachine)
        VBOX_TWEAK_INTERFACE_ENTRY(IMachine)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(MachineWrap)

    /** @name Public IMachine properties
     * @{ */
    STDMETHOD(COMGETTER(Parent))(IVirtualBox **aParent);
    STDMETHOD(COMGETTER(Icon))(ComSafeArrayOut(BYTE, aIcon));
    STDMETHOD(COMSETTER(Icon))(ComSafeArrayIn(BYTE, aIcon));
    STDMETHOD(COMGETTER(Accessible))(BOOL *aAccessible);
    STDMETHOD(COMGETTER(AccessError))(IVirtualBoxErrorInfo **aAccessError);
    STDMETHOD(COMGETTER(Name))(BSTR *aName);
    STDMETHOD(COMSETTER(Name))(IN_BSTR aName);
    STDMETHOD(COMGETTER(Description))(BSTR *aDescription);
    STDMETHOD(COMSETTER(Description))(IN_BSTR aDescription);
    STDMETHOD(COMGETTER(Id))(BSTR *aId);
    STDMETHOD(COMGETTER(Groups))(ComSafeArrayOut(BSTR, aGroups));
    STDMETHOD(COMSETTER(Groups))(ComSafeArrayIn(IN_BSTR, aGroups));
    STDMETHOD(COMGETTER(OSTypeId))(BSTR *aOSTypeId);
    STDMETHOD(COMSETTER(OSTypeId))(IN_BSTR aOSTypeId);
    STDMETHOD(COMGETTER(HardwareVersion))(BSTR *aHardwareVersion);
    STDMETHOD(COMSETTER(HardwareVersion))(IN_BSTR aHardwareVersion);
    STDMETHOD(COMGETTER(HardwareUUID))(BSTR *aHardwareUUID);
    STDMETHOD(COMSETTER(HardwareUUID))(IN_BSTR aHardwareUUID);
    STDMETHOD(COMGETTER(CPUCount))(ULONG *aCPUCount);
    STDMETHOD(COMSETTER(CPUCount))(ULONG aCPUCount);
    STDMETHOD(COMGETTER(CPUHotPlugEnabled))(BOOL *aCPUHotPlugEnabled);
    STDMETHOD(COMSETTER(CPUHotPlugEnabled))(BOOL aCPUHotPlugEnabled);
    STDMETHOD(COMGETTER(CPUExecutionCap))(ULONG *aCPUExecutionCap);
    STDMETHOD(COMSETTER(CPUExecutionCap))(ULONG aCPUExecutionCap);
    STDMETHOD(COMGETTER(CPUIDPortabilityLevel))(ULONG *aCPUIDPortabilityLevel);
    STDMETHOD(COMSETTER(CPUIDPortabilityLevel))(ULONG aCPUIDPortabilityLevel);
    STDMETHOD(COMGETTER(MemorySize))(ULONG *aMemorySize);
    STDMETHOD(COMSETTER(MemorySize))(ULONG aMemorySize);
    STDMETHOD(COMGETTER(MemoryBalloonSize))(ULONG *aMemoryBalloonSize);
    STDMETHOD(COMSETTER(MemoryBalloonSize))(ULONG aMemoryBalloonSize);
    STDMETHOD(COMGETTER(PageFusionEnabled))(BOOL *aPageFusionEnabled);
    STDMETHOD(COMSETTER(PageFusionEnabled))(BOOL aPageFusionEnabled);
    STDMETHOD(COMGETTER(GraphicsAdapter))(IGraphicsAdapter **aGraphicsAdapter);
    STDMETHOD(COMGETTER(BIOSSettings))(IBIOSSettings **aBIOSSettings);
    STDMETHOD(COMGETTER(RecordingSettings))(IRecordingSettings **aRecordingSettings);
    STDMETHOD(COMGETTER(FirmwareType))(FirmwareType_T *aFirmwareType);
    STDMETHOD(COMSETTER(FirmwareType))(FirmwareType_T aFirmwareType);
    STDMETHOD(COMGETTER(PointingHIDType))(PointingHIDType_T *aPointingHIDType);
    STDMETHOD(COMSETTER(PointingHIDType))(PointingHIDType_T aPointingHIDType);
    STDMETHOD(COMGETTER(KeyboardHIDType))(KeyboardHIDType_T *aKeyboardHIDType);
    STDMETHOD(COMSETTER(KeyboardHIDType))(KeyboardHIDType_T aKeyboardHIDType);
    STDMETHOD(COMGETTER(HPETEnabled))(BOOL *aHPETEnabled);
    STDMETHOD(COMSETTER(HPETEnabled))(BOOL aHPETEnabled);
    STDMETHOD(COMGETTER(ChipsetType))(ChipsetType_T *aChipsetType);
    STDMETHOD(COMSETTER(ChipsetType))(ChipsetType_T aChipsetType);
    STDMETHOD(COMGETTER(SnapshotFolder))(BSTR *aSnapshotFolder);
    STDMETHOD(COMSETTER(SnapshotFolder))(IN_BSTR aSnapshotFolder);
    STDMETHOD(COMGETTER(VRDEServer))(IVRDEServer **aVRDEServer);
    STDMETHOD(COMGETTER(EmulatedUSBCardReaderEnabled))(BOOL *aEmulatedUSBCardReaderEnabled);
    STDMETHOD(COMSETTER(EmulatedUSBCardReaderEnabled))(BOOL aEmulatedUSBCardReaderEnabled);
    STDMETHOD(COMGETTER(MediumAttachments))(ComSafeArrayOut(IMediumAttachment *, aMediumAttachments));
    STDMETHOD(COMGETTER(USBControllers))(ComSafeArrayOut(IUSBController *, aUSBControllers));
    STDMETHOD(COMGETTER(USBDeviceFilters))(IUSBDeviceFilters **aUSBDeviceFilters);
    STDMETHOD(COMGETTER(AudioAdapter))(IAudioAdapter **aAudioAdapter);
    STDMETHOD(COMGETTER(StorageControllers))(ComSafeArrayOut(IStorageController *, aStorageControllers));
    STDMETHOD(COMGETTER(SettingsFilePath))(BSTR *aSettingsFilePath);
    STDMETHOD(COMGETTER(SettingsAuxFilePath))(BSTR *aSettingsAuxFilePath);
    STDMETHOD(COMGETTER(SettingsModified))(BOOL *aSettingsModified);
    STDMETHOD(COMGETTER(SessionState))(SessionState_T *aSessionState);
    STDMETHOD(COMGETTER(SessionName))(BSTR *aSessionName);
    STDMETHOD(COMGETTER(SessionPID))(ULONG *aSessionPID);
    STDMETHOD(COMGETTER(State))(MachineState_T *aState);
    STDMETHOD(COMGETTER(LastStateChange))(LONG64 *aLastStateChange);
    STDMETHOD(COMGETTER(StateFilePath))(BSTR *aStateFilePath);
    STDMETHOD(COMGETTER(LogFolder))(BSTR *aLogFolder);
    STDMETHOD(COMGETTER(CurrentSnapshot))(ISnapshot **aCurrentSnapshot);
    STDMETHOD(COMGETTER(SnapshotCount))(ULONG *aSnapshotCount);
    STDMETHOD(COMGETTER(CurrentStateModified))(BOOL *aCurrentStateModified);
    STDMETHOD(COMGETTER(SharedFolders))(ComSafeArrayOut(ISharedFolder *, aSharedFolders));
    STDMETHOD(COMGETTER(ClipboardMode))(ClipboardMode_T *aClipboardMode);
    STDMETHOD(COMSETTER(ClipboardMode))(ClipboardMode_T aClipboardMode);
    STDMETHOD(COMGETTER(ClipboardFileTransfersEnabled))(BOOL *aClipboardFileTransfersEnabled);
    STDMETHOD(COMSETTER(ClipboardFileTransfersEnabled))(BOOL aClipboardFileTransfersEnabled);
    STDMETHOD(COMGETTER(DnDMode))(DnDMode_T *aDnDMode);
    STDMETHOD(COMSETTER(DnDMode))(DnDMode_T aDnDMode);
    STDMETHOD(COMGETTER(TeleporterEnabled))(BOOL *aTeleporterEnabled);
    STDMETHOD(COMSETTER(TeleporterEnabled))(BOOL aTeleporterEnabled);
    STDMETHOD(COMGETTER(TeleporterPort))(ULONG *aTeleporterPort);
    STDMETHOD(COMSETTER(TeleporterPort))(ULONG aTeleporterPort);
    STDMETHOD(COMGETTER(TeleporterAddress))(BSTR *aTeleporterAddress);
    STDMETHOD(COMSETTER(TeleporterAddress))(IN_BSTR aTeleporterAddress);
    STDMETHOD(COMGETTER(TeleporterPassword))(BSTR *aTeleporterPassword);
    STDMETHOD(COMSETTER(TeleporterPassword))(IN_BSTR aTeleporterPassword);
    STDMETHOD(COMGETTER(ParavirtProvider))(ParavirtProvider_T *aParavirtProvider);
    STDMETHOD(COMSETTER(ParavirtProvider))(ParavirtProvider_T aParavirtProvider);
    STDMETHOD(COMGETTER(RTCUseUTC))(BOOL *aRTCUseUTC);
    STDMETHOD(COMSETTER(RTCUseUTC))(BOOL aRTCUseUTC);
    STDMETHOD(COMGETTER(IOCacheEnabled))(BOOL *aIOCacheEnabled);
    STDMETHOD(COMSETTER(IOCacheEnabled))(BOOL aIOCacheEnabled);
    STDMETHOD(COMGETTER(IOCacheSize))(ULONG *aIOCacheSize);
    STDMETHOD(COMSETTER(IOCacheSize))(ULONG aIOCacheSize);
    STDMETHOD(COMGETTER(PCIDeviceAssignments))(ComSafeArrayOut(IPCIDeviceAttachment *, aPCIDeviceAssignments));
    STDMETHOD(COMGETTER(BandwidthControl))(IBandwidthControl **aBandwidthControl);
    STDMETHOD(COMGETTER(TracingEnabled))(BOOL *aTracingEnabled);
    STDMETHOD(COMSETTER(TracingEnabled))(BOOL aTracingEnabled);
    STDMETHOD(COMGETTER(TracingConfig))(BSTR *aTracingConfig);
    STDMETHOD(COMSETTER(TracingConfig))(IN_BSTR aTracingConfig);
    STDMETHOD(COMGETTER(AllowTracingToAccessVM))(BOOL *aAllowTracingToAccessVM);
    STDMETHOD(COMSETTER(AllowTracingToAccessVM))(BOOL aAllowTracingToAccessVM);
    STDMETHOD(COMGETTER(AutostartEnabled))(BOOL *aAutostartEnabled);
    STDMETHOD(COMSETTER(AutostartEnabled))(BOOL aAutostartEnabled);
    STDMETHOD(COMGETTER(AutostartDelay))(ULONG *aAutostartDelay);
    STDMETHOD(COMSETTER(AutostartDelay))(ULONG aAutostartDelay);
    STDMETHOD(COMGETTER(AutostopType))(AutostopType_T *aAutostopType);
    STDMETHOD(COMSETTER(AutostopType))(AutostopType_T aAutostopType);
    STDMETHOD(COMGETTER(DefaultFrontend))(BSTR *aDefaultFrontend);
    STDMETHOD(COMSETTER(DefaultFrontend))(IN_BSTR aDefaultFrontend);
    STDMETHOD(COMGETTER(USBProxyAvailable))(BOOL *aUSBProxyAvailable);
    STDMETHOD(COMGETTER(VMProcessPriority))(VMProcPriority_T *aVMProcessPriority);
    STDMETHOD(COMSETTER(VMProcessPriority))(VMProcPriority_T aVMProcessPriority);
    STDMETHOD(COMGETTER(ParavirtDebug))(BSTR *aParavirtDebug);
    STDMETHOD(COMSETTER(ParavirtDebug))(IN_BSTR aParavirtDebug);
    STDMETHOD(COMGETTER(CPUProfile))(BSTR *aCPUProfile);
    STDMETHOD(COMSETTER(CPUProfile))(IN_BSTR aCPUProfile);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IMachine))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IMachine))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IMachine))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IMachine))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IMachine))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IMachine))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IMachine))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IMachine))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute9IMachine))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute10IMachine))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute11IMachine))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute12IMachine))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute13IMachine))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute14IMachine))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute15IMachine))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute16IMachine))(ULONG *aReserved);
    /** @} */

    /** @name Public IMachine methods
     * @{ */
    STDMETHOD(LockMachine)(ISession *aSession,
                           LockType_T aLockType);
    STDMETHOD(LaunchVMProcess)(ISession *aSession,
                               IN_BSTR aName,
                               ComSafeArrayIn(IN_BSTR, aEnvironmentChanges),
                               IProgress **aProgress);
    STDMETHOD(SetBootOrder)(ULONG aPosition,
                            DeviceType_T aDevice);
    STDMETHOD(GetBootOrder)(ULONG aPosition,
                            DeviceType_T *aDevice);
    STDMETHOD(AttachDevice)(IN_BSTR aName,
                            LONG aControllerPort,
                            LONG aDevice,
                            DeviceType_T aType,
                            IMedium *aMedium);
    STDMETHOD(AttachDeviceWithoutMedium)(IN_BSTR aName,
                                         LONG aControllerPort,
                                         LONG aDevice,
                                         DeviceType_T aType);
    STDMETHOD(DetachDevice)(IN_BSTR aName,
                            LONG aControllerPort,
                            LONG aDevice);
    STDMETHOD(PassthroughDevice)(IN_BSTR aName,
                                 LONG aControllerPort,
                                 LONG aDevice,
                                 BOOL aPassthrough);
    STDMETHOD(TemporaryEjectDevice)(IN_BSTR aName,
                                    LONG aControllerPort,
                                    LONG aDevice,
                                    BOOL aTemporaryEject);
    STDMETHOD(NonRotationalDevice)(IN_BSTR aName,
                                   LONG aControllerPort,
                                   LONG aDevice,
                                   BOOL aNonRotational);
    STDMETHOD(SetAutoDiscardForDevice)(IN_BSTR aName,
                                       LONG aControllerPort,
                                       LONG aDevice,
                                       BOOL aDiscard);
    STDMETHOD(SetHotPluggableForDevice)(IN_BSTR aName,
                                        LONG aControllerPort,
                                        LONG aDevice,
                                        BOOL aHotPluggable);
    STDMETHOD(SetBandwidthGroupForDevice)(IN_BSTR aName,
                                          LONG aControllerPort,
                                          LONG aDevice,
                                          IBandwidthGroup *aBandwidthGroup);
    STDMETHOD(SetNoBandwidthGroupForDevice)(IN_BSTR aName,
                                            LONG aControllerPort,
                                            LONG aDevice);
    STDMETHOD(UnmountMedium)(IN_BSTR aName,
                             LONG aControllerPort,
                             LONG aDevice,
                             BOOL aForce);
    STDMETHOD(MountMedium)(IN_BSTR aName,
                           LONG aControllerPort,
                           LONG aDevice,
                           IMedium *aMedium,
                           BOOL aForce);
    STDMETHOD(GetMedium)(IN_BSTR aName,
                         LONG aControllerPort,
                         LONG aDevice,
                         IMedium **aMedium);
    STDMETHOD(GetMediumAttachmentsOfController)(IN_BSTR aName,
                                                ComSafeArrayOut(IMediumAttachment *, aMediumAttachments));
    STDMETHOD(GetMediumAttachment)(IN_BSTR aName,
                                   LONG aControllerPort,
                                   LONG aDevice,
                                   IMediumAttachment **aAttachment);
    STDMETHOD(AttachHostPCIDevice)(LONG aHostAddress,
                                   LONG aDesiredGuestAddress,
                                   BOOL aTryToUnbind);
    STDMETHOD(DetachHostPCIDevice)(LONG aHostAddress);
    STDMETHOD(GetNetworkAdapter)(ULONG aSlot,
                                 INetworkAdapter **aAdapter);
    STDMETHOD(AddStorageController)(IN_BSTR aName,
                                    StorageBus_T aConnectionType,
                                    IStorageController **aController);
    STDMETHOD(GetStorageControllerByName)(IN_BSTR aName,
                                          IStorageController **aStorageController);
    STDMETHOD(GetStorageControllerByInstance)(StorageBus_T aConnectionType,
                                              ULONG aInstance,
                                              IStorageController **aStorageController);
    STDMETHOD(RemoveStorageController)(IN_BSTR aName);
    STDMETHOD(SetStorageControllerBootable)(IN_BSTR aName,
                                            BOOL aBootable);
    STDMETHOD(AddUSBController)(IN_BSTR aName,
                                USBControllerType_T aType,
                                IUSBController **aController);
    STDMETHOD(RemoveUSBController)(IN_BSTR aName);
    STDMETHOD(GetUSBControllerByName)(IN_BSTR aName,
                                      IUSBController **aController);
    STDMETHOD(GetUSBControllerCountByType)(USBControllerType_T aType,
                                           ULONG *aControllers);
    STDMETHOD(GetSerialPort)(ULONG aSlot,
                             ISerialPort **aPort);
    STDMETHOD(GetParallelPort)(ULONG aSlot,
                               IParallelPort **aPort);
    STDMETHOD(GetExtraDataKeys)(ComSafeArrayOut(BSTR, aKeys));
    STDMETHOD(GetExtraData)(IN_BSTR aKey,
                            BSTR *aValue);
    STDMETHOD(SetExtraData)(IN_BSTR aKey,
                            IN_BSTR aValue);
    STDMETHOD(GetCPUProperty)(CPUPropertyType_T aProperty,
                              BOOL *aValue);
    STDMETHOD(SetCPUProperty)(CPUPropertyType_T aProperty,
                              BOOL aValue);
    STDMETHOD(GetCPUIDLeafByOrdinal)(ULONG aOrdinal,
                                     ULONG *aIdx,
                                     ULONG *aIdxSub,
                                     ULONG *aValEax,
                                     ULONG *aValEbx,
                                     ULONG *aValEcx,
                                     ULONG *aValEdx);
    STDMETHOD(GetCPUIDLeaf)(ULONG aIdx,
                            ULONG aIdxSub,
                            ULONG *aValEax,
                            ULONG *aValEbx,
                            ULONG *aValEcx,
                            ULONG *aValEdx);
    STDMETHOD(SetCPUIDLeaf)(ULONG aIdx,
                            ULONG aIdxSub,
                            ULONG aValEax,
                            ULONG aValEbx,
                            ULONG aValEcx,
                            ULONG aValEdx);
    STDMETHOD(RemoveCPUIDLeaf)(ULONG aIdx,
                               ULONG aIdxSub);
    STDMETHOD(RemoveAllCPUIDLeaves)();
    STDMETHOD(GetHWVirtExProperty)(HWVirtExPropertyType_T aProperty,
                                   BOOL *aValue);
    STDMETHOD(SetHWVirtExProperty)(HWVirtExPropertyType_T aProperty,
                                   BOOL aValue);
    STDMETHOD(SetSettingsFilePath)(IN_BSTR aSettingsFilePath,
                                   IProgress **aProgress);
    STDMETHOD(SaveSettings)();
    STDMETHOD(DiscardSettings)();
    STDMETHOD(Unregister)(CleanupMode_T aCleanupMode,
                          ComSafeArrayOut(IMedium *, aMedia));
    STDMETHOD(DeleteConfig)(ComSafeArrayIn(IMedium *, aMedia),
                            IProgress **aProgress);
    STDMETHOD(ExportTo)(IAppliance *aAppliance,
                        IN_BSTR aLocation,
                        IVirtualSystemDescription **aDescription);
    STDMETHOD(FindSnapshot)(IN_BSTR aNameOrId,
                            ISnapshot **aSnapshot);
    STDMETHOD(CreateSharedFolder)(IN_BSTR aName,
                                  IN_BSTR aHostPath,
                                  BOOL aWritable,
                                  BOOL aAutomount,
                                  IN_BSTR aAutoMountPoint);
    STDMETHOD(RemoveSharedFolder)(IN_BSTR aName);
    STDMETHOD(CanShowConsoleWindow)(BOOL *aCanShow);
    STDMETHOD(ShowConsoleWindow)(LONG64 *aWinId);
    STDMETHOD(GetGuestProperty)(IN_BSTR aName,
                                BSTR *aValue,
                                LONG64 *aTimestamp,
                                BSTR *aFlags);
    STDMETHOD(GetGuestPropertyValue)(IN_BSTR aProperty,
                                     BSTR *aValue);
    STDMETHOD(GetGuestPropertyTimestamp)(IN_BSTR aProperty,
                                         LONG64 *aValue);
    STDMETHOD(SetGuestProperty)(IN_BSTR aProperty,
                                IN_BSTR aValue,
                                IN_BSTR aFlags);
    STDMETHOD(SetGuestPropertyValue)(IN_BSTR aProperty,
                                     IN_BSTR aValue);
    STDMETHOD(DeleteGuestProperty)(IN_BSTR aName);
    STDMETHOD(EnumerateGuestProperties)(IN_BSTR aPatterns,
                                        ComSafeArrayOut(BSTR, aNames),
                                        ComSafeArrayOut(BSTR, aValues),
                                        ComSafeArrayOut(LONG64, aTimestamps),
                                        ComSafeArrayOut(BSTR, aFlags));
    STDMETHOD(QuerySavedGuestScreenInfo)(ULONG aScreenId,
                                         ULONG *aOriginX,
                                         ULONG *aOriginY,
                                         ULONG *aWidth,
                                         ULONG *aHeight,
                                         BOOL *aEnabled);
    STDMETHOD(ReadSavedThumbnailToArray)(ULONG aScreenId,
                                         BitmapFormat_T aBitmapFormat,
                                         ULONG *aWidth,
                                         ULONG *aHeight,
                                         ComSafeArrayOut(BYTE, aData));
    STDMETHOD(QuerySavedScreenshotInfo)(ULONG aScreenId,
                                        ULONG *aWidth,
                                        ULONG *aHeight,
                                        ComSafeArrayOut(BitmapFormat_T, aBitmapFormats));
    STDMETHOD(ReadSavedScreenshotToArray)(ULONG aScreenId,
                                          BitmapFormat_T aBitmapFormat,
                                          ULONG *aWidth,
                                          ULONG *aHeight,
                                          ComSafeArrayOut(BYTE, aData));
    STDMETHOD(HotPlugCPU)(ULONG aCpu);
    STDMETHOD(HotUnplugCPU)(ULONG aCpu);
    STDMETHOD(GetCPUStatus)(ULONG aCpu,
                            BOOL *aAttached);
    STDMETHOD(GetEffectiveParavirtProvider)(ParavirtProvider_T *aParavirtProvider);
    STDMETHOD(QueryLogFilename)(ULONG aIdx,
                                BSTR *aFilename);
    STDMETHOD(ReadLog)(ULONG aIdx,
                       LONG64 aOffset,
                       LONG64 aSize,
                       ComSafeArrayOut(BYTE, aData));
    STDMETHOD(CloneTo)(IMachine *aTarget,
                       CloneMode_T aMode,
                       ComSafeArrayIn(CloneOptions_T, aOptions),
                       IProgress **aProgress);
    STDMETHOD(MoveTo)(IN_BSTR aFolder,
                      IN_BSTR aType,
                      IProgress **aProgress);
    STDMETHOD(SaveState)(IProgress **aProgress);
    STDMETHOD(AdoptSavedState)(IN_BSTR aSavedStateFile);
    STDMETHOD(DiscardSavedState)(BOOL aFRemoveFile);
    STDMETHOD(TakeSnapshot)(IN_BSTR aName,
                            IN_BSTR aDescription,
                            BOOL aPause,
                            BSTR *aId,
                            IProgress **aProgress);
    STDMETHOD(DeleteSnapshot)(IN_BSTR aId,
                              IProgress **aProgress);
    STDMETHOD(DeleteSnapshotAndAllChildren)(IN_BSTR aId,
                                            IProgress **aProgress);
    STDMETHOD(DeleteSnapshotRange)(IN_BSTR aStartId,
                                   IN_BSTR aEndId,
                                   IProgress **aProgress);
    STDMETHOD(RestoreSnapshot)(ISnapshot *aSnapshot,
                               IProgress **aProgress);
    STDMETHOD(ApplyDefaults)(IN_BSTR aFlags);
    STDMETHOD(InternalAndReservedMethod1IMachine)();
    STDMETHOD(InternalAndReservedMethod2IMachine)();
    STDMETHOD(InternalAndReservedMethod3IMachine)();
    STDMETHOD(InternalAndReservedMethod4IMachine)();
    STDMETHOD(InternalAndReservedMethod5IMachine)();
    STDMETHOD(InternalAndReservedMethod6IMachine)();
    STDMETHOD(InternalAndReservedMethod7IMachine)();
    STDMETHOD(InternalAndReservedMethod8IMachine)();
    /** @} */

    /** @name Public IInternalMachineControl properties
     * @{ */
    /** @} */

    /** @name Public IInternalMachineControl methods
     * @{ */
    STDMETHOD(UpdateState)(MachineState_T aState);
    STDMETHOD(BeginPowerUp)(IProgress *aProgress);
    STDMETHOD(EndPowerUp)(LONG aResult);
    STDMETHOD(BeginPoweringDown)(IProgress **aProgress);
    STDMETHOD(EndPoweringDown)(LONG aResult,
                               IN_BSTR aErrMsg);
    STDMETHOD(RunUSBDeviceFilters)(IUSBDevice *aDevice,
                                   BOOL *aMatched,
                                   ULONG *aMaskedInterfaces);
    STDMETHOD(CaptureUSBDevice)(IN_BSTR aId,
                                IN_BSTR aCaptureFilename);
    STDMETHOD(DetachUSBDevice)(IN_BSTR aId,
                               BOOL aDone);
    STDMETHOD(AutoCaptureUSBDevices)();
    STDMETHOD(DetachAllUSBDevices)(BOOL aDone);
    STDMETHOD(OnSessionEnd)(ISession *aSession,
                            IProgress **aProgress);
    STDMETHOD(FinishOnlineMergeMedium)();
    STDMETHOD(PullGuestProperties)(ComSafeArrayOut(BSTR, aNames),
                                   ComSafeArrayOut(BSTR, aValues),
                                   ComSafeArrayOut(LONG64, aTimestamps),
                                   ComSafeArrayOut(BSTR, aFlags));
    STDMETHOD(ClipboardAreaRegister)(ComSafeArrayIn(IN_BSTR, aParms),
                                     ULONG *aId);
    STDMETHOD(ClipboardAreaUnregister)(ULONG aId);
    STDMETHOD(ClipboardAreaAttach)(ULONG aId);
    STDMETHOD(ClipboardAreaDetach)(ULONG aId);
    STDMETHOD(ClipboardAreaGetMostRecent)(ULONG *aId);
    STDMETHOD(ClipboardAreaGetRefCount)(ULONG aId,
                                        ULONG *aRefcount);
    STDMETHOD(PushGuestProperty)(IN_BSTR aName,
                                 IN_BSTR aValue,
                                 LONG64 aTimestamp,
                                 IN_BSTR aFlags);
    STDMETHOD(LockMedia)();
    STDMETHOD(UnlockMedia)();
    STDMETHOD(EjectMedium)(IMediumAttachment *aAttachment,
                           IMediumAttachment **aNewAttachment);
    STDMETHOD(ReportVmStatistics)(ULONG aValidStats,
                                  ULONG aCpuUser,
                                  ULONG aCpuKernel,
                                  ULONG aCpuIdle,
                                  ULONG aMemTotal,
                                  ULONG aMemFree,
                                  ULONG aMemBalloon,
                                  ULONG aMemShared,
                                  ULONG aMemCache,
                                  ULONG aPagedTotal,
                                  ULONG aMemAllocTotal,
                                  ULONG aMemFreeTotal,
                                  ULONG aMemBalloonTotal,
                                  ULONG aMemSharedTotal,
                                  ULONG aVmNetRx,
                                  ULONG aVmNetTx);
    STDMETHOD(AuthenticateExternal)(ComSafeArrayIn(IN_BSTR, aAuthParams),
                                    BSTR *aResult);
    /** @} */

private:
    /** @name Wrapped IMachine properties
     * @{ */
    virtual HRESULT getParent(ComPtr<IVirtualBox> &aParent) = 0;
    virtual HRESULT getIcon(std::vector<BYTE> &aIcon) = 0;
    virtual HRESULT setIcon(const std::vector<BYTE> &aIcon) = 0;
    virtual HRESULT getAccessible(BOOL *aAccessible) = 0;
    virtual HRESULT getAccessError(ComPtr<IVirtualBoxErrorInfo> &aAccessError) = 0;
    virtual HRESULT getName(com::Utf8Str &aName) = 0;
    virtual HRESULT setName(const com::Utf8Str &aName) = 0;
    virtual HRESULT getDescription(com::Utf8Str &aDescription) = 0;
    virtual HRESULT setDescription(const com::Utf8Str &aDescription) = 0;
    virtual HRESULT getId(com::Guid &aId) = 0;
    virtual HRESULT getGroups(std::vector<com::Utf8Str> &aGroups) = 0;
    virtual HRESULT setGroups(const std::vector<com::Utf8Str> &aGroups) = 0;
    virtual HRESULT getOSTypeId(com::Utf8Str &aOSTypeId) = 0;
    virtual HRESULT setOSTypeId(const com::Utf8Str &aOSTypeId) = 0;
    virtual HRESULT getHardwareVersion(com::Utf8Str &aHardwareVersion) = 0;
    virtual HRESULT setHardwareVersion(const com::Utf8Str &aHardwareVersion) = 0;
    virtual HRESULT getHardwareUUID(com::Guid &aHardwareUUID) = 0;
    virtual HRESULT setHardwareUUID(const com::Guid &aHardwareUUID) = 0;
    virtual HRESULT getCPUCount(ULONG *aCPUCount) = 0;
    virtual HRESULT setCPUCount(ULONG aCPUCount) = 0;
    virtual HRESULT getCPUHotPlugEnabled(BOOL *aCPUHotPlugEnabled) = 0;
    virtual HRESULT setCPUHotPlugEnabled(BOOL aCPUHotPlugEnabled) = 0;
    virtual HRESULT getCPUExecutionCap(ULONG *aCPUExecutionCap) = 0;
    virtual HRESULT setCPUExecutionCap(ULONG aCPUExecutionCap) = 0;
    virtual HRESULT getCPUIDPortabilityLevel(ULONG *aCPUIDPortabilityLevel) = 0;
    virtual HRESULT setCPUIDPortabilityLevel(ULONG aCPUIDPortabilityLevel) = 0;
    virtual HRESULT getMemorySize(ULONG *aMemorySize) = 0;
    virtual HRESULT setMemorySize(ULONG aMemorySize) = 0;
    virtual HRESULT getMemoryBalloonSize(ULONG *aMemoryBalloonSize) = 0;
    virtual HRESULT setMemoryBalloonSize(ULONG aMemoryBalloonSize) = 0;
    virtual HRESULT getPageFusionEnabled(BOOL *aPageFusionEnabled) = 0;
    virtual HRESULT setPageFusionEnabled(BOOL aPageFusionEnabled) = 0;
    virtual HRESULT getGraphicsAdapter(ComPtr<IGraphicsAdapter> &aGraphicsAdapter) = 0;
    virtual HRESULT getBIOSSettings(ComPtr<IBIOSSettings> &aBIOSSettings) = 0;
    virtual HRESULT getRecordingSettings(ComPtr<IRecordingSettings> &aRecordingSettings) = 0;
    virtual HRESULT getFirmwareType(FirmwareType_T *aFirmwareType) = 0;
    virtual HRESULT setFirmwareType(FirmwareType_T aFirmwareType) = 0;
    virtual HRESULT getPointingHIDType(PointingHIDType_T *aPointingHIDType) = 0;
    virtual HRESULT setPointingHIDType(PointingHIDType_T aPointingHIDType) = 0;
    virtual HRESULT getKeyboardHIDType(KeyboardHIDType_T *aKeyboardHIDType) = 0;
    virtual HRESULT setKeyboardHIDType(KeyboardHIDType_T aKeyboardHIDType) = 0;
    virtual HRESULT getHPETEnabled(BOOL *aHPETEnabled) = 0;
    virtual HRESULT setHPETEnabled(BOOL aHPETEnabled) = 0;
    virtual HRESULT getChipsetType(ChipsetType_T *aChipsetType) = 0;
    virtual HRESULT setChipsetType(ChipsetType_T aChipsetType) = 0;
    virtual HRESULT getSnapshotFolder(com::Utf8Str &aSnapshotFolder) = 0;
    virtual HRESULT setSnapshotFolder(const com::Utf8Str &aSnapshotFolder) = 0;
    virtual HRESULT getVRDEServer(ComPtr<IVRDEServer> &aVRDEServer) = 0;
    virtual HRESULT getEmulatedUSBCardReaderEnabled(BOOL *aEmulatedUSBCardReaderEnabled) = 0;
    virtual HRESULT setEmulatedUSBCardReaderEnabled(BOOL aEmulatedUSBCardReaderEnabled) = 0;
    virtual HRESULT getMediumAttachments(std::vector<ComPtr<IMediumAttachment> > &aMediumAttachments) = 0;
    virtual HRESULT getUSBControllers(std::vector<ComPtr<IUSBController> > &aUSBControllers) = 0;
    virtual HRESULT getUSBDeviceFilters(ComPtr<IUSBDeviceFilters> &aUSBDeviceFilters) = 0;
    virtual HRESULT getAudioAdapter(ComPtr<IAudioAdapter> &aAudioAdapter) = 0;
    virtual HRESULT getStorageControllers(std::vector<ComPtr<IStorageController> > &aStorageControllers) = 0;
    virtual HRESULT getSettingsFilePath(com::Utf8Str &aSettingsFilePath) = 0;
    virtual HRESULT getSettingsAuxFilePath(com::Utf8Str &aSettingsAuxFilePath) = 0;
    virtual HRESULT getSettingsModified(BOOL *aSettingsModified) = 0;
    virtual HRESULT getSessionState(SessionState_T *aSessionState) = 0;
    virtual HRESULT getSessionName(com::Utf8Str &aSessionName) = 0;
    virtual HRESULT getSessionPID(ULONG *aSessionPID) = 0;
    virtual HRESULT getState(MachineState_T *aState) = 0;
    virtual HRESULT getLastStateChange(LONG64 *aLastStateChange) = 0;
    virtual HRESULT getStateFilePath(com::Utf8Str &aStateFilePath) = 0;
    virtual HRESULT getLogFolder(com::Utf8Str &aLogFolder) = 0;
    virtual HRESULT getCurrentSnapshot(ComPtr<ISnapshot> &aCurrentSnapshot) = 0;
    virtual HRESULT getSnapshotCount(ULONG *aSnapshotCount) = 0;
    virtual HRESULT getCurrentStateModified(BOOL *aCurrentStateModified) = 0;
    virtual HRESULT getSharedFolders(std::vector<ComPtr<ISharedFolder> > &aSharedFolders) = 0;
    virtual HRESULT getClipboardMode(ClipboardMode_T *aClipboardMode) = 0;
    virtual HRESULT setClipboardMode(ClipboardMode_T aClipboardMode) = 0;
    virtual HRESULT getClipboardFileTransfersEnabled(BOOL *aClipboardFileTransfersEnabled) = 0;
    virtual HRESULT setClipboardFileTransfersEnabled(BOOL aClipboardFileTransfersEnabled) = 0;
    virtual HRESULT getDnDMode(DnDMode_T *aDnDMode) = 0;
    virtual HRESULT setDnDMode(DnDMode_T aDnDMode) = 0;
    virtual HRESULT getTeleporterEnabled(BOOL *aTeleporterEnabled) = 0;
    virtual HRESULT setTeleporterEnabled(BOOL aTeleporterEnabled) = 0;
    virtual HRESULT getTeleporterPort(ULONG *aTeleporterPort) = 0;
    virtual HRESULT setTeleporterPort(ULONG aTeleporterPort) = 0;
    virtual HRESULT getTeleporterAddress(com::Utf8Str &aTeleporterAddress) = 0;
    virtual HRESULT setTeleporterAddress(const com::Utf8Str &aTeleporterAddress) = 0;
    virtual HRESULT getTeleporterPassword(com::Utf8Str &aTeleporterPassword) = 0;
    virtual HRESULT setTeleporterPassword(const com::Utf8Str &aTeleporterPassword) = 0;
    virtual HRESULT getParavirtProvider(ParavirtProvider_T *aParavirtProvider) = 0;
    virtual HRESULT setParavirtProvider(ParavirtProvider_T aParavirtProvider) = 0;
    virtual HRESULT getRTCUseUTC(BOOL *aRTCUseUTC) = 0;
    virtual HRESULT setRTCUseUTC(BOOL aRTCUseUTC) = 0;
    virtual HRESULT getIOCacheEnabled(BOOL *aIOCacheEnabled) = 0;
    virtual HRESULT setIOCacheEnabled(BOOL aIOCacheEnabled) = 0;
    virtual HRESULT getIOCacheSize(ULONG *aIOCacheSize) = 0;
    virtual HRESULT setIOCacheSize(ULONG aIOCacheSize) = 0;
    virtual HRESULT getPCIDeviceAssignments(std::vector<ComPtr<IPCIDeviceAttachment> > &aPCIDeviceAssignments) = 0;
    virtual HRESULT getBandwidthControl(ComPtr<IBandwidthControl> &aBandwidthControl) = 0;
    virtual HRESULT getTracingEnabled(BOOL *aTracingEnabled) = 0;
    virtual HRESULT setTracingEnabled(BOOL aTracingEnabled) = 0;
    virtual HRESULT getTracingConfig(com::Utf8Str &aTracingConfig) = 0;
    virtual HRESULT setTracingConfig(const com::Utf8Str &aTracingConfig) = 0;
    virtual HRESULT getAllowTracingToAccessVM(BOOL *aAllowTracingToAccessVM) = 0;
    virtual HRESULT setAllowTracingToAccessVM(BOOL aAllowTracingToAccessVM) = 0;
    virtual HRESULT getAutostartEnabled(BOOL *aAutostartEnabled) = 0;
    virtual HRESULT setAutostartEnabled(BOOL aAutostartEnabled) = 0;
    virtual HRESULT getAutostartDelay(ULONG *aAutostartDelay) = 0;
    virtual HRESULT setAutostartDelay(ULONG aAutostartDelay) = 0;
    virtual HRESULT getAutostopType(AutostopType_T *aAutostopType) = 0;
    virtual HRESULT setAutostopType(AutostopType_T aAutostopType) = 0;
    virtual HRESULT getDefaultFrontend(com::Utf8Str &aDefaultFrontend) = 0;
    virtual HRESULT setDefaultFrontend(const com::Utf8Str &aDefaultFrontend) = 0;
    virtual HRESULT getUSBProxyAvailable(BOOL *aUSBProxyAvailable) = 0;
    virtual HRESULT getVMProcessPriority(VMProcPriority_T *aVMProcessPriority) = 0;
    virtual HRESULT setVMProcessPriority(VMProcPriority_T aVMProcessPriority) = 0;
    virtual HRESULT getParavirtDebug(com::Utf8Str &aParavirtDebug) = 0;
    virtual HRESULT setParavirtDebug(const com::Utf8Str &aParavirtDebug) = 0;
    virtual HRESULT getCPUProfile(com::Utf8Str &aCPUProfile) = 0;
    virtual HRESULT setCPUProfile(const com::Utf8Str &aCPUProfile) = 0;
    /** @} */

    /** @name Wrapped IMachine methods
     * @{ */
    virtual HRESULT lockMachine(const ComPtr<ISession> &aSession,
                                LockType_T aLockType) = 0;
    virtual HRESULT launchVMProcess(const ComPtr<ISession> &aSession,
                                    const com::Utf8Str &aName,
                                    const std::vector<com::Utf8Str> &aEnvironmentChanges,
                                    ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT setBootOrder(ULONG aPosition,
                                 DeviceType_T aDevice) = 0;
    virtual HRESULT getBootOrder(ULONG aPosition,
                                 DeviceType_T *aDevice) = 0;
    virtual HRESULT attachDevice(const com::Utf8Str &aName,
                                 LONG aControllerPort,
                                 LONG aDevice,
                                 DeviceType_T aType,
                                 const ComPtr<IMedium> &aMedium) = 0;
    virtual HRESULT attachDeviceWithoutMedium(const com::Utf8Str &aName,
                                              LONG aControllerPort,
                                              LONG aDevice,
                                              DeviceType_T aType) = 0;
    virtual HRESULT detachDevice(const com::Utf8Str &aName,
                                 LONG aControllerPort,
                                 LONG aDevice) = 0;
    virtual HRESULT passthroughDevice(const com::Utf8Str &aName,
                                      LONG aControllerPort,
                                      LONG aDevice,
                                      BOOL aPassthrough) = 0;
    virtual HRESULT temporaryEjectDevice(const com::Utf8Str &aName,
                                         LONG aControllerPort,
                                         LONG aDevice,
                                         BOOL aTemporaryEject) = 0;
    virtual HRESULT nonRotationalDevice(const com::Utf8Str &aName,
                                        LONG aControllerPort,
                                        LONG aDevice,
                                        BOOL aNonRotational) = 0;
    virtual HRESULT setAutoDiscardForDevice(const com::Utf8Str &aName,
                                            LONG aControllerPort,
                                            LONG aDevice,
                                            BOOL aDiscard) = 0;
    virtual HRESULT setHotPluggableForDevice(const com::Utf8Str &aName,
                                             LONG aControllerPort,
                                             LONG aDevice,
                                             BOOL aHotPluggable) = 0;
    virtual HRESULT setBandwidthGroupForDevice(const com::Utf8Str &aName,
                                               LONG aControllerPort,
                                               LONG aDevice,
                                               const ComPtr<IBandwidthGroup> &aBandwidthGroup) = 0;
    virtual HRESULT setNoBandwidthGroupForDevice(const com::Utf8Str &aName,
                                                 LONG aControllerPort,
                                                 LONG aDevice) = 0;
    virtual HRESULT unmountMedium(const com::Utf8Str &aName,
                                  LONG aControllerPort,
                                  LONG aDevice,
                                  BOOL aForce) = 0;
    virtual HRESULT mountMedium(const com::Utf8Str &aName,
                                LONG aControllerPort,
                                LONG aDevice,
                                const ComPtr<IMedium> &aMedium,
                                BOOL aForce) = 0;
    virtual HRESULT getMedium(const com::Utf8Str &aName,
                              LONG aControllerPort,
                              LONG aDevice,
                              ComPtr<IMedium> &aMedium) = 0;
    virtual HRESULT getMediumAttachmentsOfController(const com::Utf8Str &aName,
                                                     std::vector<ComPtr<IMediumAttachment> > &aMediumAttachments) = 0;
    virtual HRESULT getMediumAttachment(const com::Utf8Str &aName,
                                        LONG aControllerPort,
                                        LONG aDevice,
                                        ComPtr<IMediumAttachment> &aAttachment) = 0;
    virtual HRESULT attachHostPCIDevice(LONG aHostAddress,
                                        LONG aDesiredGuestAddress,
                                        BOOL aTryToUnbind) = 0;
    virtual HRESULT detachHostPCIDevice(LONG aHostAddress) = 0;
    virtual HRESULT getNetworkAdapter(ULONG aSlot,
                                      ComPtr<INetworkAdapter> &aAdapter) = 0;
    virtual HRESULT addStorageController(const com::Utf8Str &aName,
                                         StorageBus_T aConnectionType,
                                         ComPtr<IStorageController> &aController) = 0;
    virtual HRESULT getStorageControllerByName(const com::Utf8Str &aName,
                                               ComPtr<IStorageController> &aStorageController) = 0;
    virtual HRESULT getStorageControllerByInstance(StorageBus_T aConnectionType,
                                                   ULONG aInstance,
                                                   ComPtr<IStorageController> &aStorageController) = 0;
    virtual HRESULT removeStorageController(const com::Utf8Str &aName) = 0;
    virtual HRESULT setStorageControllerBootable(const com::Utf8Str &aName,
                                                 BOOL aBootable) = 0;
    virtual HRESULT addUSBController(const com::Utf8Str &aName,
                                     USBControllerType_T aType,
                                     ComPtr<IUSBController> &aController) = 0;
    virtual HRESULT removeUSBController(const com::Utf8Str &aName) = 0;
    virtual HRESULT getUSBControllerByName(const com::Utf8Str &aName,
                                           ComPtr<IUSBController> &aController) = 0;
    virtual HRESULT getUSBControllerCountByType(USBControllerType_T aType,
                                                ULONG *aControllers) = 0;
    virtual HRESULT getSerialPort(ULONG aSlot,
                                  ComPtr<ISerialPort> &aPort) = 0;
    virtual HRESULT getParallelPort(ULONG aSlot,
                                    ComPtr<IParallelPort> &aPort) = 0;
    virtual HRESULT getExtraDataKeys(std::vector<com::Utf8Str> &aKeys) = 0;
    virtual HRESULT getExtraData(const com::Utf8Str &aKey,
                                 com::Utf8Str &aValue) = 0;
    virtual HRESULT setExtraData(const com::Utf8Str &aKey,
                                 const com::Utf8Str &aValue) = 0;
    virtual HRESULT getCPUProperty(CPUPropertyType_T aProperty,
                                   BOOL *aValue) = 0;
    virtual HRESULT setCPUProperty(CPUPropertyType_T aProperty,
                                   BOOL aValue) = 0;
    virtual HRESULT getCPUIDLeafByOrdinal(ULONG aOrdinal,
                                          ULONG *aIdx,
                                          ULONG *aIdxSub,
                                          ULONG *aValEax,
                                          ULONG *aValEbx,
                                          ULONG *aValEcx,
                                          ULONG *aValEdx) = 0;
    virtual HRESULT getCPUIDLeaf(ULONG aIdx,
                                 ULONG aIdxSub,
                                 ULONG *aValEax,
                                 ULONG *aValEbx,
                                 ULONG *aValEcx,
                                 ULONG *aValEdx) = 0;
    virtual HRESULT setCPUIDLeaf(ULONG aIdx,
                                 ULONG aIdxSub,
                                 ULONG aValEax,
                                 ULONG aValEbx,
                                 ULONG aValEcx,
                                 ULONG aValEdx) = 0;
    virtual HRESULT removeCPUIDLeaf(ULONG aIdx,
                                    ULONG aIdxSub) = 0;
    virtual HRESULT removeAllCPUIDLeaves() = 0;
    virtual HRESULT getHWVirtExProperty(HWVirtExPropertyType_T aProperty,
                                        BOOL *aValue) = 0;
    virtual HRESULT setHWVirtExProperty(HWVirtExPropertyType_T aProperty,
                                        BOOL aValue) = 0;
    virtual HRESULT setSettingsFilePath(const com::Utf8Str &aSettingsFilePath,
                                        ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT saveSettings() = 0;
    virtual HRESULT discardSettings() = 0;
    virtual HRESULT unregister(AutoCaller &aAutoCaller,
                               CleanupMode_T aCleanupMode,
                               std::vector<ComPtr<IMedium> > &aMedia) = 0;
    virtual HRESULT deleteConfig(const std::vector<ComPtr<IMedium> > &aMedia,
                                 ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT exportTo(const ComPtr<IAppliance> &aAppliance,
                             const com::Utf8Str &aLocation,
                             ComPtr<IVirtualSystemDescription> &aDescription) = 0;
    virtual HRESULT findSnapshot(const com::Utf8Str &aNameOrId,
                                 ComPtr<ISnapshot> &aSnapshot) = 0;
    virtual HRESULT createSharedFolder(const com::Utf8Str &aName,
                                       const com::Utf8Str &aHostPath,
                                       BOOL aWritable,
                                       BOOL aAutomount,
                                       const com::Utf8Str &aAutoMountPoint) = 0;
    virtual HRESULT removeSharedFolder(const com::Utf8Str &aName) = 0;
    virtual HRESULT canShowConsoleWindow(BOOL *aCanShow) = 0;
    virtual HRESULT showConsoleWindow(LONG64 *aWinId) = 0;
    virtual HRESULT getGuestProperty(const com::Utf8Str &aName,
                                     com::Utf8Str &aValue,
                                     LONG64 *aTimestamp,
                                     com::Utf8Str &aFlags) = 0;
    virtual HRESULT getGuestPropertyValue(const com::Utf8Str &aProperty,
                                          com::Utf8Str &aValue) = 0;
    virtual HRESULT getGuestPropertyTimestamp(const com::Utf8Str &aProperty,
                                              LONG64 *aValue) = 0;
    virtual HRESULT setGuestProperty(const com::Utf8Str &aProperty,
                                     const com::Utf8Str &aValue,
                                     const com::Utf8Str &aFlags) = 0;
    virtual HRESULT setGuestPropertyValue(const com::Utf8Str &aProperty,
                                          const com::Utf8Str &aValue) = 0;
    virtual HRESULT deleteGuestProperty(const com::Utf8Str &aName) = 0;
    virtual HRESULT enumerateGuestProperties(const com::Utf8Str &aPatterns,
                                             std::vector<com::Utf8Str> &aNames,
                                             std::vector<com::Utf8Str> &aValues,
                                             std::vector<LONG64> &aTimestamps,
                                             std::vector<com::Utf8Str> &aFlags) = 0;
    virtual HRESULT querySavedGuestScreenInfo(ULONG aScreenId,
                                              ULONG *aOriginX,
                                              ULONG *aOriginY,
                                              ULONG *aWidth,
                                              ULONG *aHeight,
                                              BOOL *aEnabled) = 0;
    virtual HRESULT readSavedThumbnailToArray(ULONG aScreenId,
                                              BitmapFormat_T aBitmapFormat,
                                              ULONG *aWidth,
                                              ULONG *aHeight,
                                              std::vector<BYTE> &aData) = 0;
    virtual HRESULT querySavedScreenshotInfo(ULONG aScreenId,
                                             ULONG *aWidth,
                                             ULONG *aHeight,
                                             std::vector<BitmapFormat_T> &aBitmapFormats) = 0;
    virtual HRESULT readSavedScreenshotToArray(ULONG aScreenId,
                                               BitmapFormat_T aBitmapFormat,
                                               ULONG *aWidth,
                                               ULONG *aHeight,
                                               std::vector<BYTE> &aData) = 0;
    virtual HRESULT hotPlugCPU(ULONG aCpu) = 0;
    virtual HRESULT hotUnplugCPU(ULONG aCpu) = 0;
    virtual HRESULT getCPUStatus(ULONG aCpu,
                                 BOOL *aAttached) = 0;
    virtual HRESULT getEffectiveParavirtProvider(ParavirtProvider_T *aParavirtProvider) = 0;
    virtual HRESULT queryLogFilename(ULONG aIdx,
                                     com::Utf8Str &aFilename) = 0;
    virtual HRESULT readLog(ULONG aIdx,
                            LONG64 aOffset,
                            LONG64 aSize,
                            std::vector<BYTE> &aData) = 0;
    virtual HRESULT cloneTo(const ComPtr<IMachine> &aTarget,
                            CloneMode_T aMode,
                            const std::vector<CloneOptions_T> &aOptions,
                            ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT moveTo(const com::Utf8Str &aFolder,
                           const com::Utf8Str &aType,
                           ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT saveState(ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT adoptSavedState(const com::Utf8Str &aSavedStateFile) = 0;
    virtual HRESULT discardSavedState(BOOL aFRemoveFile) = 0;
    virtual HRESULT takeSnapshot(const com::Utf8Str &aName,
                                 const com::Utf8Str &aDescription,
                                 BOOL aPause,
                                 com::Guid &aId,
                                 ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT deleteSnapshot(const com::Guid &aId,
                                   ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT deleteSnapshotAndAllChildren(const com::Guid &aId,
                                                 ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT deleteSnapshotRange(const com::Guid &aStartId,
                                        const com::Guid &aEndId,
                                        ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT restoreSnapshot(const ComPtr<ISnapshot> &aSnapshot,
                                    ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT applyDefaults(const com::Utf8Str &aFlags) = 0;
    /** @} */

    /** @name Wrapped IInternalMachineControl properties
     * @{ */
    /** @} */

    /** @name Wrapped IInternalMachineControl methods
     * @{ */
    virtual HRESULT updateState(MachineState_T aState) = 0;
    virtual HRESULT beginPowerUp(const ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT endPowerUp(LONG aResult) = 0;
    virtual HRESULT beginPoweringDown(ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT endPoweringDown(LONG aResult,
                                    const com::Utf8Str &aErrMsg) = 0;
    virtual HRESULT runUSBDeviceFilters(const ComPtr<IUSBDevice> &aDevice,
                                        BOOL *aMatched,
                                        ULONG *aMaskedInterfaces) = 0;
    virtual HRESULT captureUSBDevice(const com::Guid &aId,
                                     const com::Utf8Str &aCaptureFilename) = 0;
    virtual HRESULT detachUSBDevice(const com::Guid &aId,
                                    BOOL aDone) = 0;
    virtual HRESULT autoCaptureUSBDevices() = 0;
    virtual HRESULT detachAllUSBDevices(BOOL aDone) = 0;
    virtual HRESULT onSessionEnd(const ComPtr<ISession> &aSession,
                                 ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT finishOnlineMergeMedium() = 0;
    virtual HRESULT pullGuestProperties(std::vector<com::Utf8Str> &aNames,
                                        std::vector<com::Utf8Str> &aValues,
                                        std::vector<LONG64> &aTimestamps,
                                        std::vector<com::Utf8Str> &aFlags) = 0;
    virtual HRESULT clipboardAreaRegister(const std::vector<com::Utf8Str> &aParms,
                                          ULONG *aId) = 0;
    virtual HRESULT clipboardAreaUnregister(ULONG aId) = 0;
    virtual HRESULT clipboardAreaAttach(ULONG aId) = 0;
    virtual HRESULT clipboardAreaDetach(ULONG aId) = 0;
    virtual HRESULT clipboardAreaGetMostRecent(ULONG *aId) = 0;
    virtual HRESULT clipboardAreaGetRefCount(ULONG aId,
                                             ULONG *aRefcount) = 0;
    virtual HRESULT pushGuestProperty(const com::Utf8Str &aName,
                                      const com::Utf8Str &aValue,
                                      LONG64 aTimestamp,
                                      const com::Utf8Str &aFlags) = 0;
    virtual HRESULT lockMedia() = 0;
    virtual HRESULT unlockMedia() = 0;
    virtual HRESULT ejectMedium(const ComPtr<IMediumAttachment> &aAttachment,
                                ComPtr<IMediumAttachment> &aNewAttachment) = 0;
    virtual HRESULT reportVmStatistics(ULONG aValidStats,
                                       ULONG aCpuUser,
                                       ULONG aCpuKernel,
                                       ULONG aCpuIdle,
                                       ULONG aMemTotal,
                                       ULONG aMemFree,
                                       ULONG aMemBalloon,
                                       ULONG aMemShared,
                                       ULONG aMemCache,
                                       ULONG aPagedTotal,
                                       ULONG aMemAllocTotal,
                                       ULONG aMemFreeTotal,
                                       ULONG aMemBalloonTotal,
                                       ULONG aMemSharedTotal,
                                       ULONG aVmNetRx,
                                       ULONG aVmNetTx) = 0;
    virtual HRESULT authenticateExternal(const std::vector<com::Utf8Str> &aAuthParams,
                                         com::Utf8Str &aResult) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(MachineWrap); /* Shuts up MSC warning C4625. */

};

#endif // !MachineWrap_H_

// ##### ENDFILE "MachineWrap.h"


// ##### BEGINFILE "EmulatedUSBWrap.h"
/** @file
 * VirtualBox API class wrapper header for IEmulatedUSB.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef EmulatedUSBWrap_H_
#define EmulatedUSBWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE EmulatedUSBWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IEmulatedUSB)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(EmulatedUSBWrap, IEmulatedUSB)
    DECLARE_NOT_AGGREGATABLE(EmulatedUSBWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(EmulatedUSBWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IEmulatedUSB)
        COM_INTERFACE_ENTRY2(IDispatch, IEmulatedUSB)
        VBOX_TWEAK_INTERFACE_ENTRY(IEmulatedUSB)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(EmulatedUSBWrap)

    /** @name Public IEmulatedUSB properties
     * @{ */
    STDMETHOD(COMGETTER(Webcams))(ComSafeArrayOut(BSTR, aWebcams));
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IEmulatedUSB))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IEmulatedUSB))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IEmulatedUSB))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IEmulatedUSB))(ULONG *aReserved);
    /** @} */

    /** @name Public IEmulatedUSB methods
     * @{ */
    STDMETHOD(WebcamAttach)(IN_BSTR aPath,
                            IN_BSTR aSettings);
    STDMETHOD(WebcamDetach)(IN_BSTR aPath);
    STDMETHOD(InternalAndReservedMethod1IEmulatedUSB)();
    STDMETHOD(InternalAndReservedMethod2IEmulatedUSB)();
    STDMETHOD(InternalAndReservedMethod3IEmulatedUSB)();
    STDMETHOD(InternalAndReservedMethod4IEmulatedUSB)();
    /** @} */

private:
    /** @name Wrapped IEmulatedUSB properties
     * @{ */
    virtual HRESULT getWebcams(std::vector<com::Utf8Str> &aWebcams) = 0;
    /** @} */

    /** @name Wrapped IEmulatedUSB methods
     * @{ */
    virtual HRESULT webcamAttach(const com::Utf8Str &aPath,
                                 const com::Utf8Str &aSettings) = 0;
    virtual HRESULT webcamDetach(const com::Utf8Str &aPath) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(EmulatedUSBWrap); /* Shuts up MSC warning C4625. */

};

#endif // !EmulatedUSBWrap_H_

// ##### ENDFILE "EmulatedUSBWrap.h"


// ##### BEGINFILE "VRDEServerInfoWrap.h"
/** @file
 * VirtualBox API class wrapper header for IVRDEServerInfo.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef VRDEServerInfoWrap_H_
#define VRDEServerInfoWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE VRDEServerInfoWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IVRDEServerInfo)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(VRDEServerInfoWrap, IVRDEServerInfo)
    DECLARE_NOT_AGGREGATABLE(VRDEServerInfoWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(VRDEServerInfoWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IVRDEServerInfo)
        COM_INTERFACE_ENTRY2(IDispatch, IVRDEServerInfo)
        VBOX_TWEAK_INTERFACE_ENTRY(IVRDEServerInfo)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(VRDEServerInfoWrap)

    /** @name Public IVRDEServerInfo properties
     * @{ */
    STDMETHOD(COMGETTER(Active))(BOOL *aActive);
    STDMETHOD(COMGETTER(Port))(LONG *aPort);
    STDMETHOD(COMGETTER(NumberOfClients))(ULONG *aNumberOfClients);
    STDMETHOD(COMGETTER(BeginTime))(LONG64 *aBeginTime);
    STDMETHOD(COMGETTER(EndTime))(LONG64 *aEndTime);
    STDMETHOD(COMGETTER(BytesSent))(LONG64 *aBytesSent);
    STDMETHOD(COMGETTER(BytesSentTotal))(LONG64 *aBytesSentTotal);
    STDMETHOD(COMGETTER(BytesReceived))(LONG64 *aBytesReceived);
    STDMETHOD(COMGETTER(BytesReceivedTotal))(LONG64 *aBytesReceivedTotal);
    STDMETHOD(COMGETTER(User))(BSTR *aUser);
    STDMETHOD(COMGETTER(Domain))(BSTR *aDomain);
    STDMETHOD(COMGETTER(ClientName))(BSTR *aClientName);
    STDMETHOD(COMGETTER(ClientIP))(BSTR *aClientIP);
    STDMETHOD(COMGETTER(ClientVersion))(ULONG *aClientVersion);
    STDMETHOD(COMGETTER(EncryptionStyle))(ULONG *aEncryptionStyle);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IVRDEServerInfo))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IVRDEServerInfo))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IVRDEServerInfo))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IVRDEServerInfo))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IVRDEServerInfo))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IVRDEServerInfo))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IVRDEServerInfo))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IVRDEServerInfo))(ULONG *aReserved);
    /** @} */

    /** @name Public IVRDEServerInfo methods
     * @{ */
    /** @} */

private:
    /** @name Wrapped IVRDEServerInfo properties
     * @{ */
    virtual HRESULT getActive(BOOL *aActive) = 0;
    virtual HRESULT getPort(LONG *aPort) = 0;
    virtual HRESULT getNumberOfClients(ULONG *aNumberOfClients) = 0;
    virtual HRESULT getBeginTime(LONG64 *aBeginTime) = 0;
    virtual HRESULT getEndTime(LONG64 *aEndTime) = 0;
    virtual HRESULT getBytesSent(LONG64 *aBytesSent) = 0;
    virtual HRESULT getBytesSentTotal(LONG64 *aBytesSentTotal) = 0;
    virtual HRESULT getBytesReceived(LONG64 *aBytesReceived) = 0;
    virtual HRESULT getBytesReceivedTotal(LONG64 *aBytesReceivedTotal) = 0;
    virtual HRESULT getUser(com::Utf8Str &aUser) = 0;
    virtual HRESULT getDomain(com::Utf8Str &aDomain) = 0;
    virtual HRESULT getClientName(com::Utf8Str &aClientName) = 0;
    virtual HRESULT getClientIP(com::Utf8Str &aClientIP) = 0;
    virtual HRESULT getClientVersion(ULONG *aClientVersion) = 0;
    virtual HRESULT getEncryptionStyle(ULONG *aEncryptionStyle) = 0;
    /** @} */

    /** @name Wrapped IVRDEServerInfo methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(VRDEServerInfoWrap); /* Shuts up MSC warning C4625. */

};

#endif // !VRDEServerInfoWrap_H_

// ##### ENDFILE "VRDEServerInfoWrap.h"


// ##### BEGINFILE "ConsoleWrap.h"
/** @file
 * VirtualBox API class wrapper header for IConsole.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef ConsoleWrap_H_
#define ConsoleWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE ConsoleWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IConsole)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(ConsoleWrap, IConsole)
    DECLARE_NOT_AGGREGATABLE(ConsoleWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(ConsoleWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IConsole)
        COM_INTERFACE_ENTRY2(IDispatch, IConsole)
        VBOX_TWEAK_INTERFACE_ENTRY(IConsole)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(ConsoleWrap)

    /** @name Public IConsole properties
     * @{ */
    STDMETHOD(COMGETTER(Machine))(IMachine **aMachine);
    STDMETHOD(COMGETTER(State))(MachineState_T *aState);
    STDMETHOD(COMGETTER(Guest))(IGuest **aGuest);
    STDMETHOD(COMGETTER(Keyboard))(IKeyboard **aKeyboard);
    STDMETHOD(COMGETTER(Mouse))(IMouse **aMouse);
    STDMETHOD(COMGETTER(Display))(IDisplay **aDisplay);
    STDMETHOD(COMGETTER(Debugger))(IMachineDebugger **aDebugger);
    STDMETHOD(COMGETTER(USBDevices))(ComSafeArrayOut(IUSBDevice *, aUSBDevices));
    STDMETHOD(COMGETTER(RemoteUSBDevices))(ComSafeArrayOut(IHostUSBDevice *, aRemoteUSBDevices));
    STDMETHOD(COMGETTER(SharedFolders))(ComSafeArrayOut(ISharedFolder *, aSharedFolders));
    STDMETHOD(COMGETTER(VRDEServerInfo))(IVRDEServerInfo **aVRDEServerInfo);
    STDMETHOD(COMGETTER(EventSource))(IEventSource **aEventSource);
    STDMETHOD(COMGETTER(AttachedPCIDevices))(ComSafeArrayOut(IPCIDeviceAttachment *, aAttachedPCIDevices));
    STDMETHOD(COMGETTER(UseHostClipboard))(BOOL *aUseHostClipboard);
    STDMETHOD(COMSETTER(UseHostClipboard))(BOOL aUseHostClipboard);
    STDMETHOD(COMGETTER(EmulatedUSB))(IEmulatedUSB **aEmulatedUSB);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IConsole))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IConsole))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IConsole))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IConsole))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IConsole))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IConsole))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IConsole))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IConsole))(ULONG *aReserved);
    /** @} */

    /** @name Public IConsole methods
     * @{ */
    STDMETHOD(PowerUp)(IProgress **aProgress);
    STDMETHOD(PowerUpPaused)(IProgress **aProgress);
    STDMETHOD(PowerDown)(IProgress **aProgress);
    STDMETHOD(Reset)();
    STDMETHOD(Pause)();
    STDMETHOD(Resume)();
    STDMETHOD(PowerButton)();
    STDMETHOD(SleepButton)();
    STDMETHOD(GetPowerButtonHandled)(BOOL *aHandled);
    STDMETHOD(GetGuestEnteredACPIMode)(BOOL *aEntered);
    STDMETHOD(GetDeviceActivity)(ComSafeArrayIn(DeviceType_T, aType),
                                 ComSafeArrayOut(DeviceActivity_T, aActivity));
    STDMETHOD(AttachUSBDevice)(IN_BSTR aId,
                               IN_BSTR aCaptureFilename);
    STDMETHOD(DetachUSBDevice)(IN_BSTR aId,
                               IUSBDevice **aDevice);
    STDMETHOD(FindUSBDeviceByAddress)(IN_BSTR aName,
                                      IUSBDevice **aDevice);
    STDMETHOD(FindUSBDeviceById)(IN_BSTR aId,
                                 IUSBDevice **aDevice);
    STDMETHOD(CreateSharedFolder)(IN_BSTR aName,
                                  IN_BSTR aHostPath,
                                  BOOL aWritable,
                                  BOOL aAutomount,
                                  IN_BSTR aAutoMountPoint);
    STDMETHOD(RemoveSharedFolder)(IN_BSTR aName);
    STDMETHOD(Teleport)(IN_BSTR aHostname,
                        ULONG aTcpport,
                        IN_BSTR aPassword,
                        ULONG aMaxDowntime,
                        IProgress **aProgress);
    STDMETHOD(AddDiskEncryptionPassword)(IN_BSTR aId,
                                         IN_BSTR aPassword,
                                         BOOL aClearOnSuspend);
    STDMETHOD(AddDiskEncryptionPasswords)(ComSafeArrayIn(IN_BSTR, aIds),
                                          ComSafeArrayIn(IN_BSTR, aPasswords),
                                          BOOL aClearOnSuspend);
    STDMETHOD(RemoveDiskEncryptionPassword)(IN_BSTR aId);
    STDMETHOD(ClearAllDiskEncryptionPasswords)();
    STDMETHOD(InternalAndReservedMethod1IConsole)();
    STDMETHOD(InternalAndReservedMethod2IConsole)();
    STDMETHOD(InternalAndReservedMethod3IConsole)();
    STDMETHOD(InternalAndReservedMethod4IConsole)();
    STDMETHOD(InternalAndReservedMethod5IConsole)();
    STDMETHOD(InternalAndReservedMethod6IConsole)();
    STDMETHOD(InternalAndReservedMethod7IConsole)();
    STDMETHOD(InternalAndReservedMethod8IConsole)();
    /** @} */

private:
    /** @name Wrapped IConsole properties
     * @{ */
    virtual HRESULT getMachine(ComPtr<IMachine> &aMachine) = 0;
    virtual HRESULT getState(MachineState_T *aState) = 0;
    virtual HRESULT getGuest(ComPtr<IGuest> &aGuest) = 0;
    virtual HRESULT getKeyboard(ComPtr<IKeyboard> &aKeyboard) = 0;
    virtual HRESULT getMouse(ComPtr<IMouse> &aMouse) = 0;
    virtual HRESULT getDisplay(ComPtr<IDisplay> &aDisplay) = 0;
    virtual HRESULT getDebugger(ComPtr<IMachineDebugger> &aDebugger) = 0;
    virtual HRESULT getUSBDevices(std::vector<ComPtr<IUSBDevice> > &aUSBDevices) = 0;
    virtual HRESULT getRemoteUSBDevices(std::vector<ComPtr<IHostUSBDevice> > &aRemoteUSBDevices) = 0;
    virtual HRESULT getSharedFolders(std::vector<ComPtr<ISharedFolder> > &aSharedFolders) = 0;
    virtual HRESULT getVRDEServerInfo(ComPtr<IVRDEServerInfo> &aVRDEServerInfo) = 0;
    virtual HRESULT getEventSource(ComPtr<IEventSource> &aEventSource) = 0;
    virtual HRESULT getAttachedPCIDevices(std::vector<ComPtr<IPCIDeviceAttachment> > &aAttachedPCIDevices) = 0;
    virtual HRESULT getUseHostClipboard(BOOL *aUseHostClipboard) = 0;
    virtual HRESULT setUseHostClipboard(BOOL aUseHostClipboard) = 0;
    virtual HRESULT getEmulatedUSB(ComPtr<IEmulatedUSB> &aEmulatedUSB) = 0;
    /** @} */

    /** @name Wrapped IConsole methods
     * @{ */
    virtual HRESULT powerUp(ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT powerUpPaused(ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT powerDown(ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT reset() = 0;
    virtual HRESULT pause() = 0;
    virtual HRESULT resume() = 0;
    virtual HRESULT powerButton() = 0;
    virtual HRESULT sleepButton() = 0;
    virtual HRESULT getPowerButtonHandled(BOOL *aHandled) = 0;
    virtual HRESULT getGuestEnteredACPIMode(BOOL *aEntered) = 0;
    virtual HRESULT getDeviceActivity(const std::vector<DeviceType_T> &aType,
                                      std::vector<DeviceActivity_T> &aActivity) = 0;
    virtual HRESULT attachUSBDevice(const com::Guid &aId,
                                    const com::Utf8Str &aCaptureFilename) = 0;
    virtual HRESULT detachUSBDevice(const com::Guid &aId,
                                    ComPtr<IUSBDevice> &aDevice) = 0;
    virtual HRESULT findUSBDeviceByAddress(const com::Utf8Str &aName,
                                           ComPtr<IUSBDevice> &aDevice) = 0;
    virtual HRESULT findUSBDeviceById(const com::Guid &aId,
                                      ComPtr<IUSBDevice> &aDevice) = 0;
    virtual HRESULT createSharedFolder(const com::Utf8Str &aName,
                                       const com::Utf8Str &aHostPath,
                                       BOOL aWritable,
                                       BOOL aAutomount,
                                       const com::Utf8Str &aAutoMountPoint) = 0;
    virtual HRESULT removeSharedFolder(const com::Utf8Str &aName) = 0;
    virtual HRESULT teleport(const com::Utf8Str &aHostname,
                             ULONG aTcpport,
                             const com::Utf8Str &aPassword,
                             ULONG aMaxDowntime,
                             ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT addDiskEncryptionPassword(const com::Utf8Str &aId,
                                              const com::Utf8Str &aPassword,
                                              BOOL aClearOnSuspend) = 0;
    virtual HRESULT addDiskEncryptionPasswords(const std::vector<com::Utf8Str> &aIds,
                                               const std::vector<com::Utf8Str> &aPasswords,
                                               BOOL aClearOnSuspend) = 0;
    virtual HRESULT removeDiskEncryptionPassword(const com::Utf8Str &aId) = 0;
    virtual HRESULT clearAllDiskEncryptionPasswords() = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(ConsoleWrap); /* Shuts up MSC warning C4625. */

};

#endif // !ConsoleWrap_H_

// ##### ENDFILE "ConsoleWrap.h"


// ##### BEGINFILE "HostNetworkInterfaceWrap.h"
/** @file
 * VirtualBox API class wrapper header for IHostNetworkInterface.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef HostNetworkInterfaceWrap_H_
#define HostNetworkInterfaceWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE HostNetworkInterfaceWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IHostNetworkInterface)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(HostNetworkInterfaceWrap, IHostNetworkInterface)
    DECLARE_NOT_AGGREGATABLE(HostNetworkInterfaceWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(HostNetworkInterfaceWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IHostNetworkInterface)
        COM_INTERFACE_ENTRY2(IDispatch, IHostNetworkInterface)
        VBOX_TWEAK_INTERFACE_ENTRY(IHostNetworkInterface)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(HostNetworkInterfaceWrap)

    /** @name Public IHostNetworkInterface properties
     * @{ */
    STDMETHOD(COMGETTER(Name))(BSTR *aName);
    STDMETHOD(COMGETTER(ShortName))(BSTR *aShortName);
    STDMETHOD(COMGETTER(Id))(BSTR *aId);
    STDMETHOD(COMGETTER(NetworkName))(BSTR *aNetworkName);
    STDMETHOD(COMGETTER(DHCPEnabled))(BOOL *aDHCPEnabled);
    STDMETHOD(COMGETTER(IPAddress))(BSTR *aIPAddress);
    STDMETHOD(COMGETTER(NetworkMask))(BSTR *aNetworkMask);
    STDMETHOD(COMGETTER(IPV6Supported))(BOOL *aIPV6Supported);
    STDMETHOD(COMGETTER(IPV6Address))(BSTR *aIPV6Address);
    STDMETHOD(COMGETTER(IPV6NetworkMaskPrefixLength))(ULONG *aIPV6NetworkMaskPrefixLength);
    STDMETHOD(COMGETTER(HardwareAddress))(BSTR *aHardwareAddress);
    STDMETHOD(COMGETTER(MediumType))(HostNetworkInterfaceMediumType_T *aMediumType);
    STDMETHOD(COMGETTER(Status))(HostNetworkInterfaceStatus_T *aStatus);
    STDMETHOD(COMGETTER(InterfaceType))(HostNetworkInterfaceType_T *aInterfaceType);
    STDMETHOD(COMGETTER(Wireless))(BOOL *aWireless);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IHostNetworkInterface))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IHostNetworkInterface))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IHostNetworkInterface))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IHostNetworkInterface))(ULONG *aReserved);
    /** @} */

    /** @name Public IHostNetworkInterface methods
     * @{ */
    STDMETHOD(EnableStaticIPConfig)(IN_BSTR aIPAddress,
                                    IN_BSTR aNetworkMask);
    STDMETHOD(EnableStaticIPConfigV6)(IN_BSTR aIPV6Address,
                                      ULONG aIPV6NetworkMaskPrefixLength);
    STDMETHOD(EnableDynamicIPConfig)();
    STDMETHOD(DHCPRediscover)();
    STDMETHOD(InternalAndReservedMethod1IHostNetworkInterface)();
    STDMETHOD(InternalAndReservedMethod2IHostNetworkInterface)();
    /** @} */

private:
    /** @name Wrapped IHostNetworkInterface properties
     * @{ */
    virtual HRESULT getName(com::Utf8Str &aName) = 0;
    virtual HRESULT getShortName(com::Utf8Str &aShortName) = 0;
    virtual HRESULT getId(com::Guid &aId) = 0;
    virtual HRESULT getNetworkName(com::Utf8Str &aNetworkName) = 0;
    virtual HRESULT getDHCPEnabled(BOOL *aDHCPEnabled) = 0;
    virtual HRESULT getIPAddress(com::Utf8Str &aIPAddress) = 0;
    virtual HRESULT getNetworkMask(com::Utf8Str &aNetworkMask) = 0;
    virtual HRESULT getIPV6Supported(BOOL *aIPV6Supported) = 0;
    virtual HRESULT getIPV6Address(com::Utf8Str &aIPV6Address) = 0;
    virtual HRESULT getIPV6NetworkMaskPrefixLength(ULONG *aIPV6NetworkMaskPrefixLength) = 0;
    virtual HRESULT getHardwareAddress(com::Utf8Str &aHardwareAddress) = 0;
    virtual HRESULT getMediumType(HostNetworkInterfaceMediumType_T *aMediumType) = 0;
    virtual HRESULT getStatus(HostNetworkInterfaceStatus_T *aStatus) = 0;
    virtual HRESULT getInterfaceType(HostNetworkInterfaceType_T *aInterfaceType) = 0;
    virtual HRESULT getWireless(BOOL *aWireless) = 0;
    /** @} */

    /** @name Wrapped IHostNetworkInterface methods
     * @{ */
    virtual HRESULT enableStaticIPConfig(const com::Utf8Str &aIPAddress,
                                         const com::Utf8Str &aNetworkMask) = 0;
    virtual HRESULT enableStaticIPConfigV6(const com::Utf8Str &aIPV6Address,
                                           ULONG aIPV6NetworkMaskPrefixLength) = 0;
    virtual HRESULT enableDynamicIPConfig() = 0;
    virtual HRESULT dHCPRediscover() = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(HostNetworkInterfaceWrap); /* Shuts up MSC warning C4625. */

};

#endif // !HostNetworkInterfaceWrap_H_

// ##### ENDFILE "HostNetworkInterfaceWrap.h"


// ##### BEGINFILE "HostVideoInputDeviceWrap.h"
/** @file
 * VirtualBox API class wrapper header for IHostVideoInputDevice.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef HostVideoInputDeviceWrap_H_
#define HostVideoInputDeviceWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE HostVideoInputDeviceWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IHostVideoInputDevice)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(HostVideoInputDeviceWrap, IHostVideoInputDevice)
    DECLARE_NOT_AGGREGATABLE(HostVideoInputDeviceWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(HostVideoInputDeviceWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IHostVideoInputDevice)
        COM_INTERFACE_ENTRY2(IDispatch, IHostVideoInputDevice)
        VBOX_TWEAK_INTERFACE_ENTRY(IHostVideoInputDevice)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(HostVideoInputDeviceWrap)

    /** @name Public IHostVideoInputDevice properties
     * @{ */
    STDMETHOD(COMGETTER(Name))(BSTR *aName);
    STDMETHOD(COMGETTER(Path))(BSTR *aPath);
    STDMETHOD(COMGETTER(Alias))(BSTR *aAlias);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IHostVideoInputDevice))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IHostVideoInputDevice))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IHostVideoInputDevice))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IHostVideoInputDevice))(ULONG *aReserved);
    /** @} */

    /** @name Public IHostVideoInputDevice methods
     * @{ */
    /** @} */

private:
    /** @name Wrapped IHostVideoInputDevice properties
     * @{ */
    virtual HRESULT getName(com::Utf8Str &aName) = 0;
    virtual HRESULT getPath(com::Utf8Str &aPath) = 0;
    virtual HRESULT getAlias(com::Utf8Str &aAlias) = 0;
    /** @} */

    /** @name Wrapped IHostVideoInputDevice methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(HostVideoInputDeviceWrap); /* Shuts up MSC warning C4625. */

};

#endif // !HostVideoInputDeviceWrap_H_

// ##### ENDFILE "HostVideoInputDeviceWrap.h"


// ##### BEGINFILE "HostUpdateWrap.h"
/** @file
 * VirtualBox API class wrapper header for IHostUpdate.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef HostUpdateWrap_H_
#define HostUpdateWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE HostUpdateWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IHostUpdate)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(HostUpdateWrap, IHostUpdate)
    DECLARE_NOT_AGGREGATABLE(HostUpdateWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(HostUpdateWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IHostUpdate)
        COM_INTERFACE_ENTRY2(IDispatch, IHostUpdate)
        VBOX_TWEAK_INTERFACE_ENTRY(IHostUpdate)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(HostUpdateWrap)

    /** @name Public IHostUpdate properties
     * @{ */
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IHostUpdate))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IHostUpdate))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IHostUpdate))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IHostUpdate))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IHostUpdate))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IHostUpdate))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IHostUpdate))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IHostUpdate))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute9IHostUpdate))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute10IHostUpdate))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute11IHostUpdate))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute12IHostUpdate))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute13IHostUpdate))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute14IHostUpdate))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute15IHostUpdate))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute16IHostUpdate))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute17IHostUpdate))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute18IHostUpdate))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute19IHostUpdate))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute20IHostUpdate))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute21IHostUpdate))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute22IHostUpdate))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute23IHostUpdate))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute24IHostUpdate))(ULONG *aReserved);
    /** @} */

    /** @name Public IHostUpdate methods
     * @{ */
    STDMETHOD(InternalAndReservedMethod1IHostUpdate)();
    STDMETHOD(InternalAndReservedMethod2IHostUpdate)();
    STDMETHOD(InternalAndReservedMethod3IHostUpdate)();
    STDMETHOD(InternalAndReservedMethod4IHostUpdate)();
    STDMETHOD(InternalAndReservedMethod5IHostUpdate)();
    STDMETHOD(InternalAndReservedMethod6IHostUpdate)();
    STDMETHOD(InternalAndReservedMethod7IHostUpdate)();
    STDMETHOD(InternalAndReservedMethod8IHostUpdate)();
    STDMETHOD(InternalAndReservedMethod9IHostUpdate)();
    STDMETHOD(InternalAndReservedMethod10IHostUpdate)();
    STDMETHOD(InternalAndReservedMethod11IHostUpdate)();
    STDMETHOD(InternalAndReservedMethod12IHostUpdate)();
    /** @} */

private:
    /** @name Wrapped IHostUpdate properties
     * @{ */
    /** @} */

    /** @name Wrapped IHostUpdate methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(HostUpdateWrap); /* Shuts up MSC warning C4625. */

};

#endif // !HostUpdateWrap_H_

// ##### ENDFILE "HostUpdateWrap.h"


// ##### BEGINFILE "HostWrap.h"
/** @file
 * VirtualBox API class wrapper header for IHost.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef HostWrap_H_
#define HostWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE HostWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IHost)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(HostWrap, IHost)
    DECLARE_NOT_AGGREGATABLE(HostWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(HostWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IHost)
        COM_INTERFACE_ENTRY2(IDispatch, IHost)
        VBOX_TWEAK_INTERFACE_ENTRY(IHost)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(HostWrap)

    /** @name Public IHost properties
     * @{ */
    STDMETHOD(COMGETTER(DVDDrives))(ComSafeArrayOut(IMedium *, aDVDDrives));
    STDMETHOD(COMGETTER(FloppyDrives))(ComSafeArrayOut(IMedium *, aFloppyDrives));
    STDMETHOD(COMGETTER(USBDevices))(ComSafeArrayOut(IHostUSBDevice *, aUSBDevices));
    STDMETHOD(COMGETTER(USBDeviceFilters))(ComSafeArrayOut(IHostUSBDeviceFilter *, aUSBDeviceFilters));
    STDMETHOD(COMGETTER(NetworkInterfaces))(ComSafeArrayOut(IHostNetworkInterface *, aNetworkInterfaces));
    STDMETHOD(COMGETTER(NameServers))(ComSafeArrayOut(BSTR, aNameServers));
    STDMETHOD(COMGETTER(DomainName))(BSTR *aDomainName);
    STDMETHOD(COMGETTER(SearchStrings))(ComSafeArrayOut(BSTR, aSearchStrings));
    STDMETHOD(COMGETTER(ProcessorCount))(ULONG *aProcessorCount);
    STDMETHOD(COMGETTER(ProcessorOnlineCount))(ULONG *aProcessorOnlineCount);
    STDMETHOD(COMGETTER(ProcessorCoreCount))(ULONG *aProcessorCoreCount);
    STDMETHOD(COMGETTER(ProcessorOnlineCoreCount))(ULONG *aProcessorOnlineCoreCount);
    STDMETHOD(COMGETTER(MemorySize))(ULONG *aMemorySize);
    STDMETHOD(COMGETTER(MemoryAvailable))(ULONG *aMemoryAvailable);
    STDMETHOD(COMGETTER(OperatingSystem))(BSTR *aOperatingSystem);
    STDMETHOD(COMGETTER(OSVersion))(BSTR *aOSVersion);
    STDMETHOD(COMGETTER(UTCTime))(LONG64 *aUTCTime);
    STDMETHOD(COMGETTER(Acceleration3DAvailable))(BOOL *aAcceleration3DAvailable);
    STDMETHOD(COMGETTER(VideoInputDevices))(ComSafeArrayOut(IHostVideoInputDevice *, aVideoInputDevices));
    STDMETHOD(COMGETTER(Update))(IHostUpdate **aUpdate);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IHost))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IHost))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IHost))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IHost))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IHost))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IHost))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IHost))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IHost))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute9IHost))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute10IHost))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute11IHost))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute12IHost))(ULONG *aReserved);
    /** @} */

    /** @name Public IHost methods
     * @{ */
    STDMETHOD(GetProcessorSpeed)(ULONG aCpuId,
                                 ULONG *aSpeed);
    STDMETHOD(GetProcessorFeature)(ProcessorFeature_T aFeature,
                                   BOOL *aSupported);
    STDMETHOD(GetProcessorDescription)(ULONG aCpuId,
                                       BSTR *aDescription);
    STDMETHOD(GetProcessorCPUIDLeaf)(ULONG aCpuId,
                                     ULONG aLeaf,
                                     ULONG aSubLeaf,
                                     ULONG *aValEax,
                                     ULONG *aValEbx,
                                     ULONG *aValEcx,
                                     ULONG *aValEdx);
    STDMETHOD(CreateHostOnlyNetworkInterface)(IHostNetworkInterface **aHostInterface,
                                              IProgress **aProgress);
    STDMETHOD(RemoveHostOnlyNetworkInterface)(IN_BSTR aId,
                                              IProgress **aProgress);
    STDMETHOD(CreateUSBDeviceFilter)(IN_BSTR aName,
                                     IHostUSBDeviceFilter **aFilter);
    STDMETHOD(InsertUSBDeviceFilter)(ULONG aPosition,
                                     IHostUSBDeviceFilter *aFilter);
    STDMETHOD(RemoveUSBDeviceFilter)(ULONG aPosition);
    STDMETHOD(FindHostDVDDrive)(IN_BSTR aName,
                                IMedium **aDrive);
    STDMETHOD(FindHostFloppyDrive)(IN_BSTR aName,
                                   IMedium **aDrive);
    STDMETHOD(FindHostNetworkInterfaceByName)(IN_BSTR aName,
                                              IHostNetworkInterface **aNetworkInterface);
    STDMETHOD(FindHostNetworkInterfaceById)(IN_BSTR aId,
                                            IHostNetworkInterface **aNetworkInterface);
    STDMETHOD(FindHostNetworkInterfacesOfType)(HostNetworkInterfaceType_T aType,
                                               ComSafeArrayOut(IHostNetworkInterface *, aNetworkInterfaces));
    STDMETHOD(FindUSBDeviceById)(IN_BSTR aId,
                                 IHostUSBDevice **aDevice);
    STDMETHOD(FindUSBDeviceByAddress)(IN_BSTR aName,
                                      IHostUSBDevice **aDevice);
    STDMETHOD(GenerateMACAddress)(BSTR *aAddress);
    STDMETHOD(AddUSBDeviceSource)(IN_BSTR aBackend,
                                  IN_BSTR aId,
                                  IN_BSTR aAddress,
                                  ComSafeArrayIn(IN_BSTR, aPropertyNames),
                                  ComSafeArrayIn(IN_BSTR, aPropertyValues));
    STDMETHOD(RemoveUSBDeviceSource)(IN_BSTR aId);
    STDMETHOD(InternalAndReservedMethod1IHost)();
    STDMETHOD(InternalAndReservedMethod2IHost)();
    STDMETHOD(InternalAndReservedMethod3IHost)();
    STDMETHOD(InternalAndReservedMethod4IHost)();
    STDMETHOD(InternalAndReservedMethod5IHost)();
    STDMETHOD(InternalAndReservedMethod6IHost)();
    /** @} */

private:
    /** @name Wrapped IHost properties
     * @{ */
    virtual HRESULT getDVDDrives(std::vector<ComPtr<IMedium> > &aDVDDrives) = 0;
    virtual HRESULT getFloppyDrives(std::vector<ComPtr<IMedium> > &aFloppyDrives) = 0;
    virtual HRESULT getUSBDevices(std::vector<ComPtr<IHostUSBDevice> > &aUSBDevices) = 0;
    virtual HRESULT getUSBDeviceFilters(std::vector<ComPtr<IHostUSBDeviceFilter> > &aUSBDeviceFilters) = 0;
    virtual HRESULT getNetworkInterfaces(std::vector<ComPtr<IHostNetworkInterface> > &aNetworkInterfaces) = 0;
    virtual HRESULT getNameServers(std::vector<com::Utf8Str> &aNameServers) = 0;
    virtual HRESULT getDomainName(com::Utf8Str &aDomainName) = 0;
    virtual HRESULT getSearchStrings(std::vector<com::Utf8Str> &aSearchStrings) = 0;
    virtual HRESULT getProcessorCount(ULONG *aProcessorCount) = 0;
    virtual HRESULT getProcessorOnlineCount(ULONG *aProcessorOnlineCount) = 0;
    virtual HRESULT getProcessorCoreCount(ULONG *aProcessorCoreCount) = 0;
    virtual HRESULT getProcessorOnlineCoreCount(ULONG *aProcessorOnlineCoreCount) = 0;
    virtual HRESULT getMemorySize(ULONG *aMemorySize) = 0;
    virtual HRESULT getMemoryAvailable(ULONG *aMemoryAvailable) = 0;
    virtual HRESULT getOperatingSystem(com::Utf8Str &aOperatingSystem) = 0;
    virtual HRESULT getOSVersion(com::Utf8Str &aOSVersion) = 0;
    virtual HRESULT getUTCTime(LONG64 *aUTCTime) = 0;
    virtual HRESULT getAcceleration3DAvailable(BOOL *aAcceleration3DAvailable) = 0;
    virtual HRESULT getVideoInputDevices(std::vector<ComPtr<IHostVideoInputDevice> > &aVideoInputDevices) = 0;
    virtual HRESULT getUpdate(ComPtr<IHostUpdate> &aUpdate) = 0;
    /** @} */

    /** @name Wrapped IHost methods
     * @{ */
    virtual HRESULT getProcessorSpeed(ULONG aCpuId,
                                      ULONG *aSpeed) = 0;
    virtual HRESULT getProcessorFeature(ProcessorFeature_T aFeature,
                                        BOOL *aSupported) = 0;
    virtual HRESULT getProcessorDescription(ULONG aCpuId,
                                            com::Utf8Str &aDescription) = 0;
    virtual HRESULT getProcessorCPUIDLeaf(ULONG aCpuId,
                                          ULONG aLeaf,
                                          ULONG aSubLeaf,
                                          ULONG *aValEax,
                                          ULONG *aValEbx,
                                          ULONG *aValEcx,
                                          ULONG *aValEdx) = 0;
    virtual HRESULT createHostOnlyNetworkInterface(ComPtr<IHostNetworkInterface> &aHostInterface,
                                                   ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT removeHostOnlyNetworkInterface(const com::Guid &aId,
                                                   ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT createUSBDeviceFilter(const com::Utf8Str &aName,
                                          ComPtr<IHostUSBDeviceFilter> &aFilter) = 0;
    virtual HRESULT insertUSBDeviceFilter(ULONG aPosition,
                                          const ComPtr<IHostUSBDeviceFilter> &aFilter) = 0;
    virtual HRESULT removeUSBDeviceFilter(ULONG aPosition) = 0;
    virtual HRESULT findHostDVDDrive(const com::Utf8Str &aName,
                                     ComPtr<IMedium> &aDrive) = 0;
    virtual HRESULT findHostFloppyDrive(const com::Utf8Str &aName,
                                        ComPtr<IMedium> &aDrive) = 0;
    virtual HRESULT findHostNetworkInterfaceByName(const com::Utf8Str &aName,
                                                   ComPtr<IHostNetworkInterface> &aNetworkInterface) = 0;
    virtual HRESULT findHostNetworkInterfaceById(const com::Guid &aId,
                                                 ComPtr<IHostNetworkInterface> &aNetworkInterface) = 0;
    virtual HRESULT findHostNetworkInterfacesOfType(HostNetworkInterfaceType_T aType,
                                                    std::vector<ComPtr<IHostNetworkInterface> > &aNetworkInterfaces) = 0;
    virtual HRESULT findUSBDeviceById(const com::Guid &aId,
                                      ComPtr<IHostUSBDevice> &aDevice) = 0;
    virtual HRESULT findUSBDeviceByAddress(const com::Utf8Str &aName,
                                           ComPtr<IHostUSBDevice> &aDevice) = 0;
    virtual HRESULT generateMACAddress(com::Utf8Str &aAddress) = 0;
    virtual HRESULT addUSBDeviceSource(const com::Utf8Str &aBackend,
                                       const com::Utf8Str &aId,
                                       const com::Utf8Str &aAddress,
                                       const std::vector<com::Utf8Str> &aPropertyNames,
                                       const std::vector<com::Utf8Str> &aPropertyValues) = 0;
    virtual HRESULT removeUSBDeviceSource(const com::Utf8Str &aId) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(HostWrap); /* Shuts up MSC warning C4625. */

};

#endif // !HostWrap_H_

// ##### ENDFILE "HostWrap.h"


// ##### BEGINFILE "SystemPropertiesWrap.h"
/** @file
 * VirtualBox API class wrapper header for ISystemProperties.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef SystemPropertiesWrap_H_
#define SystemPropertiesWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE SystemPropertiesWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(ISystemProperties)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(SystemPropertiesWrap, ISystemProperties)
    DECLARE_NOT_AGGREGATABLE(SystemPropertiesWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(SystemPropertiesWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(ISystemProperties)
        COM_INTERFACE_ENTRY2(IDispatch, ISystemProperties)
        VBOX_TWEAK_INTERFACE_ENTRY(ISystemProperties)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(SystemPropertiesWrap)

    /** @name Public ISystemProperties properties
     * @{ */
    STDMETHOD(COMGETTER(MinGuestRAM))(ULONG *aMinGuestRAM);
    STDMETHOD(COMGETTER(MaxGuestRAM))(ULONG *aMaxGuestRAM);
    STDMETHOD(COMGETTER(MinGuestVRAM))(ULONG *aMinGuestVRAM);
    STDMETHOD(COMGETTER(MaxGuestVRAM))(ULONG *aMaxGuestVRAM);
    STDMETHOD(COMGETTER(MinGuestCPUCount))(ULONG *aMinGuestCPUCount);
    STDMETHOD(COMGETTER(MaxGuestCPUCount))(ULONG *aMaxGuestCPUCount);
    STDMETHOD(COMGETTER(MaxGuestMonitors))(ULONG *aMaxGuestMonitors);
    STDMETHOD(COMGETTER(InfoVDSize))(LONG64 *aInfoVDSize);
    STDMETHOD(COMGETTER(SerialPortCount))(ULONG *aSerialPortCount);
    STDMETHOD(COMGETTER(ParallelPortCount))(ULONG *aParallelPortCount);
    STDMETHOD(COMGETTER(MaxBootPosition))(ULONG *aMaxBootPosition);
    STDMETHOD(COMGETTER(RawModeSupported))(BOOL *aRawModeSupported);
    STDMETHOD(COMGETTER(ExclusiveHwVirt))(BOOL *aExclusiveHwVirt);
    STDMETHOD(COMSETTER(ExclusiveHwVirt))(BOOL aExclusiveHwVirt);
    STDMETHOD(COMGETTER(DefaultMachineFolder))(BSTR *aDefaultMachineFolder);
    STDMETHOD(COMSETTER(DefaultMachineFolder))(IN_BSTR aDefaultMachineFolder);
    STDMETHOD(COMGETTER(LoggingLevel))(BSTR *aLoggingLevel);
    STDMETHOD(COMSETTER(LoggingLevel))(IN_BSTR aLoggingLevel);
    STDMETHOD(COMGETTER(MediumFormats))(ComSafeArrayOut(IMediumFormat *, aMediumFormats));
    STDMETHOD(COMGETTER(DefaultHardDiskFormat))(BSTR *aDefaultHardDiskFormat);
    STDMETHOD(COMSETTER(DefaultHardDiskFormat))(IN_BSTR aDefaultHardDiskFormat);
    STDMETHOD(COMGETTER(FreeDiskSpaceWarning))(LONG64 *aFreeDiskSpaceWarning);
    STDMETHOD(COMSETTER(FreeDiskSpaceWarning))(LONG64 aFreeDiskSpaceWarning);
    STDMETHOD(COMGETTER(FreeDiskSpacePercentWarning))(ULONG *aFreeDiskSpacePercentWarning);
    STDMETHOD(COMSETTER(FreeDiskSpacePercentWarning))(ULONG aFreeDiskSpacePercentWarning);
    STDMETHOD(COMGETTER(FreeDiskSpaceError))(LONG64 *aFreeDiskSpaceError);
    STDMETHOD(COMSETTER(FreeDiskSpaceError))(LONG64 aFreeDiskSpaceError);
    STDMETHOD(COMGETTER(FreeDiskSpacePercentError))(ULONG *aFreeDiskSpacePercentError);
    STDMETHOD(COMSETTER(FreeDiskSpacePercentError))(ULONG aFreeDiskSpacePercentError);
    STDMETHOD(COMGETTER(VRDEAuthLibrary))(BSTR *aVRDEAuthLibrary);
    STDMETHOD(COMSETTER(VRDEAuthLibrary))(IN_BSTR aVRDEAuthLibrary);
    STDMETHOD(COMGETTER(WebServiceAuthLibrary))(BSTR *aWebServiceAuthLibrary);
    STDMETHOD(COMSETTER(WebServiceAuthLibrary))(IN_BSTR aWebServiceAuthLibrary);
    STDMETHOD(COMGETTER(DefaultVRDEExtPack))(BSTR *aDefaultVRDEExtPack);
    STDMETHOD(COMSETTER(DefaultVRDEExtPack))(IN_BSTR aDefaultVRDEExtPack);
    STDMETHOD(COMGETTER(LogHistoryCount))(ULONG *aLogHistoryCount);
    STDMETHOD(COMSETTER(LogHistoryCount))(ULONG aLogHistoryCount);
    STDMETHOD(COMGETTER(DefaultAudioDriver))(AudioDriverType_T *aDefaultAudioDriver);
    STDMETHOD(COMGETTER(AutostartDatabasePath))(BSTR *aAutostartDatabasePath);
    STDMETHOD(COMSETTER(AutostartDatabasePath))(IN_BSTR aAutostartDatabasePath);
    STDMETHOD(COMGETTER(DefaultAdditionsISO))(BSTR *aDefaultAdditionsISO);
    STDMETHOD(COMSETTER(DefaultAdditionsISO))(IN_BSTR aDefaultAdditionsISO);
    STDMETHOD(COMGETTER(DefaultFrontend))(BSTR *aDefaultFrontend);
    STDMETHOD(COMSETTER(DefaultFrontend))(IN_BSTR aDefaultFrontend);
    STDMETHOD(COMGETTER(ScreenShotFormats))(ComSafeArrayOut(BitmapFormat_T, aScreenShotFormats));
    STDMETHOD(COMGETTER(ProxyMode))(ProxyMode_T *aProxyMode);
    STDMETHOD(COMSETTER(ProxyMode))(ProxyMode_T aProxyMode);
    STDMETHOD(COMGETTER(ProxyURL))(BSTR *aProxyURL);
    STDMETHOD(COMSETTER(ProxyURL))(IN_BSTR aProxyURL);
    STDMETHOD(COMGETTER(SupportedParavirtProviders))(ComSafeArrayOut(ParavirtProvider_T, aSupportedParavirtProviders));
    STDMETHOD(COMGETTER(SupportedClipboardModes))(ComSafeArrayOut(ClipboardMode_T, aSupportedClipboardModes));
    STDMETHOD(COMGETTER(SupportedDnDModes))(ComSafeArrayOut(DnDMode_T, aSupportedDnDModes));
    STDMETHOD(COMGETTER(SupportedFirmwareTypes))(ComSafeArrayOut(FirmwareType_T, aSupportedFirmwareTypes));
    STDMETHOD(COMGETTER(SupportedPointingHIDTypes))(ComSafeArrayOut(PointingHIDType_T, aSupportedPointingHIDTypes));
    STDMETHOD(COMGETTER(SupportedKeyboardHIDTypes))(ComSafeArrayOut(KeyboardHIDType_T, aSupportedKeyboardHIDTypes));
    STDMETHOD(COMGETTER(SupportedVFSTypes))(ComSafeArrayOut(VFSType_T, aSupportedVFSTypes));
    STDMETHOD(COMGETTER(SupportedImportOptions))(ComSafeArrayOut(ImportOptions_T, aSupportedImportOptions));
    STDMETHOD(COMGETTER(SupportedExportOptions))(ComSafeArrayOut(ExportOptions_T, aSupportedExportOptions));
    STDMETHOD(COMGETTER(SupportedRecordingAudioCodecs))(ComSafeArrayOut(RecordingAudioCodec_T, aSupportedRecordingAudioCodecs));
    STDMETHOD(COMGETTER(SupportedRecordingVideoCodecs))(ComSafeArrayOut(RecordingVideoCodec_T, aSupportedRecordingVideoCodecs));
    STDMETHOD(COMGETTER(SupportedRecordingVSMethods))(ComSafeArrayOut(RecordingVideoScalingMethod_T, aSupportedRecordingVSMethods));
    STDMETHOD(COMGETTER(SupportedRecordingVRCModes))(ComSafeArrayOut(RecordingVideoRateControlMode_T, aSupportedRecordingVRCModes));
    STDMETHOD(COMGETTER(SupportedGraphicsControllerTypes))(ComSafeArrayOut(GraphicsControllerType_T, aSupportedGraphicsControllerTypes));
    STDMETHOD(COMGETTER(SupportedCloneOptions))(ComSafeArrayOut(CloneOptions_T, aSupportedCloneOptions));
    STDMETHOD(COMGETTER(SupportedAutostopTypes))(ComSafeArrayOut(AutostopType_T, aSupportedAutostopTypes));
    STDMETHOD(COMGETTER(SupportedVMProcPriorities))(ComSafeArrayOut(VMProcPriority_T, aSupportedVMProcPriorities));
    STDMETHOD(COMGETTER(SupportedNetworkAttachmentTypes))(ComSafeArrayOut(NetworkAttachmentType_T, aSupportedNetworkAttachmentTypes));
    STDMETHOD(COMGETTER(SupportedNetworkAdapterTypes))(ComSafeArrayOut(NetworkAdapterType_T, aSupportedNetworkAdapterTypes));
    STDMETHOD(COMGETTER(SupportedPortModes))(ComSafeArrayOut(PortMode_T, aSupportedPortModes));
    STDMETHOD(COMGETTER(SupportedUartTypes))(ComSafeArrayOut(UartType_T, aSupportedUartTypes));
    STDMETHOD(COMGETTER(SupportedUSBControllerTypes))(ComSafeArrayOut(USBControllerType_T, aSupportedUSBControllerTypes));
    STDMETHOD(COMGETTER(SupportedAudioDriverTypes))(ComSafeArrayOut(AudioDriverType_T, aSupportedAudioDriverTypes));
    STDMETHOD(COMGETTER(SupportedAudioControllerTypes))(ComSafeArrayOut(AudioControllerType_T, aSupportedAudioControllerTypes));
    STDMETHOD(COMGETTER(SupportedStorageBuses))(ComSafeArrayOut(StorageBus_T, aSupportedStorageBuses));
    STDMETHOD(COMGETTER(SupportedStorageControllerTypes))(ComSafeArrayOut(StorageControllerType_T, aSupportedStorageControllerTypes));
    STDMETHOD(COMGETTER(SupportedChipsetTypes))(ComSafeArrayOut(ChipsetType_T, aSupportedChipsetTypes));
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1ISystemProperties))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2ISystemProperties))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3ISystemProperties))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4ISystemProperties))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5ISystemProperties))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6ISystemProperties))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7ISystemProperties))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8ISystemProperties))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute9ISystemProperties))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute10ISystemProperties))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute11ISystemProperties))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute12ISystemProperties))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute13ISystemProperties))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute14ISystemProperties))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute15ISystemProperties))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute16ISystemProperties))(ULONG *aReserved);
    /** @} */

    /** @name Public ISystemProperties methods
     * @{ */
    STDMETHOD(GetMaxNetworkAdapters)(ChipsetType_T aChipset,
                                     ULONG *aMaxNetworkAdapters);
    STDMETHOD(GetMaxNetworkAdaptersOfType)(ChipsetType_T aChipset,
                                           NetworkAttachmentType_T aType,
                                           ULONG *aMaxNetworkAdapters);
    STDMETHOD(GetMaxDevicesPerPortForStorageBus)(StorageBus_T aBus,
                                                 ULONG *aMaxDevicesPerPort);
    STDMETHOD(GetMinPortCountForStorageBus)(StorageBus_T aBus,
                                            ULONG *aMinPortCount);
    STDMETHOD(GetMaxPortCountForStorageBus)(StorageBus_T aBus,
                                            ULONG *aMaxPortCount);
    STDMETHOD(GetMaxInstancesOfStorageBus)(ChipsetType_T aChipset,
                                           StorageBus_T aBus,
                                           ULONG *aMaxInstances);
    STDMETHOD(GetDeviceTypesForStorageBus)(StorageBus_T aBus,
                                           ComSafeArrayOut(DeviceType_T, aDeviceTypes));
    STDMETHOD(GetStorageBusForStorageControllerType)(StorageControllerType_T aStorageControllerType,
                                                     StorageBus_T *aStorageBus);
    STDMETHOD(GetStorageControllerTypesForStorageBus)(StorageBus_T aStorageBus,
                                                      ComSafeArrayOut(StorageControllerType_T, aStorageControllerType));
    STDMETHOD(GetDefaultIoCacheSettingForStorageController)(StorageControllerType_T aControllerType,
                                                            BOOL *aEnabled);
    STDMETHOD(GetStorageControllerHotplugCapable)(StorageControllerType_T aControllerType,
                                                  BOOL *aHotplugCapable);
    STDMETHOD(GetMaxInstancesOfUSBControllerType)(ChipsetType_T aChipset,
                                                  USBControllerType_T aType,
                                                  ULONG *aMaxInstances);
    STDMETHOD(InternalAndReservedMethod1ISystemProperties)();
    STDMETHOD(InternalAndReservedMethod2ISystemProperties)();
    STDMETHOD(InternalAndReservedMethod3ISystemProperties)();
    STDMETHOD(InternalAndReservedMethod4ISystemProperties)();
    /** @} */

private:
    /** @name Wrapped ISystemProperties properties
     * @{ */
    virtual HRESULT getMinGuestRAM(ULONG *aMinGuestRAM) = 0;
    virtual HRESULT getMaxGuestRAM(ULONG *aMaxGuestRAM) = 0;
    virtual HRESULT getMinGuestVRAM(ULONG *aMinGuestVRAM) = 0;
    virtual HRESULT getMaxGuestVRAM(ULONG *aMaxGuestVRAM) = 0;
    virtual HRESULT getMinGuestCPUCount(ULONG *aMinGuestCPUCount) = 0;
    virtual HRESULT getMaxGuestCPUCount(ULONG *aMaxGuestCPUCount) = 0;
    virtual HRESULT getMaxGuestMonitors(ULONG *aMaxGuestMonitors) = 0;
    virtual HRESULT getInfoVDSize(LONG64 *aInfoVDSize) = 0;
    virtual HRESULT getSerialPortCount(ULONG *aSerialPortCount) = 0;
    virtual HRESULT getParallelPortCount(ULONG *aParallelPortCount) = 0;
    virtual HRESULT getMaxBootPosition(ULONG *aMaxBootPosition) = 0;
    virtual HRESULT getRawModeSupported(BOOL *aRawModeSupported) = 0;
    virtual HRESULT getExclusiveHwVirt(BOOL *aExclusiveHwVirt) = 0;
    virtual HRESULT setExclusiveHwVirt(BOOL aExclusiveHwVirt) = 0;
    virtual HRESULT getDefaultMachineFolder(com::Utf8Str &aDefaultMachineFolder) = 0;
    virtual HRESULT setDefaultMachineFolder(const com::Utf8Str &aDefaultMachineFolder) = 0;
    virtual HRESULT getLoggingLevel(com::Utf8Str &aLoggingLevel) = 0;
    virtual HRESULT setLoggingLevel(const com::Utf8Str &aLoggingLevel) = 0;
    virtual HRESULT getMediumFormats(std::vector<ComPtr<IMediumFormat> > &aMediumFormats) = 0;
    virtual HRESULT getDefaultHardDiskFormat(com::Utf8Str &aDefaultHardDiskFormat) = 0;
    virtual HRESULT setDefaultHardDiskFormat(const com::Utf8Str &aDefaultHardDiskFormat) = 0;
    virtual HRESULT getFreeDiskSpaceWarning(LONG64 *aFreeDiskSpaceWarning) = 0;
    virtual HRESULT setFreeDiskSpaceWarning(LONG64 aFreeDiskSpaceWarning) = 0;
    virtual HRESULT getFreeDiskSpacePercentWarning(ULONG *aFreeDiskSpacePercentWarning) = 0;
    virtual HRESULT setFreeDiskSpacePercentWarning(ULONG aFreeDiskSpacePercentWarning) = 0;
    virtual HRESULT getFreeDiskSpaceError(LONG64 *aFreeDiskSpaceError) = 0;
    virtual HRESULT setFreeDiskSpaceError(LONG64 aFreeDiskSpaceError) = 0;
    virtual HRESULT getFreeDiskSpacePercentError(ULONG *aFreeDiskSpacePercentError) = 0;
    virtual HRESULT setFreeDiskSpacePercentError(ULONG aFreeDiskSpacePercentError) = 0;
    virtual HRESULT getVRDEAuthLibrary(com::Utf8Str &aVRDEAuthLibrary) = 0;
    virtual HRESULT setVRDEAuthLibrary(const com::Utf8Str &aVRDEAuthLibrary) = 0;
    virtual HRESULT getWebServiceAuthLibrary(com::Utf8Str &aWebServiceAuthLibrary) = 0;
    virtual HRESULT setWebServiceAuthLibrary(const com::Utf8Str &aWebServiceAuthLibrary) = 0;
    virtual HRESULT getDefaultVRDEExtPack(com::Utf8Str &aDefaultVRDEExtPack) = 0;
    virtual HRESULT setDefaultVRDEExtPack(const com::Utf8Str &aDefaultVRDEExtPack) = 0;
    virtual HRESULT getLogHistoryCount(ULONG *aLogHistoryCount) = 0;
    virtual HRESULT setLogHistoryCount(ULONG aLogHistoryCount) = 0;
    virtual HRESULT getDefaultAudioDriver(AudioDriverType_T *aDefaultAudioDriver) = 0;
    virtual HRESULT getAutostartDatabasePath(com::Utf8Str &aAutostartDatabasePath) = 0;
    virtual HRESULT setAutostartDatabasePath(const com::Utf8Str &aAutostartDatabasePath) = 0;
    virtual HRESULT getDefaultAdditionsISO(com::Utf8Str &aDefaultAdditionsISO) = 0;
    virtual HRESULT setDefaultAdditionsISO(const com::Utf8Str &aDefaultAdditionsISO) = 0;
    virtual HRESULT getDefaultFrontend(com::Utf8Str &aDefaultFrontend) = 0;
    virtual HRESULT setDefaultFrontend(const com::Utf8Str &aDefaultFrontend) = 0;
    virtual HRESULT getScreenShotFormats(std::vector<BitmapFormat_T> &aScreenShotFormats) = 0;
    virtual HRESULT getProxyMode(ProxyMode_T *aProxyMode) = 0;
    virtual HRESULT setProxyMode(ProxyMode_T aProxyMode) = 0;
    virtual HRESULT getProxyURL(com::Utf8Str &aProxyURL) = 0;
    virtual HRESULT setProxyURL(const com::Utf8Str &aProxyURL) = 0;
    virtual HRESULT getSupportedParavirtProviders(std::vector<ParavirtProvider_T> &aSupportedParavirtProviders) = 0;
    virtual HRESULT getSupportedClipboardModes(std::vector<ClipboardMode_T> &aSupportedClipboardModes) = 0;
    virtual HRESULT getSupportedDnDModes(std::vector<DnDMode_T> &aSupportedDnDModes) = 0;
    virtual HRESULT getSupportedFirmwareTypes(std::vector<FirmwareType_T> &aSupportedFirmwareTypes) = 0;
    virtual HRESULT getSupportedPointingHIDTypes(std::vector<PointingHIDType_T> &aSupportedPointingHIDTypes) = 0;
    virtual HRESULT getSupportedKeyboardHIDTypes(std::vector<KeyboardHIDType_T> &aSupportedKeyboardHIDTypes) = 0;
    virtual HRESULT getSupportedVFSTypes(std::vector<VFSType_T> &aSupportedVFSTypes) = 0;
    virtual HRESULT getSupportedImportOptions(std::vector<ImportOptions_T> &aSupportedImportOptions) = 0;
    virtual HRESULT getSupportedExportOptions(std::vector<ExportOptions_T> &aSupportedExportOptions) = 0;
    virtual HRESULT getSupportedRecordingAudioCodecs(std::vector<RecordingAudioCodec_T> &aSupportedRecordingAudioCodecs) = 0;
    virtual HRESULT getSupportedRecordingVideoCodecs(std::vector<RecordingVideoCodec_T> &aSupportedRecordingVideoCodecs) = 0;
    virtual HRESULT getSupportedRecordingVSMethods(std::vector<RecordingVideoScalingMethod_T> &aSupportedRecordingVSMethods) = 0;
    virtual HRESULT getSupportedRecordingVRCModes(std::vector<RecordingVideoRateControlMode_T> &aSupportedRecordingVRCModes) = 0;
    virtual HRESULT getSupportedGraphicsControllerTypes(std::vector<GraphicsControllerType_T> &aSupportedGraphicsControllerTypes) = 0;
    virtual HRESULT getSupportedCloneOptions(std::vector<CloneOptions_T> &aSupportedCloneOptions) = 0;
    virtual HRESULT getSupportedAutostopTypes(std::vector<AutostopType_T> &aSupportedAutostopTypes) = 0;
    virtual HRESULT getSupportedVMProcPriorities(std::vector<VMProcPriority_T> &aSupportedVMProcPriorities) = 0;
    virtual HRESULT getSupportedNetworkAttachmentTypes(std::vector<NetworkAttachmentType_T> &aSupportedNetworkAttachmentTypes) = 0;
    virtual HRESULT getSupportedNetworkAdapterTypes(std::vector<NetworkAdapterType_T> &aSupportedNetworkAdapterTypes) = 0;
    virtual HRESULT getSupportedPortModes(std::vector<PortMode_T> &aSupportedPortModes) = 0;
    virtual HRESULT getSupportedUartTypes(std::vector<UartType_T> &aSupportedUartTypes) = 0;
    virtual HRESULT getSupportedUSBControllerTypes(std::vector<USBControllerType_T> &aSupportedUSBControllerTypes) = 0;
    virtual HRESULT getSupportedAudioDriverTypes(std::vector<AudioDriverType_T> &aSupportedAudioDriverTypes) = 0;
    virtual HRESULT getSupportedAudioControllerTypes(std::vector<AudioControllerType_T> &aSupportedAudioControllerTypes) = 0;
    virtual HRESULT getSupportedStorageBuses(std::vector<StorageBus_T> &aSupportedStorageBuses) = 0;
    virtual HRESULT getSupportedStorageControllerTypes(std::vector<StorageControllerType_T> &aSupportedStorageControllerTypes) = 0;
    virtual HRESULT getSupportedChipsetTypes(std::vector<ChipsetType_T> &aSupportedChipsetTypes) = 0;
    /** @} */

    /** @name Wrapped ISystemProperties methods
     * @{ */
    virtual HRESULT getMaxNetworkAdapters(ChipsetType_T aChipset,
                                          ULONG *aMaxNetworkAdapters) = 0;
    virtual HRESULT getMaxNetworkAdaptersOfType(ChipsetType_T aChipset,
                                                NetworkAttachmentType_T aType,
                                                ULONG *aMaxNetworkAdapters) = 0;
    virtual HRESULT getMaxDevicesPerPortForStorageBus(StorageBus_T aBus,
                                                      ULONG *aMaxDevicesPerPort) = 0;
    virtual HRESULT getMinPortCountForStorageBus(StorageBus_T aBus,
                                                 ULONG *aMinPortCount) = 0;
    virtual HRESULT getMaxPortCountForStorageBus(StorageBus_T aBus,
                                                 ULONG *aMaxPortCount) = 0;
    virtual HRESULT getMaxInstancesOfStorageBus(ChipsetType_T aChipset,
                                                StorageBus_T aBus,
                                                ULONG *aMaxInstances) = 0;
    virtual HRESULT getDeviceTypesForStorageBus(StorageBus_T aBus,
                                                std::vector<DeviceType_T> &aDeviceTypes) = 0;
    virtual HRESULT getStorageBusForStorageControllerType(StorageControllerType_T aStorageControllerType,
                                                          StorageBus_T *aStorageBus) = 0;
    virtual HRESULT getStorageControllerTypesForStorageBus(StorageBus_T aStorageBus,
                                                           std::vector<StorageControllerType_T> &aStorageControllerType) = 0;
    virtual HRESULT getDefaultIoCacheSettingForStorageController(StorageControllerType_T aControllerType,
                                                                 BOOL *aEnabled) = 0;
    virtual HRESULT getStorageControllerHotplugCapable(StorageControllerType_T aControllerType,
                                                       BOOL *aHotplugCapable) = 0;
    virtual HRESULT getMaxInstancesOfUSBControllerType(ChipsetType_T aChipset,
                                                       USBControllerType_T aType,
                                                       ULONG *aMaxInstances) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(SystemPropertiesWrap); /* Shuts up MSC warning C4625. */

};

#endif // !SystemPropertiesWrap_H_

// ##### ENDFILE "SystemPropertiesWrap.h"


// ##### BEGINFILE "GuestOSTypeWrap.h"
/** @file
 * VirtualBox API class wrapper header for IGuestOSType.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef GuestOSTypeWrap_H_
#define GuestOSTypeWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE GuestOSTypeWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IGuestOSType)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(GuestOSTypeWrap, IGuestOSType)
    DECLARE_NOT_AGGREGATABLE(GuestOSTypeWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(GuestOSTypeWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IGuestOSType)
        COM_INTERFACE_ENTRY2(IDispatch, IGuestOSType)
        VBOX_TWEAK_INTERFACE_ENTRY(IGuestOSType)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(GuestOSTypeWrap)

    /** @name Public IGuestOSType properties
     * @{ */
    STDMETHOD(COMGETTER(FamilyId))(BSTR *aFamilyId);
    STDMETHOD(COMGETTER(FamilyDescription))(BSTR *aFamilyDescription);
    STDMETHOD(COMGETTER(Id))(BSTR *aId);
    STDMETHOD(COMGETTER(Description))(BSTR *aDescription);
    STDMETHOD(COMGETTER(Is64Bit))(BOOL *aIs64Bit);
    STDMETHOD(COMGETTER(RecommendedIOAPIC))(BOOL *aRecommendedIOAPIC);
    STDMETHOD(COMGETTER(RecommendedVirtEx))(BOOL *aRecommendedVirtEx);
    STDMETHOD(COMGETTER(RecommendedRAM))(ULONG *aRecommendedRAM);
    STDMETHOD(COMGETTER(RecommendedGraphicsController))(GraphicsControllerType_T *aRecommendedGraphicsController);
    STDMETHOD(COMGETTER(RecommendedVRAM))(ULONG *aRecommendedVRAM);
    STDMETHOD(COMGETTER(Recommended2DVideoAcceleration))(BOOL *aRecommended2DVideoAcceleration);
    STDMETHOD(COMGETTER(Recommended3DAcceleration))(BOOL *aRecommended3DAcceleration);
    STDMETHOD(COMGETTER(RecommendedHDD))(LONG64 *aRecommendedHDD);
    STDMETHOD(COMGETTER(AdapterType))(NetworkAdapterType_T *aAdapterType);
    STDMETHOD(COMGETTER(RecommendedPAE))(BOOL *aRecommendedPAE);
    STDMETHOD(COMGETTER(RecommendedDVDStorageController))(StorageControllerType_T *aRecommendedDVDStorageController);
    STDMETHOD(COMGETTER(RecommendedDVDStorageBus))(StorageBus_T *aRecommendedDVDStorageBus);
    STDMETHOD(COMGETTER(RecommendedHDStorageController))(StorageControllerType_T *aRecommendedHDStorageController);
    STDMETHOD(COMGETTER(RecommendedHDStorageBus))(StorageBus_T *aRecommendedHDStorageBus);
    STDMETHOD(COMGETTER(RecommendedFirmware))(FirmwareType_T *aRecommendedFirmware);
    STDMETHOD(COMGETTER(RecommendedUSBHID))(BOOL *aRecommendedUSBHID);
    STDMETHOD(COMGETTER(RecommendedHPET))(BOOL *aRecommendedHPET);
    STDMETHOD(COMGETTER(RecommendedUSBTablet))(BOOL *aRecommendedUSBTablet);
    STDMETHOD(COMGETTER(RecommendedRTCUseUTC))(BOOL *aRecommendedRTCUseUTC);
    STDMETHOD(COMGETTER(RecommendedChipset))(ChipsetType_T *aRecommendedChipset);
    STDMETHOD(COMGETTER(RecommendedAudioController))(AudioControllerType_T *aRecommendedAudioController);
    STDMETHOD(COMGETTER(RecommendedAudioCodec))(AudioCodecType_T *aRecommendedAudioCodec);
    STDMETHOD(COMGETTER(RecommendedFloppy))(BOOL *aRecommendedFloppy);
    STDMETHOD(COMGETTER(RecommendedUSB))(BOOL *aRecommendedUSB);
    STDMETHOD(COMGETTER(RecommendedUSB3))(BOOL *aRecommendedUSB3);
    STDMETHOD(COMGETTER(RecommendedTFReset))(BOOL *aRecommendedTFReset);
    STDMETHOD(COMGETTER(RecommendedX2APIC))(BOOL *aRecommendedX2APIC);
    STDMETHOD(COMGETTER(RecommendedCPUCount))(ULONG *aRecommendedCPUCount);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IGuestOSType))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IGuestOSType))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IGuestOSType))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IGuestOSType))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IGuestOSType))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IGuestOSType))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IGuestOSType))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IGuestOSType))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute9IGuestOSType))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute10IGuestOSType))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute11IGuestOSType))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute12IGuestOSType))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute13IGuestOSType))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute14IGuestOSType))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute15IGuestOSType))(ULONG *aReserved);
    /** @} */

    /** @name Public IGuestOSType methods
     * @{ */
    /** @} */

private:
    /** @name Wrapped IGuestOSType properties
     * @{ */
    virtual HRESULT getFamilyId(com::Utf8Str &aFamilyId) = 0;
    virtual HRESULT getFamilyDescription(com::Utf8Str &aFamilyDescription) = 0;
    virtual HRESULT getId(com::Utf8Str &aId) = 0;
    virtual HRESULT getDescription(com::Utf8Str &aDescription) = 0;
    virtual HRESULT getIs64Bit(BOOL *aIs64Bit) = 0;
    virtual HRESULT getRecommendedIOAPIC(BOOL *aRecommendedIOAPIC) = 0;
    virtual HRESULT getRecommendedVirtEx(BOOL *aRecommendedVirtEx) = 0;
    virtual HRESULT getRecommendedRAM(ULONG *aRecommendedRAM) = 0;
    virtual HRESULT getRecommendedGraphicsController(GraphicsControllerType_T *aRecommendedGraphicsController) = 0;
    virtual HRESULT getRecommendedVRAM(ULONG *aRecommendedVRAM) = 0;
    virtual HRESULT getRecommended2DVideoAcceleration(BOOL *aRecommended2DVideoAcceleration) = 0;
    virtual HRESULT getRecommended3DAcceleration(BOOL *aRecommended3DAcceleration) = 0;
    virtual HRESULT getRecommendedHDD(LONG64 *aRecommendedHDD) = 0;
    virtual HRESULT getAdapterType(NetworkAdapterType_T *aAdapterType) = 0;
    virtual HRESULT getRecommendedPAE(BOOL *aRecommendedPAE) = 0;
    virtual HRESULT getRecommendedDVDStorageController(StorageControllerType_T *aRecommendedDVDStorageController) = 0;
    virtual HRESULT getRecommendedDVDStorageBus(StorageBus_T *aRecommendedDVDStorageBus) = 0;
    virtual HRESULT getRecommendedHDStorageController(StorageControllerType_T *aRecommendedHDStorageController) = 0;
    virtual HRESULT getRecommendedHDStorageBus(StorageBus_T *aRecommendedHDStorageBus) = 0;
    virtual HRESULT getRecommendedFirmware(FirmwareType_T *aRecommendedFirmware) = 0;
    virtual HRESULT getRecommendedUSBHID(BOOL *aRecommendedUSBHID) = 0;
    virtual HRESULT getRecommendedHPET(BOOL *aRecommendedHPET) = 0;
    virtual HRESULT getRecommendedUSBTablet(BOOL *aRecommendedUSBTablet) = 0;
    virtual HRESULT getRecommendedRTCUseUTC(BOOL *aRecommendedRTCUseUTC) = 0;
    virtual HRESULT getRecommendedChipset(ChipsetType_T *aRecommendedChipset) = 0;
    virtual HRESULT getRecommendedAudioController(AudioControllerType_T *aRecommendedAudioController) = 0;
    virtual HRESULT getRecommendedAudioCodec(AudioCodecType_T *aRecommendedAudioCodec) = 0;
    virtual HRESULT getRecommendedFloppy(BOOL *aRecommendedFloppy) = 0;
    virtual HRESULT getRecommendedUSB(BOOL *aRecommendedUSB) = 0;
    virtual HRESULT getRecommendedUSB3(BOOL *aRecommendedUSB3) = 0;
    virtual HRESULT getRecommendedTFReset(BOOL *aRecommendedTFReset) = 0;
    virtual HRESULT getRecommendedX2APIC(BOOL *aRecommendedX2APIC) = 0;
    virtual HRESULT getRecommendedCPUCount(ULONG *aRecommendedCPUCount) = 0;
    /** @} */

    /** @name Wrapped IGuestOSType methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(GuestOSTypeWrap); /* Shuts up MSC warning C4625. */

};

#endif // !GuestOSTypeWrap_H_

// ##### ENDFILE "GuestOSTypeWrap.h"


// ##### BEGINFILE "AdditionsFacilityWrap.h"
/** @file
 * VirtualBox API class wrapper header for IAdditionsFacility.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef AdditionsFacilityWrap_H_
#define AdditionsFacilityWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE AdditionsFacilityWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IAdditionsFacility)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(AdditionsFacilityWrap, IAdditionsFacility)
    DECLARE_NOT_AGGREGATABLE(AdditionsFacilityWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(AdditionsFacilityWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IAdditionsFacility)
        COM_INTERFACE_ENTRY2(IDispatch, IAdditionsFacility)
        VBOX_TWEAK_INTERFACE_ENTRY(IAdditionsFacility)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(AdditionsFacilityWrap)

    /** @name Public IAdditionsFacility properties
     * @{ */
    STDMETHOD(COMGETTER(ClassType))(AdditionsFacilityClass_T *aClassType);
    STDMETHOD(COMGETTER(LastUpdated))(LONG64 *aLastUpdated);
    STDMETHOD(COMGETTER(Name))(BSTR *aName);
    STDMETHOD(COMGETTER(Status))(AdditionsFacilityStatus_T *aStatus);
    STDMETHOD(COMGETTER(Type))(AdditionsFacilityType_T *aType);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IAdditionsFacility))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IAdditionsFacility))(ULONG *aReserved);
    /** @} */

    /** @name Public IAdditionsFacility methods
     * @{ */
    /** @} */

private:
    /** @name Wrapped IAdditionsFacility properties
     * @{ */
    virtual HRESULT getClassType(AdditionsFacilityClass_T *aClassType) = 0;
    virtual HRESULT getLastUpdated(LONG64 *aLastUpdated) = 0;
    virtual HRESULT getName(com::Utf8Str &aName) = 0;
    virtual HRESULT getStatus(AdditionsFacilityStatus_T *aStatus) = 0;
    virtual HRESULT getType(AdditionsFacilityType_T *aType) = 0;
    /** @} */

    /** @name Wrapped IAdditionsFacility methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(AdditionsFacilityWrap); /* Shuts up MSC warning C4625. */

};

#endif // !AdditionsFacilityWrap_H_

// ##### ENDFILE "AdditionsFacilityWrap.h"


// ##### BEGINFILE "DnDBaseWrap.h"
/** @file
 * VirtualBox API class wrapper header for IDnDBase.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef DnDBaseWrap_H_
#define DnDBaseWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE DnDBaseWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IDnDBase)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(DnDBaseWrap, IDnDBase)
    DECLARE_NOT_AGGREGATABLE(DnDBaseWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(DnDBaseWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IDnDBase)
        COM_INTERFACE_ENTRY2(IDispatch, IDnDBase)
        VBOX_TWEAK_INTERFACE_ENTRY(IDnDBase)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(DnDBaseWrap)

    /** @name Public IDnDBase properties
     * @{ */
    STDMETHOD(COMGETTER(Formats))(ComSafeArrayOut(BSTR, aFormats));
    STDMETHOD(COMGETTER(ProtocolVersion))(ULONG *aProtocolVersion);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IDnDBase))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IDnDBase))(ULONG *aReserved);
    /** @} */

    /** @name Public IDnDBase methods
     * @{ */
    STDMETHOD(IsFormatSupported)(IN_BSTR aFormat,
                                 BOOL *aSupported);
    STDMETHOD(AddFormats)(ComSafeArrayIn(IN_BSTR, aFormats));
    STDMETHOD(RemoveFormats)(ComSafeArrayIn(IN_BSTR, aFormats));
    STDMETHOD(InternalAndReservedMethod1IDnDBase)();
    /** @} */

private:
    /** @name Wrapped IDnDBase properties
     * @{ */
    virtual HRESULT getFormats(std::vector<com::Utf8Str> &aFormats) = 0;
    virtual HRESULT getProtocolVersion(ULONG *aProtocolVersion) = 0;
    /** @} */

    /** @name Wrapped IDnDBase methods
     * @{ */
    virtual HRESULT isFormatSupported(const com::Utf8Str &aFormat,
                                      BOOL *aSupported) = 0;
    virtual HRESULT addFormats(const std::vector<com::Utf8Str> &aFormats) = 0;
    virtual HRESULT removeFormats(const std::vector<com::Utf8Str> &aFormats) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(DnDBaseWrap); /* Shuts up MSC warning C4625. */

};

#endif // !DnDBaseWrap_H_

// ##### ENDFILE "DnDBaseWrap.h"


// ##### BEGINFILE "DnDSourceWrap.h"
/** @file
 * VirtualBox API class wrapper header for IDnDSource.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef DnDSourceWrap_H_
#define DnDSourceWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE DnDSourceWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IDnDSource)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(DnDSourceWrap, IDnDSource)
    DECLARE_NOT_AGGREGATABLE(DnDSourceWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(DnDSourceWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IDnDSource)
        COM_INTERFACE_ENTRY(IDnDBase)
        COM_INTERFACE_ENTRY2(IDispatch, IDnDSource)
        VBOX_TWEAK_INTERFACE_ENTRY(IDnDSource)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(DnDSourceWrap)

    /** @name Public IDnDBase properties
     * @{ */
    STDMETHOD(COMGETTER(Formats))(ComSafeArrayOut(BSTR, aFormats));
    STDMETHOD(COMGETTER(ProtocolVersion))(ULONG *aProtocolVersion);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IDnDBase))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IDnDBase))(ULONG *aReserved);
    /** @} */

    /** @name Public IDnDSource properties
     * @{ */
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IDnDSource))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IDnDSource))(ULONG *aReserved);
    /** @} */

    /** @name Public IDnDBase methods
     * @{ */
    STDMETHOD(IsFormatSupported)(IN_BSTR aFormat,
                                 BOOL *aSupported);
    STDMETHOD(AddFormats)(ComSafeArrayIn(IN_BSTR, aFormats));
    STDMETHOD(RemoveFormats)(ComSafeArrayIn(IN_BSTR, aFormats));
    STDMETHOD(InternalAndReservedMethod1IDnDBase)();
    /** @} */

    /** @name Public IDnDSource methods
     * @{ */
    STDMETHOD(DragIsPending)(ULONG aScreenId,
                             ComSafeArrayOut(BSTR, aFormats),
                             ComSafeArrayOut(DnDAction_T, aAllowedActions),
                             DnDAction_T *aDefaultAction);
    STDMETHOD(Drop)(IN_BSTR aFormat,
                    DnDAction_T aAction,
                    IProgress **aProgress);
    STDMETHOD(ReceiveData)(ComSafeArrayOut(BYTE, aData));
    STDMETHOD(InternalAndReservedMethod1IDnDSource)();
    /** @} */

private:
    /** @name Wrapped IDnDBase properties
     * @{ */
    virtual HRESULT getFormats(std::vector<com::Utf8Str> &aFormats) = 0;
    virtual HRESULT getProtocolVersion(ULONG *aProtocolVersion) = 0;
    /** @} */

    /** @name Wrapped IDnDSource properties
     * @{ */
    /** @} */

    /** @name Wrapped IDnDBase methods
     * @{ */
    virtual HRESULT isFormatSupported(const com::Utf8Str &aFormat,
                                      BOOL *aSupported) = 0;
    virtual HRESULT addFormats(const std::vector<com::Utf8Str> &aFormats) = 0;
    virtual HRESULT removeFormats(const std::vector<com::Utf8Str> &aFormats) = 0;
    /** @} */

    /** @name Wrapped IDnDSource methods
     * @{ */
    virtual HRESULT dragIsPending(ULONG aScreenId,
                                  std::vector<com::Utf8Str> &aFormats,
                                  std::vector<DnDAction_T> &aAllowedActions,
                                  DnDAction_T *aDefaultAction) = 0;
    virtual HRESULT drop(const com::Utf8Str &aFormat,
                         DnDAction_T aAction,
                         ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT receiveData(std::vector<BYTE> &aData) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(DnDSourceWrap); /* Shuts up MSC warning C4625. */

};

#endif // !DnDSourceWrap_H_

// ##### ENDFILE "DnDSourceWrap.h"


// ##### BEGINFILE "GuestDnDSourceWrap.h"
/** @file
 * VirtualBox API class wrapper header for IGuestDnDSource.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef GuestDnDSourceWrap_H_
#define GuestDnDSourceWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE GuestDnDSourceWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IGuestDnDSource)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(GuestDnDSourceWrap, IGuestDnDSource)
    DECLARE_NOT_AGGREGATABLE(GuestDnDSourceWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(GuestDnDSourceWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IGuestDnDSource)
        COM_INTERFACE_ENTRY(IDnDSource)
        COM_INTERFACE_ENTRY(IDnDBase)
        COM_INTERFACE_ENTRY2(IDispatch, IGuestDnDSource)
        VBOX_TWEAK_INTERFACE_ENTRY(IGuestDnDSource)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(GuestDnDSourceWrap)

    /** @name Public IDnDBase properties
     * @{ */
    STDMETHOD(COMGETTER(Formats))(ComSafeArrayOut(BSTR, aFormats));
    STDMETHOD(COMGETTER(ProtocolVersion))(ULONG *aProtocolVersion);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IDnDBase))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IDnDBase))(ULONG *aReserved);
    /** @} */

    /** @name Public IDnDSource properties
     * @{ */
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IDnDSource))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IDnDSource))(ULONG *aReserved);
    /** @} */

    /** @name Public IGuestDnDSource properties
     * @{ */
    STDMETHOD(COMGETTER(MidlDoesNotLikeEmptyInterfaces))(BOOL *aMidlDoesNotLikeEmptyInterfaces);
    /** @} */

    /** @name Public IDnDBase methods
     * @{ */
    STDMETHOD(IsFormatSupported)(IN_BSTR aFormat,
                                 BOOL *aSupported);
    STDMETHOD(AddFormats)(ComSafeArrayIn(IN_BSTR, aFormats));
    STDMETHOD(RemoveFormats)(ComSafeArrayIn(IN_BSTR, aFormats));
    STDMETHOD(InternalAndReservedMethod1IDnDBase)();
    /** @} */

    /** @name Public IDnDSource methods
     * @{ */
    STDMETHOD(DragIsPending)(ULONG aScreenId,
                             ComSafeArrayOut(BSTR, aFormats),
                             ComSafeArrayOut(DnDAction_T, aAllowedActions),
                             DnDAction_T *aDefaultAction);
    STDMETHOD(Drop)(IN_BSTR aFormat,
                    DnDAction_T aAction,
                    IProgress **aProgress);
    STDMETHOD(ReceiveData)(ComSafeArrayOut(BYTE, aData));
    STDMETHOD(InternalAndReservedMethod1IDnDSource)();
    /** @} */

    /** @name Public IGuestDnDSource methods
     * @{ */
    /** @} */

private:
    /** @name Wrapped IDnDBase properties
     * @{ */
    virtual HRESULT getFormats(std::vector<com::Utf8Str> &aFormats) = 0;
    virtual HRESULT getProtocolVersion(ULONG *aProtocolVersion) = 0;
    /** @} */

    /** @name Wrapped IDnDSource properties
     * @{ */
    /** @} */

    /** @name Wrapped IGuestDnDSource properties
     * @{ */
    //    virtual HRESULT getMidlDoesNotLikeEmptyInterfaces(BOOL *aMidlDoesNotLikeEmptyInterfaces) = 0;
    /** @} */

    /** @name Wrapped IDnDBase methods
     * @{ */
    virtual HRESULT isFormatSupported(const com::Utf8Str &aFormat,
                                      BOOL *aSupported) = 0;
    virtual HRESULT addFormats(const std::vector<com::Utf8Str> &aFormats) = 0;
    virtual HRESULT removeFormats(const std::vector<com::Utf8Str> &aFormats) = 0;
    /** @} */

    /** @name Wrapped IDnDSource methods
     * @{ */
    virtual HRESULT dragIsPending(ULONG aScreenId,
                                  std::vector<com::Utf8Str> &aFormats,
                                  std::vector<DnDAction_T> &aAllowedActions,
                                  DnDAction_T *aDefaultAction) = 0;
    virtual HRESULT drop(const com::Utf8Str &aFormat,
                         DnDAction_T aAction,
                         ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT receiveData(std::vector<BYTE> &aData) = 0;
    /** @} */

    /** @name Wrapped IGuestDnDSource methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(GuestDnDSourceWrap); /* Shuts up MSC warning C4625. */

};

#endif // !GuestDnDSourceWrap_H_

// ##### ENDFILE "GuestDnDSourceWrap.h"


// ##### BEGINFILE "DnDTargetWrap.h"
/** @file
 * VirtualBox API class wrapper header for IDnDTarget.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef DnDTargetWrap_H_
#define DnDTargetWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE DnDTargetWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IDnDTarget)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(DnDTargetWrap, IDnDTarget)
    DECLARE_NOT_AGGREGATABLE(DnDTargetWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(DnDTargetWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IDnDTarget)
        COM_INTERFACE_ENTRY(IDnDBase)
        COM_INTERFACE_ENTRY2(IDispatch, IDnDTarget)
        VBOX_TWEAK_INTERFACE_ENTRY(IDnDTarget)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(DnDTargetWrap)

    /** @name Public IDnDBase properties
     * @{ */
    STDMETHOD(COMGETTER(Formats))(ComSafeArrayOut(BSTR, aFormats));
    STDMETHOD(COMGETTER(ProtocolVersion))(ULONG *aProtocolVersion);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IDnDBase))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IDnDBase))(ULONG *aReserved);
    /** @} */

    /** @name Public IDnDTarget properties
     * @{ */
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IDnDTarget))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IDnDTarget))(ULONG *aReserved);
    /** @} */

    /** @name Public IDnDBase methods
     * @{ */
    STDMETHOD(IsFormatSupported)(IN_BSTR aFormat,
                                 BOOL *aSupported);
    STDMETHOD(AddFormats)(ComSafeArrayIn(IN_BSTR, aFormats));
    STDMETHOD(RemoveFormats)(ComSafeArrayIn(IN_BSTR, aFormats));
    STDMETHOD(InternalAndReservedMethod1IDnDBase)();
    /** @} */

    /** @name Public IDnDTarget methods
     * @{ */
    STDMETHOD(Enter)(ULONG aScreenId,
                     ULONG aY,
                     ULONG aX,
                     DnDAction_T aDefaultAction,
                     ComSafeArrayIn(DnDAction_T, aAllowedActions),
                     ComSafeArrayIn(IN_BSTR, aFormats),
                     DnDAction_T *aResultAction);
    STDMETHOD(Move)(ULONG aScreenId,
                    ULONG aX,
                    ULONG aY,
                    DnDAction_T aDefaultAction,
                    ComSafeArrayIn(DnDAction_T, aAllowedActions),
                    ComSafeArrayIn(IN_BSTR, aFormats),
                    DnDAction_T *aResultAction);
    STDMETHOD(Leave)(ULONG aScreenId);
    STDMETHOD(Drop)(ULONG aScreenId,
                    ULONG aX,
                    ULONG aY,
                    DnDAction_T aDefaultAction,
                    ComSafeArrayIn(DnDAction_T, aAllowedActions),
                    ComSafeArrayIn(IN_BSTR, aFormats),
                    BSTR *aFormat,
                    DnDAction_T *aResultAction);
    STDMETHOD(SendData)(ULONG aScreenId,
                        IN_BSTR aFormat,
                        ComSafeArrayIn(BYTE, aData),
                        IProgress **aProgress);
    STDMETHOD(Cancel)(BOOL *aVeto);
    STDMETHOD(InternalAndReservedMethod1IDnDTarget)();
    /** @} */

private:
    /** @name Wrapped IDnDBase properties
     * @{ */
    virtual HRESULT getFormats(std::vector<com::Utf8Str> &aFormats) = 0;
    virtual HRESULT getProtocolVersion(ULONG *aProtocolVersion) = 0;
    /** @} */

    /** @name Wrapped IDnDTarget properties
     * @{ */
    /** @} */

    /** @name Wrapped IDnDBase methods
     * @{ */
    virtual HRESULT isFormatSupported(const com::Utf8Str &aFormat,
                                      BOOL *aSupported) = 0;
    virtual HRESULT addFormats(const std::vector<com::Utf8Str> &aFormats) = 0;
    virtual HRESULT removeFormats(const std::vector<com::Utf8Str> &aFormats) = 0;
    /** @} */

    /** @name Wrapped IDnDTarget methods
     * @{ */
    virtual HRESULT enter(ULONG aScreenId,
                          ULONG aY,
                          ULONG aX,
                          DnDAction_T aDefaultAction,
                          const std::vector<DnDAction_T> &aAllowedActions,
                          const std::vector<com::Utf8Str> &aFormats,
                          DnDAction_T *aResultAction) = 0;
    virtual HRESULT move(ULONG aScreenId,
                         ULONG aX,
                         ULONG aY,
                         DnDAction_T aDefaultAction,
                         const std::vector<DnDAction_T> &aAllowedActions,
                         const std::vector<com::Utf8Str> &aFormats,
                         DnDAction_T *aResultAction) = 0;
    virtual HRESULT leave(ULONG aScreenId) = 0;
    virtual HRESULT drop(ULONG aScreenId,
                         ULONG aX,
                         ULONG aY,
                         DnDAction_T aDefaultAction,
                         const std::vector<DnDAction_T> &aAllowedActions,
                         const std::vector<com::Utf8Str> &aFormats,
                         com::Utf8Str &aFormat,
                         DnDAction_T *aResultAction) = 0;
    virtual HRESULT sendData(ULONG aScreenId,
                             const com::Utf8Str &aFormat,
                             const std::vector<BYTE> &aData,
                             ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT cancel(BOOL *aVeto) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(DnDTargetWrap); /* Shuts up MSC warning C4625. */

};

#endif // !DnDTargetWrap_H_

// ##### ENDFILE "DnDTargetWrap.h"


// ##### BEGINFILE "GuestDnDTargetWrap.h"
/** @file
 * VirtualBox API class wrapper header for IGuestDnDTarget.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef GuestDnDTargetWrap_H_
#define GuestDnDTargetWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE GuestDnDTargetWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IGuestDnDTarget)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(GuestDnDTargetWrap, IGuestDnDTarget)
    DECLARE_NOT_AGGREGATABLE(GuestDnDTargetWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(GuestDnDTargetWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IGuestDnDTarget)
        COM_INTERFACE_ENTRY(IDnDTarget)
        COM_INTERFACE_ENTRY(IDnDBase)
        COM_INTERFACE_ENTRY2(IDispatch, IGuestDnDTarget)
        VBOX_TWEAK_INTERFACE_ENTRY(IGuestDnDTarget)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(GuestDnDTargetWrap)

    /** @name Public IDnDBase properties
     * @{ */
    STDMETHOD(COMGETTER(Formats))(ComSafeArrayOut(BSTR, aFormats));
    STDMETHOD(COMGETTER(ProtocolVersion))(ULONG *aProtocolVersion);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IDnDBase))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IDnDBase))(ULONG *aReserved);
    /** @} */

    /** @name Public IDnDTarget properties
     * @{ */
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IDnDTarget))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IDnDTarget))(ULONG *aReserved);
    /** @} */

    /** @name Public IGuestDnDTarget properties
     * @{ */
    STDMETHOD(COMGETTER(MidlDoesNotLikeEmptyInterfaces))(BOOL *aMidlDoesNotLikeEmptyInterfaces);
    /** @} */

    /** @name Public IDnDBase methods
     * @{ */
    STDMETHOD(IsFormatSupported)(IN_BSTR aFormat,
                                 BOOL *aSupported);
    STDMETHOD(AddFormats)(ComSafeArrayIn(IN_BSTR, aFormats));
    STDMETHOD(RemoveFormats)(ComSafeArrayIn(IN_BSTR, aFormats));
    STDMETHOD(InternalAndReservedMethod1IDnDBase)();
    /** @} */

    /** @name Public IDnDTarget methods
     * @{ */
    STDMETHOD(Enter)(ULONG aScreenId,
                     ULONG aY,
                     ULONG aX,
                     DnDAction_T aDefaultAction,
                     ComSafeArrayIn(DnDAction_T, aAllowedActions),
                     ComSafeArrayIn(IN_BSTR, aFormats),
                     DnDAction_T *aResultAction);
    STDMETHOD(Move)(ULONG aScreenId,
                    ULONG aX,
                    ULONG aY,
                    DnDAction_T aDefaultAction,
                    ComSafeArrayIn(DnDAction_T, aAllowedActions),
                    ComSafeArrayIn(IN_BSTR, aFormats),
                    DnDAction_T *aResultAction);
    STDMETHOD(Leave)(ULONG aScreenId);
    STDMETHOD(Drop)(ULONG aScreenId,
                    ULONG aX,
                    ULONG aY,
                    DnDAction_T aDefaultAction,
                    ComSafeArrayIn(DnDAction_T, aAllowedActions),
                    ComSafeArrayIn(IN_BSTR, aFormats),
                    BSTR *aFormat,
                    DnDAction_T *aResultAction);
    STDMETHOD(SendData)(ULONG aScreenId,
                        IN_BSTR aFormat,
                        ComSafeArrayIn(BYTE, aData),
                        IProgress **aProgress);
    STDMETHOD(Cancel)(BOOL *aVeto);
    STDMETHOD(InternalAndReservedMethod1IDnDTarget)();
    /** @} */

    /** @name Public IGuestDnDTarget methods
     * @{ */
    /** @} */

private:
    /** @name Wrapped IDnDBase properties
     * @{ */
    virtual HRESULT getFormats(std::vector<com::Utf8Str> &aFormats) = 0;
    virtual HRESULT getProtocolVersion(ULONG *aProtocolVersion) = 0;
    /** @} */

    /** @name Wrapped IDnDTarget properties
     * @{ */
    /** @} */

    /** @name Wrapped IGuestDnDTarget properties
     * @{ */
    //    virtual HRESULT getMidlDoesNotLikeEmptyInterfaces(BOOL *aMidlDoesNotLikeEmptyInterfaces) = 0;
    /** @} */

    /** @name Wrapped IDnDBase methods
     * @{ */
    virtual HRESULT isFormatSupported(const com::Utf8Str &aFormat,
                                      BOOL *aSupported) = 0;
    virtual HRESULT addFormats(const std::vector<com::Utf8Str> &aFormats) = 0;
    virtual HRESULT removeFormats(const std::vector<com::Utf8Str> &aFormats) = 0;
    /** @} */

    /** @name Wrapped IDnDTarget methods
     * @{ */
    virtual HRESULT enter(ULONG aScreenId,
                          ULONG aY,
                          ULONG aX,
                          DnDAction_T aDefaultAction,
                          const std::vector<DnDAction_T> &aAllowedActions,
                          const std::vector<com::Utf8Str> &aFormats,
                          DnDAction_T *aResultAction) = 0;
    virtual HRESULT move(ULONG aScreenId,
                         ULONG aX,
                         ULONG aY,
                         DnDAction_T aDefaultAction,
                         const std::vector<DnDAction_T> &aAllowedActions,
                         const std::vector<com::Utf8Str> &aFormats,
                         DnDAction_T *aResultAction) = 0;
    virtual HRESULT leave(ULONG aScreenId) = 0;
    virtual HRESULT drop(ULONG aScreenId,
                         ULONG aX,
                         ULONG aY,
                         DnDAction_T aDefaultAction,
                         const std::vector<DnDAction_T> &aAllowedActions,
                         const std::vector<com::Utf8Str> &aFormats,
                         com::Utf8Str &aFormat,
                         DnDAction_T *aResultAction) = 0;
    virtual HRESULT sendData(ULONG aScreenId,
                             const com::Utf8Str &aFormat,
                             const std::vector<BYTE> &aData,
                             ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT cancel(BOOL *aVeto) = 0;
    /** @} */

    /** @name Wrapped IGuestDnDTarget methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(GuestDnDTargetWrap); /* Shuts up MSC warning C4625. */

};

#endif // !GuestDnDTargetWrap_H_

// ##### ENDFILE "GuestDnDTargetWrap.h"


// ##### BEGINFILE "GuestSessionWrap.h"
/** @file
 * VirtualBox API class wrapper header for IGuestSession.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef GuestSessionWrap_H_
#define GuestSessionWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE GuestSessionWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IGuestSession)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(GuestSessionWrap, IGuestSession)
    DECLARE_NOT_AGGREGATABLE(GuestSessionWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(GuestSessionWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IGuestSession)
        COM_INTERFACE_ENTRY2(IDispatch, IGuestSession)
        VBOX_TWEAK_INTERFACE_ENTRY(IGuestSession)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(GuestSessionWrap)

    /** @name Public IGuestSession properties
     * @{ */
    STDMETHOD(COMGETTER(User))(BSTR *aUser);
    STDMETHOD(COMGETTER(Domain))(BSTR *aDomain);
    STDMETHOD(COMGETTER(Name))(BSTR *aName);
    STDMETHOD(COMGETTER(Id))(ULONG *aId);
    STDMETHOD(COMGETTER(Timeout))(ULONG *aTimeout);
    STDMETHOD(COMSETTER(Timeout))(ULONG aTimeout);
    STDMETHOD(COMGETTER(ProtocolVersion))(ULONG *aProtocolVersion);
    STDMETHOD(COMGETTER(Status))(GuestSessionStatus_T *aStatus);
    STDMETHOD(COMGETTER(EnvironmentChanges))(ComSafeArrayOut(BSTR, aEnvironmentChanges));
    STDMETHOD(COMSETTER(EnvironmentChanges))(ComSafeArrayIn(IN_BSTR, aEnvironmentChanges));
    STDMETHOD(COMGETTER(EnvironmentBase))(ComSafeArrayOut(BSTR, aEnvironmentBase));
    STDMETHOD(COMGETTER(Processes))(ComSafeArrayOut(IGuestProcess *, aProcesses));
    STDMETHOD(COMGETTER(PathStyle))(PathStyle_T *aPathStyle);
    STDMETHOD(COMGETTER(CurrentDirectory))(BSTR *aCurrentDirectory);
    STDMETHOD(COMSETTER(CurrentDirectory))(IN_BSTR aCurrentDirectory);
    STDMETHOD(COMGETTER(UserHome))(BSTR *aUserHome);
    STDMETHOD(COMGETTER(UserDocuments))(BSTR *aUserDocuments);
    STDMETHOD(COMGETTER(Directories))(ComSafeArrayOut(IGuestDirectory *, aDirectories));
    STDMETHOD(COMGETTER(Files))(ComSafeArrayOut(IGuestFile *, aFiles));
    STDMETHOD(COMGETTER(EventSource))(IEventSource **aEventSource);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IGuestSession))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IGuestSession))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IGuestSession))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IGuestSession))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IGuestSession))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IGuestSession))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IGuestSession))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IGuestSession))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute9IGuestSession))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute10IGuestSession))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute11IGuestSession))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute12IGuestSession))(ULONG *aReserved);
    /** @} */

    /** @name Public IGuestSession methods
     * @{ */
    STDMETHOD(Close)();
    STDMETHOD(CopyFromGuest)(ComSafeArrayIn(IN_BSTR, aSources),
                             ComSafeArrayIn(IN_BSTR, aFilters),
                             ComSafeArrayIn(IN_BSTR, aFlags),
                             IN_BSTR aDestination,
                             IProgress **aProgress);
    STDMETHOD(CopyToGuest)(ComSafeArrayIn(IN_BSTR, aSources),
                           ComSafeArrayIn(IN_BSTR, aFilters),
                           ComSafeArrayIn(IN_BSTR, aFlags),
                           IN_BSTR aDestination,
                           IProgress **aProgress);
    STDMETHOD(DirectoryCopy)(IN_BSTR aSource,
                             IN_BSTR aDestination,
                             ComSafeArrayIn(DirectoryCopyFlag_T, aFlags),
                             IProgress **aProgress);
    STDMETHOD(DirectoryCopyFromGuest)(IN_BSTR aSource,
                                      IN_BSTR aDestination,
                                      ComSafeArrayIn(DirectoryCopyFlag_T, aFlags),
                                      IProgress **aProgress);
    STDMETHOD(DirectoryCopyToGuest)(IN_BSTR aSource,
                                    IN_BSTR aDestination,
                                    ComSafeArrayIn(DirectoryCopyFlag_T, aFlags),
                                    IProgress **aProgress);
    STDMETHOD(DirectoryCreate)(IN_BSTR aPath,
                               ULONG aMode,
                               ComSafeArrayIn(DirectoryCreateFlag_T, aFlags));
    STDMETHOD(DirectoryCreateTemp)(IN_BSTR aTemplateName,
                                   ULONG aMode,
                                   IN_BSTR aPath,
                                   BOOL aSecure,
                                   BSTR *aDirectory);
    STDMETHOD(DirectoryExists)(IN_BSTR aPath,
                               BOOL aFollowSymlinks,
                               BOOL *aExists);
    STDMETHOD(DirectoryOpen)(IN_BSTR aPath,
                             IN_BSTR aFilter,
                             ComSafeArrayIn(DirectoryOpenFlag_T, aFlags),
                             IGuestDirectory **aDirectory);
    STDMETHOD(DirectoryRemove)(IN_BSTR aPath);
    STDMETHOD(DirectoryRemoveRecursive)(IN_BSTR aPath,
                                        ComSafeArrayIn(DirectoryRemoveRecFlag_T, aFlags),
                                        IProgress **aProgress);
    STDMETHOD(EnvironmentScheduleSet)(IN_BSTR aName,
                                      IN_BSTR aValue);
    STDMETHOD(EnvironmentScheduleUnset)(IN_BSTR aName);
    STDMETHOD(EnvironmentGetBaseVariable)(IN_BSTR aName,
                                          BSTR *aValue);
    STDMETHOD(EnvironmentDoesBaseVariableExist)(IN_BSTR aName,
                                                BOOL *aExists);
    STDMETHOD(FileCopy)(IN_BSTR aSource,
                        IN_BSTR aDestination,
                        ComSafeArrayIn(FileCopyFlag_T, aFlags),
                        IProgress **aProgress);
    STDMETHOD(FileCopyFromGuest)(IN_BSTR aSource,
                                 IN_BSTR aDestination,
                                 ComSafeArrayIn(FileCopyFlag_T, aFlags),
                                 IProgress **aProgress);
    STDMETHOD(FileCopyToGuest)(IN_BSTR aSource,
                               IN_BSTR aDestination,
                               ComSafeArrayIn(FileCopyFlag_T, aFlags),
                               IProgress **aProgress);
    STDMETHOD(FileCreateTemp)(IN_BSTR aTemplateName,
                              ULONG aMode,
                              IN_BSTR aPath,
                              BOOL aSecure,
                              IGuestFile **aFile);
    STDMETHOD(FileExists)(IN_BSTR aPath,
                          BOOL aFollowSymlinks,
                          BOOL *aExists);
    STDMETHOD(FileOpen)(IN_BSTR aPath,
                        FileAccessMode_T aAccessMode,
                        FileOpenAction_T aOpenAction,
                        ULONG aCreationMode,
                        IGuestFile **aFile);
    STDMETHOD(FileOpenEx)(IN_BSTR aPath,
                          FileAccessMode_T aAccessMode,
                          FileOpenAction_T aOpenAction,
                          FileSharingMode_T aSharingMode,
                          ULONG aCreationMode,
                          ComSafeArrayIn(FileOpenExFlag_T, aFlags),
                          IGuestFile **aFile);
    STDMETHOD(FileQuerySize)(IN_BSTR aPath,
                             BOOL aFollowSymlinks,
                             LONG64 *aSize);
    STDMETHOD(FsObjExists)(IN_BSTR aPath,
                           BOOL aFollowSymlinks,
                           BOOL *aExists);
    STDMETHOD(FsObjQueryInfo)(IN_BSTR aPath,
                              BOOL aFollowSymlinks,
                              IGuestFsObjInfo **aInfo);
    STDMETHOD(FsObjRemove)(IN_BSTR aPath);
    STDMETHOD(FsObjRemoveArray)(ComSafeArrayIn(IN_BSTR, aPath),
                                IProgress **aProgress);
    STDMETHOD(FsObjRename)(IN_BSTR aOldPath,
                           IN_BSTR aNewPath,
                           ComSafeArrayIn(FsObjRenameFlag_T, aFlags));
    STDMETHOD(FsObjMove)(IN_BSTR aSource,
                         IN_BSTR aDestination,
                         ComSafeArrayIn(FsObjMoveFlag_T, aFlags),
                         IProgress **aProgress);
    STDMETHOD(FsObjMoveArray)(ComSafeArrayIn(IN_BSTR, aSource),
                              IN_BSTR aDestination,
                              ComSafeArrayIn(FsObjMoveFlag_T, aFlags),
                              IProgress **aProgress);
    STDMETHOD(FsObjCopyArray)(ComSafeArrayIn(IN_BSTR, aSource),
                              IN_BSTR aDestination,
                              ComSafeArrayIn(FileCopyFlag_T, aFlags),
                              IProgress **aProgress);
    STDMETHOD(FsObjSetACL)(IN_BSTR aPath,
                           BOOL aFollowSymlinks,
                           IN_BSTR aAcl,
                           ULONG aMode);
    STDMETHOD(ProcessCreate)(IN_BSTR aExecutable,
                             ComSafeArrayIn(IN_BSTR, aArguments),
                             ComSafeArrayIn(IN_BSTR, aEnvironmentChanges),
                             ComSafeArrayIn(ProcessCreateFlag_T, aFlags),
                             ULONG aTimeoutMS,
                             IGuestProcess **aGuestProcess);
    STDMETHOD(ProcessCreateEx)(IN_BSTR aExecutable,
                               ComSafeArrayIn(IN_BSTR, aArguments),
                               ComSafeArrayIn(IN_BSTR, aEnvironmentChanges),
                               ComSafeArrayIn(ProcessCreateFlag_T, aFlags),
                               ULONG aTimeoutMS,
                               ProcessPriority_T aPriority,
                               ComSafeArrayIn(LONG, aAffinity),
                               IGuestProcess **aGuestProcess);
    STDMETHOD(ProcessGet)(ULONG aPid,
                          IGuestProcess **aGuestProcess);
    STDMETHOD(SymlinkCreate)(IN_BSTR aSymlink,
                             IN_BSTR aTarget,
                             SymlinkType_T aType);
    STDMETHOD(SymlinkExists)(IN_BSTR aSymlink,
                             BOOL *aExists);
    STDMETHOD(SymlinkRead)(IN_BSTR aSymlink,
                           ComSafeArrayIn(SymlinkReadFlag_T, aFlags),
                           BSTR *aTarget);
    STDMETHOD(WaitFor)(ULONG aWaitFor,
                       ULONG aTimeoutMS,
                       GuestSessionWaitResult_T *aReason);
    STDMETHOD(WaitForArray)(ComSafeArrayIn(GuestSessionWaitForFlag_T, aWaitFor),
                            ULONG aTimeoutMS,
                            GuestSessionWaitResult_T *aReason);
    STDMETHOD(InternalAndReservedMethod1IGuestSession)();
    STDMETHOD(InternalAndReservedMethod2IGuestSession)();
    STDMETHOD(InternalAndReservedMethod3IGuestSession)();
    STDMETHOD(InternalAndReservedMethod4IGuestSession)();
    STDMETHOD(InternalAndReservedMethod5IGuestSession)();
    STDMETHOD(InternalAndReservedMethod6IGuestSession)();
    STDMETHOD(InternalAndReservedMethod7IGuestSession)();
    STDMETHOD(InternalAndReservedMethod8IGuestSession)();
    /** @} */

private:
    /** @name Wrapped IGuestSession properties
     * @{ */
    virtual HRESULT getUser(com::Utf8Str &aUser) = 0;
    virtual HRESULT getDomain(com::Utf8Str &aDomain) = 0;
    virtual HRESULT getName(com::Utf8Str &aName) = 0;
    virtual HRESULT getId(ULONG *aId) = 0;
    virtual HRESULT getTimeout(ULONG *aTimeout) = 0;
    virtual HRESULT setTimeout(ULONG aTimeout) = 0;
    virtual HRESULT getProtocolVersion(ULONG *aProtocolVersion) = 0;
    virtual HRESULT getStatus(GuestSessionStatus_T *aStatus) = 0;
    virtual HRESULT getEnvironmentChanges(std::vector<com::Utf8Str> &aEnvironmentChanges) = 0;
    virtual HRESULT setEnvironmentChanges(const std::vector<com::Utf8Str> &aEnvironmentChanges) = 0;
    virtual HRESULT getEnvironmentBase(std::vector<com::Utf8Str> &aEnvironmentBase) = 0;
    virtual HRESULT getProcesses(std::vector<ComPtr<IGuestProcess> > &aProcesses) = 0;
    virtual HRESULT getPathStyle(PathStyle_T *aPathStyle) = 0;
    virtual HRESULT getCurrentDirectory(com::Utf8Str &aCurrentDirectory) = 0;
    virtual HRESULT setCurrentDirectory(const com::Utf8Str &aCurrentDirectory) = 0;
    virtual HRESULT getUserHome(com::Utf8Str &aUserHome) = 0;
    virtual HRESULT getUserDocuments(com::Utf8Str &aUserDocuments) = 0;
    virtual HRESULT getDirectories(std::vector<ComPtr<IGuestDirectory> > &aDirectories) = 0;
    virtual HRESULT getFiles(std::vector<ComPtr<IGuestFile> > &aFiles) = 0;
    virtual HRESULT getEventSource(ComPtr<IEventSource> &aEventSource) = 0;
    /** @} */

    /** @name Wrapped IGuestSession methods
     * @{ */
    virtual HRESULT close() = 0;
    virtual HRESULT copyFromGuest(const std::vector<com::Utf8Str> &aSources,
                                  const std::vector<com::Utf8Str> &aFilters,
                                  const std::vector<com::Utf8Str> &aFlags,
                                  const com::Utf8Str &aDestination,
                                  ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT copyToGuest(const std::vector<com::Utf8Str> &aSources,
                                const std::vector<com::Utf8Str> &aFilters,
                                const std::vector<com::Utf8Str> &aFlags,
                                const com::Utf8Str &aDestination,
                                ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT directoryCopy(const com::Utf8Str &aSource,
                                  const com::Utf8Str &aDestination,
                                  const std::vector<DirectoryCopyFlag_T> &aFlags,
                                  ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT directoryCopyFromGuest(const com::Utf8Str &aSource,
                                           const com::Utf8Str &aDestination,
                                           const std::vector<DirectoryCopyFlag_T> &aFlags,
                                           ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT directoryCopyToGuest(const com::Utf8Str &aSource,
                                         const com::Utf8Str &aDestination,
                                         const std::vector<DirectoryCopyFlag_T> &aFlags,
                                         ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT directoryCreate(const com::Utf8Str &aPath,
                                    ULONG aMode,
                                    const std::vector<DirectoryCreateFlag_T> &aFlags) = 0;
    virtual HRESULT directoryCreateTemp(const com::Utf8Str &aTemplateName,
                                        ULONG aMode,
                                        const com::Utf8Str &aPath,
                                        BOOL aSecure,
                                        com::Utf8Str &aDirectory) = 0;
    virtual HRESULT directoryExists(const com::Utf8Str &aPath,
                                    BOOL aFollowSymlinks,
                                    BOOL *aExists) = 0;
    virtual HRESULT directoryOpen(const com::Utf8Str &aPath,
                                  const com::Utf8Str &aFilter,
                                  const std::vector<DirectoryOpenFlag_T> &aFlags,
                                  ComPtr<IGuestDirectory> &aDirectory) = 0;
    virtual HRESULT directoryRemove(const com::Utf8Str &aPath) = 0;
    virtual HRESULT directoryRemoveRecursive(const com::Utf8Str &aPath,
                                             const std::vector<DirectoryRemoveRecFlag_T> &aFlags,
                                             ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT environmentScheduleSet(const com::Utf8Str &aName,
                                           const com::Utf8Str &aValue) = 0;
    virtual HRESULT environmentScheduleUnset(const com::Utf8Str &aName) = 0;
    virtual HRESULT environmentGetBaseVariable(const com::Utf8Str &aName,
                                               com::Utf8Str &aValue) = 0;
    virtual HRESULT environmentDoesBaseVariableExist(const com::Utf8Str &aName,
                                                     BOOL *aExists) = 0;
    virtual HRESULT fileCopy(const com::Utf8Str &aSource,
                             const com::Utf8Str &aDestination,
                             const std::vector<FileCopyFlag_T> &aFlags,
                             ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT fileCopyFromGuest(const com::Utf8Str &aSource,
                                      const com::Utf8Str &aDestination,
                                      const std::vector<FileCopyFlag_T> &aFlags,
                                      ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT fileCopyToGuest(const com::Utf8Str &aSource,
                                    const com::Utf8Str &aDestination,
                                    const std::vector<FileCopyFlag_T> &aFlags,
                                    ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT fileCreateTemp(const com::Utf8Str &aTemplateName,
                                   ULONG aMode,
                                   const com::Utf8Str &aPath,
                                   BOOL aSecure,
                                   ComPtr<IGuestFile> &aFile) = 0;
    virtual HRESULT fileExists(const com::Utf8Str &aPath,
                               BOOL aFollowSymlinks,
                               BOOL *aExists) = 0;
    virtual HRESULT fileOpen(const com::Utf8Str &aPath,
                             FileAccessMode_T aAccessMode,
                             FileOpenAction_T aOpenAction,
                             ULONG aCreationMode,
                             ComPtr<IGuestFile> &aFile) = 0;
    virtual HRESULT fileOpenEx(const com::Utf8Str &aPath,
                               FileAccessMode_T aAccessMode,
                               FileOpenAction_T aOpenAction,
                               FileSharingMode_T aSharingMode,
                               ULONG aCreationMode,
                               const std::vector<FileOpenExFlag_T> &aFlags,
                               ComPtr<IGuestFile> &aFile) = 0;
    virtual HRESULT fileQuerySize(const com::Utf8Str &aPath,
                                  BOOL aFollowSymlinks,
                                  LONG64 *aSize) = 0;
    virtual HRESULT fsObjExists(const com::Utf8Str &aPath,
                                BOOL aFollowSymlinks,
                                BOOL *aExists) = 0;
    virtual HRESULT fsObjQueryInfo(const com::Utf8Str &aPath,
                                   BOOL aFollowSymlinks,
                                   ComPtr<IGuestFsObjInfo> &aInfo) = 0;
    virtual HRESULT fsObjRemove(const com::Utf8Str &aPath) = 0;
    virtual HRESULT fsObjRemoveArray(const std::vector<com::Utf8Str> &aPath,
                                     ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT fsObjRename(const com::Utf8Str &aOldPath,
                                const com::Utf8Str &aNewPath,
                                const std::vector<FsObjRenameFlag_T> &aFlags) = 0;
    virtual HRESULT fsObjMove(const com::Utf8Str &aSource,
                              const com::Utf8Str &aDestination,
                              const std::vector<FsObjMoveFlag_T> &aFlags,
                              ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT fsObjMoveArray(const std::vector<com::Utf8Str> &aSource,
                                   const com::Utf8Str &aDestination,
                                   const std::vector<FsObjMoveFlag_T> &aFlags,
                                   ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT fsObjCopyArray(const std::vector<com::Utf8Str> &aSource,
                                   const com::Utf8Str &aDestination,
                                   const std::vector<FileCopyFlag_T> &aFlags,
                                   ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT fsObjSetACL(const com::Utf8Str &aPath,
                                BOOL aFollowSymlinks,
                                const com::Utf8Str &aAcl,
                                ULONG aMode) = 0;
    virtual HRESULT processCreate(const com::Utf8Str &aExecutable,
                                  const std::vector<com::Utf8Str> &aArguments,
                                  const std::vector<com::Utf8Str> &aEnvironmentChanges,
                                  const std::vector<ProcessCreateFlag_T> &aFlags,
                                  ULONG aTimeoutMS,
                                  ComPtr<IGuestProcess> &aGuestProcess) = 0;
    virtual HRESULT processCreateEx(const com::Utf8Str &aExecutable,
                                    const std::vector<com::Utf8Str> &aArguments,
                                    const std::vector<com::Utf8Str> &aEnvironmentChanges,
                                    const std::vector<ProcessCreateFlag_T> &aFlags,
                                    ULONG aTimeoutMS,
                                    ProcessPriority_T aPriority,
                                    const std::vector<LONG> &aAffinity,
                                    ComPtr<IGuestProcess> &aGuestProcess) = 0;
    virtual HRESULT processGet(ULONG aPid,
                               ComPtr<IGuestProcess> &aGuestProcess) = 0;
    virtual HRESULT symlinkCreate(const com::Utf8Str &aSymlink,
                                  const com::Utf8Str &aTarget,
                                  SymlinkType_T aType) = 0;
    virtual HRESULT symlinkExists(const com::Utf8Str &aSymlink,
                                  BOOL *aExists) = 0;
    virtual HRESULT symlinkRead(const com::Utf8Str &aSymlink,
                                const std::vector<SymlinkReadFlag_T> &aFlags,
                                com::Utf8Str &aTarget) = 0;
    virtual HRESULT waitFor(ULONG aWaitFor,
                            ULONG aTimeoutMS,
                            GuestSessionWaitResult_T *aReason) = 0;
    virtual HRESULT waitForArray(const std::vector<GuestSessionWaitForFlag_T> &aWaitFor,
                                 ULONG aTimeoutMS,
                                 GuestSessionWaitResult_T *aReason) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(GuestSessionWrap); /* Shuts up MSC warning C4625. */

};

#endif // !GuestSessionWrap_H_

// ##### ENDFILE "GuestSessionWrap.h"


// ##### BEGINFILE "ProcessWrap.h"
/** @file
 * VirtualBox API class wrapper header for IProcess.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef ProcessWrap_H_
#define ProcessWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE ProcessWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IProcess)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(ProcessWrap, IProcess)
    DECLARE_NOT_AGGREGATABLE(ProcessWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(ProcessWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IProcess)
        COM_INTERFACE_ENTRY2(IDispatch, IProcess)
        VBOX_TWEAK_INTERFACE_ENTRY(IProcess)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(ProcessWrap)

    /** @name Public IProcess properties
     * @{ */
    STDMETHOD(COMGETTER(Arguments))(ComSafeArrayOut(BSTR, aArguments));
    STDMETHOD(COMGETTER(Environment))(ComSafeArrayOut(BSTR, aEnvironment));
    STDMETHOD(COMGETTER(EventSource))(IEventSource **aEventSource);
    STDMETHOD(COMGETTER(ExecutablePath))(BSTR *aExecutablePath);
    STDMETHOD(COMGETTER(ExitCode))(LONG *aExitCode);
    STDMETHOD(COMGETTER(Name))(BSTR *aName);
    STDMETHOD(COMGETTER(PID))(ULONG *aPID);
    STDMETHOD(COMGETTER(Status))(ProcessStatus_T *aStatus);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IProcess))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IProcess))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IProcess))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IProcess))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IProcess))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IProcess))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IProcess))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IProcess))(ULONG *aReserved);
    /** @} */

    /** @name Public IProcess methods
     * @{ */
    STDMETHOD(WaitFor)(ULONG aWaitFor,
                       ULONG aTimeoutMS,
                       ProcessWaitResult_T *aReason);
    STDMETHOD(WaitForArray)(ComSafeArrayIn(ProcessWaitForFlag_T, aWaitFor),
                            ULONG aTimeoutMS,
                            ProcessWaitResult_T *aReason);
    STDMETHOD(Read)(ULONG aHandle,
                    ULONG aToRead,
                    ULONG aTimeoutMS,
                    ComSafeArrayOut(BYTE, aData));
    STDMETHOD(Write)(ULONG aHandle,
                     ULONG aFlags,
                     ComSafeArrayIn(BYTE, aData),
                     ULONG aTimeoutMS,
                     ULONG *aWritten);
    STDMETHOD(WriteArray)(ULONG aHandle,
                          ComSafeArrayIn(ProcessInputFlag_T, aFlags),
                          ComSafeArrayIn(BYTE, aData),
                          ULONG aTimeoutMS,
                          ULONG *aWritten);
    STDMETHOD(Terminate)();
    STDMETHOD(InternalAndReservedMethod1IProcess)();
    STDMETHOD(InternalAndReservedMethod2IProcess)();
    STDMETHOD(InternalAndReservedMethod3IProcess)();
    STDMETHOD(InternalAndReservedMethod4IProcess)();
    /** @} */

private:
    /** @name Wrapped IProcess properties
     * @{ */
    virtual HRESULT getArguments(std::vector<com::Utf8Str> &aArguments) = 0;
    virtual HRESULT getEnvironment(std::vector<com::Utf8Str> &aEnvironment) = 0;
    virtual HRESULT getEventSource(ComPtr<IEventSource> &aEventSource) = 0;
    virtual HRESULT getExecutablePath(com::Utf8Str &aExecutablePath) = 0;
    virtual HRESULT getExitCode(LONG *aExitCode) = 0;
    virtual HRESULT getName(com::Utf8Str &aName) = 0;
    virtual HRESULT getPID(ULONG *aPID) = 0;
    virtual HRESULT getStatus(ProcessStatus_T *aStatus) = 0;
    /** @} */

    /** @name Wrapped IProcess methods
     * @{ */
    virtual HRESULT waitFor(ULONG aWaitFor,
                            ULONG aTimeoutMS,
                            ProcessWaitResult_T *aReason) = 0;
    virtual HRESULT waitForArray(const std::vector<ProcessWaitForFlag_T> &aWaitFor,
                                 ULONG aTimeoutMS,
                                 ProcessWaitResult_T *aReason) = 0;
    virtual HRESULT read(ULONG aHandle,
                         ULONG aToRead,
                         ULONG aTimeoutMS,
                         std::vector<BYTE> &aData) = 0;
    virtual HRESULT write(ULONG aHandle,
                          ULONG aFlags,
                          const std::vector<BYTE> &aData,
                          ULONG aTimeoutMS,
                          ULONG *aWritten) = 0;
    virtual HRESULT writeArray(ULONG aHandle,
                               const std::vector<ProcessInputFlag_T> &aFlags,
                               const std::vector<BYTE> &aData,
                               ULONG aTimeoutMS,
                               ULONG *aWritten) = 0;
    virtual HRESULT terminate() = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(ProcessWrap); /* Shuts up MSC warning C4625. */

};

#endif // !ProcessWrap_H_

// ##### ENDFILE "ProcessWrap.h"


// ##### BEGINFILE "GuestProcessWrap.h"
/** @file
 * VirtualBox API class wrapper header for IGuestProcess.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef GuestProcessWrap_H_
#define GuestProcessWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE GuestProcessWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IGuestProcess)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(GuestProcessWrap, IGuestProcess)
    DECLARE_NOT_AGGREGATABLE(GuestProcessWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(GuestProcessWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IGuestProcess)
        COM_INTERFACE_ENTRY(IProcess)
        COM_INTERFACE_ENTRY2(IDispatch, IGuestProcess)
        VBOX_TWEAK_INTERFACE_ENTRY(IGuestProcess)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(GuestProcessWrap)

    /** @name Public IProcess properties
     * @{ */
    STDMETHOD(COMGETTER(Arguments))(ComSafeArrayOut(BSTR, aArguments));
    STDMETHOD(COMGETTER(Environment))(ComSafeArrayOut(BSTR, aEnvironment));
    STDMETHOD(COMGETTER(EventSource))(IEventSource **aEventSource);
    STDMETHOD(COMGETTER(ExecutablePath))(BSTR *aExecutablePath);
    STDMETHOD(COMGETTER(ExitCode))(LONG *aExitCode);
    STDMETHOD(COMGETTER(Name))(BSTR *aName);
    STDMETHOD(COMGETTER(PID))(ULONG *aPID);
    STDMETHOD(COMGETTER(Status))(ProcessStatus_T *aStatus);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IProcess))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IProcess))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IProcess))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IProcess))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IProcess))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IProcess))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IProcess))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IProcess))(ULONG *aReserved);
    /** @} */

    /** @name Public IGuestProcess properties
     * @{ */
    STDMETHOD(COMGETTER(MidlDoesNotLikeEmptyInterfaces))(BOOL *aMidlDoesNotLikeEmptyInterfaces);
    /** @} */

    /** @name Public IProcess methods
     * @{ */
    STDMETHOD(WaitFor)(ULONG aWaitFor,
                       ULONG aTimeoutMS,
                       ProcessWaitResult_T *aReason);
    STDMETHOD(WaitForArray)(ComSafeArrayIn(ProcessWaitForFlag_T, aWaitFor),
                            ULONG aTimeoutMS,
                            ProcessWaitResult_T *aReason);
    STDMETHOD(Read)(ULONG aHandle,
                    ULONG aToRead,
                    ULONG aTimeoutMS,
                    ComSafeArrayOut(BYTE, aData));
    STDMETHOD(Write)(ULONG aHandle,
                     ULONG aFlags,
                     ComSafeArrayIn(BYTE, aData),
                     ULONG aTimeoutMS,
                     ULONG *aWritten);
    STDMETHOD(WriteArray)(ULONG aHandle,
                          ComSafeArrayIn(ProcessInputFlag_T, aFlags),
                          ComSafeArrayIn(BYTE, aData),
                          ULONG aTimeoutMS,
                          ULONG *aWritten);
    STDMETHOD(Terminate)();
    STDMETHOD(InternalAndReservedMethod1IProcess)();
    STDMETHOD(InternalAndReservedMethod2IProcess)();
    STDMETHOD(InternalAndReservedMethod3IProcess)();
    STDMETHOD(InternalAndReservedMethod4IProcess)();
    /** @} */

    /** @name Public IGuestProcess methods
     * @{ */
    /** @} */

private:
    /** @name Wrapped IProcess properties
     * @{ */
    virtual HRESULT getArguments(std::vector<com::Utf8Str> &aArguments) = 0;
    virtual HRESULT getEnvironment(std::vector<com::Utf8Str> &aEnvironment) = 0;
    virtual HRESULT getEventSource(ComPtr<IEventSource> &aEventSource) = 0;
    virtual HRESULT getExecutablePath(com::Utf8Str &aExecutablePath) = 0;
    virtual HRESULT getExitCode(LONG *aExitCode) = 0;
    virtual HRESULT getName(com::Utf8Str &aName) = 0;
    virtual HRESULT getPID(ULONG *aPID) = 0;
    virtual HRESULT getStatus(ProcessStatus_T *aStatus) = 0;
    /** @} */

    /** @name Wrapped IGuestProcess properties
     * @{ */
    //    virtual HRESULT getMidlDoesNotLikeEmptyInterfaces(BOOL *aMidlDoesNotLikeEmptyInterfaces) = 0;
    /** @} */

    /** @name Wrapped IProcess methods
     * @{ */
    virtual HRESULT waitFor(ULONG aWaitFor,
                            ULONG aTimeoutMS,
                            ProcessWaitResult_T *aReason) = 0;
    virtual HRESULT waitForArray(const std::vector<ProcessWaitForFlag_T> &aWaitFor,
                                 ULONG aTimeoutMS,
                                 ProcessWaitResult_T *aReason) = 0;
    virtual HRESULT read(ULONG aHandle,
                         ULONG aToRead,
                         ULONG aTimeoutMS,
                         std::vector<BYTE> &aData) = 0;
    virtual HRESULT write(ULONG aHandle,
                          ULONG aFlags,
                          const std::vector<BYTE> &aData,
                          ULONG aTimeoutMS,
                          ULONG *aWritten) = 0;
    virtual HRESULT writeArray(ULONG aHandle,
                               const std::vector<ProcessInputFlag_T> &aFlags,
                               const std::vector<BYTE> &aData,
                               ULONG aTimeoutMS,
                               ULONG *aWritten) = 0;
    virtual HRESULT terminate() = 0;
    /** @} */

    /** @name Wrapped IGuestProcess methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(GuestProcessWrap); /* Shuts up MSC warning C4625. */

};

#endif // !GuestProcessWrap_H_

// ##### ENDFILE "GuestProcessWrap.h"


// ##### BEGINFILE "DirectoryWrap.h"
/** @file
 * VirtualBox API class wrapper header for IDirectory.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef DirectoryWrap_H_
#define DirectoryWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE DirectoryWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IDirectory)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(DirectoryWrap, IDirectory)
    DECLARE_NOT_AGGREGATABLE(DirectoryWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(DirectoryWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IDirectory)
        COM_INTERFACE_ENTRY2(IDispatch, IDirectory)
        VBOX_TWEAK_INTERFACE_ENTRY(IDirectory)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(DirectoryWrap)

    /** @name Public IDirectory properties
     * @{ */
    STDMETHOD(COMGETTER(DirectoryName))(BSTR *aDirectoryName);
    STDMETHOD(COMGETTER(Filter))(BSTR *aFilter);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IDirectory))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IDirectory))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IDirectory))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IDirectory))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IDirectory))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IDirectory))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IDirectory))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IDirectory))(ULONG *aReserved);
    /** @} */

    /** @name Public IDirectory methods
     * @{ */
    STDMETHOD(Close)();
    STDMETHOD(Read)(IFsObjInfo **aObjInfo);
    STDMETHOD(InternalAndReservedMethod1IDirectory)();
    STDMETHOD(InternalAndReservedMethod2IDirectory)();
    STDMETHOD(InternalAndReservedMethod3IDirectory)();
    STDMETHOD(InternalAndReservedMethod4IDirectory)();
    /** @} */

private:
    /** @name Wrapped IDirectory properties
     * @{ */
    virtual HRESULT getDirectoryName(com::Utf8Str &aDirectoryName) = 0;
    virtual HRESULT getFilter(com::Utf8Str &aFilter) = 0;
    /** @} */

    /** @name Wrapped IDirectory methods
     * @{ */
    virtual HRESULT close() = 0;
    virtual HRESULT read(ComPtr<IFsObjInfo> &aObjInfo) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(DirectoryWrap); /* Shuts up MSC warning C4625. */

};

#endif // !DirectoryWrap_H_

// ##### ENDFILE "DirectoryWrap.h"


// ##### BEGINFILE "GuestDirectoryWrap.h"
/** @file
 * VirtualBox API class wrapper header for IGuestDirectory.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef GuestDirectoryWrap_H_
#define GuestDirectoryWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE GuestDirectoryWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IGuestDirectory)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(GuestDirectoryWrap, IGuestDirectory)
    DECLARE_NOT_AGGREGATABLE(GuestDirectoryWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(GuestDirectoryWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IGuestDirectory)
        COM_INTERFACE_ENTRY(IDirectory)
        COM_INTERFACE_ENTRY2(IDispatch, IGuestDirectory)
        VBOX_TWEAK_INTERFACE_ENTRY(IGuestDirectory)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(GuestDirectoryWrap)

    /** @name Public IDirectory properties
     * @{ */
    STDMETHOD(COMGETTER(DirectoryName))(BSTR *aDirectoryName);
    STDMETHOD(COMGETTER(Filter))(BSTR *aFilter);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IDirectory))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IDirectory))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IDirectory))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IDirectory))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IDirectory))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IDirectory))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IDirectory))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IDirectory))(ULONG *aReserved);
    /** @} */

    /** @name Public IGuestDirectory properties
     * @{ */
    STDMETHOD(COMGETTER(MidlDoesNotLikeEmptyInterfaces))(BOOL *aMidlDoesNotLikeEmptyInterfaces);
    /** @} */

    /** @name Public IDirectory methods
     * @{ */
    STDMETHOD(Close)();
    STDMETHOD(Read)(IFsObjInfo **aObjInfo);
    STDMETHOD(InternalAndReservedMethod1IDirectory)();
    STDMETHOD(InternalAndReservedMethod2IDirectory)();
    STDMETHOD(InternalAndReservedMethod3IDirectory)();
    STDMETHOD(InternalAndReservedMethod4IDirectory)();
    /** @} */

    /** @name Public IGuestDirectory methods
     * @{ */
    /** @} */

private:
    /** @name Wrapped IDirectory properties
     * @{ */
    virtual HRESULT getDirectoryName(com::Utf8Str &aDirectoryName) = 0;
    virtual HRESULT getFilter(com::Utf8Str &aFilter) = 0;
    /** @} */

    /** @name Wrapped IGuestDirectory properties
     * @{ */
    //    virtual HRESULT getMidlDoesNotLikeEmptyInterfaces(BOOL *aMidlDoesNotLikeEmptyInterfaces) = 0;
    /** @} */

    /** @name Wrapped IDirectory methods
     * @{ */
    virtual HRESULT close() = 0;
    virtual HRESULT read(ComPtr<IFsObjInfo> &aObjInfo) = 0;
    /** @} */

    /** @name Wrapped IGuestDirectory methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(GuestDirectoryWrap); /* Shuts up MSC warning C4625. */

};

#endif // !GuestDirectoryWrap_H_

// ##### ENDFILE "GuestDirectoryWrap.h"


// ##### BEGINFILE "FileWrap.h"
/** @file
 * VirtualBox API class wrapper header for IFile.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef FileWrap_H_
#define FileWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE FileWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IFile)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(FileWrap, IFile)
    DECLARE_NOT_AGGREGATABLE(FileWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(FileWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IFile)
        COM_INTERFACE_ENTRY2(IDispatch, IFile)
        VBOX_TWEAK_INTERFACE_ENTRY(IFile)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(FileWrap)

    /** @name Public IFile properties
     * @{ */
    STDMETHOD(COMGETTER(EventSource))(IEventSource **aEventSource);
    STDMETHOD(COMGETTER(Id))(ULONG *aId);
    STDMETHOD(COMGETTER(InitialSize))(LONG64 *aInitialSize);
    STDMETHOD(COMGETTER(Offset))(LONG64 *aOffset);
    STDMETHOD(COMGETTER(Status))(FileStatus_T *aStatus);
    STDMETHOD(COMGETTER(Filename))(BSTR *aFilename);
    STDMETHOD(COMGETTER(CreationMode))(ULONG *aCreationMode);
    STDMETHOD(COMGETTER(OpenAction))(FileOpenAction_T *aOpenAction);
    STDMETHOD(COMGETTER(AccessMode))(FileAccessMode_T *aAccessMode);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IFile))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IFile))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IFile))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IFile))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IFile))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IFile))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IFile))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IFile))(ULONG *aReserved);
    /** @} */

    /** @name Public IFile methods
     * @{ */
    STDMETHOD(Close)();
    STDMETHOD(QueryInfo)(IFsObjInfo **aObjInfo);
    STDMETHOD(QuerySize)(LONG64 *aSize);
    STDMETHOD(Read)(ULONG aToRead,
                    ULONG aTimeoutMS,
                    ComSafeArrayOut(BYTE, aData));
    STDMETHOD(ReadAt)(LONG64 aOffset,
                      ULONG aToRead,
                      ULONG aTimeoutMS,
                      ComSafeArrayOut(BYTE, aData));
    STDMETHOD(Seek)(LONG64 aOffset,
                    FileSeekOrigin_T aWhence,
                    LONG64 *aNewOffset);
    STDMETHOD(SetACL)(IN_BSTR aAcl,
                      ULONG aMode);
    STDMETHOD(SetSize)(LONG64 aSize);
    STDMETHOD(Write)(ComSafeArrayIn(BYTE, aData),
                     ULONG aTimeoutMS,
                     ULONG *aWritten);
    STDMETHOD(WriteAt)(LONG64 aOffset,
                       ComSafeArrayIn(BYTE, aData),
                       ULONG aTimeoutMS,
                       ULONG *aWritten);
    STDMETHOD(InternalAndReservedMethod1IFile)();
    STDMETHOD(InternalAndReservedMethod2IFile)();
    STDMETHOD(InternalAndReservedMethod3IFile)();
    STDMETHOD(InternalAndReservedMethod4IFile)();
    /** @} */

private:
    /** @name Wrapped IFile properties
     * @{ */
    virtual HRESULT getEventSource(ComPtr<IEventSource> &aEventSource) = 0;
    virtual HRESULT getId(ULONG *aId) = 0;
    virtual HRESULT getInitialSize(LONG64 *aInitialSize) = 0;
    virtual HRESULT getOffset(LONG64 *aOffset) = 0;
    virtual HRESULT getStatus(FileStatus_T *aStatus) = 0;
    virtual HRESULT getFilename(com::Utf8Str &aFilename) = 0;
    virtual HRESULT getCreationMode(ULONG *aCreationMode) = 0;
    virtual HRESULT getOpenAction(FileOpenAction_T *aOpenAction) = 0;
    virtual HRESULT getAccessMode(FileAccessMode_T *aAccessMode) = 0;
    /** @} */

    /** @name Wrapped IFile methods
     * @{ */
    virtual HRESULT close() = 0;
    virtual HRESULT queryInfo(ComPtr<IFsObjInfo> &aObjInfo) = 0;
    virtual HRESULT querySize(LONG64 *aSize) = 0;
    virtual HRESULT read(ULONG aToRead,
                         ULONG aTimeoutMS,
                         std::vector<BYTE> &aData) = 0;
    virtual HRESULT readAt(LONG64 aOffset,
                           ULONG aToRead,
                           ULONG aTimeoutMS,
                           std::vector<BYTE> &aData) = 0;
    virtual HRESULT seek(LONG64 aOffset,
                         FileSeekOrigin_T aWhence,
                         LONG64 *aNewOffset) = 0;
    virtual HRESULT setACL(const com::Utf8Str &aAcl,
                           ULONG aMode) = 0;
    virtual HRESULT setSize(LONG64 aSize) = 0;
    virtual HRESULT write(const std::vector<BYTE> &aData,
                          ULONG aTimeoutMS,
                          ULONG *aWritten) = 0;
    virtual HRESULT writeAt(LONG64 aOffset,
                            const std::vector<BYTE> &aData,
                            ULONG aTimeoutMS,
                            ULONG *aWritten) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(FileWrap); /* Shuts up MSC warning C4625. */

};

#endif // !FileWrap_H_

// ##### ENDFILE "FileWrap.h"


// ##### BEGINFILE "GuestFileWrap.h"
/** @file
 * VirtualBox API class wrapper header for IGuestFile.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef GuestFileWrap_H_
#define GuestFileWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE GuestFileWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IGuestFile)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(GuestFileWrap, IGuestFile)
    DECLARE_NOT_AGGREGATABLE(GuestFileWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(GuestFileWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IGuestFile)
        COM_INTERFACE_ENTRY(IFile)
        COM_INTERFACE_ENTRY2(IDispatch, IGuestFile)
        VBOX_TWEAK_INTERFACE_ENTRY(IGuestFile)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(GuestFileWrap)

    /** @name Public IFile properties
     * @{ */
    STDMETHOD(COMGETTER(EventSource))(IEventSource **aEventSource);
    STDMETHOD(COMGETTER(Id))(ULONG *aId);
    STDMETHOD(COMGETTER(InitialSize))(LONG64 *aInitialSize);
    STDMETHOD(COMGETTER(Offset))(LONG64 *aOffset);
    STDMETHOD(COMGETTER(Status))(FileStatus_T *aStatus);
    STDMETHOD(COMGETTER(Filename))(BSTR *aFilename);
    STDMETHOD(COMGETTER(CreationMode))(ULONG *aCreationMode);
    STDMETHOD(COMGETTER(OpenAction))(FileOpenAction_T *aOpenAction);
    STDMETHOD(COMGETTER(AccessMode))(FileAccessMode_T *aAccessMode);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IFile))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IFile))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IFile))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IFile))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IFile))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IFile))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IFile))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IFile))(ULONG *aReserved);
    /** @} */

    /** @name Public IGuestFile properties
     * @{ */
    STDMETHOD(COMGETTER(MidlDoesNotLikeEmptyInterfaces))(BOOL *aMidlDoesNotLikeEmptyInterfaces);
    /** @} */

    /** @name Public IFile methods
     * @{ */
    STDMETHOD(Close)();
    STDMETHOD(QueryInfo)(IFsObjInfo **aObjInfo);
    STDMETHOD(QuerySize)(LONG64 *aSize);
    STDMETHOD(Read)(ULONG aToRead,
                    ULONG aTimeoutMS,
                    ComSafeArrayOut(BYTE, aData));
    STDMETHOD(ReadAt)(LONG64 aOffset,
                      ULONG aToRead,
                      ULONG aTimeoutMS,
                      ComSafeArrayOut(BYTE, aData));
    STDMETHOD(Seek)(LONG64 aOffset,
                    FileSeekOrigin_T aWhence,
                    LONG64 *aNewOffset);
    STDMETHOD(SetACL)(IN_BSTR aAcl,
                      ULONG aMode);
    STDMETHOD(SetSize)(LONG64 aSize);
    STDMETHOD(Write)(ComSafeArrayIn(BYTE, aData),
                     ULONG aTimeoutMS,
                     ULONG *aWritten);
    STDMETHOD(WriteAt)(LONG64 aOffset,
                       ComSafeArrayIn(BYTE, aData),
                       ULONG aTimeoutMS,
                       ULONG *aWritten);
    STDMETHOD(InternalAndReservedMethod1IFile)();
    STDMETHOD(InternalAndReservedMethod2IFile)();
    STDMETHOD(InternalAndReservedMethod3IFile)();
    STDMETHOD(InternalAndReservedMethod4IFile)();
    /** @} */

    /** @name Public IGuestFile methods
     * @{ */
    /** @} */

private:
    /** @name Wrapped IFile properties
     * @{ */
    virtual HRESULT getEventSource(ComPtr<IEventSource> &aEventSource) = 0;
    virtual HRESULT getId(ULONG *aId) = 0;
    virtual HRESULT getInitialSize(LONG64 *aInitialSize) = 0;
    virtual HRESULT getOffset(LONG64 *aOffset) = 0;
    virtual HRESULT getStatus(FileStatus_T *aStatus) = 0;
    virtual HRESULT getFilename(com::Utf8Str &aFilename) = 0;
    virtual HRESULT getCreationMode(ULONG *aCreationMode) = 0;
    virtual HRESULT getOpenAction(FileOpenAction_T *aOpenAction) = 0;
    virtual HRESULT getAccessMode(FileAccessMode_T *aAccessMode) = 0;
    /** @} */

    /** @name Wrapped IGuestFile properties
     * @{ */
    //    virtual HRESULT getMidlDoesNotLikeEmptyInterfaces(BOOL *aMidlDoesNotLikeEmptyInterfaces) = 0;
    /** @} */

    /** @name Wrapped IFile methods
     * @{ */
    virtual HRESULT close() = 0;
    virtual HRESULT queryInfo(ComPtr<IFsObjInfo> &aObjInfo) = 0;
    virtual HRESULT querySize(LONG64 *aSize) = 0;
    virtual HRESULT read(ULONG aToRead,
                         ULONG aTimeoutMS,
                         std::vector<BYTE> &aData) = 0;
    virtual HRESULT readAt(LONG64 aOffset,
                           ULONG aToRead,
                           ULONG aTimeoutMS,
                           std::vector<BYTE> &aData) = 0;
    virtual HRESULT seek(LONG64 aOffset,
                         FileSeekOrigin_T aWhence,
                         LONG64 *aNewOffset) = 0;
    virtual HRESULT setACL(const com::Utf8Str &aAcl,
                           ULONG aMode) = 0;
    virtual HRESULT setSize(LONG64 aSize) = 0;
    virtual HRESULT write(const std::vector<BYTE> &aData,
                          ULONG aTimeoutMS,
                          ULONG *aWritten) = 0;
    virtual HRESULT writeAt(LONG64 aOffset,
                            const std::vector<BYTE> &aData,
                            ULONG aTimeoutMS,
                            ULONG *aWritten) = 0;
    /** @} */

    /** @name Wrapped IGuestFile methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(GuestFileWrap); /* Shuts up MSC warning C4625. */

};

#endif // !GuestFileWrap_H_

// ##### ENDFILE "GuestFileWrap.h"


// ##### BEGINFILE "FsObjInfoWrap.h"
/** @file
 * VirtualBox API class wrapper header for IFsObjInfo.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef FsObjInfoWrap_H_
#define FsObjInfoWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE FsObjInfoWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IFsObjInfo)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(FsObjInfoWrap, IFsObjInfo)
    DECLARE_NOT_AGGREGATABLE(FsObjInfoWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(FsObjInfoWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IFsObjInfo)
        COM_INTERFACE_ENTRY2(IDispatch, IFsObjInfo)
        VBOX_TWEAK_INTERFACE_ENTRY(IFsObjInfo)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(FsObjInfoWrap)

    /** @name Public IFsObjInfo properties
     * @{ */
    STDMETHOD(COMGETTER(Name))(BSTR *aName);
    STDMETHOD(COMGETTER(Type))(FsObjType_T *aType);
    STDMETHOD(COMGETTER(FileAttributes))(BSTR *aFileAttributes);
    STDMETHOD(COMGETTER(ObjectSize))(LONG64 *aObjectSize);
    STDMETHOD(COMGETTER(AllocatedSize))(LONG64 *aAllocatedSize);
    STDMETHOD(COMGETTER(AccessTime))(LONG64 *aAccessTime);
    STDMETHOD(COMGETTER(BirthTime))(LONG64 *aBirthTime);
    STDMETHOD(COMGETTER(ChangeTime))(LONG64 *aChangeTime);
    STDMETHOD(COMGETTER(ModificationTime))(LONG64 *aModificationTime);
    STDMETHOD(COMGETTER(UID))(LONG *aUID);
    STDMETHOD(COMGETTER(UserName))(BSTR *aUserName);
    STDMETHOD(COMGETTER(GID))(LONG *aGID);
    STDMETHOD(COMGETTER(GroupName))(BSTR *aGroupName);
    STDMETHOD(COMGETTER(NodeId))(LONG64 *aNodeId);
    STDMETHOD(COMGETTER(NodeIdDevice))(ULONG *aNodeIdDevice);
    STDMETHOD(COMGETTER(HardLinks))(ULONG *aHardLinks);
    STDMETHOD(COMGETTER(DeviceNumber))(ULONG *aDeviceNumber);
    STDMETHOD(COMGETTER(GenerationId))(ULONG *aGenerationId);
    STDMETHOD(COMGETTER(UserFlags))(ULONG *aUserFlags);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IFsObjInfo))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IFsObjInfo))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IFsObjInfo))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IFsObjInfo))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IFsObjInfo))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IFsObjInfo))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IFsObjInfo))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IFsObjInfo))(ULONG *aReserved);
    /** @} */

    /** @name Public IFsObjInfo methods
     * @{ */
    /** @} */

private:
    /** @name Wrapped IFsObjInfo properties
     * @{ */
    virtual HRESULT getName(com::Utf8Str &aName) = 0;
    virtual HRESULT getType(FsObjType_T *aType) = 0;
    virtual HRESULT getFileAttributes(com::Utf8Str &aFileAttributes) = 0;
    virtual HRESULT getObjectSize(LONG64 *aObjectSize) = 0;
    virtual HRESULT getAllocatedSize(LONG64 *aAllocatedSize) = 0;
    virtual HRESULT getAccessTime(LONG64 *aAccessTime) = 0;
    virtual HRESULT getBirthTime(LONG64 *aBirthTime) = 0;
    virtual HRESULT getChangeTime(LONG64 *aChangeTime) = 0;
    virtual HRESULT getModificationTime(LONG64 *aModificationTime) = 0;
    virtual HRESULT getUID(LONG *aUID) = 0;
    virtual HRESULT getUserName(com::Utf8Str &aUserName) = 0;
    virtual HRESULT getGID(LONG *aGID) = 0;
    virtual HRESULT getGroupName(com::Utf8Str &aGroupName) = 0;
    virtual HRESULT getNodeId(LONG64 *aNodeId) = 0;
    virtual HRESULT getNodeIdDevice(ULONG *aNodeIdDevice) = 0;
    virtual HRESULT getHardLinks(ULONG *aHardLinks) = 0;
    virtual HRESULT getDeviceNumber(ULONG *aDeviceNumber) = 0;
    virtual HRESULT getGenerationId(ULONG *aGenerationId) = 0;
    virtual HRESULT getUserFlags(ULONG *aUserFlags) = 0;
    /** @} */

    /** @name Wrapped IFsObjInfo methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(FsObjInfoWrap); /* Shuts up MSC warning C4625. */

};

#endif // !FsObjInfoWrap_H_

// ##### ENDFILE "FsObjInfoWrap.h"


// ##### BEGINFILE "GuestFsObjInfoWrap.h"
/** @file
 * VirtualBox API class wrapper header for IGuestFsObjInfo.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef GuestFsObjInfoWrap_H_
#define GuestFsObjInfoWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE GuestFsObjInfoWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IGuestFsObjInfo)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(GuestFsObjInfoWrap, IGuestFsObjInfo)
    DECLARE_NOT_AGGREGATABLE(GuestFsObjInfoWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(GuestFsObjInfoWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IGuestFsObjInfo)
        COM_INTERFACE_ENTRY(IFsObjInfo)
        COM_INTERFACE_ENTRY2(IDispatch, IGuestFsObjInfo)
        VBOX_TWEAK_INTERFACE_ENTRY(IGuestFsObjInfo)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(GuestFsObjInfoWrap)

    /** @name Public IFsObjInfo properties
     * @{ */
    STDMETHOD(COMGETTER(Name))(BSTR *aName);
    STDMETHOD(COMGETTER(Type))(FsObjType_T *aType);
    STDMETHOD(COMGETTER(FileAttributes))(BSTR *aFileAttributes);
    STDMETHOD(COMGETTER(ObjectSize))(LONG64 *aObjectSize);
    STDMETHOD(COMGETTER(AllocatedSize))(LONG64 *aAllocatedSize);
    STDMETHOD(COMGETTER(AccessTime))(LONG64 *aAccessTime);
    STDMETHOD(COMGETTER(BirthTime))(LONG64 *aBirthTime);
    STDMETHOD(COMGETTER(ChangeTime))(LONG64 *aChangeTime);
    STDMETHOD(COMGETTER(ModificationTime))(LONG64 *aModificationTime);
    STDMETHOD(COMGETTER(UID))(LONG *aUID);
    STDMETHOD(COMGETTER(UserName))(BSTR *aUserName);
    STDMETHOD(COMGETTER(GID))(LONG *aGID);
    STDMETHOD(COMGETTER(GroupName))(BSTR *aGroupName);
    STDMETHOD(COMGETTER(NodeId))(LONG64 *aNodeId);
    STDMETHOD(COMGETTER(NodeIdDevice))(ULONG *aNodeIdDevice);
    STDMETHOD(COMGETTER(HardLinks))(ULONG *aHardLinks);
    STDMETHOD(COMGETTER(DeviceNumber))(ULONG *aDeviceNumber);
    STDMETHOD(COMGETTER(GenerationId))(ULONG *aGenerationId);
    STDMETHOD(COMGETTER(UserFlags))(ULONG *aUserFlags);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IFsObjInfo))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IFsObjInfo))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IFsObjInfo))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IFsObjInfo))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IFsObjInfo))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IFsObjInfo))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IFsObjInfo))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IFsObjInfo))(ULONG *aReserved);
    /** @} */

    /** @name Public IGuestFsObjInfo properties
     * @{ */
    STDMETHOD(COMGETTER(MidlDoesNotLikeEmptyInterfaces))(BOOL *aMidlDoesNotLikeEmptyInterfaces);
    /** @} */

    /** @name Public IFsObjInfo methods
     * @{ */
    /** @} */

    /** @name Public IGuestFsObjInfo methods
     * @{ */
    /** @} */

private:
    /** @name Wrapped IFsObjInfo properties
     * @{ */
    virtual HRESULT getName(com::Utf8Str &aName) = 0;
    virtual HRESULT getType(FsObjType_T *aType) = 0;
    virtual HRESULT getFileAttributes(com::Utf8Str &aFileAttributes) = 0;
    virtual HRESULT getObjectSize(LONG64 *aObjectSize) = 0;
    virtual HRESULT getAllocatedSize(LONG64 *aAllocatedSize) = 0;
    virtual HRESULT getAccessTime(LONG64 *aAccessTime) = 0;
    virtual HRESULT getBirthTime(LONG64 *aBirthTime) = 0;
    virtual HRESULT getChangeTime(LONG64 *aChangeTime) = 0;
    virtual HRESULT getModificationTime(LONG64 *aModificationTime) = 0;
    virtual HRESULT getUID(LONG *aUID) = 0;
    virtual HRESULT getUserName(com::Utf8Str &aUserName) = 0;
    virtual HRESULT getGID(LONG *aGID) = 0;
    virtual HRESULT getGroupName(com::Utf8Str &aGroupName) = 0;
    virtual HRESULT getNodeId(LONG64 *aNodeId) = 0;
    virtual HRESULT getNodeIdDevice(ULONG *aNodeIdDevice) = 0;
    virtual HRESULT getHardLinks(ULONG *aHardLinks) = 0;
    virtual HRESULT getDeviceNumber(ULONG *aDeviceNumber) = 0;
    virtual HRESULT getGenerationId(ULONG *aGenerationId) = 0;
    virtual HRESULT getUserFlags(ULONG *aUserFlags) = 0;
    /** @} */

    /** @name Wrapped IGuestFsObjInfo properties
     * @{ */
    //    virtual HRESULT getMidlDoesNotLikeEmptyInterfaces(BOOL *aMidlDoesNotLikeEmptyInterfaces) = 0;
    /** @} */

    /** @name Wrapped IFsObjInfo methods
     * @{ */
    /** @} */

    /** @name Wrapped IGuestFsObjInfo methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(GuestFsObjInfoWrap); /* Shuts up MSC warning C4625. */

};

#endif // !GuestFsObjInfoWrap_H_

// ##### ENDFILE "GuestFsObjInfoWrap.h"


// ##### BEGINFILE "GuestWrap.h"
/** @file
 * VirtualBox API class wrapper header for IGuest.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef GuestWrap_H_
#define GuestWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE GuestWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IGuest)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(GuestWrap, IGuest)
    DECLARE_NOT_AGGREGATABLE(GuestWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(GuestWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IGuest)
        COM_INTERFACE_ENTRY2(IDispatch, IGuest)
        VBOX_TWEAK_INTERFACE_ENTRY(IGuest)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(GuestWrap)

    /** @name Public IGuest properties
     * @{ */
    STDMETHOD(COMGETTER(OSTypeId))(BSTR *aOSTypeId);
    STDMETHOD(COMGETTER(AdditionsRunLevel))(AdditionsRunLevelType_T *aAdditionsRunLevel);
    STDMETHOD(COMGETTER(AdditionsVersion))(BSTR *aAdditionsVersion);
    STDMETHOD(COMGETTER(AdditionsRevision))(ULONG *aAdditionsRevision);
    STDMETHOD(COMGETTER(DnDSource))(IGuestDnDSource **aDnDSource);
    STDMETHOD(COMGETTER(DnDTarget))(IGuestDnDTarget **aDnDTarget);
    STDMETHOD(COMGETTER(EventSource))(IEventSource **aEventSource);
    STDMETHOD(COMGETTER(Facilities))(ComSafeArrayOut(IAdditionsFacility *, aFacilities));
    STDMETHOD(COMGETTER(Sessions))(ComSafeArrayOut(IGuestSession *, aSessions));
    STDMETHOD(COMGETTER(MemoryBalloonSize))(ULONG *aMemoryBalloonSize);
    STDMETHOD(COMSETTER(MemoryBalloonSize))(ULONG aMemoryBalloonSize);
    STDMETHOD(COMGETTER(StatisticsUpdateInterval))(ULONG *aStatisticsUpdateInterval);
    STDMETHOD(COMSETTER(StatisticsUpdateInterval))(ULONG aStatisticsUpdateInterval);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IGuest))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IGuest))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IGuest))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IGuest))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IGuest))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IGuest))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IGuest))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IGuest))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute9IGuest))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute10IGuest))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute11IGuest))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute12IGuest))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute13IGuest))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute14IGuest))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute15IGuest))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute16IGuest))(ULONG *aReserved);
    /** @} */

    /** @name Public IGuest methods
     * @{ */
    STDMETHOD(InternalGetStatistics)(ULONG *aCpuUser,
                                     ULONG *aCpuKernel,
                                     ULONG *aCpuIdle,
                                     ULONG *aMemTotal,
                                     ULONG *aMemFree,
                                     ULONG *aMemBalloon,
                                     ULONG *aMemShared,
                                     ULONG *aMemCache,
                                     ULONG *aPagedTotal,
                                     ULONG *aMemAllocTotal,
                                     ULONG *aMemFreeTotal,
                                     ULONG *aMemBalloonTotal,
                                     ULONG *aMemSharedTotal);
    STDMETHOD(GetFacilityStatus)(AdditionsFacilityType_T aFacility,
                                 LONG64 *aTimestamp,
                                 AdditionsFacilityStatus_T *aStatus);
    STDMETHOD(GetAdditionsStatus)(AdditionsRunLevelType_T aLevel,
                                  BOOL *aActive);
    STDMETHOD(SetCredentials)(IN_BSTR aUserName,
                              IN_BSTR aPassword,
                              IN_BSTR aDomain,
                              BOOL aAllowInteractiveLogon);
    STDMETHOD(CreateSession)(IN_BSTR aUser,
                             IN_BSTR aPassword,
                             IN_BSTR aDomain,
                             IN_BSTR aSessionName,
                             IGuestSession **aGuestSession);
    STDMETHOD(FindSession)(IN_BSTR aSessionName,
                           ComSafeArrayOut(IGuestSession *, aSessions));
    STDMETHOD(UpdateGuestAdditions)(IN_BSTR aSource,
                                    ComSafeArrayIn(IN_BSTR, aArguments),
                                    ComSafeArrayIn(AdditionsUpdateFlag_T, aFlags),
                                    IProgress **aProgress);
    STDMETHOD(InternalAndReservedMethod1IGuest)();
    STDMETHOD(InternalAndReservedMethod2IGuest)();
    STDMETHOD(InternalAndReservedMethod3IGuest)();
    STDMETHOD(InternalAndReservedMethod4IGuest)();
    STDMETHOD(InternalAndReservedMethod5IGuest)();
    STDMETHOD(InternalAndReservedMethod6IGuest)();
    STDMETHOD(InternalAndReservedMethod7IGuest)();
    STDMETHOD(InternalAndReservedMethod8IGuest)();
    /** @} */

private:
    /** @name Wrapped IGuest properties
     * @{ */
    virtual HRESULT getOSTypeId(com::Utf8Str &aOSTypeId) = 0;
    virtual HRESULT getAdditionsRunLevel(AdditionsRunLevelType_T *aAdditionsRunLevel) = 0;
    virtual HRESULT getAdditionsVersion(com::Utf8Str &aAdditionsVersion) = 0;
    virtual HRESULT getAdditionsRevision(ULONG *aAdditionsRevision) = 0;
    virtual HRESULT getDnDSource(ComPtr<IGuestDnDSource> &aDnDSource) = 0;
    virtual HRESULT getDnDTarget(ComPtr<IGuestDnDTarget> &aDnDTarget) = 0;
    virtual HRESULT getEventSource(ComPtr<IEventSource> &aEventSource) = 0;
    virtual HRESULT getFacilities(std::vector<ComPtr<IAdditionsFacility> > &aFacilities) = 0;
    virtual HRESULT getSessions(std::vector<ComPtr<IGuestSession> > &aSessions) = 0;
    virtual HRESULT getMemoryBalloonSize(ULONG *aMemoryBalloonSize) = 0;
    virtual HRESULT setMemoryBalloonSize(ULONG aMemoryBalloonSize) = 0;
    virtual HRESULT getStatisticsUpdateInterval(ULONG *aStatisticsUpdateInterval) = 0;
    virtual HRESULT setStatisticsUpdateInterval(ULONG aStatisticsUpdateInterval) = 0;
    /** @} */

    /** @name Wrapped IGuest methods
     * @{ */
    virtual HRESULT internalGetStatistics(ULONG *aCpuUser,
                                          ULONG *aCpuKernel,
                                          ULONG *aCpuIdle,
                                          ULONG *aMemTotal,
                                          ULONG *aMemFree,
                                          ULONG *aMemBalloon,
                                          ULONG *aMemShared,
                                          ULONG *aMemCache,
                                          ULONG *aPagedTotal,
                                          ULONG *aMemAllocTotal,
                                          ULONG *aMemFreeTotal,
                                          ULONG *aMemBalloonTotal,
                                          ULONG *aMemSharedTotal) = 0;
    virtual HRESULT getFacilityStatus(AdditionsFacilityType_T aFacility,
                                      LONG64 *aTimestamp,
                                      AdditionsFacilityStatus_T *aStatus) = 0;
    virtual HRESULT getAdditionsStatus(AdditionsRunLevelType_T aLevel,
                                       BOOL *aActive) = 0;
    virtual HRESULT setCredentials(const com::Utf8Str &aUserName,
                                   const com::Utf8Str &aPassword,
                                   const com::Utf8Str &aDomain,
                                   BOOL aAllowInteractiveLogon) = 0;
    virtual HRESULT createSession(const com::Utf8Str &aUser,
                                  const com::Utf8Str &aPassword,
                                  const com::Utf8Str &aDomain,
                                  const com::Utf8Str &aSessionName,
                                  ComPtr<IGuestSession> &aGuestSession) = 0;
    virtual HRESULT findSession(const com::Utf8Str &aSessionName,
                                std::vector<ComPtr<IGuestSession> > &aSessions) = 0;
    virtual HRESULT updateGuestAdditions(const com::Utf8Str &aSource,
                                         const std::vector<com::Utf8Str> &aArguments,
                                         const std::vector<AdditionsUpdateFlag_T> &aFlags,
                                         ComPtr<IProgress> &aProgress) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(GuestWrap); /* Shuts up MSC warning C4625. */

};

#endif // !GuestWrap_H_

// ##### ENDFILE "GuestWrap.h"


// ##### BEGINFILE "ProgressWrap.h"
/** @file
 * VirtualBox API class wrapper header for IProgress.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef ProgressWrap_H_
#define ProgressWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE ProgressWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IProgress)
    , VBOX_SCRIPTABLE_IMPL(IInternalProgressControl)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(ProgressWrap, IProgress)
    DECLARE_NOT_AGGREGATABLE(ProgressWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(ProgressWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IProgress)
        COM_INTERFACE_ENTRY2(IDispatch, IProgress)
        COM_INTERFACE_ENTRY(IInternalProgressControl)
        VBOX_TWEAK_INTERFACE_ENTRY(IProgress)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(ProgressWrap)

    /** @name Public IProgress properties
     * @{ */
    STDMETHOD(COMGETTER(Id))(BSTR *aId);
    STDMETHOD(COMGETTER(Description))(BSTR *aDescription);
    STDMETHOD(COMGETTER(Initiator))(IUnknown **aInitiator);
    STDMETHOD(COMGETTER(Cancelable))(BOOL *aCancelable);
    STDMETHOD(COMGETTER(Percent))(ULONG *aPercent);
    STDMETHOD(COMGETTER(TimeRemaining))(LONG *aTimeRemaining);
    STDMETHOD(COMGETTER(Completed))(BOOL *aCompleted);
    STDMETHOD(COMGETTER(Canceled))(BOOL *aCanceled);
    STDMETHOD(COMGETTER(ResultCode))(LONG *aResultCode);
    STDMETHOD(COMGETTER(ErrorInfo))(IVirtualBoxErrorInfo **aErrorInfo);
    STDMETHOD(COMGETTER(OperationCount))(ULONG *aOperationCount);
    STDMETHOD(COMGETTER(Operation))(ULONG *aOperation);
    STDMETHOD(COMGETTER(OperationDescription))(BSTR *aOperationDescription);
    STDMETHOD(COMGETTER(OperationPercent))(ULONG *aOperationPercent);
    STDMETHOD(COMGETTER(OperationWeight))(ULONG *aOperationWeight);
    STDMETHOD(COMGETTER(Timeout))(ULONG *aTimeout);
    STDMETHOD(COMSETTER(Timeout))(ULONG aTimeout);
    STDMETHOD(COMGETTER(EventSource))(IEventSource **aEventSource);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IProgress))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IProgress))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IProgress))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IProgress))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IProgress))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IProgress))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IProgress))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IProgress))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute9IProgress))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute10IProgress))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute11IProgress))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute12IProgress))(ULONG *aReserved);
    /** @} */

    /** @name Public IProgress methods
     * @{ */
    STDMETHOD(WaitForCompletion)(LONG aTimeout);
    STDMETHOD(WaitForOperationCompletion)(ULONG aOperation,
                                          LONG aTimeout);
    STDMETHOD(Cancel)();
    STDMETHOD(InternalAndReservedMethod1IProgress)();
    STDMETHOD(InternalAndReservedMethod2IProgress)();
    STDMETHOD(InternalAndReservedMethod3IProgress)();
    STDMETHOD(InternalAndReservedMethod4IProgress)();
    STDMETHOD(InternalAndReservedMethod5IProgress)();
    STDMETHOD(InternalAndReservedMethod6IProgress)();
    STDMETHOD(InternalAndReservedMethod7IProgress)();
    STDMETHOD(InternalAndReservedMethod8IProgress)();
    /** @} */

    /** @name Public IInternalProgressControl properties
     * @{ */
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IInternalProgressControl))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IInternalProgressControl))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IInternalProgressControl))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IInternalProgressControl))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IInternalProgressControl))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IInternalProgressControl))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IInternalProgressControl))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IInternalProgressControl))(ULONG *aReserved);
    /** @} */

    /** @name Public IInternalProgressControl methods
     * @{ */
    STDMETHOD(SetCurrentOperationProgress)(ULONG aPercent);
    STDMETHOD(WaitForOtherProgressCompletion)(IProgress *aProgressOther,
                                              ULONG aTimeoutMS);
    STDMETHOD(SetNextOperation)(IN_BSTR aNextOperationDescription,
                                ULONG aNextOperationsWeight);
    STDMETHOD(NotifyPointOfNoReturn)();
    STDMETHOD(NotifyComplete)(LONG aResultCode,
                              IVirtualBoxErrorInfo *aErrorInfo);
    STDMETHOD(InternalAndReservedMethod1IInternalProgressControl)();
    STDMETHOD(InternalAndReservedMethod2IInternalProgressControl)();
    STDMETHOD(InternalAndReservedMethod3IInternalProgressControl)();
    STDMETHOD(InternalAndReservedMethod4IInternalProgressControl)();
    STDMETHOD(InternalAndReservedMethod5IInternalProgressControl)();
    STDMETHOD(InternalAndReservedMethod6IInternalProgressControl)();
    STDMETHOD(InternalAndReservedMethod7IInternalProgressControl)();
    STDMETHOD(InternalAndReservedMethod8IInternalProgressControl)();
    /** @} */

private:
    /** @name Wrapped IProgress properties
     * @{ */
    virtual HRESULT getId(com::Guid &aId) = 0;
    virtual HRESULT getDescription(com::Utf8Str &aDescription) = 0;
    virtual HRESULT getInitiator(ComPtr<IUnknown> &aInitiator) = 0;
    virtual HRESULT getCancelable(BOOL *aCancelable) = 0;
    virtual HRESULT getPercent(ULONG *aPercent) = 0;
    virtual HRESULT getTimeRemaining(LONG *aTimeRemaining) = 0;
    virtual HRESULT getCompleted(BOOL *aCompleted) = 0;
    virtual HRESULT getCanceled(BOOL *aCanceled) = 0;
    virtual HRESULT getResultCode(LONG *aResultCode) = 0;
    virtual HRESULT getErrorInfo(ComPtr<IVirtualBoxErrorInfo> &aErrorInfo) = 0;
    virtual HRESULT getOperationCount(ULONG *aOperationCount) = 0;
    virtual HRESULT getOperation(ULONG *aOperation) = 0;
    virtual HRESULT getOperationDescription(com::Utf8Str &aOperationDescription) = 0;
    virtual HRESULT getOperationPercent(ULONG *aOperationPercent) = 0;
    virtual HRESULT getOperationWeight(ULONG *aOperationWeight) = 0;
    virtual HRESULT getTimeout(ULONG *aTimeout) = 0;
    virtual HRESULT setTimeout(ULONG aTimeout) = 0;
    virtual HRESULT getEventSource(ComPtr<IEventSource> &aEventSource) = 0;
    /** @} */

    /** @name Wrapped IProgress methods
     * @{ */
    virtual HRESULT waitForCompletion(LONG aTimeout) = 0;
    virtual HRESULT waitForOperationCompletion(ULONG aOperation,
                                               LONG aTimeout) = 0;
    virtual HRESULT cancel() = 0;
    /** @} */

    /** @name Wrapped IInternalProgressControl properties
     * @{ */
    /** @} */

    /** @name Wrapped IInternalProgressControl methods
     * @{ */
    virtual HRESULT setCurrentOperationProgress(ULONG aPercent) = 0;
    virtual HRESULT waitForOtherProgressCompletion(const ComPtr<IProgress> &aProgressOther,
                                                   ULONG aTimeoutMS) = 0;
    virtual HRESULT setNextOperation(const com::Utf8Str &aNextOperationDescription,
                                     ULONG aNextOperationsWeight) = 0;
    virtual HRESULT notifyPointOfNoReturn() = 0;
    virtual HRESULT notifyComplete(LONG aResultCode,
                                   const ComPtr<IVirtualBoxErrorInfo> &aErrorInfo) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(ProgressWrap); /* Shuts up MSC warning C4625. */

};

#endif // !ProgressWrap_H_

// ##### ENDFILE "ProgressWrap.h"


// ##### BEGINFILE "SnapshotWrap.h"
/** @file
 * VirtualBox API class wrapper header for ISnapshot.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef SnapshotWrap_H_
#define SnapshotWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE SnapshotWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(ISnapshot)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(SnapshotWrap, ISnapshot)
    DECLARE_NOT_AGGREGATABLE(SnapshotWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(SnapshotWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(ISnapshot)
        COM_INTERFACE_ENTRY2(IDispatch, ISnapshot)
        VBOX_TWEAK_INTERFACE_ENTRY(ISnapshot)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(SnapshotWrap)

    /** @name Public ISnapshot properties
     * @{ */
    STDMETHOD(COMGETTER(Id))(BSTR *aId);
    STDMETHOD(COMGETTER(Name))(BSTR *aName);
    STDMETHOD(COMSETTER(Name))(IN_BSTR aName);
    STDMETHOD(COMGETTER(Description))(BSTR *aDescription);
    STDMETHOD(COMSETTER(Description))(IN_BSTR aDescription);
    STDMETHOD(COMGETTER(TimeStamp))(LONG64 *aTimeStamp);
    STDMETHOD(COMGETTER(Online))(BOOL *aOnline);
    STDMETHOD(COMGETTER(Machine))(IMachine **aMachine);
    STDMETHOD(COMGETTER(Parent))(ISnapshot **aParent);
    STDMETHOD(COMGETTER(Children))(ComSafeArrayOut(ISnapshot *, aChildren));
    STDMETHOD(COMGETTER(ChildrenCount))(ULONG *aChildrenCount);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1ISnapshot))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2ISnapshot))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3ISnapshot))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4ISnapshot))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5ISnapshot))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6ISnapshot))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7ISnapshot))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8ISnapshot))(ULONG *aReserved);
    /** @} */

    /** @name Public ISnapshot methods
     * @{ */
    STDMETHOD(InternalAndReservedMethod1ISnapshot)();
    STDMETHOD(InternalAndReservedMethod2ISnapshot)();
    STDMETHOD(InternalAndReservedMethod3ISnapshot)();
    STDMETHOD(InternalAndReservedMethod4ISnapshot)();
    /** @} */

private:
    /** @name Wrapped ISnapshot properties
     * @{ */
    virtual HRESULT getId(com::Guid &aId) = 0;
    virtual HRESULT getName(com::Utf8Str &aName) = 0;
    virtual HRESULT setName(const com::Utf8Str &aName) = 0;
    virtual HRESULT getDescription(com::Utf8Str &aDescription) = 0;
    virtual HRESULT setDescription(const com::Utf8Str &aDescription) = 0;
    virtual HRESULT getTimeStamp(LONG64 *aTimeStamp) = 0;
    virtual HRESULT getOnline(BOOL *aOnline) = 0;
    virtual HRESULT getMachine(ComPtr<IMachine> &aMachine) = 0;
    virtual HRESULT getParent(ComPtr<ISnapshot> &aParent) = 0;
    virtual HRESULT getChildren(std::vector<ComPtr<ISnapshot> > &aChildren) = 0;
    virtual HRESULT getChildrenCount(ULONG *aChildrenCount) = 0;
    /** @} */

    /** @name Wrapped ISnapshot methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(SnapshotWrap); /* Shuts up MSC warning C4625. */

};

#endif // !SnapshotWrap_H_

// ##### ENDFILE "SnapshotWrap.h"


// ##### BEGINFILE "MediumAttachmentWrap.h"
/** @file
 * VirtualBox API class wrapper header for IMediumAttachment.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef MediumAttachmentWrap_H_
#define MediumAttachmentWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE MediumAttachmentWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IMediumAttachment)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(MediumAttachmentWrap, IMediumAttachment)
    DECLARE_NOT_AGGREGATABLE(MediumAttachmentWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(MediumAttachmentWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IMediumAttachment)
        COM_INTERFACE_ENTRY2(IDispatch, IMediumAttachment)
        VBOX_TWEAK_INTERFACE_ENTRY(IMediumAttachment)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(MediumAttachmentWrap)

    /** @name Public IMediumAttachment properties
     * @{ */
    STDMETHOD(COMGETTER(Machine))(IMachine **aMachine);
    STDMETHOD(COMGETTER(Medium))(IMedium **aMedium);
    STDMETHOD(COMGETTER(Controller))(BSTR *aController);
    STDMETHOD(COMGETTER(Port))(LONG *aPort);
    STDMETHOD(COMGETTER(Device))(LONG *aDevice);
    STDMETHOD(COMGETTER(Type))(DeviceType_T *aType);
    STDMETHOD(COMGETTER(Passthrough))(BOOL *aPassthrough);
    STDMETHOD(COMGETTER(TemporaryEject))(BOOL *aTemporaryEject);
    STDMETHOD(COMGETTER(IsEjected))(BOOL *aIsEjected);
    STDMETHOD(COMGETTER(NonRotational))(BOOL *aNonRotational);
    STDMETHOD(COMGETTER(Discard))(BOOL *aDiscard);
    STDMETHOD(COMGETTER(HotPluggable))(BOOL *aHotPluggable);
    STDMETHOD(COMGETTER(BandwidthGroup))(IBandwidthGroup **aBandwidthGroup);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IMediumAttachment))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IMediumAttachment))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IMediumAttachment))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IMediumAttachment))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IMediumAttachment))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IMediumAttachment))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IMediumAttachment))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IMediumAttachment))(ULONG *aReserved);
    /** @} */

    /** @name Public IMediumAttachment methods
     * @{ */
    /** @} */

private:
    /** @name Wrapped IMediumAttachment properties
     * @{ */
    virtual HRESULT getMachine(ComPtr<IMachine> &aMachine) = 0;
    virtual HRESULT getMedium(ComPtr<IMedium> &aMedium) = 0;
    virtual HRESULT getController(com::Utf8Str &aController) = 0;
    virtual HRESULT getPort(LONG *aPort) = 0;
    virtual HRESULT getDevice(LONG *aDevice) = 0;
    virtual HRESULT getType(DeviceType_T *aType) = 0;
    virtual HRESULT getPassthrough(BOOL *aPassthrough) = 0;
    virtual HRESULT getTemporaryEject(BOOL *aTemporaryEject) = 0;
    virtual HRESULT getIsEjected(BOOL *aIsEjected) = 0;
    virtual HRESULT getNonRotational(BOOL *aNonRotational) = 0;
    virtual HRESULT getDiscard(BOOL *aDiscard) = 0;
    virtual HRESULT getHotPluggable(BOOL *aHotPluggable) = 0;
    virtual HRESULT getBandwidthGroup(ComPtr<IBandwidthGroup> &aBandwidthGroup) = 0;
    /** @} */

    /** @name Wrapped IMediumAttachment methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(MediumAttachmentWrap); /* Shuts up MSC warning C4625. */

};

#endif // !MediumAttachmentWrap_H_

// ##### ENDFILE "MediumAttachmentWrap.h"


// ##### BEGINFILE "MediumWrap.h"
/** @file
 * VirtualBox API class wrapper header for IMedium.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef MediumWrap_H_
#define MediumWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE MediumWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IMedium)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(MediumWrap, IMedium)
    DECLARE_NOT_AGGREGATABLE(MediumWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(MediumWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IMedium)
        COM_INTERFACE_ENTRY2(IDispatch, IMedium)
        VBOX_TWEAK_INTERFACE_ENTRY(IMedium)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(MediumWrap)

    /** @name Public IMedium properties
     * @{ */
    STDMETHOD(COMGETTER(Id))(BSTR *aId);
    STDMETHOD(COMGETTER(Description))(BSTR *aDescription);
    STDMETHOD(COMSETTER(Description))(IN_BSTR aDescription);
    STDMETHOD(COMGETTER(State))(MediumState_T *aState);
    STDMETHOD(COMGETTER(Variant))(ComSafeArrayOut(MediumVariant_T, aVariant));
    STDMETHOD(COMGETTER(Location))(BSTR *aLocation);
    STDMETHOD(COMSETTER(Location))(IN_BSTR aLocation);
    STDMETHOD(COMGETTER(Name))(BSTR *aName);
    STDMETHOD(COMGETTER(DeviceType))(DeviceType_T *aDeviceType);
    STDMETHOD(COMGETTER(HostDrive))(BOOL *aHostDrive);
    STDMETHOD(COMGETTER(Size))(LONG64 *aSize);
    STDMETHOD(COMGETTER(Format))(BSTR *aFormat);
    STDMETHOD(COMGETTER(MediumFormat))(IMediumFormat **aMediumFormat);
    STDMETHOD(COMGETTER(Type))(MediumType_T *aType);
    STDMETHOD(COMSETTER(Type))(MediumType_T aType);
    STDMETHOD(COMGETTER(AllowedTypes))(ComSafeArrayOut(MediumType_T, aAllowedTypes));
    STDMETHOD(COMGETTER(Parent))(IMedium **aParent);
    STDMETHOD(COMGETTER(Children))(ComSafeArrayOut(IMedium *, aChildren));
    STDMETHOD(COMGETTER(Base))(IMedium **aBase);
    STDMETHOD(COMGETTER(ReadOnly))(BOOL *aReadOnly);
    STDMETHOD(COMGETTER(LogicalSize))(LONG64 *aLogicalSize);
    STDMETHOD(COMGETTER(AutoReset))(BOOL *aAutoReset);
    STDMETHOD(COMSETTER(AutoReset))(BOOL aAutoReset);
    STDMETHOD(COMGETTER(LastAccessError))(BSTR *aLastAccessError);
    STDMETHOD(COMGETTER(MachineIds))(ComSafeArrayOut(BSTR, aMachineIds));
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IMedium))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IMedium))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IMedium))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IMedium))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IMedium))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IMedium))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IMedium))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IMedium))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute9IMedium))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute10IMedium))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute11IMedium))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute12IMedium))(ULONG *aReserved);
    /** @} */

    /** @name Public IMedium methods
     * @{ */
    STDMETHOD(SetIds)(BOOL aSetImageId,
                      IN_BSTR aImageId,
                      BOOL aSetParentId,
                      IN_BSTR aParentId);
    STDMETHOD(RefreshState)(MediumState_T *aState);
    STDMETHOD(GetSnapshotIds)(IN_BSTR aMachineId,
                              ComSafeArrayOut(BSTR, aSnapshotIds));
    STDMETHOD(LockRead)(IToken **aToken);
    STDMETHOD(LockWrite)(IToken **aToken);
    STDMETHOD(Close)();
    STDMETHOD(GetProperty)(IN_BSTR aName,
                           BSTR *aValue);
    STDMETHOD(SetProperty)(IN_BSTR aName,
                           IN_BSTR aValue);
    STDMETHOD(GetProperties)(IN_BSTR aNames,
                             ComSafeArrayOut(BSTR, aReturnNames),
                             ComSafeArrayOut(BSTR, aReturnValues));
    STDMETHOD(SetProperties)(ComSafeArrayIn(IN_BSTR, aNames),
                             ComSafeArrayIn(IN_BSTR, aValues));
    STDMETHOD(CreateBaseStorage)(LONG64 aLogicalSize,
                                 ComSafeArrayIn(MediumVariant_T, aVariant),
                                 IProgress **aProgress);
    STDMETHOD(DeleteStorage)(IProgress **aProgress);
    STDMETHOD(CreateDiffStorage)(IMedium *aTarget,
                                 ComSafeArrayIn(MediumVariant_T, aVariant),
                                 IProgress **aProgress);
    STDMETHOD(MergeTo)(IMedium *aTarget,
                       IProgress **aProgress);
    STDMETHOD(CloneTo)(IMedium *aTarget,
                       ComSafeArrayIn(MediumVariant_T, aVariant),
                       IMedium *aParent,
                       IProgress **aProgress);
    STDMETHOD(CloneToBase)(IMedium *aTarget,
                           ComSafeArrayIn(MediumVariant_T, aVariant),
                           IProgress **aProgress);
    STDMETHOD(MoveTo)(IN_BSTR aLocation,
                      IProgress **aProgress);
    STDMETHOD(Compact)(IProgress **aProgress);
    STDMETHOD(Resize)(LONG64 aLogicalSize,
                      IProgress **aProgress);
    STDMETHOD(Reset)(IProgress **aProgress);
    STDMETHOD(ChangeEncryption)(IN_BSTR aCurrentPassword,
                                IN_BSTR aCipher,
                                IN_BSTR aNewPassword,
                                IN_BSTR aNewPasswordId,
                                IProgress **aProgress);
    STDMETHOD(GetEncryptionSettings)(BSTR *aCipher,
                                     BSTR *aPasswordId);
    STDMETHOD(CheckEncryptionPassword)(IN_BSTR aPassword);
    STDMETHOD(OpenForIO)(BOOL aWritable,
                         IN_BSTR aPassword,
                         IMediumIO **aMediumIO);
    STDMETHOD(InternalAndReservedMethod1IMedium)();
    STDMETHOD(InternalAndReservedMethod2IMedium)();
    STDMETHOD(InternalAndReservedMethod3IMedium)();
    STDMETHOD(InternalAndReservedMethod4IMedium)();
    STDMETHOD(InternalAndReservedMethod5IMedium)();
    STDMETHOD(InternalAndReservedMethod6IMedium)();
    STDMETHOD(InternalAndReservedMethod7IMedium)();
    STDMETHOD(InternalAndReservedMethod8IMedium)();
    /** @} */

private:
    /** @name Wrapped IMedium properties
     * @{ */
    virtual HRESULT getId(com::Guid &aId) = 0;
    virtual HRESULT getDescription(AutoCaller &aAutoCaller, com::Utf8Str &aDescription) = 0;
    virtual HRESULT setDescription(AutoCaller &aAutoCaller, const com::Utf8Str &aDescription) = 0;
    virtual HRESULT getState(MediumState_T *aState) = 0;
    virtual HRESULT getVariant(std::vector<MediumVariant_T> &aVariant) = 0;
    virtual HRESULT getLocation(com::Utf8Str &aLocation) = 0;
    virtual HRESULT setLocation(const com::Utf8Str &aLocation) = 0;
    virtual HRESULT getName(com::Utf8Str &aName) = 0;
    virtual HRESULT getDeviceType(DeviceType_T *aDeviceType) = 0;
    virtual HRESULT getHostDrive(BOOL *aHostDrive) = 0;
    virtual HRESULT getSize(LONG64 *aSize) = 0;
    virtual HRESULT getFormat(com::Utf8Str &aFormat) = 0;
    virtual HRESULT getMediumFormat(ComPtr<IMediumFormat> &aMediumFormat) = 0;
    virtual HRESULT getType(AutoCaller &aAutoCaller, MediumType_T *aType) = 0;
    virtual HRESULT setType(AutoCaller &aAutoCaller, MediumType_T aType) = 0;
    virtual HRESULT getAllowedTypes(std::vector<MediumType_T> &aAllowedTypes) = 0;
    virtual HRESULT getParent(AutoCaller &aAutoCaller, ComPtr<IMedium> &aParent) = 0;
    virtual HRESULT getChildren(AutoCaller &aAutoCaller, std::vector<ComPtr<IMedium> > &aChildren) = 0;
    virtual HRESULT getBase(AutoCaller &aAutoCaller, ComPtr<IMedium> &aBase) = 0;
    virtual HRESULT getReadOnly(AutoCaller &aAutoCaller, BOOL *aReadOnly) = 0;
    virtual HRESULT getLogicalSize(LONG64 *aLogicalSize) = 0;
    virtual HRESULT getAutoReset(BOOL *aAutoReset) = 0;
    virtual HRESULT setAutoReset(BOOL aAutoReset) = 0;
    virtual HRESULT getLastAccessError(com::Utf8Str &aLastAccessError) = 0;
    virtual HRESULT getMachineIds(std::vector<com::Guid> &aMachineIds) = 0;
    /** @} */

    /** @name Wrapped IMedium methods
     * @{ */
    virtual HRESULT setIds(AutoCaller &aAutoCaller,
                           BOOL aSetImageId,
                           const com::Guid &aImageId,
                           BOOL aSetParentId,
                           const com::Guid &aParentId) = 0;
    virtual HRESULT refreshState(AutoCaller &aAutoCaller,
                                 MediumState_T *aState) = 0;
    virtual HRESULT getSnapshotIds(const com::Guid &aMachineId,
                                   std::vector<com::Guid> &aSnapshotIds) = 0;
    virtual HRESULT lockRead(ComPtr<IToken> &aToken) = 0;
    virtual HRESULT lockWrite(ComPtr<IToken> &aToken) = 0;
    virtual HRESULT close(AutoCaller &aAutoCaller) = 0;
    virtual HRESULT getProperty(const com::Utf8Str &aName,
                                com::Utf8Str &aValue) = 0;
    virtual HRESULT setProperty(const com::Utf8Str &aName,
                                const com::Utf8Str &aValue) = 0;
    virtual HRESULT getProperties(const com::Utf8Str &aNames,
                                  std::vector<com::Utf8Str> &aReturnNames,
                                  std::vector<com::Utf8Str> &aReturnValues) = 0;
    virtual HRESULT setProperties(const std::vector<com::Utf8Str> &aNames,
                                  const std::vector<com::Utf8Str> &aValues) = 0;
    virtual HRESULT createBaseStorage(LONG64 aLogicalSize,
                                      const std::vector<MediumVariant_T> &aVariant,
                                      ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT deleteStorage(ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT createDiffStorage(AutoCaller &aAutoCaller,
                                      const ComPtr<IMedium> &aTarget,
                                      const std::vector<MediumVariant_T> &aVariant,
                                      ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT mergeTo(const ComPtr<IMedium> &aTarget,
                            ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT cloneTo(const ComPtr<IMedium> &aTarget,
                            const std::vector<MediumVariant_T> &aVariant,
                            const ComPtr<IMedium> &aParent,
                            ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT cloneToBase(const ComPtr<IMedium> &aTarget,
                                const std::vector<MediumVariant_T> &aVariant,
                                ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT moveTo(AutoCaller &aAutoCaller,
                           const com::Utf8Str &aLocation,
                           ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT compact(ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT resize(LONG64 aLogicalSize,
                           ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT reset(AutoCaller &aAutoCaller,
                          ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT changeEncryption(const com::Utf8Str &aCurrentPassword,
                                     const com::Utf8Str &aCipher,
                                     const com::Utf8Str &aNewPassword,
                                     const com::Utf8Str &aNewPasswordId,
                                     ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT getEncryptionSettings(AutoCaller &aAutoCaller,
                                          com::Utf8Str &aCipher,
                                          com::Utf8Str &aPasswordId) = 0;
    virtual HRESULT checkEncryptionPassword(const com::Utf8Str &aPassword) = 0;
    virtual HRESULT openForIO(BOOL aWritable,
                              const com::Utf8Str &aPassword,
                              ComPtr<IMediumIO> &aMediumIO) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(MediumWrap); /* Shuts up MSC warning C4625. */

};

#endif // !MediumWrap_H_

// ##### ENDFILE "MediumWrap.h"


// ##### BEGINFILE "MediumFormatWrap.h"
/** @file
 * VirtualBox API class wrapper header for IMediumFormat.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef MediumFormatWrap_H_
#define MediumFormatWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE MediumFormatWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IMediumFormat)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(MediumFormatWrap, IMediumFormat)
    DECLARE_NOT_AGGREGATABLE(MediumFormatWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(MediumFormatWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IMediumFormat)
        COM_INTERFACE_ENTRY2(IDispatch, IMediumFormat)
        VBOX_TWEAK_INTERFACE_ENTRY(IMediumFormat)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(MediumFormatWrap)

    /** @name Public IMediumFormat properties
     * @{ */
    STDMETHOD(COMGETTER(Id))(BSTR *aId);
    STDMETHOD(COMGETTER(Name))(BSTR *aName);
    STDMETHOD(COMGETTER(Capabilities))(ComSafeArrayOut(MediumFormatCapabilities_T, aCapabilities));
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IMediumFormat))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IMediumFormat))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IMediumFormat))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IMediumFormat))(ULONG *aReserved);
    /** @} */

    /** @name Public IMediumFormat methods
     * @{ */
    STDMETHOD(DescribeFileExtensions)(ComSafeArrayOut(BSTR, aExtensions),
                                      ComSafeArrayOut(DeviceType_T, aTypes));
    STDMETHOD(DescribeProperties)(ComSafeArrayOut(BSTR, aNames),
                                  ComSafeArrayOut(BSTR, aDescriptions),
                                  ComSafeArrayOut(DataType_T, aTypes),
                                  ComSafeArrayOut(ULONG, aFlags),
                                  ComSafeArrayOut(BSTR, aDefaults));
    STDMETHOD(InternalAndReservedMethod1IMediumFormat)();
    STDMETHOD(InternalAndReservedMethod2IMediumFormat)();
    /** @} */

private:
    /** @name Wrapped IMediumFormat properties
     * @{ */
    virtual HRESULT getId(com::Utf8Str &aId) = 0;
    virtual HRESULT getName(com::Utf8Str &aName) = 0;
    virtual HRESULT getCapabilities(std::vector<MediumFormatCapabilities_T> &aCapabilities) = 0;
    /** @} */

    /** @name Wrapped IMediumFormat methods
     * @{ */
    virtual HRESULT describeFileExtensions(std::vector<com::Utf8Str> &aExtensions,
                                           std::vector<DeviceType_T> &aTypes) = 0;
    virtual HRESULT describeProperties(std::vector<com::Utf8Str> &aNames,
                                       std::vector<com::Utf8Str> &aDescriptions,
                                       std::vector<DataType_T> &aTypes,
                                       std::vector<ULONG> &aFlags,
                                       std::vector<com::Utf8Str> &aDefaults) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(MediumFormatWrap); /* Shuts up MSC warning C4625. */

};

#endif // !MediumFormatWrap_H_

// ##### ENDFILE "MediumFormatWrap.h"


// ##### BEGINFILE "DataStreamWrap.h"
/** @file
 * VirtualBox API class wrapper header for IDataStream.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef DataStreamWrap_H_
#define DataStreamWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE DataStreamWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IDataStream)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(DataStreamWrap, IDataStream)
    DECLARE_NOT_AGGREGATABLE(DataStreamWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(DataStreamWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IDataStream)
        COM_INTERFACE_ENTRY2(IDispatch, IDataStream)
        VBOX_TWEAK_INTERFACE_ENTRY(IDataStream)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(DataStreamWrap)

    /** @name Public IDataStream properties
     * @{ */
    STDMETHOD(COMGETTER(ReadSize))(ULONG *aReadSize);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IDataStream))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IDataStream))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IDataStream))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IDataStream))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IDataStream))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IDataStream))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IDataStream))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IDataStream))(ULONG *aReserved);
    /** @} */

    /** @name Public IDataStream methods
     * @{ */
    STDMETHOD(Read)(ULONG aSize,
                    ULONG aTimeoutMS,
                    ComSafeArrayOut(BYTE, aData));
    STDMETHOD(InternalAndReservedMethod1IDataStream)();
    STDMETHOD(InternalAndReservedMethod2IDataStream)();
    STDMETHOD(InternalAndReservedMethod3IDataStream)();
    STDMETHOD(InternalAndReservedMethod4IDataStream)();
    /** @} */

private:
    /** @name Wrapped IDataStream properties
     * @{ */
    virtual HRESULT getReadSize(ULONG *aReadSize) = 0;
    /** @} */

    /** @name Wrapped IDataStream methods
     * @{ */
    virtual HRESULT read(ULONG aSize,
                         ULONG aTimeoutMS,
                         std::vector<BYTE> &aData) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(DataStreamWrap); /* Shuts up MSC warning C4625. */

};

#endif // !DataStreamWrap_H_

// ##### ENDFILE "DataStreamWrap.h"


// ##### BEGINFILE "MediumIOWrap.h"
/** @file
 * VirtualBox API class wrapper header for IMediumIO.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef MediumIOWrap_H_
#define MediumIOWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE MediumIOWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IMediumIO)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(MediumIOWrap, IMediumIO)
    DECLARE_NOT_AGGREGATABLE(MediumIOWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(MediumIOWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IMediumIO)
        COM_INTERFACE_ENTRY2(IDispatch, IMediumIO)
        VBOX_TWEAK_INTERFACE_ENTRY(IMediumIO)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(MediumIOWrap)

    /** @name Public IMediumIO properties
     * @{ */
    STDMETHOD(COMGETTER(Medium))(IMedium **aMedium);
    STDMETHOD(COMGETTER(Writable))(BOOL *aWritable);
    STDMETHOD(COMGETTER(Explorer))(IVFSExplorer **aExplorer);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IMediumIO))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IMediumIO))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IMediumIO))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IMediumIO))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IMediumIO))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IMediumIO))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IMediumIO))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IMediumIO))(ULONG *aReserved);
    /** @} */

    /** @name Public IMediumIO methods
     * @{ */
    STDMETHOD(Read)(LONG64 aOffset,
                    ULONG aSize,
                    ComSafeArrayOut(BYTE, aData));
    STDMETHOD(Write)(LONG64 aOffset,
                     ComSafeArrayIn(BYTE, aData),
                     ULONG *aWritten);
    STDMETHOD(FormatFAT)(BOOL aQuick);
    STDMETHOD(InitializePartitionTable)(PartitionTableType_T aFormat,
                                        BOOL aWholeDiskInOneEntry);
    STDMETHOD(ConvertToStream)(IN_BSTR aFormat,
                               ComSafeArrayIn(MediumVariant_T, aVariant),
                               ULONG aBufferSize,
                               IDataStream **aStream,
                               IProgress **aProgress);
    STDMETHOD(Close)();
    STDMETHOD(InternalAndReservedMethod1IMediumIO)();
    STDMETHOD(InternalAndReservedMethod2IMediumIO)();
    STDMETHOD(InternalAndReservedMethod3IMediumIO)();
    STDMETHOD(InternalAndReservedMethod4IMediumIO)();
    /** @} */

private:
    /** @name Wrapped IMediumIO properties
     * @{ */
    virtual HRESULT getMedium(ComPtr<IMedium> &aMedium) = 0;
    virtual HRESULT getWritable(BOOL *aWritable) = 0;
    virtual HRESULT getExplorer(ComPtr<IVFSExplorer> &aExplorer) = 0;
    /** @} */

    /** @name Wrapped IMediumIO methods
     * @{ */
    virtual HRESULT read(LONG64 aOffset,
                         ULONG aSize,
                         std::vector<BYTE> &aData) = 0;
    virtual HRESULT write(LONG64 aOffset,
                          const std::vector<BYTE> &aData,
                          ULONG *aWritten) = 0;
    virtual HRESULT formatFAT(BOOL aQuick) = 0;
    virtual HRESULT initializePartitionTable(PartitionTableType_T aFormat,
                                             BOOL aWholeDiskInOneEntry) = 0;
    virtual HRESULT convertToStream(const com::Utf8Str &aFormat,
                                    const std::vector<MediumVariant_T> &aVariant,
                                    ULONG aBufferSize,
                                    ComPtr<IDataStream> &aStream,
                                    ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT close() = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(MediumIOWrap); /* Shuts up MSC warning C4625. */

};

#endif // !MediumIOWrap_H_

// ##### ENDFILE "MediumIOWrap.h"


// ##### BEGINFILE "TokenWrap.h"
/** @file
 * VirtualBox API class wrapper header for IToken.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef TokenWrap_H_
#define TokenWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE TokenWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IToken)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(TokenWrap, IToken)
    DECLARE_NOT_AGGREGATABLE(TokenWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(TokenWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IToken)
        COM_INTERFACE_ENTRY2(IDispatch, IToken)
        VBOX_TWEAK_INTERFACE_ENTRY(IToken)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(TokenWrap)

    /** @name Public IToken properties
     * @{ */
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IToken))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IToken))(ULONG *aReserved);
    /** @} */

    /** @name Public IToken methods
     * @{ */
    STDMETHOD(Abandon)();
    STDMETHOD(Dummy)();
    STDMETHOD(InternalAndReservedMethod1IToken)();
    /** @} */

private:
    /** @name Wrapped IToken properties
     * @{ */
    /** @} */

    /** @name Wrapped IToken methods
     * @{ */
    virtual HRESULT abandon(AutoCaller &aAutoCaller) = 0;
    virtual HRESULT dummy() = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(TokenWrap); /* Shuts up MSC warning C4625. */

};

#endif // !TokenWrap_H_

// ##### ENDFILE "TokenWrap.h"


// ##### BEGINFILE "KeyboardWrap.h"
/** @file
 * VirtualBox API class wrapper header for IKeyboard.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef KeyboardWrap_H_
#define KeyboardWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE KeyboardWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IKeyboard)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(KeyboardWrap, IKeyboard)
    DECLARE_NOT_AGGREGATABLE(KeyboardWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(KeyboardWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IKeyboard)
        COM_INTERFACE_ENTRY2(IDispatch, IKeyboard)
        VBOX_TWEAK_INTERFACE_ENTRY(IKeyboard)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(KeyboardWrap)

    /** @name Public IKeyboard properties
     * @{ */
    STDMETHOD(COMGETTER(KeyboardLEDs))(ComSafeArrayOut(KeyboardLED_T, aKeyboardLEDs));
    STDMETHOD(COMGETTER(EventSource))(IEventSource **aEventSource);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IKeyboard))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IKeyboard))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IKeyboard))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IKeyboard))(ULONG *aReserved);
    /** @} */

    /** @name Public IKeyboard methods
     * @{ */
    STDMETHOD(PutScancode)(LONG aScancode);
    STDMETHOD(PutScancodes)(ComSafeArrayIn(LONG, aScancodes),
                            ULONG *aCodesStored);
    STDMETHOD(PutCAD)();
    STDMETHOD(ReleaseKeys)();
    STDMETHOD(PutUsageCode)(LONG aUsageCode,
                            LONG aUsagePage,
                            BOOL aKeyRelease);
    STDMETHOD(InternalAndReservedMethod1IKeyboard)();
    STDMETHOD(InternalAndReservedMethod2IKeyboard)();
    STDMETHOD(InternalAndReservedMethod3IKeyboard)();
    STDMETHOD(InternalAndReservedMethod4IKeyboard)();
    /** @} */

private:
    /** @name Wrapped IKeyboard properties
     * @{ */
    virtual HRESULT getKeyboardLEDs(std::vector<KeyboardLED_T> &aKeyboardLEDs) = 0;
    virtual HRESULT getEventSource(ComPtr<IEventSource> &aEventSource) = 0;
    /** @} */

    /** @name Wrapped IKeyboard methods
     * @{ */
    virtual HRESULT putScancode(LONG aScancode) = 0;
    virtual HRESULT putScancodes(const std::vector<LONG> &aScancodes,
                                 ULONG *aCodesStored) = 0;
    virtual HRESULT putCAD() = 0;
    virtual HRESULT releaseKeys() = 0;
    virtual HRESULT putUsageCode(LONG aUsageCode,
                                 LONG aUsagePage,
                                 BOOL aKeyRelease) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(KeyboardWrap); /* Shuts up MSC warning C4625. */

};

#endif // !KeyboardWrap_H_

// ##### ENDFILE "KeyboardWrap.h"


// ##### BEGINFILE "MousePointerShapeWrap.h"
/** @file
 * VirtualBox API class wrapper header for IMousePointerShape.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef MousePointerShapeWrap_H_
#define MousePointerShapeWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE MousePointerShapeWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IMousePointerShape)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(MousePointerShapeWrap, IMousePointerShape)
    DECLARE_NOT_AGGREGATABLE(MousePointerShapeWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(MousePointerShapeWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IMousePointerShape)
        COM_INTERFACE_ENTRY2(IDispatch, IMousePointerShape)
        VBOX_TWEAK_INTERFACE_ENTRY(IMousePointerShape)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(MousePointerShapeWrap)

    /** @name Public IMousePointerShape properties
     * @{ */
    STDMETHOD(COMGETTER(Visible))(BOOL *aVisible);
    STDMETHOD(COMGETTER(Alpha))(BOOL *aAlpha);
    STDMETHOD(COMGETTER(HotX))(ULONG *aHotX);
    STDMETHOD(COMGETTER(HotY))(ULONG *aHotY);
    STDMETHOD(COMGETTER(Width))(ULONG *aWidth);
    STDMETHOD(COMGETTER(Height))(ULONG *aHeight);
    STDMETHOD(COMGETTER(Shape))(ComSafeArrayOut(BYTE, aShape));
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IMousePointerShape))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IMousePointerShape))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IMousePointerShape))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IMousePointerShape))(ULONG *aReserved);
    /** @} */

    /** @name Public IMousePointerShape methods
     * @{ */
    /** @} */

private:
    /** @name Wrapped IMousePointerShape properties
     * @{ */
    virtual HRESULT getVisible(BOOL *aVisible) = 0;
    virtual HRESULT getAlpha(BOOL *aAlpha) = 0;
    virtual HRESULT getHotX(ULONG *aHotX) = 0;
    virtual HRESULT getHotY(ULONG *aHotY) = 0;
    virtual HRESULT getWidth(ULONG *aWidth) = 0;
    virtual HRESULT getHeight(ULONG *aHeight) = 0;
    virtual HRESULT getShape(std::vector<BYTE> &aShape) = 0;
    /** @} */

    /** @name Wrapped IMousePointerShape methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(MousePointerShapeWrap); /* Shuts up MSC warning C4625. */

};

#endif // !MousePointerShapeWrap_H_

// ##### ENDFILE "MousePointerShapeWrap.h"


// ##### BEGINFILE "MouseWrap.h"
/** @file
 * VirtualBox API class wrapper header for IMouse.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef MouseWrap_H_
#define MouseWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE MouseWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IMouse)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(MouseWrap, IMouse)
    DECLARE_NOT_AGGREGATABLE(MouseWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(MouseWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IMouse)
        COM_INTERFACE_ENTRY2(IDispatch, IMouse)
        VBOX_TWEAK_INTERFACE_ENTRY(IMouse)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(MouseWrap)

    /** @name Public IMouse properties
     * @{ */
    STDMETHOD(COMGETTER(AbsoluteSupported))(BOOL *aAbsoluteSupported);
    STDMETHOD(COMGETTER(RelativeSupported))(BOOL *aRelativeSupported);
    STDMETHOD(COMGETTER(MultiTouchSupported))(BOOL *aMultiTouchSupported);
    STDMETHOD(COMGETTER(NeedsHostCursor))(BOOL *aNeedsHostCursor);
    STDMETHOD(COMGETTER(PointerShape))(IMousePointerShape **aPointerShape);
    STDMETHOD(COMGETTER(EventSource))(IEventSource **aEventSource);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IMouse))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IMouse))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IMouse))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IMouse))(ULONG *aReserved);
    /** @} */

    /** @name Public IMouse methods
     * @{ */
    STDMETHOD(PutMouseEvent)(LONG aDx,
                             LONG aDy,
                             LONG aDz,
                             LONG aDw,
                             LONG aButtonState);
    STDMETHOD(PutMouseEventAbsolute)(LONG aX,
                                     LONG aY,
                                     LONG aDz,
                                     LONG aDw,
                                     LONG aButtonState);
    STDMETHOD(PutEventMultiTouch)(LONG aCount,
                                  ComSafeArrayIn(LONG64, aContacts),
                                  ULONG aScanTime);
    STDMETHOD(PutEventMultiTouchString)(LONG aCount,
                                        IN_BSTR aContacts,
                                        ULONG aScanTime);
    STDMETHOD(InternalAndReservedMethod1IMouse)();
    STDMETHOD(InternalAndReservedMethod2IMouse)();
    STDMETHOD(InternalAndReservedMethod3IMouse)();
    STDMETHOD(InternalAndReservedMethod4IMouse)();
    /** @} */

private:
    /** @name Wrapped IMouse properties
     * @{ */
    virtual HRESULT getAbsoluteSupported(BOOL *aAbsoluteSupported) = 0;
    virtual HRESULT getRelativeSupported(BOOL *aRelativeSupported) = 0;
    virtual HRESULT getMultiTouchSupported(BOOL *aMultiTouchSupported) = 0;
    virtual HRESULT getNeedsHostCursor(BOOL *aNeedsHostCursor) = 0;
    virtual HRESULT getPointerShape(ComPtr<IMousePointerShape> &aPointerShape) = 0;
    virtual HRESULT getEventSource(ComPtr<IEventSource> &aEventSource) = 0;
    /** @} */

    /** @name Wrapped IMouse methods
     * @{ */
    virtual HRESULT putMouseEvent(LONG aDx,
                                  LONG aDy,
                                  LONG aDz,
                                  LONG aDw,
                                  LONG aButtonState) = 0;
    virtual HRESULT putMouseEventAbsolute(LONG aX,
                                          LONG aY,
                                          LONG aDz,
                                          LONG aDw,
                                          LONG aButtonState) = 0;
    virtual HRESULT putEventMultiTouch(LONG aCount,
                                       const std::vector<LONG64> &aContacts,
                                       ULONG aScanTime) = 0;
    virtual HRESULT putEventMultiTouchString(LONG aCount,
                                             const com::Utf8Str &aContacts,
                                             ULONG aScanTime) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(MouseWrap); /* Shuts up MSC warning C4625. */

};

#endif // !MouseWrap_H_

// ##### ENDFILE "MouseWrap.h"


// ##### BEGINFILE "DisplaySourceBitmapWrap.h"
/** @file
 * VirtualBox API class wrapper header for IDisplaySourceBitmap.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef DisplaySourceBitmapWrap_H_
#define DisplaySourceBitmapWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE DisplaySourceBitmapWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IDisplaySourceBitmap)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(DisplaySourceBitmapWrap, IDisplaySourceBitmap)
    DECLARE_NOT_AGGREGATABLE(DisplaySourceBitmapWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(DisplaySourceBitmapWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IDisplaySourceBitmap)
        COM_INTERFACE_ENTRY2(IDispatch, IDisplaySourceBitmap)
        VBOX_TWEAK_INTERFACE_ENTRY(IDisplaySourceBitmap)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(DisplaySourceBitmapWrap)

    /** @name Public IDisplaySourceBitmap properties
     * @{ */
    STDMETHOD(COMGETTER(ScreenId))(ULONG *aScreenId);
    /** @} */

    /** @name Public IDisplaySourceBitmap methods
     * @{ */
    STDMETHOD(QueryBitmapInfo)(BYTE **aAddress,
                               ULONG *aWidth,
                               ULONG *aHeight,
                               ULONG *aBitsPerPixel,
                               ULONG *aBytesPerLine,
                               BitmapFormat_T *aBitmapFormat);
    /** @} */

private:
    /** @name Wrapped IDisplaySourceBitmap properties
     * @{ */
    virtual HRESULT getScreenId(ULONG *aScreenId) = 0;
    /** @} */

    /** @name Wrapped IDisplaySourceBitmap methods
     * @{ */
    virtual HRESULT queryBitmapInfo(BYTE **aAddress,
                                    ULONG *aWidth,
                                    ULONG *aHeight,
                                    ULONG *aBitsPerPixel,
                                    ULONG *aBytesPerLine,
                                    BitmapFormat_T *aBitmapFormat) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(DisplaySourceBitmapWrap); /* Shuts up MSC warning C4625. */

};

#endif // !DisplaySourceBitmapWrap_H_

// ##### ENDFILE "DisplaySourceBitmapWrap.h"


// ##### BEGINFILE "FramebufferWrap.h"
/** @file
 * VirtualBox API class wrapper header for IFramebuffer.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef FramebufferWrap_H_
#define FramebufferWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE FramebufferWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IFramebuffer)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(FramebufferWrap, IFramebuffer)
    DECLARE_NOT_AGGREGATABLE(FramebufferWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(FramebufferWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IFramebuffer)
        COM_INTERFACE_ENTRY2(IDispatch, IFramebuffer)
        VBOX_TWEAK_INTERFACE_ENTRY(IFramebuffer)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(FramebufferWrap)

    /** @name Public IFramebuffer properties
     * @{ */
    STDMETHOD(COMGETTER(Width))(ULONG *aWidth);
    STDMETHOD(COMGETTER(Height))(ULONG *aHeight);
    STDMETHOD(COMGETTER(BitsPerPixel))(ULONG *aBitsPerPixel);
    STDMETHOD(COMGETTER(BytesPerLine))(ULONG *aBytesPerLine);
    STDMETHOD(COMGETTER(PixelFormat))(BitmapFormat_T *aPixelFormat);
    STDMETHOD(COMGETTER(HeightReduction))(ULONG *aHeightReduction);
    STDMETHOD(COMGETTER(Overlay))(IFramebufferOverlay **aOverlay);
    STDMETHOD(COMGETTER(WinId))(LONG64 *aWinId);
    STDMETHOD(COMGETTER(Capabilities))(ComSafeArrayOut(FramebufferCapabilities_T, aCapabilities));
    /** @} */

    /** @name Public IFramebuffer methods
     * @{ */
    STDMETHOD(NotifyUpdate)(ULONG aX,
                            ULONG aY,
                            ULONG aWidth,
                            ULONG aHeight);
    STDMETHOD(NotifyUpdateImage)(ULONG aX,
                                 ULONG aY,
                                 ULONG aWidth,
                                 ULONG aHeight,
                                 ComSafeArrayIn(BYTE, aImage));
    STDMETHOD(NotifyChange)(ULONG aScreenId,
                            ULONG aXOrigin,
                            ULONG aYOrigin,
                            ULONG aWidth,
                            ULONG aHeight);
    STDMETHOD(VideoModeSupported)(ULONG aWidth,
                                  ULONG aHeight,
                                  ULONG aBpp,
                                  BOOL *aSupported);
    STDMETHOD(GetVisibleRegion)(BYTE *aRectangles,
                                ULONG aCount,
                                ULONG *aCountCopied);
    STDMETHOD(SetVisibleRegion)(BYTE *aRectangles,
                                ULONG aCount);
    STDMETHOD(ProcessVHWACommand)(BYTE *aCommand,
                                  LONG aEnmCmd,
                                  BOOL aFromGuest);
    STDMETHOD(Notify3DEvent)(ULONG aType,
                             ComSafeArrayIn(BYTE, aData));
    /** @} */

private:
    /** @name Wrapped IFramebuffer properties
     * @{ */
    virtual HRESULT getWidth(ULONG *aWidth) = 0;
    virtual HRESULT getHeight(ULONG *aHeight) = 0;
    virtual HRESULT getBitsPerPixel(ULONG *aBitsPerPixel) = 0;
    virtual HRESULT getBytesPerLine(ULONG *aBytesPerLine) = 0;
    virtual HRESULT getPixelFormat(BitmapFormat_T *aPixelFormat) = 0;
    virtual HRESULT getHeightReduction(ULONG *aHeightReduction) = 0;
    virtual HRESULT getOverlay(ComPtr<IFramebufferOverlay> &aOverlay) = 0;
    virtual HRESULT getWinId(LONG64 *aWinId) = 0;
    virtual HRESULT getCapabilities(std::vector<FramebufferCapabilities_T> &aCapabilities) = 0;
    /** @} */

    /** @name Wrapped IFramebuffer methods
     * @{ */
    virtual HRESULT notifyUpdate(ULONG aX,
                                 ULONG aY,
                                 ULONG aWidth,
                                 ULONG aHeight) = 0;
    virtual HRESULT notifyUpdateImage(ULONG aX,
                                      ULONG aY,
                                      ULONG aWidth,
                                      ULONG aHeight,
                                      const std::vector<BYTE> &aImage) = 0;
    virtual HRESULT notifyChange(ULONG aScreenId,
                                 ULONG aXOrigin,
                                 ULONG aYOrigin,
                                 ULONG aWidth,
                                 ULONG aHeight) = 0;
    virtual HRESULT videoModeSupported(ULONG aWidth,
                                       ULONG aHeight,
                                       ULONG aBpp,
                                       BOOL *aSupported) = 0;
    virtual HRESULT getVisibleRegion(BYTE *aRectangles,
                                     ULONG aCount,
                                     ULONG *aCountCopied) = 0;
    virtual HRESULT setVisibleRegion(BYTE *aRectangles,
                                     ULONG aCount) = 0;
    virtual HRESULT processVHWACommand(BYTE *aCommand,
                                       LONG aEnmCmd,
                                       BOOL aFromGuest) = 0;
    virtual HRESULT notify3DEvent(ULONG aType,
                                  const std::vector<BYTE> &aData) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(FramebufferWrap); /* Shuts up MSC warning C4625. */

};

#endif // !FramebufferWrap_H_

// ##### ENDFILE "FramebufferWrap.h"


// ##### BEGINFILE "FramebufferOverlayWrap.h"
/** @file
 * VirtualBox API class wrapper header for IFramebufferOverlay.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef FramebufferOverlayWrap_H_
#define FramebufferOverlayWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE FramebufferOverlayWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IFramebufferOverlay)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(FramebufferOverlayWrap, IFramebufferOverlay)
    DECLARE_NOT_AGGREGATABLE(FramebufferOverlayWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(FramebufferOverlayWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IFramebufferOverlay)
        COM_INTERFACE_ENTRY(IFramebuffer)
        COM_INTERFACE_ENTRY2(IDispatch, IFramebufferOverlay)
        VBOX_TWEAK_INTERFACE_ENTRY(IFramebufferOverlay)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(FramebufferOverlayWrap)

    /** @name Public IFramebuffer properties
     * @{ */
    STDMETHOD(COMGETTER(Width))(ULONG *aWidth);
    STDMETHOD(COMGETTER(Height))(ULONG *aHeight);
    STDMETHOD(COMGETTER(BitsPerPixel))(ULONG *aBitsPerPixel);
    STDMETHOD(COMGETTER(BytesPerLine))(ULONG *aBytesPerLine);
    STDMETHOD(COMGETTER(PixelFormat))(BitmapFormat_T *aPixelFormat);
    STDMETHOD(COMGETTER(HeightReduction))(ULONG *aHeightReduction);
    STDMETHOD(COMGETTER(Overlay))(IFramebufferOverlay **aOverlay);
    STDMETHOD(COMGETTER(WinId))(LONG64 *aWinId);
    STDMETHOD(COMGETTER(Capabilities))(ComSafeArrayOut(FramebufferCapabilities_T, aCapabilities));
    /** @} */

    /** @name Public IFramebufferOverlay properties
     * @{ */
    STDMETHOD(COMGETTER(X))(ULONG *aX);
    STDMETHOD(COMGETTER(Y))(ULONG *aY);
    STDMETHOD(COMGETTER(Visible))(BOOL *aVisible);
    STDMETHOD(COMSETTER(Visible))(BOOL aVisible);
    STDMETHOD(COMGETTER(Alpha))(ULONG *aAlpha);
    STDMETHOD(COMSETTER(Alpha))(ULONG aAlpha);
    /** @} */

    /** @name Public IFramebuffer methods
     * @{ */
    STDMETHOD(NotifyUpdate)(ULONG aX,
                            ULONG aY,
                            ULONG aWidth,
                            ULONG aHeight);
    STDMETHOD(NotifyUpdateImage)(ULONG aX,
                                 ULONG aY,
                                 ULONG aWidth,
                                 ULONG aHeight,
                                 ComSafeArrayIn(BYTE, aImage));
    STDMETHOD(NotifyChange)(ULONG aScreenId,
                            ULONG aXOrigin,
                            ULONG aYOrigin,
                            ULONG aWidth,
                            ULONG aHeight);
    STDMETHOD(VideoModeSupported)(ULONG aWidth,
                                  ULONG aHeight,
                                  ULONG aBpp,
                                  BOOL *aSupported);
    STDMETHOD(GetVisibleRegion)(BYTE *aRectangles,
                                ULONG aCount,
                                ULONG *aCountCopied);
    STDMETHOD(SetVisibleRegion)(BYTE *aRectangles,
                                ULONG aCount);
    STDMETHOD(ProcessVHWACommand)(BYTE *aCommand,
                                  LONG aEnmCmd,
                                  BOOL aFromGuest);
    STDMETHOD(Notify3DEvent)(ULONG aType,
                             ComSafeArrayIn(BYTE, aData));
    /** @} */

    /** @name Public IFramebufferOverlay methods
     * @{ */
    STDMETHOD(Move)(ULONG aX,
                    ULONG aY);
    /** @} */

private:
    /** @name Wrapped IFramebuffer properties
     * @{ */
    virtual HRESULT getWidth(ULONG *aWidth) = 0;
    virtual HRESULT getHeight(ULONG *aHeight) = 0;
    virtual HRESULT getBitsPerPixel(ULONG *aBitsPerPixel) = 0;
    virtual HRESULT getBytesPerLine(ULONG *aBytesPerLine) = 0;
    virtual HRESULT getPixelFormat(BitmapFormat_T *aPixelFormat) = 0;
    virtual HRESULT getHeightReduction(ULONG *aHeightReduction) = 0;
    virtual HRESULT getOverlay(ComPtr<IFramebufferOverlay> &aOverlay) = 0;
    virtual HRESULT getWinId(LONG64 *aWinId) = 0;
    virtual HRESULT getCapabilities(std::vector<FramebufferCapabilities_T> &aCapabilities) = 0;
    /** @} */

    /** @name Wrapped IFramebufferOverlay properties
     * @{ */
    virtual HRESULT getX(ULONG *aX) = 0;
    virtual HRESULT getY(ULONG *aY) = 0;
    virtual HRESULT getVisible(BOOL *aVisible) = 0;
    virtual HRESULT setVisible(BOOL aVisible) = 0;
    virtual HRESULT getAlpha(ULONG *aAlpha) = 0;
    virtual HRESULT setAlpha(ULONG aAlpha) = 0;
    /** @} */

    /** @name Wrapped IFramebuffer methods
     * @{ */
    virtual HRESULT notifyUpdate(ULONG aX,
                                 ULONG aY,
                                 ULONG aWidth,
                                 ULONG aHeight) = 0;
    virtual HRESULT notifyUpdateImage(ULONG aX,
                                      ULONG aY,
                                      ULONG aWidth,
                                      ULONG aHeight,
                                      const std::vector<BYTE> &aImage) = 0;
    virtual HRESULT notifyChange(ULONG aScreenId,
                                 ULONG aXOrigin,
                                 ULONG aYOrigin,
                                 ULONG aWidth,
                                 ULONG aHeight) = 0;
    virtual HRESULT videoModeSupported(ULONG aWidth,
                                       ULONG aHeight,
                                       ULONG aBpp,
                                       BOOL *aSupported) = 0;
    virtual HRESULT getVisibleRegion(BYTE *aRectangles,
                                     ULONG aCount,
                                     ULONG *aCountCopied) = 0;
    virtual HRESULT setVisibleRegion(BYTE *aRectangles,
                                     ULONG aCount) = 0;
    virtual HRESULT processVHWACommand(BYTE *aCommand,
                                       LONG aEnmCmd,
                                       BOOL aFromGuest) = 0;
    virtual HRESULT notify3DEvent(ULONG aType,
                                  const std::vector<BYTE> &aData) = 0;
    /** @} */

    /** @name Wrapped IFramebufferOverlay methods
     * @{ */
    virtual HRESULT move(ULONG aX,
                         ULONG aY) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(FramebufferOverlayWrap); /* Shuts up MSC warning C4625. */

};

#endif // !FramebufferOverlayWrap_H_

// ##### ENDFILE "FramebufferOverlayWrap.h"


// ##### BEGINFILE "GuestScreenInfoWrap.h"
/** @file
 * VirtualBox API class wrapper header for IGuestScreenInfo.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef GuestScreenInfoWrap_H_
#define GuestScreenInfoWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE GuestScreenInfoWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IGuestScreenInfo)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(GuestScreenInfoWrap, IGuestScreenInfo)
    DECLARE_NOT_AGGREGATABLE(GuestScreenInfoWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(GuestScreenInfoWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IGuestScreenInfo)
        COM_INTERFACE_ENTRY2(IDispatch, IGuestScreenInfo)
        VBOX_TWEAK_INTERFACE_ENTRY(IGuestScreenInfo)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(GuestScreenInfoWrap)

    /** @name Public IGuestScreenInfo properties
     * @{ */
    STDMETHOD(COMGETTER(ScreenId))(ULONG *aScreenId);
    STDMETHOD(COMGETTER(GuestMonitorStatus))(GuestMonitorStatus_T *aGuestMonitorStatus);
    STDMETHOD(COMGETTER(Primary))(BOOL *aPrimary);
    STDMETHOD(COMGETTER(Origin))(BOOL *aOrigin);
    STDMETHOD(COMGETTER(OriginX))(LONG *aOriginX);
    STDMETHOD(COMGETTER(OriginY))(LONG *aOriginY);
    STDMETHOD(COMGETTER(Width))(ULONG *aWidth);
    STDMETHOD(COMGETTER(Height))(ULONG *aHeight);
    STDMETHOD(COMGETTER(BitsPerPixel))(ULONG *aBitsPerPixel);
    STDMETHOD(COMGETTER(ExtendedInfo))(BSTR *aExtendedInfo);
    /** @} */

    /** @name Public IGuestScreenInfo methods
     * @{ */
    /** @} */

private:
    /** @name Wrapped IGuestScreenInfo properties
     * @{ */
    virtual HRESULT getScreenId(ULONG *aScreenId) = 0;
    virtual HRESULT getGuestMonitorStatus(GuestMonitorStatus_T *aGuestMonitorStatus) = 0;
    virtual HRESULT getPrimary(BOOL *aPrimary) = 0;
    virtual HRESULT getOrigin(BOOL *aOrigin) = 0;
    virtual HRESULT getOriginX(LONG *aOriginX) = 0;
    virtual HRESULT getOriginY(LONG *aOriginY) = 0;
    virtual HRESULT getWidth(ULONG *aWidth) = 0;
    virtual HRESULT getHeight(ULONG *aHeight) = 0;
    virtual HRESULT getBitsPerPixel(ULONG *aBitsPerPixel) = 0;
    virtual HRESULT getExtendedInfo(com::Utf8Str &aExtendedInfo) = 0;
    /** @} */

    /** @name Wrapped IGuestScreenInfo methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(GuestScreenInfoWrap); /* Shuts up MSC warning C4625. */

};

#endif // !GuestScreenInfoWrap_H_

// ##### ENDFILE "GuestScreenInfoWrap.h"


// ##### BEGINFILE "DisplayWrap.h"
/** @file
 * VirtualBox API class wrapper header for IDisplay.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef DisplayWrap_H_
#define DisplayWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE DisplayWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IDisplay)
    , VBOX_SCRIPTABLE_IMPL(IEventListener)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(DisplayWrap, IDisplay)
    DECLARE_NOT_AGGREGATABLE(DisplayWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(DisplayWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IDisplay)
        COM_INTERFACE_ENTRY2(IDispatch, IDisplay)
        COM_INTERFACE_ENTRY(IEventListener)
        VBOX_TWEAK_INTERFACE_ENTRY(IDisplay)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(DisplayWrap)

    /** @name Public IDisplay properties
     * @{ */
    STDMETHOD(COMGETTER(GuestScreenLayout))(ComSafeArrayOut(IGuestScreenInfo *, aGuestScreenLayout));
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IDisplay))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IDisplay))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IDisplay))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IDisplay))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IDisplay))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IDisplay))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IDisplay))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IDisplay))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute9IDisplay))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute10IDisplay))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute11IDisplay))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute12IDisplay))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute13IDisplay))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute14IDisplay))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute15IDisplay))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute16IDisplay))(ULONG *aReserved);
    /** @} */

    /** @name Public IDisplay methods
     * @{ */
    STDMETHOD(GetScreenResolution)(ULONG aScreenId,
                                   ULONG *aWidth,
                                   ULONG *aHeight,
                                   ULONG *aBitsPerPixel,
                                   LONG *aXOrigin,
                                   LONG *aYOrigin,
                                   GuestMonitorStatus_T *aGuestMonitorStatus);
    STDMETHOD(AttachFramebuffer)(ULONG aScreenId,
                                 IFramebuffer *aFramebuffer,
                                 BSTR *aId);
    STDMETHOD(DetachFramebuffer)(ULONG aScreenId,
                                 IN_BSTR aId);
    STDMETHOD(QueryFramebuffer)(ULONG aScreenId,
                                IFramebuffer **aFramebuffer);
    STDMETHOD(SetVideoModeHint)(ULONG aDisplay,
                                BOOL aEnabled,
                                BOOL aChangeOrigin,
                                LONG aOriginX,
                                LONG aOriginY,
                                ULONG aWidth,
                                ULONG aHeight,
                                ULONG aBitsPerPixel,
                                BOOL aNotify);
    STDMETHOD(GetVideoModeHint)(ULONG aDisplay,
                                BOOL *aEnabled,
                                BOOL *aChangeOrigin,
                                LONG *aOriginX,
                                LONG *aOriginY,
                                ULONG *aWidth,
                                ULONG *aHeight,
                                ULONG *aBitsPerPixel);
    STDMETHOD(SetSeamlessMode)(BOOL aEnabled);
    STDMETHOD(TakeScreenShot)(ULONG aScreenId,
                              BYTE *aAddress,
                              ULONG aWidth,
                              ULONG aHeight,
                              BitmapFormat_T aBitmapFormat);
    STDMETHOD(TakeScreenShotToArray)(ULONG aScreenId,
                                     ULONG aWidth,
                                     ULONG aHeight,
                                     BitmapFormat_T aBitmapFormat,
                                     ComSafeArrayOut(BYTE, aScreenData));
    STDMETHOD(DrawToScreen)(ULONG aScreenId,
                            BYTE *aAddress,
                            ULONG aX,
                            ULONG aY,
                            ULONG aWidth,
                            ULONG aHeight);
    STDMETHOD(InvalidateAndUpdate)();
    STDMETHOD(InvalidateAndUpdateScreen)(ULONG aScreenId);
    STDMETHOD(CompleteVHWACommand)(BYTE *aCommand);
    STDMETHOD(ViewportChanged)(ULONG aScreenId,
                               ULONG aX,
                               ULONG aY,
                               ULONG aWidth,
                               ULONG aHeight);
    STDMETHOD(QuerySourceBitmap)(ULONG aScreenId,
                                 IDisplaySourceBitmap **aDisplaySourceBitmap);
    STDMETHOD(NotifyScaleFactorChange)(ULONG aScreenId,
                                       ULONG aU32ScaleFactorWMultiplied,
                                       ULONG aU32ScaleFactorHMultiplied);
    STDMETHOD(NotifyHiDPIOutputPolicyChange)(BOOL aFUnscaledHiDPI);
    STDMETHOD(SetScreenLayout)(ScreenLayoutMode_T aScreenLayoutMode,
                               ComSafeArrayIn(IGuestScreenInfo *, aGuestScreenInfo));
    STDMETHOD(DetachScreens)(ComSafeArrayIn(LONG, aScreenIds));
    STDMETHOD(CreateGuestScreenInfo)(ULONG aDisplay,
                                     GuestMonitorStatus_T aStatus,
                                     BOOL aPrimary,
                                     BOOL aChangeOrigin,
                                     LONG aOriginX,
                                     LONG aOriginY,
                                     ULONG aWidth,
                                     ULONG aHeight,
                                     ULONG aBitsPerPixel,
                                     IGuestScreenInfo **aGuestScreenInfo);
    STDMETHOD(InternalAndReservedMethod1IDisplay)();
    STDMETHOD(InternalAndReservedMethod2IDisplay)();
    STDMETHOD(InternalAndReservedMethod3IDisplay)();
    STDMETHOD(InternalAndReservedMethod4IDisplay)();
    STDMETHOD(InternalAndReservedMethod5IDisplay)();
    STDMETHOD(InternalAndReservedMethod6IDisplay)();
    STDMETHOD(InternalAndReservedMethod7IDisplay)();
    STDMETHOD(InternalAndReservedMethod8IDisplay)();
    /** @} */

    /** @name Public IEventListener properties
     * @{ */
    /** @} */

    /** @name Public IEventListener methods
     * @{ */
    STDMETHOD(HandleEvent)(IEvent *aEvent);
    /** @} */

private:
    /** @name Wrapped IDisplay properties
     * @{ */
    virtual HRESULT getGuestScreenLayout(std::vector<ComPtr<IGuestScreenInfo> > &aGuestScreenLayout) = 0;
    /** @} */

    /** @name Wrapped IDisplay methods
     * @{ */
    virtual HRESULT getScreenResolution(ULONG aScreenId,
                                        ULONG *aWidth,
                                        ULONG *aHeight,
                                        ULONG *aBitsPerPixel,
                                        LONG *aXOrigin,
                                        LONG *aYOrigin,
                                        GuestMonitorStatus_T *aGuestMonitorStatus) = 0;
    virtual HRESULT attachFramebuffer(ULONG aScreenId,
                                      const ComPtr<IFramebuffer> &aFramebuffer,
                                      com::Guid &aId) = 0;
    virtual HRESULT detachFramebuffer(ULONG aScreenId,
                                      const com::Guid &aId) = 0;
    virtual HRESULT queryFramebuffer(ULONG aScreenId,
                                     ComPtr<IFramebuffer> &aFramebuffer) = 0;
    virtual HRESULT setVideoModeHint(ULONG aDisplay,
                                     BOOL aEnabled,
                                     BOOL aChangeOrigin,
                                     LONG aOriginX,
                                     LONG aOriginY,
                                     ULONG aWidth,
                                     ULONG aHeight,
                                     ULONG aBitsPerPixel,
                                     BOOL aNotify) = 0;
    virtual HRESULT getVideoModeHint(ULONG aDisplay,
                                     BOOL *aEnabled,
                                     BOOL *aChangeOrigin,
                                     LONG *aOriginX,
                                     LONG *aOriginY,
                                     ULONG *aWidth,
                                     ULONG *aHeight,
                                     ULONG *aBitsPerPixel) = 0;
    virtual HRESULT setSeamlessMode(BOOL aEnabled) = 0;
    virtual HRESULT takeScreenShot(ULONG aScreenId,
                                   BYTE *aAddress,
                                   ULONG aWidth,
                                   ULONG aHeight,
                                   BitmapFormat_T aBitmapFormat) = 0;
    virtual HRESULT takeScreenShotToArray(ULONG aScreenId,
                                          ULONG aWidth,
                                          ULONG aHeight,
                                          BitmapFormat_T aBitmapFormat,
                                          std::vector<BYTE> &aScreenData) = 0;
    virtual HRESULT drawToScreen(ULONG aScreenId,
                                 BYTE *aAddress,
                                 ULONG aX,
                                 ULONG aY,
                                 ULONG aWidth,
                                 ULONG aHeight) = 0;
    virtual HRESULT invalidateAndUpdate() = 0;
    virtual HRESULT invalidateAndUpdateScreen(ULONG aScreenId) = 0;
    virtual HRESULT completeVHWACommand(BYTE *aCommand) = 0;
    virtual HRESULT viewportChanged(ULONG aScreenId,
                                    ULONG aX,
                                    ULONG aY,
                                    ULONG aWidth,
                                    ULONG aHeight) = 0;
    virtual HRESULT querySourceBitmap(ULONG aScreenId,
                                      ComPtr<IDisplaySourceBitmap> &aDisplaySourceBitmap) = 0;
    virtual HRESULT notifyScaleFactorChange(ULONG aScreenId,
                                            ULONG aU32ScaleFactorWMultiplied,
                                            ULONG aU32ScaleFactorHMultiplied) = 0;
    virtual HRESULT notifyHiDPIOutputPolicyChange(BOOL aFUnscaledHiDPI) = 0;
    virtual HRESULT setScreenLayout(ScreenLayoutMode_T aScreenLayoutMode,
                                    const std::vector<ComPtr<IGuestScreenInfo> > &aGuestScreenInfo) = 0;
    virtual HRESULT detachScreens(const std::vector<LONG> &aScreenIds) = 0;
    virtual HRESULT createGuestScreenInfo(ULONG aDisplay,
                                          GuestMonitorStatus_T aStatus,
                                          BOOL aPrimary,
                                          BOOL aChangeOrigin,
                                          LONG aOriginX,
                                          LONG aOriginY,
                                          ULONG aWidth,
                                          ULONG aHeight,
                                          ULONG aBitsPerPixel,
                                          ComPtr<IGuestScreenInfo> &aGuestScreenInfo) = 0;
    /** @} */

    /** @name Wrapped IEventListener properties
     * @{ */
    /** @} */

    /** @name Wrapped IEventListener methods
     * @{ */
    virtual HRESULT handleEvent(const ComPtr<IEvent> &aEvent) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(DisplayWrap); /* Shuts up MSC warning C4625. */

};

#endif // !DisplayWrap_H_

// ##### ENDFILE "DisplayWrap.h"


// ##### BEGINFILE "NetworkAdapterWrap.h"
/** @file
 * VirtualBox API class wrapper header for INetworkAdapter.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef NetworkAdapterWrap_H_
#define NetworkAdapterWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE NetworkAdapterWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(INetworkAdapter)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(NetworkAdapterWrap, INetworkAdapter)
    DECLARE_NOT_AGGREGATABLE(NetworkAdapterWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(NetworkAdapterWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(INetworkAdapter)
        COM_INTERFACE_ENTRY2(IDispatch, INetworkAdapter)
        VBOX_TWEAK_INTERFACE_ENTRY(INetworkAdapter)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(NetworkAdapterWrap)

    /** @name Public INetworkAdapter properties
     * @{ */
    STDMETHOD(COMGETTER(AdapterType))(NetworkAdapterType_T *aAdapterType);
    STDMETHOD(COMSETTER(AdapterType))(NetworkAdapterType_T aAdapterType);
    STDMETHOD(COMGETTER(Slot))(ULONG *aSlot);
    STDMETHOD(COMGETTER(Enabled))(BOOL *aEnabled);
    STDMETHOD(COMSETTER(Enabled))(BOOL aEnabled);
    STDMETHOD(COMGETTER(MACAddress))(BSTR *aMACAddress);
    STDMETHOD(COMSETTER(MACAddress))(IN_BSTR aMACAddress);
    STDMETHOD(COMGETTER(AttachmentType))(NetworkAttachmentType_T *aAttachmentType);
    STDMETHOD(COMSETTER(AttachmentType))(NetworkAttachmentType_T aAttachmentType);
    STDMETHOD(COMGETTER(BridgedInterface))(BSTR *aBridgedInterface);
    STDMETHOD(COMSETTER(BridgedInterface))(IN_BSTR aBridgedInterface);
    STDMETHOD(COMGETTER(HostOnlyInterface))(BSTR *aHostOnlyInterface);
    STDMETHOD(COMSETTER(HostOnlyInterface))(IN_BSTR aHostOnlyInterface);
    STDMETHOD(COMGETTER(InternalNetwork))(BSTR *aInternalNetwork);
    STDMETHOD(COMSETTER(InternalNetwork))(IN_BSTR aInternalNetwork);
    STDMETHOD(COMGETTER(NATNetwork))(BSTR *aNATNetwork);
    STDMETHOD(COMSETTER(NATNetwork))(IN_BSTR aNATNetwork);
    STDMETHOD(COMGETTER(GenericDriver))(BSTR *aGenericDriver);
    STDMETHOD(COMSETTER(GenericDriver))(IN_BSTR aGenericDriver);
    STDMETHOD(COMGETTER(CloudNetwork))(BSTR *aCloudNetwork);
    STDMETHOD(COMSETTER(CloudNetwork))(IN_BSTR aCloudNetwork);
    STDMETHOD(COMGETTER(CableConnected))(BOOL *aCableConnected);
    STDMETHOD(COMSETTER(CableConnected))(BOOL aCableConnected);
    STDMETHOD(COMGETTER(LineSpeed))(ULONG *aLineSpeed);
    STDMETHOD(COMSETTER(LineSpeed))(ULONG aLineSpeed);
    STDMETHOD(COMGETTER(PromiscModePolicy))(NetworkAdapterPromiscModePolicy_T *aPromiscModePolicy);
    STDMETHOD(COMSETTER(PromiscModePolicy))(NetworkAdapterPromiscModePolicy_T aPromiscModePolicy);
    STDMETHOD(COMGETTER(TraceEnabled))(BOOL *aTraceEnabled);
    STDMETHOD(COMSETTER(TraceEnabled))(BOOL aTraceEnabled);
    STDMETHOD(COMGETTER(TraceFile))(BSTR *aTraceFile);
    STDMETHOD(COMSETTER(TraceFile))(IN_BSTR aTraceFile);
    STDMETHOD(COMGETTER(NATEngine))(INATEngine **aNATEngine);
    STDMETHOD(COMGETTER(BootPriority))(ULONG *aBootPriority);
    STDMETHOD(COMSETTER(BootPriority))(ULONG aBootPriority);
    STDMETHOD(COMGETTER(BandwidthGroup))(IBandwidthGroup **aBandwidthGroup);
    STDMETHOD(COMSETTER(BandwidthGroup))(IBandwidthGroup *aBandwidthGroup);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1INetworkAdapter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2INetworkAdapter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3INetworkAdapter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4INetworkAdapter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5INetworkAdapter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6INetworkAdapter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7INetworkAdapter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8INetworkAdapter))(ULONG *aReserved);
    /** @} */

    /** @name Public INetworkAdapter methods
     * @{ */
    STDMETHOD(GetProperty)(IN_BSTR aKey,
                           BSTR *aValue);
    STDMETHOD(SetProperty)(IN_BSTR aKey,
                           IN_BSTR aValue);
    STDMETHOD(GetProperties)(IN_BSTR aNames,
                             ComSafeArrayOut(BSTR, aReturnNames),
                             ComSafeArrayOut(BSTR, aReturnValues));
    STDMETHOD(InternalAndReservedMethod1INetworkAdapter)();
    STDMETHOD(InternalAndReservedMethod2INetworkAdapter)();
    STDMETHOD(InternalAndReservedMethod3INetworkAdapter)();
    STDMETHOD(InternalAndReservedMethod4INetworkAdapter)();
    /** @} */

private:
    /** @name Wrapped INetworkAdapter properties
     * @{ */
    virtual HRESULT getAdapterType(NetworkAdapterType_T *aAdapterType) = 0;
    virtual HRESULT setAdapterType(NetworkAdapterType_T aAdapterType) = 0;
    virtual HRESULT getSlot(ULONG *aSlot) = 0;
    virtual HRESULT getEnabled(BOOL *aEnabled) = 0;
    virtual HRESULT setEnabled(BOOL aEnabled) = 0;
    virtual HRESULT getMACAddress(com::Utf8Str &aMACAddress) = 0;
    virtual HRESULT setMACAddress(const com::Utf8Str &aMACAddress) = 0;
    virtual HRESULT getAttachmentType(NetworkAttachmentType_T *aAttachmentType) = 0;
    virtual HRESULT setAttachmentType(NetworkAttachmentType_T aAttachmentType) = 0;
    virtual HRESULT getBridgedInterface(com::Utf8Str &aBridgedInterface) = 0;
    virtual HRESULT setBridgedInterface(const com::Utf8Str &aBridgedInterface) = 0;
    virtual HRESULT getHostOnlyInterface(com::Utf8Str &aHostOnlyInterface) = 0;
    virtual HRESULT setHostOnlyInterface(const com::Utf8Str &aHostOnlyInterface) = 0;
    virtual HRESULT getInternalNetwork(com::Utf8Str &aInternalNetwork) = 0;
    virtual HRESULT setInternalNetwork(const com::Utf8Str &aInternalNetwork) = 0;
    virtual HRESULT getNATNetwork(com::Utf8Str &aNATNetwork) = 0;
    virtual HRESULT setNATNetwork(const com::Utf8Str &aNATNetwork) = 0;
    virtual HRESULT getGenericDriver(com::Utf8Str &aGenericDriver) = 0;
    virtual HRESULT setGenericDriver(const com::Utf8Str &aGenericDriver) = 0;
    virtual HRESULT getCloudNetwork(com::Utf8Str &aCloudNetwork) = 0;
    virtual HRESULT setCloudNetwork(const com::Utf8Str &aCloudNetwork) = 0;
    virtual HRESULT getCableConnected(BOOL *aCableConnected) = 0;
    virtual HRESULT setCableConnected(BOOL aCableConnected) = 0;
    virtual HRESULT getLineSpeed(ULONG *aLineSpeed) = 0;
    virtual HRESULT setLineSpeed(ULONG aLineSpeed) = 0;
    virtual HRESULT getPromiscModePolicy(NetworkAdapterPromiscModePolicy_T *aPromiscModePolicy) = 0;
    virtual HRESULT setPromiscModePolicy(NetworkAdapterPromiscModePolicy_T aPromiscModePolicy) = 0;
    virtual HRESULT getTraceEnabled(BOOL *aTraceEnabled) = 0;
    virtual HRESULT setTraceEnabled(BOOL aTraceEnabled) = 0;
    virtual HRESULT getTraceFile(com::Utf8Str &aTraceFile) = 0;
    virtual HRESULT setTraceFile(const com::Utf8Str &aTraceFile) = 0;
    virtual HRESULT getNATEngine(ComPtr<INATEngine> &aNATEngine) = 0;
    virtual HRESULT getBootPriority(ULONG *aBootPriority) = 0;
    virtual HRESULT setBootPriority(ULONG aBootPriority) = 0;
    virtual HRESULT getBandwidthGroup(ComPtr<IBandwidthGroup> &aBandwidthGroup) = 0;
    virtual HRESULT setBandwidthGroup(const ComPtr<IBandwidthGroup> &aBandwidthGroup) = 0;
    /** @} */

    /** @name Wrapped INetworkAdapter methods
     * @{ */
    virtual HRESULT getProperty(const com::Utf8Str &aKey,
                                com::Utf8Str &aValue) = 0;
    virtual HRESULT setProperty(const com::Utf8Str &aKey,
                                const com::Utf8Str &aValue) = 0;
    virtual HRESULT getProperties(const com::Utf8Str &aNames,
                                  std::vector<com::Utf8Str> &aReturnNames,
                                  std::vector<com::Utf8Str> &aReturnValues) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(NetworkAdapterWrap); /* Shuts up MSC warning C4625. */

};

#endif // !NetworkAdapterWrap_H_

// ##### ENDFILE "NetworkAdapterWrap.h"


// ##### BEGINFILE "SerialPortWrap.h"
/** @file
 * VirtualBox API class wrapper header for ISerialPort.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef SerialPortWrap_H_
#define SerialPortWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE SerialPortWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(ISerialPort)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(SerialPortWrap, ISerialPort)
    DECLARE_NOT_AGGREGATABLE(SerialPortWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(SerialPortWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(ISerialPort)
        COM_INTERFACE_ENTRY2(IDispatch, ISerialPort)
        VBOX_TWEAK_INTERFACE_ENTRY(ISerialPort)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(SerialPortWrap)

    /** @name Public ISerialPort properties
     * @{ */
    STDMETHOD(COMGETTER(Slot))(ULONG *aSlot);
    STDMETHOD(COMGETTER(Enabled))(BOOL *aEnabled);
    STDMETHOD(COMSETTER(Enabled))(BOOL aEnabled);
    STDMETHOD(COMGETTER(IOBase))(ULONG *aIOBase);
    STDMETHOD(COMSETTER(IOBase))(ULONG aIOBase);
    STDMETHOD(COMGETTER(IRQ))(ULONG *aIRQ);
    STDMETHOD(COMSETTER(IRQ))(ULONG aIRQ);
    STDMETHOD(COMGETTER(HostMode))(PortMode_T *aHostMode);
    STDMETHOD(COMSETTER(HostMode))(PortMode_T aHostMode);
    STDMETHOD(COMGETTER(Server))(BOOL *aServer);
    STDMETHOD(COMSETTER(Server))(BOOL aServer);
    STDMETHOD(COMGETTER(Path))(BSTR *aPath);
    STDMETHOD(COMSETTER(Path))(IN_BSTR aPath);
    STDMETHOD(COMGETTER(UartType))(UartType_T *aUartType);
    STDMETHOD(COMSETTER(UartType))(UartType_T aUartType);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1ISerialPort))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2ISerialPort))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3ISerialPort))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4ISerialPort))(ULONG *aReserved);
    /** @} */

    /** @name Public ISerialPort methods
     * @{ */
    /** @} */

private:
    /** @name Wrapped ISerialPort properties
     * @{ */
    virtual HRESULT getSlot(ULONG *aSlot) = 0;
    virtual HRESULT getEnabled(BOOL *aEnabled) = 0;
    virtual HRESULT setEnabled(BOOL aEnabled) = 0;
    virtual HRESULT getIOBase(ULONG *aIOBase) = 0;
    virtual HRESULT setIOBase(ULONG aIOBase) = 0;
    virtual HRESULT getIRQ(ULONG *aIRQ) = 0;
    virtual HRESULT setIRQ(ULONG aIRQ) = 0;
    virtual HRESULT getHostMode(PortMode_T *aHostMode) = 0;
    virtual HRESULT setHostMode(PortMode_T aHostMode) = 0;
    virtual HRESULT getServer(BOOL *aServer) = 0;
    virtual HRESULT setServer(BOOL aServer) = 0;
    virtual HRESULT getPath(com::Utf8Str &aPath) = 0;
    virtual HRESULT setPath(const com::Utf8Str &aPath) = 0;
    virtual HRESULT getUartType(UartType_T *aUartType) = 0;
    virtual HRESULT setUartType(UartType_T aUartType) = 0;
    /** @} */

    /** @name Wrapped ISerialPort methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(SerialPortWrap); /* Shuts up MSC warning C4625. */

};

#endif // !SerialPortWrap_H_

// ##### ENDFILE "SerialPortWrap.h"


// ##### BEGINFILE "ParallelPortWrap.h"
/** @file
 * VirtualBox API class wrapper header for IParallelPort.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef ParallelPortWrap_H_
#define ParallelPortWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE ParallelPortWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IParallelPort)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(ParallelPortWrap, IParallelPort)
    DECLARE_NOT_AGGREGATABLE(ParallelPortWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(ParallelPortWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IParallelPort)
        COM_INTERFACE_ENTRY2(IDispatch, IParallelPort)
        VBOX_TWEAK_INTERFACE_ENTRY(IParallelPort)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(ParallelPortWrap)

    /** @name Public IParallelPort properties
     * @{ */
    STDMETHOD(COMGETTER(Slot))(ULONG *aSlot);
    STDMETHOD(COMGETTER(Enabled))(BOOL *aEnabled);
    STDMETHOD(COMSETTER(Enabled))(BOOL aEnabled);
    STDMETHOD(COMGETTER(IOBase))(ULONG *aIOBase);
    STDMETHOD(COMSETTER(IOBase))(ULONG aIOBase);
    STDMETHOD(COMGETTER(IRQ))(ULONG *aIRQ);
    STDMETHOD(COMSETTER(IRQ))(ULONG aIRQ);
    STDMETHOD(COMGETTER(Path))(BSTR *aPath);
    STDMETHOD(COMSETTER(Path))(IN_BSTR aPath);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IParallelPort))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IParallelPort))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IParallelPort))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IParallelPort))(ULONG *aReserved);
    /** @} */

    /** @name Public IParallelPort methods
     * @{ */
    /** @} */

private:
    /** @name Wrapped IParallelPort properties
     * @{ */
    virtual HRESULT getSlot(ULONG *aSlot) = 0;
    virtual HRESULT getEnabled(BOOL *aEnabled) = 0;
    virtual HRESULT setEnabled(BOOL aEnabled) = 0;
    virtual HRESULT getIOBase(ULONG *aIOBase) = 0;
    virtual HRESULT setIOBase(ULONG aIOBase) = 0;
    virtual HRESULT getIRQ(ULONG *aIRQ) = 0;
    virtual HRESULT setIRQ(ULONG aIRQ) = 0;
    virtual HRESULT getPath(com::Utf8Str &aPath) = 0;
    virtual HRESULT setPath(const com::Utf8Str &aPath) = 0;
    /** @} */

    /** @name Wrapped IParallelPort methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(ParallelPortWrap); /* Shuts up MSC warning C4625. */

};

#endif // !ParallelPortWrap_H_

// ##### ENDFILE "ParallelPortWrap.h"


// ##### BEGINFILE "MachineDebuggerWrap.h"
/** @file
 * VirtualBox API class wrapper header for IMachineDebugger.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef MachineDebuggerWrap_H_
#define MachineDebuggerWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE MachineDebuggerWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IMachineDebugger)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(MachineDebuggerWrap, IMachineDebugger)
    DECLARE_NOT_AGGREGATABLE(MachineDebuggerWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(MachineDebuggerWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IMachineDebugger)
        COM_INTERFACE_ENTRY2(IDispatch, IMachineDebugger)
        VBOX_TWEAK_INTERFACE_ENTRY(IMachineDebugger)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(MachineDebuggerWrap)

    /** @name Public IMachineDebugger properties
     * @{ */
    STDMETHOD(COMGETTER(SingleStep))(BOOL *aSingleStep);
    STDMETHOD(COMSETTER(SingleStep))(BOOL aSingleStep);
    STDMETHOD(COMGETTER(RecompileUser))(BOOL *aRecompileUser);
    STDMETHOD(COMSETTER(RecompileUser))(BOOL aRecompileUser);
    STDMETHOD(COMGETTER(RecompileSupervisor))(BOOL *aRecompileSupervisor);
    STDMETHOD(COMSETTER(RecompileSupervisor))(BOOL aRecompileSupervisor);
    STDMETHOD(COMGETTER(ExecuteAllInIEM))(BOOL *aExecuteAllInIEM);
    STDMETHOD(COMSETTER(ExecuteAllInIEM))(BOOL aExecuteAllInIEM);
    STDMETHOD(COMGETTER(PATMEnabled))(BOOL *aPATMEnabled);
    STDMETHOD(COMSETTER(PATMEnabled))(BOOL aPATMEnabled);
    STDMETHOD(COMGETTER(CSAMEnabled))(BOOL *aCSAMEnabled);
    STDMETHOD(COMSETTER(CSAMEnabled))(BOOL aCSAMEnabled);
    STDMETHOD(COMGETTER(LogEnabled))(BOOL *aLogEnabled);
    STDMETHOD(COMSETTER(LogEnabled))(BOOL aLogEnabled);
    STDMETHOD(COMGETTER(LogDbgFlags))(BSTR *aLogDbgFlags);
    STDMETHOD(COMGETTER(LogDbgGroups))(BSTR *aLogDbgGroups);
    STDMETHOD(COMGETTER(LogDbgDestinations))(BSTR *aLogDbgDestinations);
    STDMETHOD(COMGETTER(LogRelFlags))(BSTR *aLogRelFlags);
    STDMETHOD(COMGETTER(LogRelGroups))(BSTR *aLogRelGroups);
    STDMETHOD(COMGETTER(LogRelDestinations))(BSTR *aLogRelDestinations);
    STDMETHOD(COMGETTER(ExecutionEngine))(VMExecutionEngine_T *aExecutionEngine);
    STDMETHOD(COMGETTER(HWVirtExEnabled))(BOOL *aHWVirtExEnabled);
    STDMETHOD(COMGETTER(HWVirtExNestedPagingEnabled))(BOOL *aHWVirtExNestedPagingEnabled);
    STDMETHOD(COMGETTER(HWVirtExVPIDEnabled))(BOOL *aHWVirtExVPIDEnabled);
    STDMETHOD(COMGETTER(HWVirtExUXEnabled))(BOOL *aHWVirtExUXEnabled);
    STDMETHOD(COMGETTER(OSName))(BSTR *aOSName);
    STDMETHOD(COMGETTER(OSVersion))(BSTR *aOSVersion);
    STDMETHOD(COMGETTER(PAEEnabled))(BOOL *aPAEEnabled);
    STDMETHOD(COMGETTER(VirtualTimeRate))(ULONG *aVirtualTimeRate);
    STDMETHOD(COMSETTER(VirtualTimeRate))(ULONG aVirtualTimeRate);
    STDMETHOD(COMGETTER(VM))(LONG64 *aVM);
    STDMETHOD(COMGETTER(Uptime))(LONG64 *aUptime);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IMachineDebugger))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IMachineDebugger))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IMachineDebugger))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IMachineDebugger))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IMachineDebugger))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IMachineDebugger))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IMachineDebugger))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IMachineDebugger))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute9IMachineDebugger))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute10IMachineDebugger))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute11IMachineDebugger))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute12IMachineDebugger))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute13IMachineDebugger))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute14IMachineDebugger))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute15IMachineDebugger))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute16IMachineDebugger))(ULONG *aReserved);
    /** @} */

    /** @name Public IMachineDebugger methods
     * @{ */
    STDMETHOD(DumpGuestCore)(IN_BSTR aFilename,
                             IN_BSTR aCompression);
    STDMETHOD(DumpHostProcessCore)(IN_BSTR aFilename,
                                   IN_BSTR aCompression);
    STDMETHOD(Info)(IN_BSTR aName,
                    IN_BSTR aArgs,
                    BSTR *aInfo);
    STDMETHOD(InjectNMI)();
    STDMETHOD(ModifyLogGroups)(IN_BSTR aSettings);
    STDMETHOD(ModifyLogFlags)(IN_BSTR aSettings);
    STDMETHOD(ModifyLogDestinations)(IN_BSTR aSettings);
    STDMETHOD(ReadPhysicalMemory)(LONG64 aAddress,
                                  ULONG aSize,
                                  ComSafeArrayOut(BYTE, aBytes));
    STDMETHOD(WritePhysicalMemory)(LONG64 aAddress,
                                   ULONG aSize,
                                   ComSafeArrayIn(BYTE, aBytes));
    STDMETHOD(ReadVirtualMemory)(ULONG aCpuId,
                                 LONG64 aAddress,
                                 ULONG aSize,
                                 ComSafeArrayOut(BYTE, aBytes));
    STDMETHOD(WriteVirtualMemory)(ULONG aCpuId,
                                  LONG64 aAddress,
                                  ULONG aSize,
                                  ComSafeArrayIn(BYTE, aBytes));
    STDMETHOD(LoadPlugIn)(IN_BSTR aName,
                          BSTR *aPlugInName);
    STDMETHOD(UnloadPlugIn)(IN_BSTR aName);
    STDMETHOD(DetectOS)(BSTR *aOs);
    STDMETHOD(QueryOSKernelLog)(ULONG aMaxMessages,
                                BSTR *aDmesg);
    STDMETHOD(GetRegister)(ULONG aCpuId,
                           IN_BSTR aName,
                           BSTR *aValue);
    STDMETHOD(GetRegisters)(ULONG aCpuId,
                            ComSafeArrayOut(BSTR, aNames),
                            ComSafeArrayOut(BSTR, aValues));
    STDMETHOD(SetRegister)(ULONG aCpuId,
                           IN_BSTR aName,
                           IN_BSTR aValue);
    STDMETHOD(SetRegisters)(ULONG aCpuId,
                            ComSafeArrayIn(IN_BSTR, aNames),
                            ComSafeArrayIn(IN_BSTR, aValues));
    STDMETHOD(DumpGuestStack)(ULONG aCpuId,
                              BSTR *aStack);
    STDMETHOD(ResetStats)(IN_BSTR aPattern);
    STDMETHOD(DumpStats)(IN_BSTR aPattern);
    STDMETHOD(GetStats)(IN_BSTR aPattern,
                        BOOL aWithDescriptions,
                        BSTR *aStats);
    STDMETHOD(GetCPULoad)(ULONG aCpuId,
                          ULONG *aPctExecuting,
                          ULONG *aPctHalted,
                          ULONG *aPctOther,
                          LONG64 *aMsInterval);
    STDMETHOD(InternalAndReservedMethod1IMachineDebugger)();
    STDMETHOD(InternalAndReservedMethod2IMachineDebugger)();
    STDMETHOD(InternalAndReservedMethod3IMachineDebugger)();
    STDMETHOD(InternalAndReservedMethod4IMachineDebugger)();
    STDMETHOD(InternalAndReservedMethod5IMachineDebugger)();
    STDMETHOD(InternalAndReservedMethod6IMachineDebugger)();
    STDMETHOD(InternalAndReservedMethod7IMachineDebugger)();
    STDMETHOD(InternalAndReservedMethod8IMachineDebugger)();
    STDMETHOD(InternalAndReservedMethod9IMachineDebugger)();
    STDMETHOD(InternalAndReservedMethod10IMachineDebugger)();
    STDMETHOD(InternalAndReservedMethod11IMachineDebugger)();
    STDMETHOD(InternalAndReservedMethod12IMachineDebugger)();
    STDMETHOD(InternalAndReservedMethod13IMachineDebugger)();
    STDMETHOD(InternalAndReservedMethod14IMachineDebugger)();
    STDMETHOD(InternalAndReservedMethod15IMachineDebugger)();
    STDMETHOD(InternalAndReservedMethod16IMachineDebugger)();
    /** @} */

private:
    /** @name Wrapped IMachineDebugger properties
     * @{ */
    virtual HRESULT getSingleStep(BOOL *aSingleStep) = 0;
    virtual HRESULT setSingleStep(BOOL aSingleStep) = 0;
    virtual HRESULT getRecompileUser(BOOL *aRecompileUser) = 0;
    virtual HRESULT setRecompileUser(BOOL aRecompileUser) = 0;
    virtual HRESULT getRecompileSupervisor(BOOL *aRecompileSupervisor) = 0;
    virtual HRESULT setRecompileSupervisor(BOOL aRecompileSupervisor) = 0;
    virtual HRESULT getExecuteAllInIEM(BOOL *aExecuteAllInIEM) = 0;
    virtual HRESULT setExecuteAllInIEM(BOOL aExecuteAllInIEM) = 0;
    virtual HRESULT getPATMEnabled(BOOL *aPATMEnabled) = 0;
    virtual HRESULT setPATMEnabled(BOOL aPATMEnabled) = 0;
    virtual HRESULT getCSAMEnabled(BOOL *aCSAMEnabled) = 0;
    virtual HRESULT setCSAMEnabled(BOOL aCSAMEnabled) = 0;
    virtual HRESULT getLogEnabled(BOOL *aLogEnabled) = 0;
    virtual HRESULT setLogEnabled(BOOL aLogEnabled) = 0;
    virtual HRESULT getLogDbgFlags(com::Utf8Str &aLogDbgFlags) = 0;
    virtual HRESULT getLogDbgGroups(com::Utf8Str &aLogDbgGroups) = 0;
    virtual HRESULT getLogDbgDestinations(com::Utf8Str &aLogDbgDestinations) = 0;
    virtual HRESULT getLogRelFlags(com::Utf8Str &aLogRelFlags) = 0;
    virtual HRESULT getLogRelGroups(com::Utf8Str &aLogRelGroups) = 0;
    virtual HRESULT getLogRelDestinations(com::Utf8Str &aLogRelDestinations) = 0;
    virtual HRESULT getExecutionEngine(VMExecutionEngine_T *aExecutionEngine) = 0;
    virtual HRESULT getHWVirtExEnabled(BOOL *aHWVirtExEnabled) = 0;
    virtual HRESULT getHWVirtExNestedPagingEnabled(BOOL *aHWVirtExNestedPagingEnabled) = 0;
    virtual HRESULT getHWVirtExVPIDEnabled(BOOL *aHWVirtExVPIDEnabled) = 0;
    virtual HRESULT getHWVirtExUXEnabled(BOOL *aHWVirtExUXEnabled) = 0;
    virtual HRESULT getOSName(com::Utf8Str &aOSName) = 0;
    virtual HRESULT getOSVersion(com::Utf8Str &aOSVersion) = 0;
    virtual HRESULT getPAEEnabled(BOOL *aPAEEnabled) = 0;
    virtual HRESULT getVirtualTimeRate(ULONG *aVirtualTimeRate) = 0;
    virtual HRESULT setVirtualTimeRate(ULONG aVirtualTimeRate) = 0;
    virtual HRESULT getVM(LONG64 *aVM) = 0;
    virtual HRESULT getUptime(LONG64 *aUptime) = 0;
    /** @} */

    /** @name Wrapped IMachineDebugger methods
     * @{ */
    virtual HRESULT dumpGuestCore(const com::Utf8Str &aFilename,
                                  const com::Utf8Str &aCompression) = 0;
    virtual HRESULT dumpHostProcessCore(const com::Utf8Str &aFilename,
                                        const com::Utf8Str &aCompression) = 0;
    virtual HRESULT info(const com::Utf8Str &aName,
                         const com::Utf8Str &aArgs,
                         com::Utf8Str &aInfo) = 0;
    virtual HRESULT injectNMI() = 0;
    virtual HRESULT modifyLogGroups(const com::Utf8Str &aSettings) = 0;
    virtual HRESULT modifyLogFlags(const com::Utf8Str &aSettings) = 0;
    virtual HRESULT modifyLogDestinations(const com::Utf8Str &aSettings) = 0;
    virtual HRESULT readPhysicalMemory(LONG64 aAddress,
                                       ULONG aSize,
                                       std::vector<BYTE> &aBytes) = 0;
    virtual HRESULT writePhysicalMemory(LONG64 aAddress,
                                        ULONG aSize,
                                        const std::vector<BYTE> &aBytes) = 0;
    virtual HRESULT readVirtualMemory(ULONG aCpuId,
                                      LONG64 aAddress,
                                      ULONG aSize,
                                      std::vector<BYTE> &aBytes) = 0;
    virtual HRESULT writeVirtualMemory(ULONG aCpuId,
                                       LONG64 aAddress,
                                       ULONG aSize,
                                       const std::vector<BYTE> &aBytes) = 0;
    virtual HRESULT loadPlugIn(const com::Utf8Str &aName,
                               com::Utf8Str &aPlugInName) = 0;
    virtual HRESULT unloadPlugIn(const com::Utf8Str &aName) = 0;
    virtual HRESULT detectOS(com::Utf8Str &aOs) = 0;
    virtual HRESULT queryOSKernelLog(ULONG aMaxMessages,
                                     com::Utf8Str &aDmesg) = 0;
    virtual HRESULT getRegister(ULONG aCpuId,
                                const com::Utf8Str &aName,
                                com::Utf8Str &aValue) = 0;
    virtual HRESULT getRegisters(ULONG aCpuId,
                                 std::vector<com::Utf8Str> &aNames,
                                 std::vector<com::Utf8Str> &aValues) = 0;
    virtual HRESULT setRegister(ULONG aCpuId,
                                const com::Utf8Str &aName,
                                const com::Utf8Str &aValue) = 0;
    virtual HRESULT setRegisters(ULONG aCpuId,
                                 const std::vector<com::Utf8Str> &aNames,
                                 const std::vector<com::Utf8Str> &aValues) = 0;
    virtual HRESULT dumpGuestStack(ULONG aCpuId,
                                   com::Utf8Str &aStack) = 0;
    virtual HRESULT resetStats(const com::Utf8Str &aPattern) = 0;
    virtual HRESULT dumpStats(const com::Utf8Str &aPattern) = 0;
    virtual HRESULT getStats(const com::Utf8Str &aPattern,
                             BOOL aWithDescriptions,
                             com::Utf8Str &aStats) = 0;
    virtual HRESULT getCPULoad(ULONG aCpuId,
                               ULONG *aPctExecuting,
                               ULONG *aPctHalted,
                               ULONG *aPctOther,
                               LONG64 *aMsInterval) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(MachineDebuggerWrap); /* Shuts up MSC warning C4625. */

};

#endif // !MachineDebuggerWrap_H_

// ##### ENDFILE "MachineDebuggerWrap.h"


// ##### BEGINFILE "USBDeviceFiltersWrap.h"
/** @file
 * VirtualBox API class wrapper header for IUSBDeviceFilters.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef USBDeviceFiltersWrap_H_
#define USBDeviceFiltersWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE USBDeviceFiltersWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IUSBDeviceFilters)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(USBDeviceFiltersWrap, IUSBDeviceFilters)
    DECLARE_NOT_AGGREGATABLE(USBDeviceFiltersWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(USBDeviceFiltersWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IUSBDeviceFilters)
        COM_INTERFACE_ENTRY2(IDispatch, IUSBDeviceFilters)
        VBOX_TWEAK_INTERFACE_ENTRY(IUSBDeviceFilters)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(USBDeviceFiltersWrap)

    /** @name Public IUSBDeviceFilters properties
     * @{ */
    STDMETHOD(COMGETTER(DeviceFilters))(ComSafeArrayOut(IUSBDeviceFilter *, aDeviceFilters));
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IUSBDeviceFilters))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IUSBDeviceFilters))(ULONG *aReserved);
    /** @} */

    /** @name Public IUSBDeviceFilters methods
     * @{ */
    STDMETHOD(CreateDeviceFilter)(IN_BSTR aName,
                                  IUSBDeviceFilter **aFilter);
    STDMETHOD(InsertDeviceFilter)(ULONG aPosition,
                                  IUSBDeviceFilter *aFilter);
    STDMETHOD(RemoveDeviceFilter)(ULONG aPosition,
                                  IUSBDeviceFilter **aFilter);
    STDMETHOD(InternalAndReservedMethod1IUSBDeviceFilters)();
    STDMETHOD(InternalAndReservedMethod2IUSBDeviceFilters)();
    /** @} */

private:
    /** @name Wrapped IUSBDeviceFilters properties
     * @{ */
    virtual HRESULT getDeviceFilters(std::vector<ComPtr<IUSBDeviceFilter> > &aDeviceFilters) = 0;
    /** @} */

    /** @name Wrapped IUSBDeviceFilters methods
     * @{ */
    virtual HRESULT createDeviceFilter(const com::Utf8Str &aName,
                                       ComPtr<IUSBDeviceFilter> &aFilter) = 0;
    virtual HRESULT insertDeviceFilter(ULONG aPosition,
                                       const ComPtr<IUSBDeviceFilter> &aFilter) = 0;
    virtual HRESULT removeDeviceFilter(ULONG aPosition,
                                       ComPtr<IUSBDeviceFilter> &aFilter) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(USBDeviceFiltersWrap); /* Shuts up MSC warning C4625. */

};

#endif // !USBDeviceFiltersWrap_H_

// ##### ENDFILE "USBDeviceFiltersWrap.h"


// ##### BEGINFILE "USBControllerWrap.h"
/** @file
 * VirtualBox API class wrapper header for IUSBController.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef USBControllerWrap_H_
#define USBControllerWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE USBControllerWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IUSBController)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(USBControllerWrap, IUSBController)
    DECLARE_NOT_AGGREGATABLE(USBControllerWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(USBControllerWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IUSBController)
        COM_INTERFACE_ENTRY2(IDispatch, IUSBController)
        VBOX_TWEAK_INTERFACE_ENTRY(IUSBController)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(USBControllerWrap)

    /** @name Public IUSBController properties
     * @{ */
    STDMETHOD(COMGETTER(Name))(BSTR *aName);
    STDMETHOD(COMSETTER(Name))(IN_BSTR aName);
    STDMETHOD(COMGETTER(Type))(USBControllerType_T *aType);
    STDMETHOD(COMSETTER(Type))(USBControllerType_T aType);
    STDMETHOD(COMGETTER(USBStandard))(USHORT *aUSBStandard);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IUSBController))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IUSBController))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IUSBController))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IUSBController))(ULONG *aReserved);
    /** @} */

    /** @name Public IUSBController methods
     * @{ */
    /** @} */

private:
    /** @name Wrapped IUSBController properties
     * @{ */
    virtual HRESULT getName(com::Utf8Str &aName) = 0;
    virtual HRESULT setName(const com::Utf8Str &aName) = 0;
    virtual HRESULT getType(USBControllerType_T *aType) = 0;
    virtual HRESULT setType(USBControllerType_T aType) = 0;
    virtual HRESULT getUSBStandard(USHORT *aUSBStandard) = 0;
    /** @} */

    /** @name Wrapped IUSBController methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(USBControllerWrap); /* Shuts up MSC warning C4625. */

};

#endif // !USBControllerWrap_H_

// ##### ENDFILE "USBControllerWrap.h"


// ##### BEGINFILE "USBDeviceWrap.h"
/** @file
 * VirtualBox API class wrapper header for IUSBDevice.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef USBDeviceWrap_H_
#define USBDeviceWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE USBDeviceWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IUSBDevice)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(USBDeviceWrap, IUSBDevice)
    DECLARE_NOT_AGGREGATABLE(USBDeviceWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(USBDeviceWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IUSBDevice)
        COM_INTERFACE_ENTRY2(IDispatch, IUSBDevice)
        VBOX_TWEAK_INTERFACE_ENTRY(IUSBDevice)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(USBDeviceWrap)

    /** @name Public IUSBDevice properties
     * @{ */
    STDMETHOD(COMGETTER(Id))(BSTR *aId);
    STDMETHOD(COMGETTER(VendorId))(USHORT *aVendorId);
    STDMETHOD(COMGETTER(ProductId))(USHORT *aProductId);
    STDMETHOD(COMGETTER(Revision))(USHORT *aRevision);
    STDMETHOD(COMGETTER(Manufacturer))(BSTR *aManufacturer);
    STDMETHOD(COMGETTER(Product))(BSTR *aProduct);
    STDMETHOD(COMGETTER(SerialNumber))(BSTR *aSerialNumber);
    STDMETHOD(COMGETTER(Address))(BSTR *aAddress);
    STDMETHOD(COMGETTER(Port))(USHORT *aPort);
    STDMETHOD(COMGETTER(PortPath))(BSTR *aPortPath);
    STDMETHOD(COMGETTER(Version))(USHORT *aVersion);
    STDMETHOD(COMGETTER(Speed))(USBConnectionSpeed_T *aSpeed);
    STDMETHOD(COMGETTER(Remote))(BOOL *aRemote);
    STDMETHOD(COMGETTER(DeviceInfo))(ComSafeArrayOut(BSTR, aDeviceInfo));
    STDMETHOD(COMGETTER(Backend))(BSTR *aBackend);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IUSBDevice))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IUSBDevice))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IUSBDevice))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IUSBDevice))(ULONG *aReserved);
    /** @} */

    /** @name Public IUSBDevice methods
     * @{ */
    /** @} */

private:
    /** @name Wrapped IUSBDevice properties
     * @{ */
    virtual HRESULT getId(com::Guid &aId) = 0;
    virtual HRESULT getVendorId(USHORT *aVendorId) = 0;
    virtual HRESULT getProductId(USHORT *aProductId) = 0;
    virtual HRESULT getRevision(USHORT *aRevision) = 0;
    virtual HRESULT getManufacturer(com::Utf8Str &aManufacturer) = 0;
    virtual HRESULT getProduct(com::Utf8Str &aProduct) = 0;
    virtual HRESULT getSerialNumber(com::Utf8Str &aSerialNumber) = 0;
    virtual HRESULT getAddress(com::Utf8Str &aAddress) = 0;
    virtual HRESULT getPort(USHORT *aPort) = 0;
    virtual HRESULT getPortPath(com::Utf8Str &aPortPath) = 0;
    virtual HRESULT getVersion(USHORT *aVersion) = 0;
    virtual HRESULT getSpeed(USBConnectionSpeed_T *aSpeed) = 0;
    virtual HRESULT getRemote(BOOL *aRemote) = 0;
    virtual HRESULT getDeviceInfo(std::vector<com::Utf8Str> &aDeviceInfo) = 0;
    virtual HRESULT getBackend(com::Utf8Str &aBackend) = 0;
    /** @} */

    /** @name Wrapped IUSBDevice methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(USBDeviceWrap); /* Shuts up MSC warning C4625. */

};

#endif // !USBDeviceWrap_H_

// ##### ENDFILE "USBDeviceWrap.h"


// ##### BEGINFILE "USBDeviceFilterWrap.h"
/** @file
 * VirtualBox API class wrapper header for IUSBDeviceFilter.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef USBDeviceFilterWrap_H_
#define USBDeviceFilterWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE USBDeviceFilterWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IUSBDeviceFilter)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(USBDeviceFilterWrap, IUSBDeviceFilter)
    DECLARE_NOT_AGGREGATABLE(USBDeviceFilterWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(USBDeviceFilterWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IUSBDeviceFilter)
        COM_INTERFACE_ENTRY2(IDispatch, IUSBDeviceFilter)
        VBOX_TWEAK_INTERFACE_ENTRY(IUSBDeviceFilter)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(USBDeviceFilterWrap)

    /** @name Public IUSBDeviceFilter properties
     * @{ */
    STDMETHOD(COMGETTER(Name))(BSTR *aName);
    STDMETHOD(COMSETTER(Name))(IN_BSTR aName);
    STDMETHOD(COMGETTER(Active))(BOOL *aActive);
    STDMETHOD(COMSETTER(Active))(BOOL aActive);
    STDMETHOD(COMGETTER(VendorId))(BSTR *aVendorId);
    STDMETHOD(COMSETTER(VendorId))(IN_BSTR aVendorId);
    STDMETHOD(COMGETTER(ProductId))(BSTR *aProductId);
    STDMETHOD(COMSETTER(ProductId))(IN_BSTR aProductId);
    STDMETHOD(COMGETTER(Revision))(BSTR *aRevision);
    STDMETHOD(COMSETTER(Revision))(IN_BSTR aRevision);
    STDMETHOD(COMGETTER(Manufacturer))(BSTR *aManufacturer);
    STDMETHOD(COMSETTER(Manufacturer))(IN_BSTR aManufacturer);
    STDMETHOD(COMGETTER(Product))(BSTR *aProduct);
    STDMETHOD(COMSETTER(Product))(IN_BSTR aProduct);
    STDMETHOD(COMGETTER(SerialNumber))(BSTR *aSerialNumber);
    STDMETHOD(COMSETTER(SerialNumber))(IN_BSTR aSerialNumber);
    STDMETHOD(COMGETTER(Port))(BSTR *aPort);
    STDMETHOD(COMSETTER(Port))(IN_BSTR aPort);
    STDMETHOD(COMGETTER(Remote))(BSTR *aRemote);
    STDMETHOD(COMSETTER(Remote))(IN_BSTR aRemote);
    STDMETHOD(COMGETTER(MaskedInterfaces))(ULONG *aMaskedInterfaces);
    STDMETHOD(COMSETTER(MaskedInterfaces))(ULONG aMaskedInterfaces);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IUSBDeviceFilter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IUSBDeviceFilter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IUSBDeviceFilter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IUSBDeviceFilter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IUSBDeviceFilter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IUSBDeviceFilter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IUSBDeviceFilter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IUSBDeviceFilter))(ULONG *aReserved);
    /** @} */

    /** @name Public IUSBDeviceFilter methods
     * @{ */
    /** @} */

private:
    /** @name Wrapped IUSBDeviceFilter properties
     * @{ */
    virtual HRESULT getName(com::Utf8Str &aName) = 0;
    virtual HRESULT setName(const com::Utf8Str &aName) = 0;
    virtual HRESULT getActive(BOOL *aActive) = 0;
    virtual HRESULT setActive(BOOL aActive) = 0;
    virtual HRESULT getVendorId(com::Utf8Str &aVendorId) = 0;
    virtual HRESULT setVendorId(const com::Utf8Str &aVendorId) = 0;
    virtual HRESULT getProductId(com::Utf8Str &aProductId) = 0;
    virtual HRESULT setProductId(const com::Utf8Str &aProductId) = 0;
    virtual HRESULT getRevision(com::Utf8Str &aRevision) = 0;
    virtual HRESULT setRevision(const com::Utf8Str &aRevision) = 0;
    virtual HRESULT getManufacturer(com::Utf8Str &aManufacturer) = 0;
    virtual HRESULT setManufacturer(const com::Utf8Str &aManufacturer) = 0;
    virtual HRESULT getProduct(com::Utf8Str &aProduct) = 0;
    virtual HRESULT setProduct(const com::Utf8Str &aProduct) = 0;
    virtual HRESULT getSerialNumber(com::Utf8Str &aSerialNumber) = 0;
    virtual HRESULT setSerialNumber(const com::Utf8Str &aSerialNumber) = 0;
    virtual HRESULT getPort(com::Utf8Str &aPort) = 0;
    virtual HRESULT setPort(const com::Utf8Str &aPort) = 0;
    virtual HRESULT getRemote(com::Utf8Str &aRemote) = 0;
    virtual HRESULT setRemote(const com::Utf8Str &aRemote) = 0;
    virtual HRESULT getMaskedInterfaces(ULONG *aMaskedInterfaces) = 0;
    virtual HRESULT setMaskedInterfaces(ULONG aMaskedInterfaces) = 0;
    /** @} */

    /** @name Wrapped IUSBDeviceFilter methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(USBDeviceFilterWrap); /* Shuts up MSC warning C4625. */

};

#endif // !USBDeviceFilterWrap_H_

// ##### ENDFILE "USBDeviceFilterWrap.h"


// ##### BEGINFILE "HostUSBDeviceWrap.h"
/** @file
 * VirtualBox API class wrapper header for IHostUSBDevice.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef HostUSBDeviceWrap_H_
#define HostUSBDeviceWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE HostUSBDeviceWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IHostUSBDevice)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(HostUSBDeviceWrap, IHostUSBDevice)
    DECLARE_NOT_AGGREGATABLE(HostUSBDeviceWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(HostUSBDeviceWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IHostUSBDevice)
        COM_INTERFACE_ENTRY(IUSBDevice)
        COM_INTERFACE_ENTRY2(IDispatch, IHostUSBDevice)
        VBOX_TWEAK_INTERFACE_ENTRY(IHostUSBDevice)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(HostUSBDeviceWrap)

    /** @name Public IUSBDevice properties
     * @{ */
    STDMETHOD(COMGETTER(Id))(BSTR *aId);
    STDMETHOD(COMGETTER(VendorId))(USHORT *aVendorId);
    STDMETHOD(COMGETTER(ProductId))(USHORT *aProductId);
    STDMETHOD(COMGETTER(Revision))(USHORT *aRevision);
    STDMETHOD(COMGETTER(Manufacturer))(BSTR *aManufacturer);
    STDMETHOD(COMGETTER(Product))(BSTR *aProduct);
    STDMETHOD(COMGETTER(SerialNumber))(BSTR *aSerialNumber);
    STDMETHOD(COMGETTER(Address))(BSTR *aAddress);
    STDMETHOD(COMGETTER(Port))(USHORT *aPort);
    STDMETHOD(COMGETTER(PortPath))(BSTR *aPortPath);
    STDMETHOD(COMGETTER(Version))(USHORT *aVersion);
    STDMETHOD(COMGETTER(Speed))(USBConnectionSpeed_T *aSpeed);
    STDMETHOD(COMGETTER(Remote))(BOOL *aRemote);
    STDMETHOD(COMGETTER(DeviceInfo))(ComSafeArrayOut(BSTR, aDeviceInfo));
    STDMETHOD(COMGETTER(Backend))(BSTR *aBackend);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IUSBDevice))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IUSBDevice))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IUSBDevice))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IUSBDevice))(ULONG *aReserved);
    /** @} */

    /** @name Public IHostUSBDevice properties
     * @{ */
    STDMETHOD(COMGETTER(State))(USBDeviceState_T *aState);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IHostUSBDevice))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IHostUSBDevice))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IHostUSBDevice))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IHostUSBDevice))(ULONG *aReserved);
    /** @} */

    /** @name Public IUSBDevice methods
     * @{ */
    /** @} */

    /** @name Public IHostUSBDevice methods
     * @{ */
    /** @} */

private:
    /** @name Wrapped IUSBDevice properties
     * @{ */
    virtual HRESULT getId(com::Guid &aId) = 0;
    virtual HRESULT getVendorId(USHORT *aVendorId) = 0;
    virtual HRESULT getProductId(USHORT *aProductId) = 0;
    virtual HRESULT getRevision(USHORT *aRevision) = 0;
    virtual HRESULT getManufacturer(com::Utf8Str &aManufacturer) = 0;
    virtual HRESULT getProduct(com::Utf8Str &aProduct) = 0;
    virtual HRESULT getSerialNumber(com::Utf8Str &aSerialNumber) = 0;
    virtual HRESULT getAddress(com::Utf8Str &aAddress) = 0;
    virtual HRESULT getPort(USHORT *aPort) = 0;
    virtual HRESULT getPortPath(com::Utf8Str &aPortPath) = 0;
    virtual HRESULT getVersion(USHORT *aVersion) = 0;
    virtual HRESULT getSpeed(USBConnectionSpeed_T *aSpeed) = 0;
    virtual HRESULT getRemote(BOOL *aRemote) = 0;
    virtual HRESULT getDeviceInfo(std::vector<com::Utf8Str> &aDeviceInfo) = 0;
    virtual HRESULT getBackend(com::Utf8Str &aBackend) = 0;
    /** @} */

    /** @name Wrapped IHostUSBDevice properties
     * @{ */
    virtual HRESULT getState(USBDeviceState_T *aState) = 0;
    /** @} */

    /** @name Wrapped IUSBDevice methods
     * @{ */
    /** @} */

    /** @name Wrapped IHostUSBDevice methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(HostUSBDeviceWrap); /* Shuts up MSC warning C4625. */

};

#endif // !HostUSBDeviceWrap_H_

// ##### ENDFILE "HostUSBDeviceWrap.h"


// ##### BEGINFILE "HostUSBDeviceFilterWrap.h"
/** @file
 * VirtualBox API class wrapper header for IHostUSBDeviceFilter.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef HostUSBDeviceFilterWrap_H_
#define HostUSBDeviceFilterWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE HostUSBDeviceFilterWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IHostUSBDeviceFilter)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(HostUSBDeviceFilterWrap, IHostUSBDeviceFilter)
    DECLARE_NOT_AGGREGATABLE(HostUSBDeviceFilterWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(HostUSBDeviceFilterWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IHostUSBDeviceFilter)
        COM_INTERFACE_ENTRY(IUSBDeviceFilter)
        COM_INTERFACE_ENTRY2(IDispatch, IHostUSBDeviceFilter)
        VBOX_TWEAK_INTERFACE_ENTRY(IHostUSBDeviceFilter)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(HostUSBDeviceFilterWrap)

    /** @name Public IUSBDeviceFilter properties
     * @{ */
    STDMETHOD(COMGETTER(Name))(BSTR *aName);
    STDMETHOD(COMSETTER(Name))(IN_BSTR aName);
    STDMETHOD(COMGETTER(Active))(BOOL *aActive);
    STDMETHOD(COMSETTER(Active))(BOOL aActive);
    STDMETHOD(COMGETTER(VendorId))(BSTR *aVendorId);
    STDMETHOD(COMSETTER(VendorId))(IN_BSTR aVendorId);
    STDMETHOD(COMGETTER(ProductId))(BSTR *aProductId);
    STDMETHOD(COMSETTER(ProductId))(IN_BSTR aProductId);
    STDMETHOD(COMGETTER(Revision))(BSTR *aRevision);
    STDMETHOD(COMSETTER(Revision))(IN_BSTR aRevision);
    STDMETHOD(COMGETTER(Manufacturer))(BSTR *aManufacturer);
    STDMETHOD(COMSETTER(Manufacturer))(IN_BSTR aManufacturer);
    STDMETHOD(COMGETTER(Product))(BSTR *aProduct);
    STDMETHOD(COMSETTER(Product))(IN_BSTR aProduct);
    STDMETHOD(COMGETTER(SerialNumber))(BSTR *aSerialNumber);
    STDMETHOD(COMSETTER(SerialNumber))(IN_BSTR aSerialNumber);
    STDMETHOD(COMGETTER(Port))(BSTR *aPort);
    STDMETHOD(COMSETTER(Port))(IN_BSTR aPort);
    STDMETHOD(COMGETTER(Remote))(BSTR *aRemote);
    STDMETHOD(COMSETTER(Remote))(IN_BSTR aRemote);
    STDMETHOD(COMGETTER(MaskedInterfaces))(ULONG *aMaskedInterfaces);
    STDMETHOD(COMSETTER(MaskedInterfaces))(ULONG aMaskedInterfaces);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IUSBDeviceFilter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IUSBDeviceFilter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IUSBDeviceFilter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IUSBDeviceFilter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IUSBDeviceFilter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IUSBDeviceFilter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IUSBDeviceFilter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IUSBDeviceFilter))(ULONG *aReserved);
    /** @} */

    /** @name Public IHostUSBDeviceFilter properties
     * @{ */
    STDMETHOD(COMGETTER(Action))(USBDeviceFilterAction_T *aAction);
    STDMETHOD(COMSETTER(Action))(USBDeviceFilterAction_T aAction);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IHostUSBDeviceFilter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IHostUSBDeviceFilter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IHostUSBDeviceFilter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IHostUSBDeviceFilter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IHostUSBDeviceFilter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IHostUSBDeviceFilter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IHostUSBDeviceFilter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IHostUSBDeviceFilter))(ULONG *aReserved);
    /** @} */

    /** @name Public IUSBDeviceFilter methods
     * @{ */
    /** @} */

    /** @name Public IHostUSBDeviceFilter methods
     * @{ */
    /** @} */

private:
    /** @name Wrapped IUSBDeviceFilter properties
     * @{ */
    virtual HRESULT getName(com::Utf8Str &aName) = 0;
    virtual HRESULT setName(const com::Utf8Str &aName) = 0;
    virtual HRESULT getActive(BOOL *aActive) = 0;
    virtual HRESULT setActive(BOOL aActive) = 0;
    virtual HRESULT getVendorId(com::Utf8Str &aVendorId) = 0;
    virtual HRESULT setVendorId(const com::Utf8Str &aVendorId) = 0;
    virtual HRESULT getProductId(com::Utf8Str &aProductId) = 0;
    virtual HRESULT setProductId(const com::Utf8Str &aProductId) = 0;
    virtual HRESULT getRevision(com::Utf8Str &aRevision) = 0;
    virtual HRESULT setRevision(const com::Utf8Str &aRevision) = 0;
    virtual HRESULT getManufacturer(com::Utf8Str &aManufacturer) = 0;
    virtual HRESULT setManufacturer(const com::Utf8Str &aManufacturer) = 0;
    virtual HRESULT getProduct(com::Utf8Str &aProduct) = 0;
    virtual HRESULT setProduct(const com::Utf8Str &aProduct) = 0;
    virtual HRESULT getSerialNumber(com::Utf8Str &aSerialNumber) = 0;
    virtual HRESULT setSerialNumber(const com::Utf8Str &aSerialNumber) = 0;
    virtual HRESULT getPort(com::Utf8Str &aPort) = 0;
    virtual HRESULT setPort(const com::Utf8Str &aPort) = 0;
    virtual HRESULT getRemote(com::Utf8Str &aRemote) = 0;
    virtual HRESULT setRemote(const com::Utf8Str &aRemote) = 0;
    virtual HRESULT getMaskedInterfaces(ULONG *aMaskedInterfaces) = 0;
    virtual HRESULT setMaskedInterfaces(ULONG aMaskedInterfaces) = 0;
    /** @} */

    /** @name Wrapped IHostUSBDeviceFilter properties
     * @{ */
    virtual HRESULT getAction(USBDeviceFilterAction_T *aAction) = 0;
    virtual HRESULT setAction(USBDeviceFilterAction_T aAction) = 0;
    /** @} */

    /** @name Wrapped IUSBDeviceFilter methods
     * @{ */
    /** @} */

    /** @name Wrapped IHostUSBDeviceFilter methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(HostUSBDeviceFilterWrap); /* Shuts up MSC warning C4625. */

};

#endif // !HostUSBDeviceFilterWrap_H_

// ##### ENDFILE "HostUSBDeviceFilterWrap.h"


// ##### BEGINFILE "USBProxyBackendWrap.h"
/** @file
 * VirtualBox API class wrapper header for IUSBProxyBackend.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef USBProxyBackendWrap_H_
#define USBProxyBackendWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE USBProxyBackendWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IUSBProxyBackend)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(USBProxyBackendWrap, IUSBProxyBackend)
    DECLARE_NOT_AGGREGATABLE(USBProxyBackendWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(USBProxyBackendWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IUSBProxyBackend)
        COM_INTERFACE_ENTRY2(IDispatch, IUSBProxyBackend)
        VBOX_TWEAK_INTERFACE_ENTRY(IUSBProxyBackend)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(USBProxyBackendWrap)

    /** @name Public IUSBProxyBackend properties
     * @{ */
    STDMETHOD(COMGETTER(Name))(BSTR *aName);
    STDMETHOD(COMGETTER(Type))(BSTR *aType);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IUSBProxyBackend))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IUSBProxyBackend))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IUSBProxyBackend))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IUSBProxyBackend))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IUSBProxyBackend))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IUSBProxyBackend))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IUSBProxyBackend))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IUSBProxyBackend))(ULONG *aReserved);
    /** @} */

    /** @name Public IUSBProxyBackend methods
     * @{ */
    STDMETHOD(InternalAndReservedMethod1IUSBProxyBackend)();
    STDMETHOD(InternalAndReservedMethod2IUSBProxyBackend)();
    STDMETHOD(InternalAndReservedMethod3IUSBProxyBackend)();
    STDMETHOD(InternalAndReservedMethod4IUSBProxyBackend)();
    /** @} */

private:
    /** @name Wrapped IUSBProxyBackend properties
     * @{ */
    virtual HRESULT getName(com::Utf8Str &aName) = 0;
    virtual HRESULT getType(com::Utf8Str &aType) = 0;
    /** @} */

    /** @name Wrapped IUSBProxyBackend methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(USBProxyBackendWrap); /* Shuts up MSC warning C4625. */

};

#endif // !USBProxyBackendWrap_H_

// ##### ENDFILE "USBProxyBackendWrap.h"


// ##### BEGINFILE "AudioAdapterWrap.h"
/** @file
 * VirtualBox API class wrapper header for IAudioAdapter.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef AudioAdapterWrap_H_
#define AudioAdapterWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE AudioAdapterWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IAudioAdapter)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(AudioAdapterWrap, IAudioAdapter)
    DECLARE_NOT_AGGREGATABLE(AudioAdapterWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(AudioAdapterWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IAudioAdapter)
        COM_INTERFACE_ENTRY2(IDispatch, IAudioAdapter)
        VBOX_TWEAK_INTERFACE_ENTRY(IAudioAdapter)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(AudioAdapterWrap)

    /** @name Public IAudioAdapter properties
     * @{ */
    STDMETHOD(COMGETTER(Enabled))(BOOL *aEnabled);
    STDMETHOD(COMSETTER(Enabled))(BOOL aEnabled);
    STDMETHOD(COMGETTER(EnabledIn))(BOOL *aEnabledIn);
    STDMETHOD(COMSETTER(EnabledIn))(BOOL aEnabledIn);
    STDMETHOD(COMGETTER(EnabledOut))(BOOL *aEnabledOut);
    STDMETHOD(COMSETTER(EnabledOut))(BOOL aEnabledOut);
    STDMETHOD(COMGETTER(AudioController))(AudioControllerType_T *aAudioController);
    STDMETHOD(COMSETTER(AudioController))(AudioControllerType_T aAudioController);
    STDMETHOD(COMGETTER(AudioCodec))(AudioCodecType_T *aAudioCodec);
    STDMETHOD(COMSETTER(AudioCodec))(AudioCodecType_T aAudioCodec);
    STDMETHOD(COMGETTER(AudioDriver))(AudioDriverType_T *aAudioDriver);
    STDMETHOD(COMSETTER(AudioDriver))(AudioDriverType_T aAudioDriver);
    STDMETHOD(COMGETTER(PropertiesList))(ComSafeArrayOut(BSTR, aPropertiesList));
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IAudioAdapter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IAudioAdapter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IAudioAdapter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IAudioAdapter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IAudioAdapter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IAudioAdapter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IAudioAdapter))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IAudioAdapter))(ULONG *aReserved);
    /** @} */

    /** @name Public IAudioAdapter methods
     * @{ */
    STDMETHOD(SetProperty)(IN_BSTR aKey,
                           IN_BSTR aValue);
    STDMETHOD(GetProperty)(IN_BSTR aKey,
                           BSTR *aValue);
    STDMETHOD(InternalAndReservedMethod1IAudioAdapter)();
    STDMETHOD(InternalAndReservedMethod2IAudioAdapter)();
    STDMETHOD(InternalAndReservedMethod3IAudioAdapter)();
    STDMETHOD(InternalAndReservedMethod4IAudioAdapter)();
    /** @} */

private:
    /** @name Wrapped IAudioAdapter properties
     * @{ */
    virtual HRESULT getEnabled(BOOL *aEnabled) = 0;
    virtual HRESULT setEnabled(BOOL aEnabled) = 0;
    virtual HRESULT getEnabledIn(BOOL *aEnabledIn) = 0;
    virtual HRESULT setEnabledIn(BOOL aEnabledIn) = 0;
    virtual HRESULT getEnabledOut(BOOL *aEnabledOut) = 0;
    virtual HRESULT setEnabledOut(BOOL aEnabledOut) = 0;
    virtual HRESULT getAudioController(AudioControllerType_T *aAudioController) = 0;
    virtual HRESULT setAudioController(AudioControllerType_T aAudioController) = 0;
    virtual HRESULT getAudioCodec(AudioCodecType_T *aAudioCodec) = 0;
    virtual HRESULT setAudioCodec(AudioCodecType_T aAudioCodec) = 0;
    virtual HRESULT getAudioDriver(AudioDriverType_T *aAudioDriver) = 0;
    virtual HRESULT setAudioDriver(AudioDriverType_T aAudioDriver) = 0;
    virtual HRESULT getPropertiesList(std::vector<com::Utf8Str> &aPropertiesList) = 0;
    /** @} */

    /** @name Wrapped IAudioAdapter methods
     * @{ */
    virtual HRESULT setProperty(const com::Utf8Str &aKey,
                                const com::Utf8Str &aValue) = 0;
    virtual HRESULT getProperty(const com::Utf8Str &aKey,
                                com::Utf8Str &aValue) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(AudioAdapterWrap); /* Shuts up MSC warning C4625. */

};

#endif // !AudioAdapterWrap_H_

// ##### ENDFILE "AudioAdapterWrap.h"


// ##### BEGINFILE "VRDEServerWrap.h"
/** @file
 * VirtualBox API class wrapper header for IVRDEServer.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef VRDEServerWrap_H_
#define VRDEServerWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE VRDEServerWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IVRDEServer)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(VRDEServerWrap, IVRDEServer)
    DECLARE_NOT_AGGREGATABLE(VRDEServerWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(VRDEServerWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IVRDEServer)
        COM_INTERFACE_ENTRY2(IDispatch, IVRDEServer)
        VBOX_TWEAK_INTERFACE_ENTRY(IVRDEServer)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(VRDEServerWrap)

    /** @name Public IVRDEServer properties
     * @{ */
    STDMETHOD(COMGETTER(Enabled))(BOOL *aEnabled);
    STDMETHOD(COMSETTER(Enabled))(BOOL aEnabled);
    STDMETHOD(COMGETTER(AuthType))(AuthType_T *aAuthType);
    STDMETHOD(COMSETTER(AuthType))(AuthType_T aAuthType);
    STDMETHOD(COMGETTER(AuthTimeout))(ULONG *aAuthTimeout);
    STDMETHOD(COMSETTER(AuthTimeout))(ULONG aAuthTimeout);
    STDMETHOD(COMGETTER(AllowMultiConnection))(BOOL *aAllowMultiConnection);
    STDMETHOD(COMSETTER(AllowMultiConnection))(BOOL aAllowMultiConnection);
    STDMETHOD(COMGETTER(ReuseSingleConnection))(BOOL *aReuseSingleConnection);
    STDMETHOD(COMSETTER(ReuseSingleConnection))(BOOL aReuseSingleConnection);
    STDMETHOD(COMGETTER(VRDEExtPack))(BSTR *aVRDEExtPack);
    STDMETHOD(COMSETTER(VRDEExtPack))(IN_BSTR aVRDEExtPack);
    STDMETHOD(COMGETTER(AuthLibrary))(BSTR *aAuthLibrary);
    STDMETHOD(COMSETTER(AuthLibrary))(IN_BSTR aAuthLibrary);
    STDMETHOD(COMGETTER(VRDEProperties))(ComSafeArrayOut(BSTR, aVRDEProperties));
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IVRDEServer))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IVRDEServer))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IVRDEServer))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IVRDEServer))(ULONG *aReserved);
    /** @} */

    /** @name Public IVRDEServer methods
     * @{ */
    STDMETHOD(SetVRDEProperty)(IN_BSTR aKey,
                               IN_BSTR aValue);
    STDMETHOD(GetVRDEProperty)(IN_BSTR aKey,
                               BSTR *aValue);
    STDMETHOD(InternalAndReservedMethod1IVRDEServer)();
    STDMETHOD(InternalAndReservedMethod2IVRDEServer)();
    /** @} */

private:
    /** @name Wrapped IVRDEServer properties
     * @{ */
    virtual HRESULT getEnabled(BOOL *aEnabled) = 0;
    virtual HRESULT setEnabled(BOOL aEnabled) = 0;
    virtual HRESULT getAuthType(AuthType_T *aAuthType) = 0;
    virtual HRESULT setAuthType(AuthType_T aAuthType) = 0;
    virtual HRESULT getAuthTimeout(ULONG *aAuthTimeout) = 0;
    virtual HRESULT setAuthTimeout(ULONG aAuthTimeout) = 0;
    virtual HRESULT getAllowMultiConnection(BOOL *aAllowMultiConnection) = 0;
    virtual HRESULT setAllowMultiConnection(BOOL aAllowMultiConnection) = 0;
    virtual HRESULT getReuseSingleConnection(BOOL *aReuseSingleConnection) = 0;
    virtual HRESULT setReuseSingleConnection(BOOL aReuseSingleConnection) = 0;
    virtual HRESULT getVRDEExtPack(com::Utf8Str &aVRDEExtPack) = 0;
    virtual HRESULT setVRDEExtPack(const com::Utf8Str &aVRDEExtPack) = 0;
    virtual HRESULT getAuthLibrary(com::Utf8Str &aAuthLibrary) = 0;
    virtual HRESULT setAuthLibrary(const com::Utf8Str &aAuthLibrary) = 0;
    virtual HRESULT getVRDEProperties(std::vector<com::Utf8Str> &aVRDEProperties) = 0;
    /** @} */

    /** @name Wrapped IVRDEServer methods
     * @{ */
    virtual HRESULT setVRDEProperty(const com::Utf8Str &aKey,
                                    const com::Utf8Str &aValue) = 0;
    virtual HRESULT getVRDEProperty(const com::Utf8Str &aKey,
                                    com::Utf8Str &aValue) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(VRDEServerWrap); /* Shuts up MSC warning C4625. */

};

#endif // !VRDEServerWrap_H_

// ##### ENDFILE "VRDEServerWrap.h"


// ##### BEGINFILE "SharedFolderWrap.h"
/** @file
 * VirtualBox API class wrapper header for ISharedFolder.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef SharedFolderWrap_H_
#define SharedFolderWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE SharedFolderWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(ISharedFolder)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(SharedFolderWrap, ISharedFolder)
    DECLARE_NOT_AGGREGATABLE(SharedFolderWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(SharedFolderWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(ISharedFolder)
        COM_INTERFACE_ENTRY2(IDispatch, ISharedFolder)
        VBOX_TWEAK_INTERFACE_ENTRY(ISharedFolder)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(SharedFolderWrap)

    /** @name Public ISharedFolder properties
     * @{ */
    STDMETHOD(COMGETTER(Name))(BSTR *aName);
    STDMETHOD(COMGETTER(HostPath))(BSTR *aHostPath);
    STDMETHOD(COMGETTER(Accessible))(BOOL *aAccessible);
    STDMETHOD(COMGETTER(Writable))(BOOL *aWritable);
    STDMETHOD(COMSETTER(Writable))(BOOL aWritable);
    STDMETHOD(COMGETTER(AutoMount))(BOOL *aAutoMount);
    STDMETHOD(COMSETTER(AutoMount))(BOOL aAutoMount);
    STDMETHOD(COMGETTER(AutoMountPoint))(BSTR *aAutoMountPoint);
    STDMETHOD(COMSETTER(AutoMountPoint))(IN_BSTR aAutoMountPoint);
    STDMETHOD(COMGETTER(LastAccessError))(BSTR *aLastAccessError);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1ISharedFolder))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2ISharedFolder))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3ISharedFolder))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4ISharedFolder))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5ISharedFolder))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6ISharedFolder))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7ISharedFolder))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8ISharedFolder))(ULONG *aReserved);
    /** @} */

    /** @name Public ISharedFolder methods
     * @{ */
    /** @} */

private:
    /** @name Wrapped ISharedFolder properties
     * @{ */
    virtual HRESULT getName(com::Utf8Str &aName) = 0;
    virtual HRESULT getHostPath(com::Utf8Str &aHostPath) = 0;
    virtual HRESULT getAccessible(BOOL *aAccessible) = 0;
    virtual HRESULT getWritable(BOOL *aWritable) = 0;
    virtual HRESULT setWritable(BOOL aWritable) = 0;
    virtual HRESULT getAutoMount(BOOL *aAutoMount) = 0;
    virtual HRESULT setAutoMount(BOOL aAutoMount) = 0;
    virtual HRESULT getAutoMountPoint(com::Utf8Str &aAutoMountPoint) = 0;
    virtual HRESULT setAutoMountPoint(const com::Utf8Str &aAutoMountPoint) = 0;
    virtual HRESULT getLastAccessError(com::Utf8Str &aLastAccessError) = 0;
    /** @} */

    /** @name Wrapped ISharedFolder methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(SharedFolderWrap); /* Shuts up MSC warning C4625. */

};

#endif // !SharedFolderWrap_H_

// ##### ENDFILE "SharedFolderWrap.h"


// ##### BEGINFILE "SessionWrap.h"
/** @file
 * VirtualBox API class wrapper header for ISession.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef SessionWrap_H_
#define SessionWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE SessionWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(ISession)
    , VBOX_SCRIPTABLE_IMPL(IInternalSessionControl)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(SessionWrap, ISession)
    DECLARE_NOT_AGGREGATABLE(SessionWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(SessionWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(ISession)
        COM_INTERFACE_ENTRY2(IDispatch, ISession)
        COM_INTERFACE_ENTRY(IInternalSessionControl)
        VBOX_TWEAK_INTERFACE_ENTRY(ISession)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(SessionWrap)

    /** @name Public ISession properties
     * @{ */
    STDMETHOD(COMGETTER(State))(SessionState_T *aState);
    STDMETHOD(COMGETTER(Type))(SessionType_T *aType);
    STDMETHOD(COMGETTER(Name))(BSTR *aName);
    STDMETHOD(COMSETTER(Name))(IN_BSTR aName);
    STDMETHOD(COMGETTER(Machine))(IMachine **aMachine);
    STDMETHOD(COMGETTER(Console))(IConsole **aConsole);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1ISession))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2ISession))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3ISession))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4ISession))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5ISession))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6ISession))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7ISession))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8ISession))(ULONG *aReserved);
    /** @} */

    /** @name Public ISession methods
     * @{ */
    STDMETHOD(UnlockMachine)();
    STDMETHOD(InternalAndReservedMethod1ISession)();
    STDMETHOD(InternalAndReservedMethod2ISession)();
    STDMETHOD(InternalAndReservedMethod3ISession)();
    STDMETHOD(InternalAndReservedMethod4ISession)();
    /** @} */

    /** @name Public IInternalSessionControl properties
     * @{ */
    STDMETHOD(COMGETTER(PID))(ULONG *aPID);
    STDMETHOD(COMGETTER(RemoteConsole))(IConsole **aRemoteConsole);
    STDMETHOD(COMGETTER(NominalState))(MachineState_T *aNominalState);
    /** @} */

    /** @name Public IInternalSessionControl methods
     * @{ */
#ifndef VBOX_WITH_XPCOM
    STDMETHOD(AssignMachine)(IMachine *aMachine,
                             LockType_T aLockType,
                             IN_BSTR aTokenId);
#endif /* !VBOX_WITH_XPCOM */
#ifdef VBOX_WITH_XPCOM
    STDMETHOD(AssignMachine)(IMachine *aMachine,
                             LockType_T aLockType,
                             IToken *aToken);
#endif /* VBOX_WITH_XPCOM */
    STDMETHOD(AssignRemoteMachine)(IMachine *aMachine,
                                   IConsole *aConsole);
    STDMETHOD(UpdateMachineState)(MachineState_T aMachineState);
    STDMETHOD(Uninitialize)();
    STDMETHOD(OnNetworkAdapterChange)(INetworkAdapter *aNetworkAdapter,
                                      BOOL aChangeAdapter);
    STDMETHOD(OnAudioAdapterChange)(IAudioAdapter *aAudioAdapter);
    STDMETHOD(OnSerialPortChange)(ISerialPort *aSerialPort);
    STDMETHOD(OnParallelPortChange)(IParallelPort *aParallelPort);
    STDMETHOD(OnStorageControllerChange)(IN_BSTR aMachineId,
                                         IN_BSTR aControllerName);
    STDMETHOD(OnMediumChange)(IMediumAttachment *aMediumAttachment,
                              BOOL aForce);
    STDMETHOD(OnStorageDeviceChange)(IMediumAttachment *aMediumAttachment,
                                     BOOL aRemove,
                                     BOOL aSilent);
    STDMETHOD(OnVMProcessPriorityChange)(VMProcPriority_T aPriority);
    STDMETHOD(OnClipboardModeChange)(ClipboardMode_T aClipboardMode);
    STDMETHOD(OnClipboardFileTransferModeChange)(BOOL aEnabled);
    STDMETHOD(OnDnDModeChange)(DnDMode_T aDndMode);
    STDMETHOD(OnCPUChange)(ULONG aCpu,
                           BOOL aAdd);
    STDMETHOD(OnCPUExecutionCapChange)(ULONG aExecutionCap);
    STDMETHOD(OnVRDEServerChange)(BOOL aRestart);
    STDMETHOD(OnRecordingChange)(BOOL aEnable);
    STDMETHOD(OnUSBControllerChange)();
    STDMETHOD(OnSharedFolderChange)(BOOL aGlobal);
    STDMETHOD(OnUSBDeviceAttach)(IUSBDevice *aDevice,
                                 IVirtualBoxErrorInfo *aError,
                                 ULONG aMaskedInterfaces,
                                 IN_BSTR aCaptureFilename);
    STDMETHOD(OnUSBDeviceDetach)(IN_BSTR aId,
                                 IVirtualBoxErrorInfo *aError);
    STDMETHOD(OnShowWindow)(BOOL aCheck,
                            BOOL *aCanShow,
                            LONG64 *aWinId);
    STDMETHOD(OnBandwidthGroupChange)(IBandwidthGroup *aBandwidthGroup);
    STDMETHOD(AccessGuestProperty)(IN_BSTR aName,
                                   IN_BSTR aValue,
                                   IN_BSTR aFlags,
                                   ULONG aAccessMode,
                                   BSTR *aRetValue,
                                   LONG64 *aRetTimestamp,
                                   BSTR *aRetFlags);
    STDMETHOD(EnumerateGuestProperties)(IN_BSTR aPatterns,
                                        ComSafeArrayOut(BSTR, aKeys),
                                        ComSafeArrayOut(BSTR, aValues),
                                        ComSafeArrayOut(LONG64, aTimestamps),
                                        ComSafeArrayOut(BSTR, aFlags));
    STDMETHOD(OnlineMergeMedium)(IMediumAttachment *aMediumAttachment,
                                 ULONG aSourceIdx,
                                 ULONG aTargetIdx,
                                 IProgress *aProgress);
    STDMETHOD(ReconfigureMediumAttachments)(ComSafeArrayIn(IMediumAttachment *, aAttachments));
    STDMETHOD(EnableVMMStatistics)(BOOL aEnable);
    STDMETHOD(PauseWithReason)(Reason_T aReason);
    STDMETHOD(ResumeWithReason)(Reason_T aReason);
    STDMETHOD(SaveStateWithReason)(Reason_T aReason,
                                   IProgress *aProgress,
                                   ISnapshot *aSnapshot,
                                   IN_BSTR aStateFilePath,
                                   BOOL aPauseVM,
                                   BOOL *aLeftPaused);
    STDMETHOD(CancelSaveStateWithReason)();
    /** @} */

private:
    /** @name Wrapped ISession properties
     * @{ */
    virtual HRESULT getState(SessionState_T *aState) = 0;
    virtual HRESULT getType(SessionType_T *aType) = 0;
    virtual HRESULT getName(com::Utf8Str &aName) = 0;
    virtual HRESULT setName(const com::Utf8Str &aName) = 0;
    virtual HRESULT getMachine(ComPtr<IMachine> &aMachine) = 0;
    virtual HRESULT getConsole(ComPtr<IConsole> &aConsole) = 0;
    /** @} */

    /** @name Wrapped ISession methods
     * @{ */
    virtual HRESULT unlockMachine() = 0;
    /** @} */

    /** @name Wrapped IInternalSessionControl properties
     * @{ */
    virtual HRESULT getPID(ULONG *aPID) = 0;
    virtual HRESULT getRemoteConsole(ComPtr<IConsole> &aRemoteConsole) = 0;
    virtual HRESULT getNominalState(MachineState_T *aNominalState) = 0;
    /** @} */

    /** @name Wrapped IInternalSessionControl methods
     * @{ */
#ifndef VBOX_WITH_XPCOM
    virtual HRESULT assignMachine(const ComPtr<IMachine> &aMachine,
                                  LockType_T aLockType,
                                  const com::Utf8Str &aTokenId) = 0;
#endif /* !VBOX_WITH_XPCOM */
#ifdef VBOX_WITH_XPCOM
    virtual HRESULT assignMachine(const ComPtr<IMachine> &aMachine,
                                  LockType_T aLockType,
                                  const ComPtr<IToken> &aToken) = 0;
#endif /* VBOX_WITH_XPCOM */
    virtual HRESULT assignRemoteMachine(const ComPtr<IMachine> &aMachine,
                                        const ComPtr<IConsole> &aConsole) = 0;
    virtual HRESULT updateMachineState(MachineState_T aMachineState) = 0;
    virtual HRESULT uninitialize() = 0;
    virtual HRESULT onNetworkAdapterChange(const ComPtr<INetworkAdapter> &aNetworkAdapter,
                                           BOOL aChangeAdapter) = 0;
    virtual HRESULT onAudioAdapterChange(const ComPtr<IAudioAdapter> &aAudioAdapter) = 0;
    virtual HRESULT onSerialPortChange(const ComPtr<ISerialPort> &aSerialPort) = 0;
    virtual HRESULT onParallelPortChange(const ComPtr<IParallelPort> &aParallelPort) = 0;
    virtual HRESULT onStorageControllerChange(const com::Guid &aMachineId,
                                              const com::Utf8Str &aControllerName) = 0;
    virtual HRESULT onMediumChange(const ComPtr<IMediumAttachment> &aMediumAttachment,
                                   BOOL aForce) = 0;
    virtual HRESULT onStorageDeviceChange(const ComPtr<IMediumAttachment> &aMediumAttachment,
                                          BOOL aRemove,
                                          BOOL aSilent) = 0;
    virtual HRESULT onVMProcessPriorityChange(VMProcPriority_T aPriority) = 0;
    virtual HRESULT onClipboardModeChange(ClipboardMode_T aClipboardMode) = 0;
    virtual HRESULT onClipboardFileTransferModeChange(BOOL aEnabled) = 0;
    virtual HRESULT onDnDModeChange(DnDMode_T aDndMode) = 0;
    virtual HRESULT onCPUChange(ULONG aCpu,
                                BOOL aAdd) = 0;
    virtual HRESULT onCPUExecutionCapChange(ULONG aExecutionCap) = 0;
    virtual HRESULT onVRDEServerChange(BOOL aRestart) = 0;
    virtual HRESULT onRecordingChange(BOOL aEnable) = 0;
    virtual HRESULT onUSBControllerChange() = 0;
    virtual HRESULT onSharedFolderChange(BOOL aGlobal) = 0;
    virtual HRESULT onUSBDeviceAttach(const ComPtr<IUSBDevice> &aDevice,
                                      const ComPtr<IVirtualBoxErrorInfo> &aError,
                                      ULONG aMaskedInterfaces,
                                      const com::Utf8Str &aCaptureFilename) = 0;
    virtual HRESULT onUSBDeviceDetach(const com::Guid &aId,
                                      const ComPtr<IVirtualBoxErrorInfo> &aError) = 0;
    virtual HRESULT onShowWindow(BOOL aCheck,
                                 BOOL *aCanShow,
                                 LONG64 *aWinId) = 0;
    virtual HRESULT onBandwidthGroupChange(const ComPtr<IBandwidthGroup> &aBandwidthGroup) = 0;
    virtual HRESULT accessGuestProperty(const com::Utf8Str &aName,
                                        const com::Utf8Str &aValue,
                                        const com::Utf8Str &aFlags,
                                        ULONG aAccessMode,
                                        com::Utf8Str &aRetValue,
                                        LONG64 *aRetTimestamp,
                                        com::Utf8Str &aRetFlags) = 0;
    virtual HRESULT enumerateGuestProperties(const com::Utf8Str &aPatterns,
                                             std::vector<com::Utf8Str> &aKeys,
                                             std::vector<com::Utf8Str> &aValues,
                                             std::vector<LONG64> &aTimestamps,
                                             std::vector<com::Utf8Str> &aFlags) = 0;
    virtual HRESULT onlineMergeMedium(const ComPtr<IMediumAttachment> &aMediumAttachment,
                                      ULONG aSourceIdx,
                                      ULONG aTargetIdx,
                                      const ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT reconfigureMediumAttachments(const std::vector<ComPtr<IMediumAttachment> > &aAttachments) = 0;
    virtual HRESULT enableVMMStatistics(BOOL aEnable) = 0;
    virtual HRESULT pauseWithReason(Reason_T aReason) = 0;
    virtual HRESULT resumeWithReason(Reason_T aReason) = 0;
    virtual HRESULT saveStateWithReason(Reason_T aReason,
                                        const ComPtr<IProgress> &aProgress,
                                        const ComPtr<ISnapshot> &aSnapshot,
                                        const com::Utf8Str &aStateFilePath,
                                        BOOL aPauseVM,
                                        BOOL *aLeftPaused) = 0;
    virtual HRESULT cancelSaveStateWithReason() = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(SessionWrap); /* Shuts up MSC warning C4625. */

};

#endif // !SessionWrap_H_

// ##### ENDFILE "SessionWrap.h"


// ##### BEGINFILE "StorageControllerWrap.h"
/** @file
 * VirtualBox API class wrapper header for IStorageController.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef StorageControllerWrap_H_
#define StorageControllerWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE StorageControllerWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IStorageController)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(StorageControllerWrap, IStorageController)
    DECLARE_NOT_AGGREGATABLE(StorageControllerWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(StorageControllerWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IStorageController)
        COM_INTERFACE_ENTRY2(IDispatch, IStorageController)
        VBOX_TWEAK_INTERFACE_ENTRY(IStorageController)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(StorageControllerWrap)

    /** @name Public IStorageController properties
     * @{ */
    STDMETHOD(COMGETTER(Name))(BSTR *aName);
    STDMETHOD(COMSETTER(Name))(IN_BSTR aName);
    STDMETHOD(COMGETTER(MaxDevicesPerPortCount))(ULONG *aMaxDevicesPerPortCount);
    STDMETHOD(COMGETTER(MinPortCount))(ULONG *aMinPortCount);
    STDMETHOD(COMGETTER(MaxPortCount))(ULONG *aMaxPortCount);
    STDMETHOD(COMGETTER(Instance))(ULONG *aInstance);
    STDMETHOD(COMSETTER(Instance))(ULONG aInstance);
    STDMETHOD(COMGETTER(PortCount))(ULONG *aPortCount);
    STDMETHOD(COMSETTER(PortCount))(ULONG aPortCount);
    STDMETHOD(COMGETTER(Bus))(StorageBus_T *aBus);
    STDMETHOD(COMGETTER(ControllerType))(StorageControllerType_T *aControllerType);
    STDMETHOD(COMSETTER(ControllerType))(StorageControllerType_T aControllerType);
    STDMETHOD(COMGETTER(UseHostIOCache))(BOOL *aUseHostIOCache);
    STDMETHOD(COMSETTER(UseHostIOCache))(BOOL aUseHostIOCache);
    STDMETHOD(COMGETTER(Bootable))(BOOL *aBootable);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IStorageController))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IStorageController))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IStorageController))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IStorageController))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IStorageController))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IStorageController))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IStorageController))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IStorageController))(ULONG *aReserved);
    /** @} */

    /** @name Public IStorageController methods
     * @{ */
    STDMETHOD(InternalAndReservedMethod1IStorageController)();
    STDMETHOD(InternalAndReservedMethod2IStorageController)();
    STDMETHOD(InternalAndReservedMethod3IStorageController)();
    STDMETHOD(InternalAndReservedMethod4IStorageController)();
    /** @} */

private:
    /** @name Wrapped IStorageController properties
     * @{ */
    virtual HRESULT getName(com::Utf8Str &aName) = 0;
    virtual HRESULT setName(const com::Utf8Str &aName) = 0;
    virtual HRESULT getMaxDevicesPerPortCount(ULONG *aMaxDevicesPerPortCount) = 0;
    virtual HRESULT getMinPortCount(ULONG *aMinPortCount) = 0;
    virtual HRESULT getMaxPortCount(ULONG *aMaxPortCount) = 0;
    virtual HRESULT getInstance(ULONG *aInstance) = 0;
    virtual HRESULT setInstance(ULONG aInstance) = 0;
    virtual HRESULT getPortCount(ULONG *aPortCount) = 0;
    virtual HRESULT setPortCount(ULONG aPortCount) = 0;
    virtual HRESULT getBus(StorageBus_T *aBus) = 0;
    virtual HRESULT getControllerType(StorageControllerType_T *aControllerType) = 0;
    virtual HRESULT setControllerType(StorageControllerType_T aControllerType) = 0;
    virtual HRESULT getUseHostIOCache(BOOL *aUseHostIOCache) = 0;
    virtual HRESULT setUseHostIOCache(BOOL aUseHostIOCache) = 0;
    virtual HRESULT getBootable(BOOL *aBootable) = 0;
    /** @} */

    /** @name Wrapped IStorageController methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(StorageControllerWrap); /* Shuts up MSC warning C4625. */

};

#endif // !StorageControllerWrap_H_

// ##### ENDFILE "StorageControllerWrap.h"


// ##### BEGINFILE "PerformanceMetricWrap.h"
/** @file
 * VirtualBox API class wrapper header for IPerformanceMetric.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef PerformanceMetricWrap_H_
#define PerformanceMetricWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE PerformanceMetricWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IPerformanceMetric)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(PerformanceMetricWrap, IPerformanceMetric)
    DECLARE_NOT_AGGREGATABLE(PerformanceMetricWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(PerformanceMetricWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IPerformanceMetric)
        COM_INTERFACE_ENTRY2(IDispatch, IPerformanceMetric)
        VBOX_TWEAK_INTERFACE_ENTRY(IPerformanceMetric)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(PerformanceMetricWrap)

    /** @name Public IPerformanceMetric properties
     * @{ */
    STDMETHOD(COMGETTER(MetricName))(BSTR *aMetricName);
    STDMETHOD(COMGETTER(Object))(IUnknown **aObject);
    STDMETHOD(COMGETTER(Description))(BSTR *aDescription);
    STDMETHOD(COMGETTER(Period))(ULONG *aPeriod);
    STDMETHOD(COMGETTER(Count))(ULONG *aCount);
    STDMETHOD(COMGETTER(Unit))(BSTR *aUnit);
    STDMETHOD(COMGETTER(MinimumValue))(LONG *aMinimumValue);
    STDMETHOD(COMGETTER(MaximumValue))(LONG *aMaximumValue);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IPerformanceMetric))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IPerformanceMetric))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IPerformanceMetric))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IPerformanceMetric))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IPerformanceMetric))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IPerformanceMetric))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IPerformanceMetric))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IPerformanceMetric))(ULONG *aReserved);
    /** @} */

    /** @name Public IPerformanceMetric methods
     * @{ */
    /** @} */

private:
    /** @name Wrapped IPerformanceMetric properties
     * @{ */
    virtual HRESULT getMetricName(com::Utf8Str &aMetricName) = 0;
    virtual HRESULT getObject(ComPtr<IUnknown> &aObject) = 0;
    virtual HRESULT getDescription(com::Utf8Str &aDescription) = 0;
    virtual HRESULT getPeriod(ULONG *aPeriod) = 0;
    virtual HRESULT getCount(ULONG *aCount) = 0;
    virtual HRESULT getUnit(com::Utf8Str &aUnit) = 0;
    virtual HRESULT getMinimumValue(LONG *aMinimumValue) = 0;
    virtual HRESULT getMaximumValue(LONG *aMaximumValue) = 0;
    /** @} */

    /** @name Wrapped IPerformanceMetric methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(PerformanceMetricWrap); /* Shuts up MSC warning C4625. */

};

#endif // !PerformanceMetricWrap_H_

// ##### ENDFILE "PerformanceMetricWrap.h"


// ##### BEGINFILE "PerformanceCollectorWrap.h"
/** @file
 * VirtualBox API class wrapper header for IPerformanceCollector.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef PerformanceCollectorWrap_H_
#define PerformanceCollectorWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE PerformanceCollectorWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IPerformanceCollector)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(PerformanceCollectorWrap, IPerformanceCollector)
    DECLARE_NOT_AGGREGATABLE(PerformanceCollectorWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(PerformanceCollectorWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IPerformanceCollector)
        COM_INTERFACE_ENTRY2(IDispatch, IPerformanceCollector)
        VBOX_TWEAK_INTERFACE_ENTRY(IPerformanceCollector)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(PerformanceCollectorWrap)

    /** @name Public IPerformanceCollector properties
     * @{ */
    STDMETHOD(COMGETTER(MetricNames))(ComSafeArrayOut(BSTR, aMetricNames));
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IPerformanceCollector))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IPerformanceCollector))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IPerformanceCollector))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IPerformanceCollector))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IPerformanceCollector))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IPerformanceCollector))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IPerformanceCollector))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IPerformanceCollector))(ULONG *aReserved);
    /** @} */

    /** @name Public IPerformanceCollector methods
     * @{ */
    STDMETHOD(GetMetrics)(ComSafeArrayIn(IN_BSTR, aMetricNames),
                          ComSafeArrayIn(IUnknown *, aObjects),
                          ComSafeArrayOut(IPerformanceMetric *, aMetrics));
    STDMETHOD(SetupMetrics)(ComSafeArrayIn(IN_BSTR, aMetricNames),
                            ComSafeArrayIn(IUnknown *, aObjects),
                            ULONG aPeriod,
                            ULONG aCount,
                            ComSafeArrayOut(IPerformanceMetric *, aAffectedMetrics));
    STDMETHOD(EnableMetrics)(ComSafeArrayIn(IN_BSTR, aMetricNames),
                             ComSafeArrayIn(IUnknown *, aObjects),
                             ComSafeArrayOut(IPerformanceMetric *, aAffectedMetrics));
    STDMETHOD(DisableMetrics)(ComSafeArrayIn(IN_BSTR, aMetricNames),
                              ComSafeArrayIn(IUnknown *, aObjects),
                              ComSafeArrayOut(IPerformanceMetric *, aAffectedMetrics));
    STDMETHOD(QueryMetricsData)(ComSafeArrayIn(IN_BSTR, aMetricNames),
                                ComSafeArrayIn(IUnknown *, aObjects),
                                ComSafeArrayOut(BSTR, aReturnMetricNames),
                                ComSafeArrayOut(IUnknown *, aReturnObjects),
                                ComSafeArrayOut(BSTR, aReturnUnits),
                                ComSafeArrayOut(ULONG, aReturnScales),
                                ComSafeArrayOut(ULONG, aReturnSequenceNumbers),
                                ComSafeArrayOut(ULONG, aReturnDataIndices),
                                ComSafeArrayOut(ULONG, aReturnDataLengths),
                                ComSafeArrayOut(LONG, aReturnData));
    STDMETHOD(InternalAndReservedMethod1IPerformanceCollector)();
    STDMETHOD(InternalAndReservedMethod2IPerformanceCollector)();
    STDMETHOD(InternalAndReservedMethod3IPerformanceCollector)();
    STDMETHOD(InternalAndReservedMethod4IPerformanceCollector)();
    /** @} */

private:
    /** @name Wrapped IPerformanceCollector properties
     * @{ */
    virtual HRESULT getMetricNames(std::vector<com::Utf8Str> &aMetricNames) = 0;
    /** @} */

    /** @name Wrapped IPerformanceCollector methods
     * @{ */
    virtual HRESULT getMetrics(const std::vector<com::Utf8Str> &aMetricNames,
                               const std::vector<ComPtr<IUnknown> > &aObjects,
                               std::vector<ComPtr<IPerformanceMetric> > &aMetrics) = 0;
    virtual HRESULT setupMetrics(const std::vector<com::Utf8Str> &aMetricNames,
                                 const std::vector<ComPtr<IUnknown> > &aObjects,
                                 ULONG aPeriod,
                                 ULONG aCount,
                                 std::vector<ComPtr<IPerformanceMetric> > &aAffectedMetrics) = 0;
    virtual HRESULT enableMetrics(const std::vector<com::Utf8Str> &aMetricNames,
                                  const std::vector<ComPtr<IUnknown> > &aObjects,
                                  std::vector<ComPtr<IPerformanceMetric> > &aAffectedMetrics) = 0;
    virtual HRESULT disableMetrics(const std::vector<com::Utf8Str> &aMetricNames,
                                   const std::vector<ComPtr<IUnknown> > &aObjects,
                                   std::vector<ComPtr<IPerformanceMetric> > &aAffectedMetrics) = 0;
    virtual HRESULT queryMetricsData(const std::vector<com::Utf8Str> &aMetricNames,
                                     const std::vector<ComPtr<IUnknown> > &aObjects,
                                     std::vector<com::Utf8Str> &aReturnMetricNames,
                                     std::vector<ComPtr<IUnknown> > &aReturnObjects,
                                     std::vector<com::Utf8Str> &aReturnUnits,
                                     std::vector<ULONG> &aReturnScales,
                                     std::vector<ULONG> &aReturnSequenceNumbers,
                                     std::vector<ULONG> &aReturnDataIndices,
                                     std::vector<ULONG> &aReturnDataLengths,
                                     std::vector<LONG> &aReturnData) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(PerformanceCollectorWrap); /* Shuts up MSC warning C4625. */

};

#endif // !PerformanceCollectorWrap_H_

// ##### ENDFILE "PerformanceCollectorWrap.h"


// ##### BEGINFILE "NATEngineWrap.h"
/** @file
 * VirtualBox API class wrapper header for INATEngine.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef NATEngineWrap_H_
#define NATEngineWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE NATEngineWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(INATEngine)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(NATEngineWrap, INATEngine)
    DECLARE_NOT_AGGREGATABLE(NATEngineWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(NATEngineWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(INATEngine)
        COM_INTERFACE_ENTRY2(IDispatch, INATEngine)
        VBOX_TWEAK_INTERFACE_ENTRY(INATEngine)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(NATEngineWrap)

    /** @name Public INATEngine properties
     * @{ */
    STDMETHOD(COMGETTER(Network))(BSTR *aNetwork);
    STDMETHOD(COMSETTER(Network))(IN_BSTR aNetwork);
    STDMETHOD(COMGETTER(HostIP))(BSTR *aHostIP);
    STDMETHOD(COMSETTER(HostIP))(IN_BSTR aHostIP);
    STDMETHOD(COMGETTER(TFTPPrefix))(BSTR *aTFTPPrefix);
    STDMETHOD(COMSETTER(TFTPPrefix))(IN_BSTR aTFTPPrefix);
    STDMETHOD(COMGETTER(TFTPBootFile))(BSTR *aTFTPBootFile);
    STDMETHOD(COMSETTER(TFTPBootFile))(IN_BSTR aTFTPBootFile);
    STDMETHOD(COMGETTER(TFTPNextServer))(BSTR *aTFTPNextServer);
    STDMETHOD(COMSETTER(TFTPNextServer))(IN_BSTR aTFTPNextServer);
    STDMETHOD(COMGETTER(AliasMode))(ULONG *aAliasMode);
    STDMETHOD(COMSETTER(AliasMode))(ULONG aAliasMode);
    STDMETHOD(COMGETTER(DNSPassDomain))(BOOL *aDNSPassDomain);
    STDMETHOD(COMSETTER(DNSPassDomain))(BOOL aDNSPassDomain);
    STDMETHOD(COMGETTER(DNSProxy))(BOOL *aDNSProxy);
    STDMETHOD(COMSETTER(DNSProxy))(BOOL aDNSProxy);
    STDMETHOD(COMGETTER(DNSUseHostResolver))(BOOL *aDNSUseHostResolver);
    STDMETHOD(COMSETTER(DNSUseHostResolver))(BOOL aDNSUseHostResolver);
    STDMETHOD(COMGETTER(Redirects))(ComSafeArrayOut(BSTR, aRedirects));
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1INATEngine))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2INATEngine))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3INATEngine))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4INATEngine))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5INATEngine))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6INATEngine))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7INATEngine))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8INATEngine))(ULONG *aReserved);
    /** @} */

    /** @name Public INATEngine methods
     * @{ */
    STDMETHOD(SetNetworkSettings)(ULONG aMtu,
                                  ULONG aSockSnd,
                                  ULONG aSockRcv,
                                  ULONG aTcpWndSnd,
                                  ULONG aTcpWndRcv);
    STDMETHOD(GetNetworkSettings)(ULONG *aMtu,
                                  ULONG *aSockSnd,
                                  ULONG *aSockRcv,
                                  ULONG *aTcpWndSnd,
                                  ULONG *aTcpWndRcv);
    STDMETHOD(AddRedirect)(IN_BSTR aName,
                           NATProtocol_T aProto,
                           IN_BSTR aHostIP,
                           USHORT aHostPort,
                           IN_BSTR aGuestIP,
                           USHORT aGuestPort);
    STDMETHOD(RemoveRedirect)(IN_BSTR aName);
    STDMETHOD(InternalAndReservedMethod1INATEngine)();
    STDMETHOD(InternalAndReservedMethod2INATEngine)();
    STDMETHOD(InternalAndReservedMethod3INATEngine)();
    STDMETHOD(InternalAndReservedMethod4INATEngine)();
    /** @} */

private:
    /** @name Wrapped INATEngine properties
     * @{ */
    virtual HRESULT getNetwork(com::Utf8Str &aNetwork) = 0;
    virtual HRESULT setNetwork(const com::Utf8Str &aNetwork) = 0;
    virtual HRESULT getHostIP(com::Utf8Str &aHostIP) = 0;
    virtual HRESULT setHostIP(const com::Utf8Str &aHostIP) = 0;
    virtual HRESULT getTFTPPrefix(com::Utf8Str &aTFTPPrefix) = 0;
    virtual HRESULT setTFTPPrefix(const com::Utf8Str &aTFTPPrefix) = 0;
    virtual HRESULT getTFTPBootFile(com::Utf8Str &aTFTPBootFile) = 0;
    virtual HRESULT setTFTPBootFile(const com::Utf8Str &aTFTPBootFile) = 0;
    virtual HRESULT getTFTPNextServer(com::Utf8Str &aTFTPNextServer) = 0;
    virtual HRESULT setTFTPNextServer(const com::Utf8Str &aTFTPNextServer) = 0;
    virtual HRESULT getAliasMode(ULONG *aAliasMode) = 0;
    virtual HRESULT setAliasMode(ULONG aAliasMode) = 0;
    virtual HRESULT getDNSPassDomain(BOOL *aDNSPassDomain) = 0;
    virtual HRESULT setDNSPassDomain(BOOL aDNSPassDomain) = 0;
    virtual HRESULT getDNSProxy(BOOL *aDNSProxy) = 0;
    virtual HRESULT setDNSProxy(BOOL aDNSProxy) = 0;
    virtual HRESULT getDNSUseHostResolver(BOOL *aDNSUseHostResolver) = 0;
    virtual HRESULT setDNSUseHostResolver(BOOL aDNSUseHostResolver) = 0;
    virtual HRESULT getRedirects(std::vector<com::Utf8Str> &aRedirects) = 0;
    /** @} */

    /** @name Wrapped INATEngine methods
     * @{ */
    virtual HRESULT setNetworkSettings(ULONG aMtu,
                                       ULONG aSockSnd,
                                       ULONG aSockRcv,
                                       ULONG aTcpWndSnd,
                                       ULONG aTcpWndRcv) = 0;
    virtual HRESULT getNetworkSettings(ULONG *aMtu,
                                       ULONG *aSockSnd,
                                       ULONG *aSockRcv,
                                       ULONG *aTcpWndSnd,
                                       ULONG *aTcpWndRcv) = 0;
    virtual HRESULT addRedirect(const com::Utf8Str &aName,
                                NATProtocol_T aProto,
                                const com::Utf8Str &aHostIP,
                                USHORT aHostPort,
                                const com::Utf8Str &aGuestIP,
                                USHORT aGuestPort) = 0;
    virtual HRESULT removeRedirect(const com::Utf8Str &aName) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(NATEngineWrap); /* Shuts up MSC warning C4625. */

};

#endif // !NATEngineWrap_H_

// ##### ENDFILE "NATEngineWrap.h"


// ##### BEGINFILE "ExtPackPlugInWrap.h"
/** @file
 * VirtualBox API class wrapper header for IExtPackPlugIn.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef ExtPackPlugInWrap_H_
#define ExtPackPlugInWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE ExtPackPlugInWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IExtPackPlugIn)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(ExtPackPlugInWrap, IExtPackPlugIn)
    DECLARE_NOT_AGGREGATABLE(ExtPackPlugInWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(ExtPackPlugInWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IExtPackPlugIn)
        COM_INTERFACE_ENTRY2(IDispatch, IExtPackPlugIn)
        VBOX_TWEAK_INTERFACE_ENTRY(IExtPackPlugIn)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(ExtPackPlugInWrap)

    /** @name Public IExtPackPlugIn properties
     * @{ */
    STDMETHOD(COMGETTER(Name))(BSTR *aName);
    STDMETHOD(COMGETTER(Description))(BSTR *aDescription);
    STDMETHOD(COMGETTER(Frontend))(BSTR *aFrontend);
    STDMETHOD(COMGETTER(ModulePath))(BSTR *aModulePath);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IExtPackPlugIn))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IExtPackPlugIn))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IExtPackPlugIn))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IExtPackPlugIn))(ULONG *aReserved);
    /** @} */

    /** @name Public IExtPackPlugIn methods
     * @{ */
    /** @} */

private:
    /** @name Wrapped IExtPackPlugIn properties
     * @{ */
    virtual HRESULT getName(com::Utf8Str &aName) = 0;
    virtual HRESULT getDescription(com::Utf8Str &aDescription) = 0;
    virtual HRESULT getFrontend(com::Utf8Str &aFrontend) = 0;
    virtual HRESULT getModulePath(com::Utf8Str &aModulePath) = 0;
    /** @} */

    /** @name Wrapped IExtPackPlugIn methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(ExtPackPlugInWrap); /* Shuts up MSC warning C4625. */

};

#endif // !ExtPackPlugInWrap_H_

// ##### ENDFILE "ExtPackPlugInWrap.h"


// ##### BEGINFILE "ExtPackBaseWrap.h"
/** @file
 * VirtualBox API class wrapper header for IExtPackBase.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef ExtPackBaseWrap_H_
#define ExtPackBaseWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE ExtPackBaseWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IExtPackBase)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(ExtPackBaseWrap, IExtPackBase)
    DECLARE_NOT_AGGREGATABLE(ExtPackBaseWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(ExtPackBaseWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IExtPackBase)
        COM_INTERFACE_ENTRY2(IDispatch, IExtPackBase)
        VBOX_TWEAK_INTERFACE_ENTRY(IExtPackBase)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(ExtPackBaseWrap)

    /** @name Public IExtPackBase properties
     * @{ */
    STDMETHOD(COMGETTER(Name))(BSTR *aName);
    STDMETHOD(COMGETTER(Description))(BSTR *aDescription);
    STDMETHOD(COMGETTER(Version))(BSTR *aVersion);
    STDMETHOD(COMGETTER(Revision))(ULONG *aRevision);
    STDMETHOD(COMGETTER(Edition))(BSTR *aEdition);
    STDMETHOD(COMGETTER(VRDEModule))(BSTR *aVRDEModule);
    STDMETHOD(COMGETTER(PlugIns))(ComSafeArrayOut(IExtPackPlugIn *, aPlugIns));
    STDMETHOD(COMGETTER(Usable))(BOOL *aUsable);
    STDMETHOD(COMGETTER(WhyUnusable))(BSTR *aWhyUnusable);
    STDMETHOD(COMGETTER(ShowLicense))(BOOL *aShowLicense);
    STDMETHOD(COMGETTER(License))(BSTR *aLicense);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IExtPackBase))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IExtPackBase))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IExtPackBase))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IExtPackBase))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IExtPackBase))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IExtPackBase))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IExtPackBase))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IExtPackBase))(ULONG *aReserved);
    /** @} */

    /** @name Public IExtPackBase methods
     * @{ */
    STDMETHOD(QueryLicense)(IN_BSTR aPreferredLocale,
                            IN_BSTR aPreferredLanguage,
                            IN_BSTR aFormat,
                            BSTR *aLicenseText);
    STDMETHOD(InternalAndReservedMethod1IExtPackBase)();
    STDMETHOD(InternalAndReservedMethod2IExtPackBase)();
    STDMETHOD(InternalAndReservedMethod3IExtPackBase)();
    STDMETHOD(InternalAndReservedMethod4IExtPackBase)();
    /** @} */

private:
    /** @name Wrapped IExtPackBase properties
     * @{ */
    virtual HRESULT getName(com::Utf8Str &aName) = 0;
    virtual HRESULT getDescription(com::Utf8Str &aDescription) = 0;
    virtual HRESULT getVersion(com::Utf8Str &aVersion) = 0;
    virtual HRESULT getRevision(ULONG *aRevision) = 0;
    virtual HRESULT getEdition(com::Utf8Str &aEdition) = 0;
    virtual HRESULT getVRDEModule(com::Utf8Str &aVRDEModule) = 0;
    virtual HRESULT getPlugIns(std::vector<ComPtr<IExtPackPlugIn> > &aPlugIns) = 0;
    virtual HRESULT getUsable(BOOL *aUsable) = 0;
    virtual HRESULT getWhyUnusable(com::Utf8Str &aWhyUnusable) = 0;
    virtual HRESULT getShowLicense(BOOL *aShowLicense) = 0;
    virtual HRESULT getLicense(com::Utf8Str &aLicense) = 0;
    /** @} */

    /** @name Wrapped IExtPackBase methods
     * @{ */
    virtual HRESULT queryLicense(const com::Utf8Str &aPreferredLocale,
                                 const com::Utf8Str &aPreferredLanguage,
                                 const com::Utf8Str &aFormat,
                                 com::Utf8Str &aLicenseText) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(ExtPackBaseWrap); /* Shuts up MSC warning C4625. */

};

#endif // !ExtPackBaseWrap_H_

// ##### ENDFILE "ExtPackBaseWrap.h"


// ##### BEGINFILE "ExtPackWrap.h"
/** @file
 * VirtualBox API class wrapper header for IExtPack.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef ExtPackWrap_H_
#define ExtPackWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE ExtPackWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IExtPack)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(ExtPackWrap, IExtPack)
    DECLARE_NOT_AGGREGATABLE(ExtPackWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(ExtPackWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IExtPack)
        COM_INTERFACE_ENTRY(IExtPackBase)
        COM_INTERFACE_ENTRY2(IDispatch, IExtPack)
        VBOX_TWEAK_INTERFACE_ENTRY(IExtPack)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(ExtPackWrap)

    /** @name Public IExtPackBase properties
     * @{ */
    STDMETHOD(COMGETTER(Name))(BSTR *aName);
    STDMETHOD(COMGETTER(Description))(BSTR *aDescription);
    STDMETHOD(COMGETTER(Version))(BSTR *aVersion);
    STDMETHOD(COMGETTER(Revision))(ULONG *aRevision);
    STDMETHOD(COMGETTER(Edition))(BSTR *aEdition);
    STDMETHOD(COMGETTER(VRDEModule))(BSTR *aVRDEModule);
    STDMETHOD(COMGETTER(PlugIns))(ComSafeArrayOut(IExtPackPlugIn *, aPlugIns));
    STDMETHOD(COMGETTER(Usable))(BOOL *aUsable);
    STDMETHOD(COMGETTER(WhyUnusable))(BSTR *aWhyUnusable);
    STDMETHOD(COMGETTER(ShowLicense))(BOOL *aShowLicense);
    STDMETHOD(COMGETTER(License))(BSTR *aLicense);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IExtPackBase))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IExtPackBase))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IExtPackBase))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IExtPackBase))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IExtPackBase))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IExtPackBase))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IExtPackBase))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IExtPackBase))(ULONG *aReserved);
    /** @} */

    /** @name Public IExtPack properties
     * @{ */
    /** @} */

    /** @name Public IExtPackBase methods
     * @{ */
    STDMETHOD(QueryLicense)(IN_BSTR aPreferredLocale,
                            IN_BSTR aPreferredLanguage,
                            IN_BSTR aFormat,
                            BSTR *aLicenseText);
    STDMETHOD(InternalAndReservedMethod1IExtPackBase)();
    STDMETHOD(InternalAndReservedMethod2IExtPackBase)();
    STDMETHOD(InternalAndReservedMethod3IExtPackBase)();
    STDMETHOD(InternalAndReservedMethod4IExtPackBase)();
    /** @} */

    /** @name Public IExtPack methods
     * @{ */
    STDMETHOD(QueryObject)(IN_BSTR aObjUuid,
                           IUnknown **aReturnInterface);
    /** @} */

private:
    /** @name Wrapped IExtPackBase properties
     * @{ */
    virtual HRESULT getName(com::Utf8Str &aName) = 0;
    virtual HRESULT getDescription(com::Utf8Str &aDescription) = 0;
    virtual HRESULT getVersion(com::Utf8Str &aVersion) = 0;
    virtual HRESULT getRevision(ULONG *aRevision) = 0;
    virtual HRESULT getEdition(com::Utf8Str &aEdition) = 0;
    virtual HRESULT getVRDEModule(com::Utf8Str &aVRDEModule) = 0;
    virtual HRESULT getPlugIns(std::vector<ComPtr<IExtPackPlugIn> > &aPlugIns) = 0;
    virtual HRESULT getUsable(BOOL *aUsable) = 0;
    virtual HRESULT getWhyUnusable(com::Utf8Str &aWhyUnusable) = 0;
    virtual HRESULT getShowLicense(BOOL *aShowLicense) = 0;
    virtual HRESULT getLicense(com::Utf8Str &aLicense) = 0;
    /** @} */

    /** @name Wrapped IExtPack properties
     * @{ */
    /** @} */

    /** @name Wrapped IExtPackBase methods
     * @{ */
    virtual HRESULT queryLicense(const com::Utf8Str &aPreferredLocale,
                                 const com::Utf8Str &aPreferredLanguage,
                                 const com::Utf8Str &aFormat,
                                 com::Utf8Str &aLicenseText) = 0;
    /** @} */

    /** @name Wrapped IExtPack methods
     * @{ */
    virtual HRESULT queryObject(const com::Utf8Str &aObjUuid,
                                ComPtr<IUnknown> &aReturnInterface) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(ExtPackWrap); /* Shuts up MSC warning C4625. */

};

#endif // !ExtPackWrap_H_

// ##### ENDFILE "ExtPackWrap.h"


// ##### BEGINFILE "ExtPackFileWrap.h"
/** @file
 * VirtualBox API class wrapper header for IExtPackFile.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef ExtPackFileWrap_H_
#define ExtPackFileWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE ExtPackFileWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IExtPackFile)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(ExtPackFileWrap, IExtPackFile)
    DECLARE_NOT_AGGREGATABLE(ExtPackFileWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(ExtPackFileWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IExtPackFile)
        COM_INTERFACE_ENTRY(IExtPackBase)
        COM_INTERFACE_ENTRY2(IDispatch, IExtPackFile)
        VBOX_TWEAK_INTERFACE_ENTRY(IExtPackFile)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(ExtPackFileWrap)

    /** @name Public IExtPackBase properties
     * @{ */
    STDMETHOD(COMGETTER(Name))(BSTR *aName);
    STDMETHOD(COMGETTER(Description))(BSTR *aDescription);
    STDMETHOD(COMGETTER(Version))(BSTR *aVersion);
    STDMETHOD(COMGETTER(Revision))(ULONG *aRevision);
    STDMETHOD(COMGETTER(Edition))(BSTR *aEdition);
    STDMETHOD(COMGETTER(VRDEModule))(BSTR *aVRDEModule);
    STDMETHOD(COMGETTER(PlugIns))(ComSafeArrayOut(IExtPackPlugIn *, aPlugIns));
    STDMETHOD(COMGETTER(Usable))(BOOL *aUsable);
    STDMETHOD(COMGETTER(WhyUnusable))(BSTR *aWhyUnusable);
    STDMETHOD(COMGETTER(ShowLicense))(BOOL *aShowLicense);
    STDMETHOD(COMGETTER(License))(BSTR *aLicense);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IExtPackBase))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IExtPackBase))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IExtPackBase))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IExtPackBase))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IExtPackBase))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IExtPackBase))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IExtPackBase))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IExtPackBase))(ULONG *aReserved);
    /** @} */

    /** @name Public IExtPackFile properties
     * @{ */
    STDMETHOD(COMGETTER(FilePath))(BSTR *aFilePath);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IExtPackFile))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IExtPackFile))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IExtPackFile))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IExtPackFile))(ULONG *aReserved);
    /** @} */

    /** @name Public IExtPackBase methods
     * @{ */
    STDMETHOD(QueryLicense)(IN_BSTR aPreferredLocale,
                            IN_BSTR aPreferredLanguage,
                            IN_BSTR aFormat,
                            BSTR *aLicenseText);
    STDMETHOD(InternalAndReservedMethod1IExtPackBase)();
    STDMETHOD(InternalAndReservedMethod2IExtPackBase)();
    STDMETHOD(InternalAndReservedMethod3IExtPackBase)();
    STDMETHOD(InternalAndReservedMethod4IExtPackBase)();
    /** @} */

    /** @name Public IExtPackFile methods
     * @{ */
    STDMETHOD(Install)(BOOL aReplace,
                       IN_BSTR aDisplayInfo,
                       IProgress **aProgess);
    STDMETHOD(InternalAndReservedMethod1IExtPackFile)();
    STDMETHOD(InternalAndReservedMethod2IExtPackFile)();
    /** @} */

private:
    /** @name Wrapped IExtPackBase properties
     * @{ */
    virtual HRESULT getName(com::Utf8Str &aName) = 0;
    virtual HRESULT getDescription(com::Utf8Str &aDescription) = 0;
    virtual HRESULT getVersion(com::Utf8Str &aVersion) = 0;
    virtual HRESULT getRevision(ULONG *aRevision) = 0;
    virtual HRESULT getEdition(com::Utf8Str &aEdition) = 0;
    virtual HRESULT getVRDEModule(com::Utf8Str &aVRDEModule) = 0;
    virtual HRESULT getPlugIns(std::vector<ComPtr<IExtPackPlugIn> > &aPlugIns) = 0;
    virtual HRESULT getUsable(BOOL *aUsable) = 0;
    virtual HRESULT getWhyUnusable(com::Utf8Str &aWhyUnusable) = 0;
    virtual HRESULT getShowLicense(BOOL *aShowLicense) = 0;
    virtual HRESULT getLicense(com::Utf8Str &aLicense) = 0;
    /** @} */

    /** @name Wrapped IExtPackFile properties
     * @{ */
    virtual HRESULT getFilePath(com::Utf8Str &aFilePath) = 0;
    /** @} */

    /** @name Wrapped IExtPackBase methods
     * @{ */
    virtual HRESULT queryLicense(const com::Utf8Str &aPreferredLocale,
                                 const com::Utf8Str &aPreferredLanguage,
                                 const com::Utf8Str &aFormat,
                                 com::Utf8Str &aLicenseText) = 0;
    /** @} */

    /** @name Wrapped IExtPackFile methods
     * @{ */
    virtual HRESULT install(BOOL aReplace,
                            const com::Utf8Str &aDisplayInfo,
                            ComPtr<IProgress> &aProgess) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(ExtPackFileWrap); /* Shuts up MSC warning C4625. */

};

#endif // !ExtPackFileWrap_H_

// ##### ENDFILE "ExtPackFileWrap.h"


// ##### BEGINFILE "ExtPackManagerWrap.h"
/** @file
 * VirtualBox API class wrapper header for IExtPackManager.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef ExtPackManagerWrap_H_
#define ExtPackManagerWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE ExtPackManagerWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IExtPackManager)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(ExtPackManagerWrap, IExtPackManager)
    DECLARE_NOT_AGGREGATABLE(ExtPackManagerWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(ExtPackManagerWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IExtPackManager)
        COM_INTERFACE_ENTRY2(IDispatch, IExtPackManager)
        VBOX_TWEAK_INTERFACE_ENTRY(IExtPackManager)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(ExtPackManagerWrap)

    /** @name Public IExtPackManager properties
     * @{ */
    STDMETHOD(COMGETTER(InstalledExtPacks))(ComSafeArrayOut(IExtPack *, aInstalledExtPacks));
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IExtPackManager))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IExtPackManager))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IExtPackManager))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IExtPackManager))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IExtPackManager))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IExtPackManager))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IExtPackManager))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IExtPackManager))(ULONG *aReserved);
    /** @} */

    /** @name Public IExtPackManager methods
     * @{ */
    STDMETHOD(Find)(IN_BSTR aName,
                    IExtPack **aReturnData);
    STDMETHOD(OpenExtPackFile)(IN_BSTR aPath,
                               IExtPackFile **aFile);
    STDMETHOD(Uninstall)(IN_BSTR aName,
                         BOOL aForcedRemoval,
                         IN_BSTR aDisplayInfo,
                         IProgress **aProgess);
    STDMETHOD(Cleanup)();
    STDMETHOD(QueryAllPlugInsForFrontend)(IN_BSTR aFrontendName,
                                          ComSafeArrayOut(BSTR, aPlugInModules));
    STDMETHOD(IsExtPackUsable)(IN_BSTR aName,
                               BOOL *aUsable);
    STDMETHOD(InternalAndReservedMethod1IExtPackManager)();
    STDMETHOD(InternalAndReservedMethod2IExtPackManager)();
    STDMETHOD(InternalAndReservedMethod3IExtPackManager)();
    STDMETHOD(InternalAndReservedMethod4IExtPackManager)();
    /** @} */

private:
    /** @name Wrapped IExtPackManager properties
     * @{ */
    virtual HRESULT getInstalledExtPacks(std::vector<ComPtr<IExtPack> > &aInstalledExtPacks) = 0;
    /** @} */

    /** @name Wrapped IExtPackManager methods
     * @{ */
    virtual HRESULT find(const com::Utf8Str &aName,
                         ComPtr<IExtPack> &aReturnData) = 0;
    virtual HRESULT openExtPackFile(const com::Utf8Str &aPath,
                                    ComPtr<IExtPackFile> &aFile) = 0;
    virtual HRESULT uninstall(const com::Utf8Str &aName,
                              BOOL aForcedRemoval,
                              const com::Utf8Str &aDisplayInfo,
                              ComPtr<IProgress> &aProgess) = 0;
    virtual HRESULT cleanup() = 0;
    virtual HRESULT queryAllPlugInsForFrontend(const com::Utf8Str &aFrontendName,
                                               std::vector<com::Utf8Str> &aPlugInModules) = 0;
    virtual HRESULT isExtPackUsable(const com::Utf8Str &aName,
                                    BOOL *aUsable) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(ExtPackManagerWrap); /* Shuts up MSC warning C4625. */

};

#endif // !ExtPackManagerWrap_H_

// ##### ENDFILE "ExtPackManagerWrap.h"


// ##### BEGINFILE "BandwidthGroupWrap.h"
/** @file
 * VirtualBox API class wrapper header for IBandwidthGroup.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef BandwidthGroupWrap_H_
#define BandwidthGroupWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE BandwidthGroupWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IBandwidthGroup)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(BandwidthGroupWrap, IBandwidthGroup)
    DECLARE_NOT_AGGREGATABLE(BandwidthGroupWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(BandwidthGroupWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IBandwidthGroup)
        COM_INTERFACE_ENTRY2(IDispatch, IBandwidthGroup)
        VBOX_TWEAK_INTERFACE_ENTRY(IBandwidthGroup)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(BandwidthGroupWrap)

    /** @name Public IBandwidthGroup properties
     * @{ */
    STDMETHOD(COMGETTER(Name))(BSTR *aName);
    STDMETHOD(COMGETTER(Type))(BandwidthGroupType_T *aType);
    STDMETHOD(COMGETTER(Reference))(ULONG *aReference);
    STDMETHOD(COMGETTER(MaxBytesPerSec))(LONG64 *aMaxBytesPerSec);
    STDMETHOD(COMSETTER(MaxBytesPerSec))(LONG64 aMaxBytesPerSec);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IBandwidthGroup))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IBandwidthGroup))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IBandwidthGroup))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IBandwidthGroup))(ULONG *aReserved);
    /** @} */

    /** @name Public IBandwidthGroup methods
     * @{ */
    /** @} */

private:
    /** @name Wrapped IBandwidthGroup properties
     * @{ */
    virtual HRESULT getName(com::Utf8Str &aName) = 0;
    virtual HRESULT getType(BandwidthGroupType_T *aType) = 0;
    virtual HRESULT getReference(ULONG *aReference) = 0;
    virtual HRESULT getMaxBytesPerSec(LONG64 *aMaxBytesPerSec) = 0;
    virtual HRESULT setMaxBytesPerSec(LONG64 aMaxBytesPerSec) = 0;
    /** @} */

    /** @name Wrapped IBandwidthGroup methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(BandwidthGroupWrap); /* Shuts up MSC warning C4625. */

};

#endif // !BandwidthGroupWrap_H_

// ##### ENDFILE "BandwidthGroupWrap.h"


// ##### BEGINFILE "BandwidthControlWrap.h"
/** @file
 * VirtualBox API class wrapper header for IBandwidthControl.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef BandwidthControlWrap_H_
#define BandwidthControlWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE BandwidthControlWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IBandwidthControl)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(BandwidthControlWrap, IBandwidthControl)
    DECLARE_NOT_AGGREGATABLE(BandwidthControlWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(BandwidthControlWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IBandwidthControl)
        COM_INTERFACE_ENTRY2(IDispatch, IBandwidthControl)
        VBOX_TWEAK_INTERFACE_ENTRY(IBandwidthControl)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(BandwidthControlWrap)

    /** @name Public IBandwidthControl properties
     * @{ */
    STDMETHOD(COMGETTER(NumGroups))(ULONG *aNumGroups);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IBandwidthControl))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IBandwidthControl))(ULONG *aReserved);
    /** @} */

    /** @name Public IBandwidthControl methods
     * @{ */
    STDMETHOD(CreateBandwidthGroup)(IN_BSTR aName,
                                    BandwidthGroupType_T aType,
                                    LONG64 aMaxBytesPerSec);
    STDMETHOD(DeleteBandwidthGroup)(IN_BSTR aName);
    STDMETHOD(GetBandwidthGroup)(IN_BSTR aName,
                                 IBandwidthGroup **aBandwidthGroup);
    STDMETHOD(GetAllBandwidthGroups)(ComSafeArrayOut(IBandwidthGroup *, aBandwidthGroups));
    STDMETHOD(InternalAndReservedMethod1IBandwidthControl)();
    STDMETHOD(InternalAndReservedMethod2IBandwidthControl)();
    /** @} */

private:
    /** @name Wrapped IBandwidthControl properties
     * @{ */
    virtual HRESULT getNumGroups(ULONG *aNumGroups) = 0;
    /** @} */

    /** @name Wrapped IBandwidthControl methods
     * @{ */
    virtual HRESULT createBandwidthGroup(const com::Utf8Str &aName,
                                         BandwidthGroupType_T aType,
                                         LONG64 aMaxBytesPerSec) = 0;
    virtual HRESULT deleteBandwidthGroup(const com::Utf8Str &aName) = 0;
    virtual HRESULT getBandwidthGroup(const com::Utf8Str &aName,
                                      ComPtr<IBandwidthGroup> &aBandwidthGroup) = 0;
    virtual HRESULT getAllBandwidthGroups(std::vector<ComPtr<IBandwidthGroup> > &aBandwidthGroups) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(BandwidthControlWrap); /* Shuts up MSC warning C4625. */

};

#endif // !BandwidthControlWrap_H_

// ##### ENDFILE "BandwidthControlWrap.h"


// ##### BEGINFILE "VirtualBoxClientWrap.h"
/** @file
 * VirtualBox API class wrapper header for IVirtualBoxClient.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef VirtualBoxClientWrap_H_
#define VirtualBoxClientWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE VirtualBoxClientWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IVirtualBoxClient)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(VirtualBoxClientWrap, IVirtualBoxClient)
    DECLARE_NOT_AGGREGATABLE(VirtualBoxClientWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(VirtualBoxClientWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IVirtualBoxClient)
        COM_INTERFACE_ENTRY2(IDispatch, IVirtualBoxClient)
        VBOX_TWEAK_INTERFACE_ENTRY(IVirtualBoxClient)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(VirtualBoxClientWrap)

    /** @name Public IVirtualBoxClient properties
     * @{ */
    STDMETHOD(COMGETTER(VirtualBox))(IVirtualBox **aVirtualBox);
    STDMETHOD(COMGETTER(Session))(ISession **aSession);
    STDMETHOD(COMGETTER(EventSource))(IEventSource **aEventSource);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IVirtualBoxClient))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IVirtualBoxClient))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IVirtualBoxClient))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IVirtualBoxClient))(ULONG *aReserved);
    /** @} */

    /** @name Public IVirtualBoxClient methods
     * @{ */
    STDMETHOD(CheckMachineError)(IMachine *aMachine);
    STDMETHOD(InternalAndReservedMethod1IVirtualBoxClient)();
    STDMETHOD(InternalAndReservedMethod2IVirtualBoxClient)();
    STDMETHOD(InternalAndReservedMethod3IVirtualBoxClient)();
    STDMETHOD(InternalAndReservedMethod4IVirtualBoxClient)();
    /** @} */

private:
    /** @name Wrapped IVirtualBoxClient properties
     * @{ */
    virtual HRESULT getVirtualBox(ComPtr<IVirtualBox> &aVirtualBox) = 0;
    virtual HRESULT getSession(ComPtr<ISession> &aSession) = 0;
    virtual HRESULT getEventSource(ComPtr<IEventSource> &aEventSource) = 0;
    /** @} */

    /** @name Wrapped IVirtualBoxClient methods
     * @{ */
    virtual HRESULT checkMachineError(const ComPtr<IMachine> &aMachine) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(VirtualBoxClientWrap); /* Shuts up MSC warning C4625. */

};

#endif // !VirtualBoxClientWrap_H_

// ##### ENDFILE "VirtualBoxClientWrap.h"


// ##### BEGINFILE "EventSourceWrap.h"
/** @file
 * VirtualBox API class wrapper header for IEventSource.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef EventSourceWrap_H_
#define EventSourceWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE EventSourceWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IEventSource)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(EventSourceWrap, IEventSource)
    DECLARE_NOT_AGGREGATABLE(EventSourceWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(EventSourceWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IEventSource)
        COM_INTERFACE_ENTRY2(IDispatch, IEventSource)
        VBOX_TWEAK_INTERFACE_ENTRY(IEventSource)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(EventSourceWrap)

    /** @name Public IEventSource properties
     * @{ */
    /** @} */

    /** @name Public IEventSource methods
     * @{ */
    STDMETHOD(CreateListener)(IEventListener **aListener);
    STDMETHOD(CreateAggregator)(ComSafeArrayIn(IEventSource *, aSubordinates),
                                IEventSource **aResult);
    STDMETHOD(RegisterListener)(IEventListener *aListener,
                                ComSafeArrayIn(VBoxEventType_T, aInteresting),
                                BOOL aActive);
    STDMETHOD(UnregisterListener)(IEventListener *aListener);
    STDMETHOD(FireEvent)(IEvent *aEvent,
                         LONG aTimeout,
                         BOOL *aResult);
    STDMETHOD(GetEvent)(IEventListener *aListener,
                        LONG aTimeout,
                        IEvent **aEvent);
    STDMETHOD(EventProcessed)(IEventListener *aListener,
                              IEvent *aEvent);
    /** @} */

private:
    /** @name Wrapped IEventSource properties
     * @{ */
    /** @} */

    /** @name Wrapped IEventSource methods
     * @{ */
    virtual HRESULT createListener(ComPtr<IEventListener> &aListener) = 0;
    virtual HRESULT createAggregator(const std::vector<ComPtr<IEventSource> > &aSubordinates,
                                     ComPtr<IEventSource> &aResult) = 0;
    virtual HRESULT registerListener(const ComPtr<IEventListener> &aListener,
                                     const std::vector<VBoxEventType_T> &aInteresting,
                                     BOOL aActive) = 0;
    virtual HRESULT unregisterListener(const ComPtr<IEventListener> &aListener) = 0;
    virtual HRESULT fireEvent(const ComPtr<IEvent> &aEvent,
                              LONG aTimeout,
                              BOOL *aResult) = 0;
    virtual HRESULT getEvent(const ComPtr<IEventListener> &aListener,
                             LONG aTimeout,
                             ComPtr<IEvent> &aEvent) = 0;
    virtual HRESULT eventProcessed(const ComPtr<IEventListener> &aListener,
                                   const ComPtr<IEvent> &aEvent) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(EventSourceWrap); /* Shuts up MSC warning C4625. */

};

#endif // !EventSourceWrap_H_

// ##### ENDFILE "EventSourceWrap.h"


// ##### BEGINFILE "EventListenerWrap.h"
/** @file
 * VirtualBox API class wrapper header for IEventListener.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef EventListenerWrap_H_
#define EventListenerWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE EventListenerWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IEventListener)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(EventListenerWrap, IEventListener)
    DECLARE_NOT_AGGREGATABLE(EventListenerWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(EventListenerWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IEventListener)
        COM_INTERFACE_ENTRY2(IDispatch, IEventListener)
        VBOX_TWEAK_INTERFACE_ENTRY(IEventListener)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(EventListenerWrap)

    /** @name Public IEventListener properties
     * @{ */
    /** @} */

    /** @name Public IEventListener methods
     * @{ */
    STDMETHOD(HandleEvent)(IEvent *aEvent);
    /** @} */

private:
    /** @name Wrapped IEventListener properties
     * @{ */
    /** @} */

    /** @name Wrapped IEventListener methods
     * @{ */
    virtual HRESULT handleEvent(const ComPtr<IEvent> &aEvent) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(EventListenerWrap); /* Shuts up MSC warning C4625. */

};

#endif // !EventListenerWrap_H_

// ##### ENDFILE "EventListenerWrap.h"


// ##### BEGINFILE "EventWrap.h"
/** @file
 * VirtualBox API class wrapper header for IEvent.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef EventWrap_H_
#define EventWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE EventWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IEvent)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(EventWrap, IEvent)
    DECLARE_NOT_AGGREGATABLE(EventWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(EventWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IEvent)
        COM_INTERFACE_ENTRY2(IDispatch, IEvent)
        VBOX_TWEAK_INTERFACE_ENTRY(IEvent)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(EventWrap)

    /** @name Public IEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Type))(VBoxEventType_T *aType);
    STDMETHOD(COMGETTER(Source))(IEventSource **aSource);
    STDMETHOD(COMGETTER(Waitable))(BOOL *aWaitable);
    /** @} */

    /** @name Public IEvent methods
     * @{ */
    STDMETHOD(SetProcessed)();
    STDMETHOD(WaitProcessed)(LONG aTimeout,
                             BOOL *aResult);
    /** @} */

private:
    /** @name Wrapped IEvent properties
     * @{ */
    virtual HRESULT getType(VBoxEventType_T *aType) = 0;
    virtual HRESULT getSource(ComPtr<IEventSource> &aSource) = 0;
    virtual HRESULT getWaitable(BOOL *aWaitable) = 0;
    /** @} */

    /** @name Wrapped IEvent methods
     * @{ */
    virtual HRESULT setProcessed() = 0;
    virtual HRESULT waitProcessed(LONG aTimeout,
                                  BOOL *aResult) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(EventWrap); /* Shuts up MSC warning C4625. */

};

#endif // !EventWrap_H_

// ##### ENDFILE "EventWrap.h"


// ##### BEGINFILE "ReusableEventWrap.h"
/** @file
 * VirtualBox API class wrapper header for IReusableEvent.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef ReusableEventWrap_H_
#define ReusableEventWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE ReusableEventWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IReusableEvent)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(ReusableEventWrap, IReusableEvent)
    DECLARE_NOT_AGGREGATABLE(ReusableEventWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(ReusableEventWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IReusableEvent)
        COM_INTERFACE_ENTRY(IEvent)
        COM_INTERFACE_ENTRY2(IDispatch, IReusableEvent)
        VBOX_TWEAK_INTERFACE_ENTRY(IReusableEvent)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(ReusableEventWrap)

    /** @name Public IEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Type))(VBoxEventType_T *aType);
    STDMETHOD(COMGETTER(Source))(IEventSource **aSource);
    STDMETHOD(COMGETTER(Waitable))(BOOL *aWaitable);
    /** @} */

    /** @name Public IReusableEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Generation))(ULONG *aGeneration);
    /** @} */

    /** @name Public IEvent methods
     * @{ */
    STDMETHOD(SetProcessed)();
    STDMETHOD(WaitProcessed)(LONG aTimeout,
                             BOOL *aResult);
    /** @} */

    /** @name Public IReusableEvent methods
     * @{ */
    STDMETHOD(Reuse)();
    /** @} */

private:
    /** @name Wrapped IEvent properties
     * @{ */
    virtual HRESULT getType(VBoxEventType_T *aType) = 0;
    virtual HRESULT getSource(ComPtr<IEventSource> &aSource) = 0;
    virtual HRESULT getWaitable(BOOL *aWaitable) = 0;
    /** @} */

    /** @name Wrapped IReusableEvent properties
     * @{ */
    virtual HRESULT getGeneration(ULONG *aGeneration) = 0;
    /** @} */

    /** @name Wrapped IEvent methods
     * @{ */
    virtual HRESULT setProcessed() = 0;
    virtual HRESULT waitProcessed(LONG aTimeout,
                                  BOOL *aResult) = 0;
    /** @} */

    /** @name Wrapped IReusableEvent methods
     * @{ */
    virtual HRESULT reuse() = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(ReusableEventWrap); /* Shuts up MSC warning C4625. */

};

#endif // !ReusableEventWrap_H_

// ##### ENDFILE "ReusableEventWrap.h"


// ##### BEGINFILE "MachineEventWrap.h"
/** @file
 * VirtualBox API class wrapper header for IMachineEvent.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef MachineEventWrap_H_
#define MachineEventWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE MachineEventWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IMachineEvent)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(MachineEventWrap, IMachineEvent)
    DECLARE_NOT_AGGREGATABLE(MachineEventWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(MachineEventWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IMachineEvent)
        COM_INTERFACE_ENTRY(IEvent)
        COM_INTERFACE_ENTRY2(IDispatch, IMachineEvent)
        VBOX_TWEAK_INTERFACE_ENTRY(IMachineEvent)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(MachineEventWrap)

    /** @name Public IEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Type))(VBoxEventType_T *aType);
    STDMETHOD(COMGETTER(Source))(IEventSource **aSource);
    STDMETHOD(COMGETTER(Waitable))(BOOL *aWaitable);
    /** @} */

    /** @name Public IMachineEvent properties
     * @{ */
    STDMETHOD(COMGETTER(MachineId))(BSTR *aMachineId);
    /** @} */

    /** @name Public IEvent methods
     * @{ */
    STDMETHOD(SetProcessed)();
    STDMETHOD(WaitProcessed)(LONG aTimeout,
                             BOOL *aResult);
    /** @} */

    /** @name Public IMachineEvent methods
     * @{ */
    /** @} */

private:
    /** @name Wrapped IEvent properties
     * @{ */
    virtual HRESULT getType(VBoxEventType_T *aType) = 0;
    virtual HRESULT getSource(ComPtr<IEventSource> &aSource) = 0;
    virtual HRESULT getWaitable(BOOL *aWaitable) = 0;
    /** @} */

    /** @name Wrapped IMachineEvent properties
     * @{ */
    virtual HRESULT getMachineId(com::Guid &aMachineId) = 0;
    /** @} */

    /** @name Wrapped IEvent methods
     * @{ */
    virtual HRESULT setProcessed() = 0;
    virtual HRESULT waitProcessed(LONG aTimeout,
                                  BOOL *aResult) = 0;
    /** @} */

    /** @name Wrapped IMachineEvent methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(MachineEventWrap); /* Shuts up MSC warning C4625. */

};

#endif // !MachineEventWrap_H_

// ##### ENDFILE "MachineEventWrap.h"


// ##### BEGINFILE "SnapshotEventWrap.h"
/** @file
 * VirtualBox API class wrapper header for ISnapshotEvent.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef SnapshotEventWrap_H_
#define SnapshotEventWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE SnapshotEventWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(ISnapshotEvent)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(SnapshotEventWrap, ISnapshotEvent)
    DECLARE_NOT_AGGREGATABLE(SnapshotEventWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(SnapshotEventWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(ISnapshotEvent)
        COM_INTERFACE_ENTRY(IMachineEvent)
        COM_INTERFACE_ENTRY(IEvent)
        COM_INTERFACE_ENTRY2(IDispatch, ISnapshotEvent)
        VBOX_TWEAK_INTERFACE_ENTRY(ISnapshotEvent)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(SnapshotEventWrap)

    /** @name Public IEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Type))(VBoxEventType_T *aType);
    STDMETHOD(COMGETTER(Source))(IEventSource **aSource);
    STDMETHOD(COMGETTER(Waitable))(BOOL *aWaitable);
    /** @} */

    /** @name Public IMachineEvent properties
     * @{ */
    STDMETHOD(COMGETTER(MachineId))(BSTR *aMachineId);
    /** @} */

    /** @name Public ISnapshotEvent properties
     * @{ */
    STDMETHOD(COMGETTER(SnapshotId))(BSTR *aSnapshotId);
    /** @} */

    /** @name Public IEvent methods
     * @{ */
    STDMETHOD(SetProcessed)();
    STDMETHOD(WaitProcessed)(LONG aTimeout,
                             BOOL *aResult);
    /** @} */

    /** @name Public IMachineEvent methods
     * @{ */
    /** @} */

    /** @name Public ISnapshotEvent methods
     * @{ */
    /** @} */

private:
    /** @name Wrapped IEvent properties
     * @{ */
    virtual HRESULT getType(VBoxEventType_T *aType) = 0;
    virtual HRESULT getSource(ComPtr<IEventSource> &aSource) = 0;
    virtual HRESULT getWaitable(BOOL *aWaitable) = 0;
    /** @} */

    /** @name Wrapped IMachineEvent properties
     * @{ */
    virtual HRESULT getMachineId(com::Guid &aMachineId) = 0;
    /** @} */

    /** @name Wrapped ISnapshotEvent properties
     * @{ */
    virtual HRESULT getSnapshotId(com::Guid &aSnapshotId) = 0;
    /** @} */

    /** @name Wrapped IEvent methods
     * @{ */
    virtual HRESULT setProcessed() = 0;
    virtual HRESULT waitProcessed(LONG aTimeout,
                                  BOOL *aResult) = 0;
    /** @} */

    /** @name Wrapped IMachineEvent methods
     * @{ */
    /** @} */

    /** @name Wrapped ISnapshotEvent methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(SnapshotEventWrap); /* Shuts up MSC warning C4625. */

};

#endif // !SnapshotEventWrap_H_

// ##### ENDFILE "SnapshotEventWrap.h"


// ##### BEGINFILE "GuestSessionEventWrap.h"
/** @file
 * VirtualBox API class wrapper header for IGuestSessionEvent.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef GuestSessionEventWrap_H_
#define GuestSessionEventWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE GuestSessionEventWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IGuestSessionEvent)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(GuestSessionEventWrap, IGuestSessionEvent)
    DECLARE_NOT_AGGREGATABLE(GuestSessionEventWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(GuestSessionEventWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IGuestSessionEvent)
        COM_INTERFACE_ENTRY(IEvent)
        COM_INTERFACE_ENTRY2(IDispatch, IGuestSessionEvent)
        VBOX_TWEAK_INTERFACE_ENTRY(IGuestSessionEvent)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(GuestSessionEventWrap)

    /** @name Public IEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Type))(VBoxEventType_T *aType);
    STDMETHOD(COMGETTER(Source))(IEventSource **aSource);
    STDMETHOD(COMGETTER(Waitable))(BOOL *aWaitable);
    /** @} */

    /** @name Public IGuestSessionEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Session))(IGuestSession **aSession);
    /** @} */

    /** @name Public IEvent methods
     * @{ */
    STDMETHOD(SetProcessed)();
    STDMETHOD(WaitProcessed)(LONG aTimeout,
                             BOOL *aResult);
    /** @} */

    /** @name Public IGuestSessionEvent methods
     * @{ */
    /** @} */

private:
    /** @name Wrapped IEvent properties
     * @{ */
    virtual HRESULT getType(VBoxEventType_T *aType) = 0;
    virtual HRESULT getSource(ComPtr<IEventSource> &aSource) = 0;
    virtual HRESULT getWaitable(BOOL *aWaitable) = 0;
    /** @} */

    /** @name Wrapped IGuestSessionEvent properties
     * @{ */
    virtual HRESULT getSession(ComPtr<IGuestSession> &aSession) = 0;
    /** @} */

    /** @name Wrapped IEvent methods
     * @{ */
    virtual HRESULT setProcessed() = 0;
    virtual HRESULT waitProcessed(LONG aTimeout,
                                  BOOL *aResult) = 0;
    /** @} */

    /** @name Wrapped IGuestSessionEvent methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(GuestSessionEventWrap); /* Shuts up MSC warning C4625. */

};

#endif // !GuestSessionEventWrap_H_

// ##### ENDFILE "GuestSessionEventWrap.h"


// ##### BEGINFILE "GuestProcessEventWrap.h"
/** @file
 * VirtualBox API class wrapper header for IGuestProcessEvent.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef GuestProcessEventWrap_H_
#define GuestProcessEventWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE GuestProcessEventWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IGuestProcessEvent)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(GuestProcessEventWrap, IGuestProcessEvent)
    DECLARE_NOT_AGGREGATABLE(GuestProcessEventWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(GuestProcessEventWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IGuestProcessEvent)
        COM_INTERFACE_ENTRY(IGuestSessionEvent)
        COM_INTERFACE_ENTRY(IEvent)
        COM_INTERFACE_ENTRY2(IDispatch, IGuestProcessEvent)
        VBOX_TWEAK_INTERFACE_ENTRY(IGuestProcessEvent)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(GuestProcessEventWrap)

    /** @name Public IEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Type))(VBoxEventType_T *aType);
    STDMETHOD(COMGETTER(Source))(IEventSource **aSource);
    STDMETHOD(COMGETTER(Waitable))(BOOL *aWaitable);
    /** @} */

    /** @name Public IGuestSessionEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Session))(IGuestSession **aSession);
    /** @} */

    /** @name Public IGuestProcessEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Process))(IGuestProcess **aProcess);
    STDMETHOD(COMGETTER(Pid))(ULONG *aPid);
    /** @} */

    /** @name Public IEvent methods
     * @{ */
    STDMETHOD(SetProcessed)();
    STDMETHOD(WaitProcessed)(LONG aTimeout,
                             BOOL *aResult);
    /** @} */

    /** @name Public IGuestSessionEvent methods
     * @{ */
    /** @} */

    /** @name Public IGuestProcessEvent methods
     * @{ */
    /** @} */

private:
    /** @name Wrapped IEvent properties
     * @{ */
    virtual HRESULT getType(VBoxEventType_T *aType) = 0;
    virtual HRESULT getSource(ComPtr<IEventSource> &aSource) = 0;
    virtual HRESULT getWaitable(BOOL *aWaitable) = 0;
    /** @} */

    /** @name Wrapped IGuestSessionEvent properties
     * @{ */
    virtual HRESULT getSession(ComPtr<IGuestSession> &aSession) = 0;
    /** @} */

    /** @name Wrapped IGuestProcessEvent properties
     * @{ */
    virtual HRESULT getProcess(ComPtr<IGuestProcess> &aProcess) = 0;
    virtual HRESULT getPid(ULONG *aPid) = 0;
    /** @} */

    /** @name Wrapped IEvent methods
     * @{ */
    virtual HRESULT setProcessed() = 0;
    virtual HRESULT waitProcessed(LONG aTimeout,
                                  BOOL *aResult) = 0;
    /** @} */

    /** @name Wrapped IGuestSessionEvent methods
     * @{ */
    /** @} */

    /** @name Wrapped IGuestProcessEvent methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(GuestProcessEventWrap); /* Shuts up MSC warning C4625. */

};

#endif // !GuestProcessEventWrap_H_

// ##### ENDFILE "GuestProcessEventWrap.h"


// ##### BEGINFILE "GuestProcessIOEventWrap.h"
/** @file
 * VirtualBox API class wrapper header for IGuestProcessIOEvent.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef GuestProcessIOEventWrap_H_
#define GuestProcessIOEventWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE GuestProcessIOEventWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IGuestProcessIOEvent)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(GuestProcessIOEventWrap, IGuestProcessIOEvent)
    DECLARE_NOT_AGGREGATABLE(GuestProcessIOEventWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(GuestProcessIOEventWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IGuestProcessIOEvent)
        COM_INTERFACE_ENTRY(IGuestProcessEvent)
        COM_INTERFACE_ENTRY(IGuestSessionEvent)
        COM_INTERFACE_ENTRY(IEvent)
        COM_INTERFACE_ENTRY2(IDispatch, IGuestProcessIOEvent)
        VBOX_TWEAK_INTERFACE_ENTRY(IGuestProcessIOEvent)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(GuestProcessIOEventWrap)

    /** @name Public IEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Type))(VBoxEventType_T *aType);
    STDMETHOD(COMGETTER(Source))(IEventSource **aSource);
    STDMETHOD(COMGETTER(Waitable))(BOOL *aWaitable);
    /** @} */

    /** @name Public IGuestSessionEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Session))(IGuestSession **aSession);
    /** @} */

    /** @name Public IGuestProcessEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Process))(IGuestProcess **aProcess);
    STDMETHOD(COMGETTER(Pid))(ULONG *aPid);
    /** @} */

    /** @name Public IGuestProcessIOEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Handle))(ULONG *aHandle);
    STDMETHOD(COMGETTER(Processed))(ULONG *aProcessed);
    /** @} */

    /** @name Public IEvent methods
     * @{ */
    STDMETHOD(SetProcessed)();
    STDMETHOD(WaitProcessed)(LONG aTimeout,
                             BOOL *aResult);
    /** @} */

    /** @name Public IGuestSessionEvent methods
     * @{ */
    /** @} */

    /** @name Public IGuestProcessEvent methods
     * @{ */
    /** @} */

    /** @name Public IGuestProcessIOEvent methods
     * @{ */
    /** @} */

private:
    /** @name Wrapped IEvent properties
     * @{ */
    virtual HRESULT getType(VBoxEventType_T *aType) = 0;
    virtual HRESULT getSource(ComPtr<IEventSource> &aSource) = 0;
    virtual HRESULT getWaitable(BOOL *aWaitable) = 0;
    /** @} */

    /** @name Wrapped IGuestSessionEvent properties
     * @{ */
    virtual HRESULT getSession(ComPtr<IGuestSession> &aSession) = 0;
    /** @} */

    /** @name Wrapped IGuestProcessEvent properties
     * @{ */
    virtual HRESULT getProcess(ComPtr<IGuestProcess> &aProcess) = 0;
    virtual HRESULT getPid(ULONG *aPid) = 0;
    /** @} */

    /** @name Wrapped IGuestProcessIOEvent properties
     * @{ */
    virtual HRESULT getHandle(ULONG *aHandle) = 0;
    virtual HRESULT getProcessed(ULONG *aProcessed) = 0;
    /** @} */

    /** @name Wrapped IEvent methods
     * @{ */
    virtual HRESULT setProcessed() = 0;
    virtual HRESULT waitProcessed(LONG aTimeout,
                                  BOOL *aResult) = 0;
    /** @} */

    /** @name Wrapped IGuestSessionEvent methods
     * @{ */
    /** @} */

    /** @name Wrapped IGuestProcessEvent methods
     * @{ */
    /** @} */

    /** @name Wrapped IGuestProcessIOEvent methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(GuestProcessIOEventWrap); /* Shuts up MSC warning C4625. */

};

#endif // !GuestProcessIOEventWrap_H_

// ##### ENDFILE "GuestProcessIOEventWrap.h"


// ##### BEGINFILE "GuestFileEventWrap.h"
/** @file
 * VirtualBox API class wrapper header for IGuestFileEvent.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef GuestFileEventWrap_H_
#define GuestFileEventWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE GuestFileEventWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IGuestFileEvent)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(GuestFileEventWrap, IGuestFileEvent)
    DECLARE_NOT_AGGREGATABLE(GuestFileEventWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(GuestFileEventWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IGuestFileEvent)
        COM_INTERFACE_ENTRY(IGuestSessionEvent)
        COM_INTERFACE_ENTRY(IEvent)
        COM_INTERFACE_ENTRY2(IDispatch, IGuestFileEvent)
        VBOX_TWEAK_INTERFACE_ENTRY(IGuestFileEvent)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(GuestFileEventWrap)

    /** @name Public IEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Type))(VBoxEventType_T *aType);
    STDMETHOD(COMGETTER(Source))(IEventSource **aSource);
    STDMETHOD(COMGETTER(Waitable))(BOOL *aWaitable);
    /** @} */

    /** @name Public IGuestSessionEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Session))(IGuestSession **aSession);
    /** @} */

    /** @name Public IGuestFileEvent properties
     * @{ */
    STDMETHOD(COMGETTER(File))(IGuestFile **aFile);
    /** @} */

    /** @name Public IEvent methods
     * @{ */
    STDMETHOD(SetProcessed)();
    STDMETHOD(WaitProcessed)(LONG aTimeout,
                             BOOL *aResult);
    /** @} */

    /** @name Public IGuestSessionEvent methods
     * @{ */
    /** @} */

    /** @name Public IGuestFileEvent methods
     * @{ */
    /** @} */

private:
    /** @name Wrapped IEvent properties
     * @{ */
    virtual HRESULT getType(VBoxEventType_T *aType) = 0;
    virtual HRESULT getSource(ComPtr<IEventSource> &aSource) = 0;
    virtual HRESULT getWaitable(BOOL *aWaitable) = 0;
    /** @} */

    /** @name Wrapped IGuestSessionEvent properties
     * @{ */
    virtual HRESULT getSession(ComPtr<IGuestSession> &aSession) = 0;
    /** @} */

    /** @name Wrapped IGuestFileEvent properties
     * @{ */
    virtual HRESULT getFile(ComPtr<IGuestFile> &aFile) = 0;
    /** @} */

    /** @name Wrapped IEvent methods
     * @{ */
    virtual HRESULT setProcessed() = 0;
    virtual HRESULT waitProcessed(LONG aTimeout,
                                  BOOL *aResult) = 0;
    /** @} */

    /** @name Wrapped IGuestSessionEvent methods
     * @{ */
    /** @} */

    /** @name Wrapped IGuestFileEvent methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(GuestFileEventWrap); /* Shuts up MSC warning C4625. */

};

#endif // !GuestFileEventWrap_H_

// ##### ENDFILE "GuestFileEventWrap.h"


// ##### BEGINFILE "GuestFileIOEventWrap.h"
/** @file
 * VirtualBox API class wrapper header for IGuestFileIOEvent.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef GuestFileIOEventWrap_H_
#define GuestFileIOEventWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE GuestFileIOEventWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IGuestFileIOEvent)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(GuestFileIOEventWrap, IGuestFileIOEvent)
    DECLARE_NOT_AGGREGATABLE(GuestFileIOEventWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(GuestFileIOEventWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IGuestFileIOEvent)
        COM_INTERFACE_ENTRY(IGuestFileEvent)
        COM_INTERFACE_ENTRY(IGuestSessionEvent)
        COM_INTERFACE_ENTRY(IEvent)
        COM_INTERFACE_ENTRY2(IDispatch, IGuestFileIOEvent)
        VBOX_TWEAK_INTERFACE_ENTRY(IGuestFileIOEvent)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(GuestFileIOEventWrap)

    /** @name Public IEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Type))(VBoxEventType_T *aType);
    STDMETHOD(COMGETTER(Source))(IEventSource **aSource);
    STDMETHOD(COMGETTER(Waitable))(BOOL *aWaitable);
    /** @} */

    /** @name Public IGuestSessionEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Session))(IGuestSession **aSession);
    /** @} */

    /** @name Public IGuestFileEvent properties
     * @{ */
    STDMETHOD(COMGETTER(File))(IGuestFile **aFile);
    /** @} */

    /** @name Public IGuestFileIOEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Offset))(LONG64 *aOffset);
    STDMETHOD(COMGETTER(Processed))(ULONG *aProcessed);
    /** @} */

    /** @name Public IEvent methods
     * @{ */
    STDMETHOD(SetProcessed)();
    STDMETHOD(WaitProcessed)(LONG aTimeout,
                             BOOL *aResult);
    /** @} */

    /** @name Public IGuestSessionEvent methods
     * @{ */
    /** @} */

    /** @name Public IGuestFileEvent methods
     * @{ */
    /** @} */

    /** @name Public IGuestFileIOEvent methods
     * @{ */
    /** @} */

private:
    /** @name Wrapped IEvent properties
     * @{ */
    virtual HRESULT getType(VBoxEventType_T *aType) = 0;
    virtual HRESULT getSource(ComPtr<IEventSource> &aSource) = 0;
    virtual HRESULT getWaitable(BOOL *aWaitable) = 0;
    /** @} */

    /** @name Wrapped IGuestSessionEvent properties
     * @{ */
    virtual HRESULT getSession(ComPtr<IGuestSession> &aSession) = 0;
    /** @} */

    /** @name Wrapped IGuestFileEvent properties
     * @{ */
    virtual HRESULT getFile(ComPtr<IGuestFile> &aFile) = 0;
    /** @} */

    /** @name Wrapped IGuestFileIOEvent properties
     * @{ */
    virtual HRESULT getOffset(LONG64 *aOffset) = 0;
    virtual HRESULT getProcessed(ULONG *aProcessed) = 0;
    /** @} */

    /** @name Wrapped IEvent methods
     * @{ */
    virtual HRESULT setProcessed() = 0;
    virtual HRESULT waitProcessed(LONG aTimeout,
                                  BOOL *aResult) = 0;
    /** @} */

    /** @name Wrapped IGuestSessionEvent methods
     * @{ */
    /** @} */

    /** @name Wrapped IGuestFileEvent methods
     * @{ */
    /** @} */

    /** @name Wrapped IGuestFileIOEvent methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(GuestFileIOEventWrap); /* Shuts up MSC warning C4625. */

};

#endif // !GuestFileIOEventWrap_H_

// ##### ENDFILE "GuestFileIOEventWrap.h"


// ##### BEGINFILE "VetoEventWrap.h"
/** @file
 * VirtualBox API class wrapper header for IVetoEvent.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef VetoEventWrap_H_
#define VetoEventWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE VetoEventWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IVetoEvent)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(VetoEventWrap, IVetoEvent)
    DECLARE_NOT_AGGREGATABLE(VetoEventWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(VetoEventWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IVetoEvent)
        COM_INTERFACE_ENTRY(IEvent)
        COM_INTERFACE_ENTRY2(IDispatch, IVetoEvent)
        VBOX_TWEAK_INTERFACE_ENTRY(IVetoEvent)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(VetoEventWrap)

    /** @name Public IEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Type))(VBoxEventType_T *aType);
    STDMETHOD(COMGETTER(Source))(IEventSource **aSource);
    STDMETHOD(COMGETTER(Waitable))(BOOL *aWaitable);
    /** @} */

    /** @name Public IVetoEvent properties
     * @{ */
    /** @} */

    /** @name Public IEvent methods
     * @{ */
    STDMETHOD(SetProcessed)();
    STDMETHOD(WaitProcessed)(LONG aTimeout,
                             BOOL *aResult);
    /** @} */

    /** @name Public IVetoEvent methods
     * @{ */
    STDMETHOD(AddVeto)(IN_BSTR aReason);
    STDMETHOD(IsVetoed)(BOOL *aResult);
    STDMETHOD(GetVetos)(ComSafeArrayOut(BSTR, aResult));
    STDMETHOD(AddApproval)(IN_BSTR aReason);
    STDMETHOD(IsApproved)(BOOL *aResult);
    STDMETHOD(GetApprovals)(ComSafeArrayOut(BSTR, aResult));
    /** @} */

private:
    /** @name Wrapped IEvent properties
     * @{ */
    virtual HRESULT getType(VBoxEventType_T *aType) = 0;
    virtual HRESULT getSource(ComPtr<IEventSource> &aSource) = 0;
    virtual HRESULT getWaitable(BOOL *aWaitable) = 0;
    /** @} */

    /** @name Wrapped IVetoEvent properties
     * @{ */
    /** @} */

    /** @name Wrapped IEvent methods
     * @{ */
    virtual HRESULT setProcessed() = 0;
    virtual HRESULT waitProcessed(LONG aTimeout,
                                  BOOL *aResult) = 0;
    /** @} */

    /** @name Wrapped IVetoEvent methods
     * @{ */
    virtual HRESULT addVeto(const com::Utf8Str &aReason) = 0;
    virtual HRESULT isVetoed(BOOL *aResult) = 0;
    virtual HRESULT getVetos(std::vector<com::Utf8Str> &aResult) = 0;
    virtual HRESULT addApproval(const com::Utf8Str &aReason) = 0;
    virtual HRESULT isApproved(BOOL *aResult) = 0;
    virtual HRESULT getApprovals(std::vector<com::Utf8Str> &aResult) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(VetoEventWrap); /* Shuts up MSC warning C4625. */

};

#endif // !VetoEventWrap_H_

// ##### ENDFILE "VetoEventWrap.h"


// ##### BEGINFILE "ProgressEventWrap.h"
/** @file
 * VirtualBox API class wrapper header for IProgressEvent.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef ProgressEventWrap_H_
#define ProgressEventWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE ProgressEventWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IProgressEvent)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(ProgressEventWrap, IProgressEvent)
    DECLARE_NOT_AGGREGATABLE(ProgressEventWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(ProgressEventWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IProgressEvent)
        COM_INTERFACE_ENTRY(IEvent)
        COM_INTERFACE_ENTRY2(IDispatch, IProgressEvent)
        VBOX_TWEAK_INTERFACE_ENTRY(IProgressEvent)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(ProgressEventWrap)

    /** @name Public IEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Type))(VBoxEventType_T *aType);
    STDMETHOD(COMGETTER(Source))(IEventSource **aSource);
    STDMETHOD(COMGETTER(Waitable))(BOOL *aWaitable);
    /** @} */

    /** @name Public IProgressEvent properties
     * @{ */
    STDMETHOD(COMGETTER(ProgressId))(BSTR *aProgressId);
    /** @} */

    /** @name Public IEvent methods
     * @{ */
    STDMETHOD(SetProcessed)();
    STDMETHOD(WaitProcessed)(LONG aTimeout,
                             BOOL *aResult);
    /** @} */

    /** @name Public IProgressEvent methods
     * @{ */
    /** @} */

private:
    /** @name Wrapped IEvent properties
     * @{ */
    virtual HRESULT getType(VBoxEventType_T *aType) = 0;
    virtual HRESULT getSource(ComPtr<IEventSource> &aSource) = 0;
    virtual HRESULT getWaitable(BOOL *aWaitable) = 0;
    /** @} */

    /** @name Wrapped IProgressEvent properties
     * @{ */
    virtual HRESULT getProgressId(com::Guid &aProgressId) = 0;
    /** @} */

    /** @name Wrapped IEvent methods
     * @{ */
    virtual HRESULT setProcessed() = 0;
    virtual HRESULT waitProcessed(LONG aTimeout,
                                  BOOL *aResult) = 0;
    /** @} */

    /** @name Wrapped IProgressEvent methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(ProgressEventWrap); /* Shuts up MSC warning C4625. */

};

#endif // !ProgressEventWrap_H_

// ##### ENDFILE "ProgressEventWrap.h"


// ##### BEGINFILE "StringArrayWrap.h"
/** @file
 * VirtualBox API class wrapper header for IStringArray.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef StringArrayWrap_H_
#define StringArrayWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE StringArrayWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IStringArray)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(StringArrayWrap, IStringArray)
    DECLARE_NOT_AGGREGATABLE(StringArrayWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(StringArrayWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IStringArray)
        COM_INTERFACE_ENTRY2(IDispatch, IStringArray)
        VBOX_TWEAK_INTERFACE_ENTRY(IStringArray)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(StringArrayWrap)

    /** @name Public IStringArray properties
     * @{ */
    STDMETHOD(COMGETTER(Values))(ComSafeArrayOut(BSTR, aValues));
    /** @} */

    /** @name Public IStringArray methods
     * @{ */
    STDMETHOD(InternalAndReservedMethod1IStringArray)();
    STDMETHOD(InternalAndReservedMethod2IStringArray)();
    STDMETHOD(InternalAndReservedMethod3IStringArray)();
    STDMETHOD(InternalAndReservedMethod4IStringArray)();
    /** @} */

private:
    /** @name Wrapped IStringArray properties
     * @{ */
    virtual HRESULT getValues(std::vector<com::Utf8Str> &aValues) = 0;
    /** @} */

    /** @name Wrapped IStringArray methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(StringArrayWrap); /* Shuts up MSC warning C4625. */

};

#endif // !StringArrayWrap_H_

// ##### ENDFILE "StringArrayWrap.h"


// ##### BEGINFILE "FormValueWrap.h"
/** @file
 * VirtualBox API class wrapper header for IFormValue.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef FormValueWrap_H_
#define FormValueWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE FormValueWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IFormValue)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(FormValueWrap, IFormValue)
    DECLARE_NOT_AGGREGATABLE(FormValueWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(FormValueWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IFormValue)
        COM_INTERFACE_ENTRY2(IDispatch, IFormValue)
        VBOX_TWEAK_INTERFACE_ENTRY(IFormValue)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(FormValueWrap)

    /** @name Public IFormValue properties
     * @{ */
    STDMETHOD(COMGETTER(Type))(FormValueType_T *aType);
    STDMETHOD(COMGETTER(Generation))(LONG *aGeneration);
    STDMETHOD(COMGETTER(Enabled))(BOOL *aEnabled);
    STDMETHOD(COMGETTER(Visible))(BOOL *aVisible);
    STDMETHOD(COMGETTER(Label))(BSTR *aLabel);
    STDMETHOD(COMGETTER(Description))(BSTR *aDescription);
    STDMETHOD(COMGETTER(Help))(BSTR *aHelp);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IFormValue))(ULONG *aReserved);
    /** @} */

    /** @name Public IFormValue methods
     * @{ */
    STDMETHOD(InternalAndReservedMethod1IFormValue)();
    STDMETHOD(InternalAndReservedMethod2IFormValue)();
    STDMETHOD(InternalAndReservedMethod3IFormValue)();
    STDMETHOD(InternalAndReservedMethod4IFormValue)();
    /** @} */

private:
    /** @name Wrapped IFormValue properties
     * @{ */
    virtual HRESULT getType(FormValueType_T *aType) = 0;
    virtual HRESULT getGeneration(LONG *aGeneration) = 0;
    virtual HRESULT getEnabled(BOOL *aEnabled) = 0;
    virtual HRESULT getVisible(BOOL *aVisible) = 0;
    virtual HRESULT getLabel(com::Utf8Str &aLabel) = 0;
    virtual HRESULT getDescription(com::Utf8Str &aDescription) = 0;
    virtual HRESULT getHelp(com::Utf8Str &aHelp) = 0;
    /** @} */

    /** @name Wrapped IFormValue methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(FormValueWrap); /* Shuts up MSC warning C4625. */

};

#endif // !FormValueWrap_H_

// ##### ENDFILE "FormValueWrap.h"


// ##### BEGINFILE "BooleanFormValueWrap.h"
/** @file
 * VirtualBox API class wrapper header for IBooleanFormValue.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef BooleanFormValueWrap_H_
#define BooleanFormValueWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE BooleanFormValueWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IBooleanFormValue)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(BooleanFormValueWrap, IBooleanFormValue)
    DECLARE_NOT_AGGREGATABLE(BooleanFormValueWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(BooleanFormValueWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IBooleanFormValue)
        COM_INTERFACE_ENTRY(IFormValue)
        COM_INTERFACE_ENTRY2(IDispatch, IBooleanFormValue)
        VBOX_TWEAK_INTERFACE_ENTRY(IBooleanFormValue)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(BooleanFormValueWrap)

    /** @name Public IFormValue properties
     * @{ */
    STDMETHOD(COMGETTER(Type))(FormValueType_T *aType);
    STDMETHOD(COMGETTER(Generation))(LONG *aGeneration);
    STDMETHOD(COMGETTER(Enabled))(BOOL *aEnabled);
    STDMETHOD(COMGETTER(Visible))(BOOL *aVisible);
    STDMETHOD(COMGETTER(Label))(BSTR *aLabel);
    STDMETHOD(COMGETTER(Description))(BSTR *aDescription);
    STDMETHOD(COMGETTER(Help))(BSTR *aHelp);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IFormValue))(ULONG *aReserved);
    /** @} */

    /** @name Public IBooleanFormValue properties
     * @{ */
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IBooleanFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IBooleanFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IBooleanFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IBooleanFormValue))(ULONG *aReserved);
    /** @} */

    /** @name Public IFormValue methods
     * @{ */
    STDMETHOD(InternalAndReservedMethod1IFormValue)();
    STDMETHOD(InternalAndReservedMethod2IFormValue)();
    STDMETHOD(InternalAndReservedMethod3IFormValue)();
    STDMETHOD(InternalAndReservedMethod4IFormValue)();
    /** @} */

    /** @name Public IBooleanFormValue methods
     * @{ */
    STDMETHOD(GetSelected)(BOOL *aSelected);
    STDMETHOD(SetSelected)(BOOL aSelected,
                           IProgress **aProgress);
    STDMETHOD(InternalAndReservedMethod1IBooleanFormValue)();
    STDMETHOD(InternalAndReservedMethod2IBooleanFormValue)();
    STDMETHOD(InternalAndReservedMethod3IBooleanFormValue)();
    STDMETHOD(InternalAndReservedMethod4IBooleanFormValue)();
    /** @} */

private:
    /** @name Wrapped IFormValue properties
     * @{ */
    virtual HRESULT getType(FormValueType_T *aType) = 0;
    virtual HRESULT getGeneration(LONG *aGeneration) = 0;
    virtual HRESULT getEnabled(BOOL *aEnabled) = 0;
    virtual HRESULT getVisible(BOOL *aVisible) = 0;
    virtual HRESULT getLabel(com::Utf8Str &aLabel) = 0;
    virtual HRESULT getDescription(com::Utf8Str &aDescription) = 0;
    virtual HRESULT getHelp(com::Utf8Str &aHelp) = 0;
    /** @} */

    /** @name Wrapped IBooleanFormValue properties
     * @{ */
    /** @} */

    /** @name Wrapped IFormValue methods
     * @{ */
    /** @} */

    /** @name Wrapped IBooleanFormValue methods
     * @{ */
    virtual HRESULT getSelected(BOOL *aSelected) = 0;
    virtual HRESULT setSelected(BOOL aSelected,
                                ComPtr<IProgress> &aProgress) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(BooleanFormValueWrap); /* Shuts up MSC warning C4625. */

};

#endif // !BooleanFormValueWrap_H_

// ##### ENDFILE "BooleanFormValueWrap.h"


// ##### BEGINFILE "RangedIntegerFormValueWrap.h"
/** @file
 * VirtualBox API class wrapper header for IRangedIntegerFormValue.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef RangedIntegerFormValueWrap_H_
#define RangedIntegerFormValueWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE RangedIntegerFormValueWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IRangedIntegerFormValue)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(RangedIntegerFormValueWrap, IRangedIntegerFormValue)
    DECLARE_NOT_AGGREGATABLE(RangedIntegerFormValueWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(RangedIntegerFormValueWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IRangedIntegerFormValue)
        COM_INTERFACE_ENTRY(IFormValue)
        COM_INTERFACE_ENTRY2(IDispatch, IRangedIntegerFormValue)
        VBOX_TWEAK_INTERFACE_ENTRY(IRangedIntegerFormValue)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(RangedIntegerFormValueWrap)

    /** @name Public IFormValue properties
     * @{ */
    STDMETHOD(COMGETTER(Type))(FormValueType_T *aType);
    STDMETHOD(COMGETTER(Generation))(LONG *aGeneration);
    STDMETHOD(COMGETTER(Enabled))(BOOL *aEnabled);
    STDMETHOD(COMGETTER(Visible))(BOOL *aVisible);
    STDMETHOD(COMGETTER(Label))(BSTR *aLabel);
    STDMETHOD(COMGETTER(Description))(BSTR *aDescription);
    STDMETHOD(COMGETTER(Help))(BSTR *aHelp);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IFormValue))(ULONG *aReserved);
    /** @} */

    /** @name Public IRangedIntegerFormValue properties
     * @{ */
    STDMETHOD(COMGETTER(Suffix))(BSTR *aSuffix);
    STDMETHOD(COMGETTER(Minimum))(LONG *aMinimum);
    STDMETHOD(COMGETTER(Maximum))(LONG *aMaximum);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IRangedIntegerFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IRangedIntegerFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IRangedIntegerFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IRangedIntegerFormValue))(ULONG *aReserved);
    /** @} */

    /** @name Public IFormValue methods
     * @{ */
    STDMETHOD(InternalAndReservedMethod1IFormValue)();
    STDMETHOD(InternalAndReservedMethod2IFormValue)();
    STDMETHOD(InternalAndReservedMethod3IFormValue)();
    STDMETHOD(InternalAndReservedMethod4IFormValue)();
    /** @} */

    /** @name Public IRangedIntegerFormValue methods
     * @{ */
    STDMETHOD(GetInteger)(LONG *aValue);
    STDMETHOD(SetInteger)(LONG aValue,
                          IProgress **aProgress);
    STDMETHOD(InternalAndReservedMethod1IRangedIntegerFormValue)();
    STDMETHOD(InternalAndReservedMethod2IRangedIntegerFormValue)();
    STDMETHOD(InternalAndReservedMethod3IRangedIntegerFormValue)();
    STDMETHOD(InternalAndReservedMethod4IRangedIntegerFormValue)();
    /** @} */

private:
    /** @name Wrapped IFormValue properties
     * @{ */
    virtual HRESULT getType(FormValueType_T *aType) = 0;
    virtual HRESULT getGeneration(LONG *aGeneration) = 0;
    virtual HRESULT getEnabled(BOOL *aEnabled) = 0;
    virtual HRESULT getVisible(BOOL *aVisible) = 0;
    virtual HRESULT getLabel(com::Utf8Str &aLabel) = 0;
    virtual HRESULT getDescription(com::Utf8Str &aDescription) = 0;
    virtual HRESULT getHelp(com::Utf8Str &aHelp) = 0;
    /** @} */

    /** @name Wrapped IRangedIntegerFormValue properties
     * @{ */
    virtual HRESULT getSuffix(com::Utf8Str &aSuffix) = 0;
    virtual HRESULT getMinimum(LONG *aMinimum) = 0;
    virtual HRESULT getMaximum(LONG *aMaximum) = 0;
    /** @} */

    /** @name Wrapped IFormValue methods
     * @{ */
    /** @} */

    /** @name Wrapped IRangedIntegerFormValue methods
     * @{ */
    virtual HRESULT getInteger(LONG *aValue) = 0;
    virtual HRESULT setInteger(LONG aValue,
                               ComPtr<IProgress> &aProgress) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(RangedIntegerFormValueWrap); /* Shuts up MSC warning C4625. */

};

#endif // !RangedIntegerFormValueWrap_H_

// ##### ENDFILE "RangedIntegerFormValueWrap.h"


// ##### BEGINFILE "StringFormValueWrap.h"
/** @file
 * VirtualBox API class wrapper header for IStringFormValue.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef StringFormValueWrap_H_
#define StringFormValueWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE StringFormValueWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IStringFormValue)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(StringFormValueWrap, IStringFormValue)
    DECLARE_NOT_AGGREGATABLE(StringFormValueWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(StringFormValueWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IStringFormValue)
        COM_INTERFACE_ENTRY(IFormValue)
        COM_INTERFACE_ENTRY2(IDispatch, IStringFormValue)
        VBOX_TWEAK_INTERFACE_ENTRY(IStringFormValue)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(StringFormValueWrap)

    /** @name Public IFormValue properties
     * @{ */
    STDMETHOD(COMGETTER(Type))(FormValueType_T *aType);
    STDMETHOD(COMGETTER(Generation))(LONG *aGeneration);
    STDMETHOD(COMGETTER(Enabled))(BOOL *aEnabled);
    STDMETHOD(COMGETTER(Visible))(BOOL *aVisible);
    STDMETHOD(COMGETTER(Label))(BSTR *aLabel);
    STDMETHOD(COMGETTER(Description))(BSTR *aDescription);
    STDMETHOD(COMGETTER(Help))(BSTR *aHelp);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IFormValue))(ULONG *aReserved);
    /** @} */

    /** @name Public IStringFormValue properties
     * @{ */
    STDMETHOD(COMGETTER(Multiline))(BOOL *aMultiline);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IStringFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IStringFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IStringFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IStringFormValue))(ULONG *aReserved);
    /** @} */

    /** @name Public IFormValue methods
     * @{ */
    STDMETHOD(InternalAndReservedMethod1IFormValue)();
    STDMETHOD(InternalAndReservedMethod2IFormValue)();
    STDMETHOD(InternalAndReservedMethod3IFormValue)();
    STDMETHOD(InternalAndReservedMethod4IFormValue)();
    /** @} */

    /** @name Public IStringFormValue methods
     * @{ */
    STDMETHOD(GetString)(BSTR *aText);
    STDMETHOD(SetString)(IN_BSTR aText,
                         IProgress **aProgress);
    STDMETHOD(InternalAndReservedMethod1IStringFormValue)();
    STDMETHOD(InternalAndReservedMethod2IStringFormValue)();
    STDMETHOD(InternalAndReservedMethod3IStringFormValue)();
    STDMETHOD(InternalAndReservedMethod4IStringFormValue)();
    /** @} */

private:
    /** @name Wrapped IFormValue properties
     * @{ */
    virtual HRESULT getType(FormValueType_T *aType) = 0;
    virtual HRESULT getGeneration(LONG *aGeneration) = 0;
    virtual HRESULT getEnabled(BOOL *aEnabled) = 0;
    virtual HRESULT getVisible(BOOL *aVisible) = 0;
    virtual HRESULT getLabel(com::Utf8Str &aLabel) = 0;
    virtual HRESULT getDescription(com::Utf8Str &aDescription) = 0;
    virtual HRESULT getHelp(com::Utf8Str &aHelp) = 0;
    /** @} */

    /** @name Wrapped IStringFormValue properties
     * @{ */
    virtual HRESULT getMultiline(BOOL *aMultiline) = 0;
    /** @} */

    /** @name Wrapped IFormValue methods
     * @{ */
    /** @} */

    /** @name Wrapped IStringFormValue methods
     * @{ */
    virtual HRESULT getString(com::Utf8Str &aText) = 0;
    virtual HRESULT setString(const com::Utf8Str &aText,
                              ComPtr<IProgress> &aProgress) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(StringFormValueWrap); /* Shuts up MSC warning C4625. */

};

#endif // !StringFormValueWrap_H_

// ##### ENDFILE "StringFormValueWrap.h"


// ##### BEGINFILE "ChoiceFormValueWrap.h"
/** @file
 * VirtualBox API class wrapper header for IChoiceFormValue.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef ChoiceFormValueWrap_H_
#define ChoiceFormValueWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE ChoiceFormValueWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IChoiceFormValue)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(ChoiceFormValueWrap, IChoiceFormValue)
    DECLARE_NOT_AGGREGATABLE(ChoiceFormValueWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(ChoiceFormValueWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IChoiceFormValue)
        COM_INTERFACE_ENTRY(IFormValue)
        COM_INTERFACE_ENTRY2(IDispatch, IChoiceFormValue)
        VBOX_TWEAK_INTERFACE_ENTRY(IChoiceFormValue)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(ChoiceFormValueWrap)

    /** @name Public IFormValue properties
     * @{ */
    STDMETHOD(COMGETTER(Type))(FormValueType_T *aType);
    STDMETHOD(COMGETTER(Generation))(LONG *aGeneration);
    STDMETHOD(COMGETTER(Enabled))(BOOL *aEnabled);
    STDMETHOD(COMGETTER(Visible))(BOOL *aVisible);
    STDMETHOD(COMGETTER(Label))(BSTR *aLabel);
    STDMETHOD(COMGETTER(Description))(BSTR *aDescription);
    STDMETHOD(COMGETTER(Help))(BSTR *aHelp);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IFormValue))(ULONG *aReserved);
    /** @} */

    /** @name Public IChoiceFormValue properties
     * @{ */
    STDMETHOD(COMGETTER(Values))(ComSafeArrayOut(BSTR, aValues));
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IChoiceFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IChoiceFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IChoiceFormValue))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IChoiceFormValue))(ULONG *aReserved);
    /** @} */

    /** @name Public IFormValue methods
     * @{ */
    STDMETHOD(InternalAndReservedMethod1IFormValue)();
    STDMETHOD(InternalAndReservedMethod2IFormValue)();
    STDMETHOD(InternalAndReservedMethod3IFormValue)();
    STDMETHOD(InternalAndReservedMethod4IFormValue)();
    /** @} */

    /** @name Public IChoiceFormValue methods
     * @{ */
    STDMETHOD(GetSelectedIndex)(LONG *aIndex);
    STDMETHOD(SetSelectedIndex)(LONG aIndex,
                                IProgress **aProgress);
    STDMETHOD(InternalAndReservedMethod1IChoiceFormValue)();
    STDMETHOD(InternalAndReservedMethod2IChoiceFormValue)();
    STDMETHOD(InternalAndReservedMethod3IChoiceFormValue)();
    STDMETHOD(InternalAndReservedMethod4IChoiceFormValue)();
    /** @} */

private:
    /** @name Wrapped IFormValue properties
     * @{ */
    virtual HRESULT getType(FormValueType_T *aType) = 0;
    virtual HRESULT getGeneration(LONG *aGeneration) = 0;
    virtual HRESULT getEnabled(BOOL *aEnabled) = 0;
    virtual HRESULT getVisible(BOOL *aVisible) = 0;
    virtual HRESULT getLabel(com::Utf8Str &aLabel) = 0;
    virtual HRESULT getDescription(com::Utf8Str &aDescription) = 0;
    virtual HRESULT getHelp(com::Utf8Str &aHelp) = 0;
    /** @} */

    /** @name Wrapped IChoiceFormValue properties
     * @{ */
    virtual HRESULT getValues(std::vector<com::Utf8Str> &aValues) = 0;
    /** @} */

    /** @name Wrapped IFormValue methods
     * @{ */
    /** @} */

    /** @name Wrapped IChoiceFormValue methods
     * @{ */
    virtual HRESULT getSelectedIndex(LONG *aIndex) = 0;
    virtual HRESULT setSelectedIndex(LONG aIndex,
                                     ComPtr<IProgress> &aProgress) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(ChoiceFormValueWrap); /* Shuts up MSC warning C4625. */

};

#endif // !ChoiceFormValueWrap_H_

// ##### ENDFILE "ChoiceFormValueWrap.h"


// ##### BEGINFILE "FormWrap.h"
/** @file
 * VirtualBox API class wrapper header for IForm.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef FormWrap_H_
#define FormWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE FormWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IForm)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(FormWrap, IForm)
    DECLARE_NOT_AGGREGATABLE(FormWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(FormWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IForm)
        COM_INTERFACE_ENTRY2(IDispatch, IForm)
        VBOX_TWEAK_INTERFACE_ENTRY(IForm)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(FormWrap)

    /** @name Public IForm properties
     * @{ */
    STDMETHOD(COMGETTER(Values))(ComSafeArrayOut(IFormValue *, aValues));
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IForm))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IForm))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IForm))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IForm))(ULONG *aReserved);
    /** @} */

    /** @name Public IForm methods
     * @{ */
    STDMETHOD(InternalAndReservedMethod1IForm)();
    STDMETHOD(InternalAndReservedMethod2IForm)();
    STDMETHOD(InternalAndReservedMethod3IForm)();
    STDMETHOD(InternalAndReservedMethod4IForm)();
    /** @} */

private:
    /** @name Wrapped IForm properties
     * @{ */
    virtual HRESULT getValues(std::vector<ComPtr<IFormValue> > &aValues) = 0;
    /** @} */

    /** @name Wrapped IForm methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(FormWrap); /* Shuts up MSC warning C4625. */

};

#endif // !FormWrap_H_

// ##### ENDFILE "FormWrap.h"


// ##### BEGINFILE "VirtualSystemDescriptionFormWrap.h"
/** @file
 * VirtualBox API class wrapper header for IVirtualSystemDescriptionForm.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef VirtualSystemDescriptionFormWrap_H_
#define VirtualSystemDescriptionFormWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE VirtualSystemDescriptionFormWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IVirtualSystemDescriptionForm)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(VirtualSystemDescriptionFormWrap, IVirtualSystemDescriptionForm)
    DECLARE_NOT_AGGREGATABLE(VirtualSystemDescriptionFormWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(VirtualSystemDescriptionFormWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IVirtualSystemDescriptionForm)
        COM_INTERFACE_ENTRY(IForm)
        COM_INTERFACE_ENTRY2(IDispatch, IVirtualSystemDescriptionForm)
        VBOX_TWEAK_INTERFACE_ENTRY(IVirtualSystemDescriptionForm)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(VirtualSystemDescriptionFormWrap)

    /** @name Public IForm properties
     * @{ */
    STDMETHOD(COMGETTER(Values))(ComSafeArrayOut(IFormValue *, aValues));
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IForm))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IForm))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IForm))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IForm))(ULONG *aReserved);
    /** @} */

    /** @name Public IVirtualSystemDescriptionForm properties
     * @{ */
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IVirtualSystemDescriptionForm))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IVirtualSystemDescriptionForm))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IVirtualSystemDescriptionForm))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IVirtualSystemDescriptionForm))(ULONG *aReserved);
    /** @} */

    /** @name Public IForm methods
     * @{ */
    STDMETHOD(InternalAndReservedMethod1IForm)();
    STDMETHOD(InternalAndReservedMethod2IForm)();
    STDMETHOD(InternalAndReservedMethod3IForm)();
    STDMETHOD(InternalAndReservedMethod4IForm)();
    /** @} */

    /** @name Public IVirtualSystemDescriptionForm methods
     * @{ */
    STDMETHOD(GetVirtualSystemDescription)(IVirtualSystemDescription **aDescription);
    STDMETHOD(InternalAndReservedMethod1IVirtualSystemDescriptionForm)();
    STDMETHOD(InternalAndReservedMethod2IVirtualSystemDescriptionForm)();
    STDMETHOD(InternalAndReservedMethod3IVirtualSystemDescriptionForm)();
    STDMETHOD(InternalAndReservedMethod4IVirtualSystemDescriptionForm)();
    /** @} */

private:
    /** @name Wrapped IForm properties
     * @{ */
    virtual HRESULT getValues(std::vector<ComPtr<IFormValue> > &aValues) = 0;
    /** @} */

    /** @name Wrapped IVirtualSystemDescriptionForm properties
     * @{ */
    /** @} */

    /** @name Wrapped IForm methods
     * @{ */
    /** @} */

    /** @name Wrapped IVirtualSystemDescriptionForm methods
     * @{ */
    virtual HRESULT getVirtualSystemDescription(ComPtr<IVirtualSystemDescription> &aDescription) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(VirtualSystemDescriptionFormWrap); /* Shuts up MSC warning C4625. */

};

#endif // !VirtualSystemDescriptionFormWrap_H_

// ##### ENDFILE "VirtualSystemDescriptionFormWrap.h"


// ##### BEGINFILE "CloudNetworkGatewayInfoWrap.h"
/** @file
 * VirtualBox API class wrapper header for ICloudNetworkGatewayInfo.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef CloudNetworkGatewayInfoWrap_H_
#define CloudNetworkGatewayInfoWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE CloudNetworkGatewayInfoWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(ICloudNetworkGatewayInfo)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(CloudNetworkGatewayInfoWrap, ICloudNetworkGatewayInfo)
    DECLARE_NOT_AGGREGATABLE(CloudNetworkGatewayInfoWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(CloudNetworkGatewayInfoWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(ICloudNetworkGatewayInfo)
        COM_INTERFACE_ENTRY2(IDispatch, ICloudNetworkGatewayInfo)
        VBOX_TWEAK_INTERFACE_ENTRY(ICloudNetworkGatewayInfo)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(CloudNetworkGatewayInfoWrap)

    /** @name Public ICloudNetworkGatewayInfo properties
     * @{ */
    STDMETHOD(COMGETTER(PublicIP))(BSTR *aPublicIP);
    STDMETHOD(COMGETTER(SecondaryPublicIP))(BSTR *aSecondaryPublicIP);
    STDMETHOD(COMGETTER(MacAddress))(BSTR *aMacAddress);
    STDMETHOD(COMGETTER(InstanceId))(BSTR *aInstanceId);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1ICloudNetworkGatewayInfo))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2ICloudNetworkGatewayInfo))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3ICloudNetworkGatewayInfo))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4ICloudNetworkGatewayInfo))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5ICloudNetworkGatewayInfo))(ULONG *aReserved);
    /** @} */

    /** @name Public ICloudNetworkGatewayInfo methods
     * @{ */
    /** @} */

private:
    /** @name Wrapped ICloudNetworkGatewayInfo properties
     * @{ */
    virtual HRESULT getPublicIP(com::Utf8Str &aPublicIP) = 0;
    virtual HRESULT getSecondaryPublicIP(com::Utf8Str &aSecondaryPublicIP) = 0;
    virtual HRESULT getMacAddress(com::Utf8Str &aMacAddress) = 0;
    virtual HRESULT getInstanceId(com::Utf8Str &aInstanceId) = 0;
    /** @} */

    /** @name Wrapped ICloudNetworkGatewayInfo methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(CloudNetworkGatewayInfoWrap); /* Shuts up MSC warning C4625. */

};

#endif // !CloudNetworkGatewayInfoWrap_H_

// ##### ENDFILE "CloudNetworkGatewayInfoWrap.h"


// ##### BEGINFILE "CloudNetworkEnvironmentInfoWrap.h"
/** @file
 * VirtualBox API class wrapper header for ICloudNetworkEnvironmentInfo.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef CloudNetworkEnvironmentInfoWrap_H_
#define CloudNetworkEnvironmentInfoWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE CloudNetworkEnvironmentInfoWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(ICloudNetworkEnvironmentInfo)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(CloudNetworkEnvironmentInfoWrap, ICloudNetworkEnvironmentInfo)
    DECLARE_NOT_AGGREGATABLE(CloudNetworkEnvironmentInfoWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(CloudNetworkEnvironmentInfoWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(ICloudNetworkEnvironmentInfo)
        COM_INTERFACE_ENTRY2(IDispatch, ICloudNetworkEnvironmentInfo)
        VBOX_TWEAK_INTERFACE_ENTRY(ICloudNetworkEnvironmentInfo)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(CloudNetworkEnvironmentInfoWrap)

    /** @name Public ICloudNetworkEnvironmentInfo properties
     * @{ */
    STDMETHOD(COMGETTER(TunnelNetworkId))(BSTR *aTunnelNetworkId);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1ICloudNetworkEnvironmentInfo))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2ICloudNetworkEnvironmentInfo))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3ICloudNetworkEnvironmentInfo))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4ICloudNetworkEnvironmentInfo))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5ICloudNetworkEnvironmentInfo))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6ICloudNetworkEnvironmentInfo))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7ICloudNetworkEnvironmentInfo))(ULONG *aReserved);
    /** @} */

    /** @name Public ICloudNetworkEnvironmentInfo methods
     * @{ */
    /** @} */

private:
    /** @name Wrapped ICloudNetworkEnvironmentInfo properties
     * @{ */
    virtual HRESULT getTunnelNetworkId(com::Utf8Str &aTunnelNetworkId) = 0;
    /** @} */

    /** @name Wrapped ICloudNetworkEnvironmentInfo methods
     * @{ */
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(CloudNetworkEnvironmentInfoWrap); /* Shuts up MSC warning C4625. */

};

#endif // !CloudNetworkEnvironmentInfoWrap_H_

// ##### ENDFILE "CloudNetworkEnvironmentInfoWrap.h"


// ##### BEGINFILE "CloudClientWrap.h"
/** @file
 * VirtualBox API class wrapper header for ICloudClient.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef CloudClientWrap_H_
#define CloudClientWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE CloudClientWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(ICloudClient)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(CloudClientWrap, ICloudClient)
    DECLARE_NOT_AGGREGATABLE(CloudClientWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(CloudClientWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(ICloudClient)
        COM_INTERFACE_ENTRY2(IDispatch, ICloudClient)
        VBOX_TWEAK_INTERFACE_ENTRY(ICloudClient)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(CloudClientWrap)

    /** @name Public ICloudClient properties
     * @{ */
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1ICloudClient))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2ICloudClient))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3ICloudClient))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4ICloudClient))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5ICloudClient))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6ICloudClient))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7ICloudClient))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8ICloudClient))(ULONG *aReserved);
    /** @} */

    /** @name Public ICloudClient methods
     * @{ */
    STDMETHOD(GetExportDescriptionForm)(IVirtualSystemDescription *aDescription,
                                        IVirtualSystemDescriptionForm **aForm,
                                        IProgress **aProgress);
    STDMETHOD(ExportVM)(IVirtualSystemDescription *aDescription,
                        IProgress *aProgress);
    STDMETHOD(GetLaunchDescriptionForm)(IVirtualSystemDescription *aDescription,
                                        IVirtualSystemDescriptionForm **aForm,
                                        IProgress **aProgress);
    STDMETHOD(LaunchVM)(IVirtualSystemDescription *aDescription,
                        IProgress **aProgress);
    STDMETHOD(GetImportDescriptionForm)(IVirtualSystemDescription *aDescription,
                                        IVirtualSystemDescriptionForm **aForm,
                                        IProgress **aProgress);
    STDMETHOD(ImportInstance)(IVirtualSystemDescription *aDescription,
                              IProgress *aProgress);
    STDMETHOD(ListInstances)(ComSafeArrayIn(CloudMachineState_T, aMachineState),
                             IStringArray **aReturnNames,
                             IStringArray **aReturnIds,
                             IProgress **aProgress);
    STDMETHOD(ListImages)(ComSafeArrayIn(CloudImageState_T, aImageState),
                          IStringArray **aReturnNames,
                          IStringArray **aReturnIds,
                          IProgress **aProgress);
    STDMETHOD(GetInstanceInfo)(IN_BSTR aUid,
                               IVirtualSystemDescription *aDescription,
                               IProgress **aProgress);
    STDMETHOD(StartInstance)(IN_BSTR aUid,
                             IProgress **aProgress);
    STDMETHOD(PauseInstance)(IN_BSTR aUid,
                             IProgress **aProgress);
    STDMETHOD(TerminateInstance)(IN_BSTR aUid,
                                 IProgress **aProgress);
    STDMETHOD(CreateImage)(ComSafeArrayIn(IN_BSTR, aParameters),
                           IProgress **aProgress);
    STDMETHOD(ExportImage)(IMedium *aImage,
                           ComSafeArrayIn(IN_BSTR, aParameters),
                           IProgress **aProgress);
    STDMETHOD(ImportImage)(IN_BSTR aUid,
                           ComSafeArrayIn(IN_BSTR, aParameters),
                           IProgress **aProgress);
    STDMETHOD(DeleteImage)(IN_BSTR aUid,
                           IProgress **aProgress);
    STDMETHOD(GetImageInfo)(IN_BSTR aUid,
                            IStringArray **aInfoArray,
                            IProgress **aProgress);
    STDMETHOD(StartCloudNetworkGateway)(ICloudNetwork *aNetwork,
                                        IN_BSTR aSshPublicKey,
                                        ICloudNetworkGatewayInfo **aGatewayInfo,
                                        IProgress **aProgress);
    STDMETHOD(SetupCloudNetworkEnvironment)(IN_BSTR aTunnelNetworkName,
                                            IN_BSTR aTunnelNetworkRange,
                                            IN_BSTR aGatewayOsName,
                                            IN_BSTR aGatewayOsVersion,
                                            IN_BSTR aGatewayShape,
                                            ICloudNetworkEnvironmentInfo **aNetworkEnvironmentInfo,
                                            IProgress **aProgress);
    STDMETHOD(InternalAndReservedMethod1ICloudClient)();
    STDMETHOD(InternalAndReservedMethod2ICloudClient)();
    STDMETHOD(InternalAndReservedMethod3ICloudClient)();
    STDMETHOD(InternalAndReservedMethod4ICloudClient)();
    STDMETHOD(InternalAndReservedMethod5ICloudClient)();
    STDMETHOD(InternalAndReservedMethod6ICloudClient)();
    STDMETHOD(InternalAndReservedMethod7ICloudClient)();
    STDMETHOD(InternalAndReservedMethod8ICloudClient)();
    STDMETHOD(InternalAndReservedMethod9ICloudClient)();
    STDMETHOD(InternalAndReservedMethod10ICloudClient)();
    STDMETHOD(InternalAndReservedMethod11ICloudClient)();
    STDMETHOD(InternalAndReservedMethod12ICloudClient)();
    STDMETHOD(InternalAndReservedMethod13ICloudClient)();
    STDMETHOD(InternalAndReservedMethod14ICloudClient)();
    STDMETHOD(InternalAndReservedMethod15ICloudClient)();
    /** @} */

private:
    /** @name Wrapped ICloudClient properties
     * @{ */
    /** @} */

    /** @name Wrapped ICloudClient methods
     * @{ */
    virtual HRESULT getExportDescriptionForm(const ComPtr<IVirtualSystemDescription> &aDescription,
                                             ComPtr<IVirtualSystemDescriptionForm> &aForm,
                                             ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT exportVM(const ComPtr<IVirtualSystemDescription> &aDescription,
                             const ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT getLaunchDescriptionForm(const ComPtr<IVirtualSystemDescription> &aDescription,
                                             ComPtr<IVirtualSystemDescriptionForm> &aForm,
                                             ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT launchVM(const ComPtr<IVirtualSystemDescription> &aDescription,
                             ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT getImportDescriptionForm(const ComPtr<IVirtualSystemDescription> &aDescription,
                                             ComPtr<IVirtualSystemDescriptionForm> &aForm,
                                             ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT importInstance(const ComPtr<IVirtualSystemDescription> &aDescription,
                                   const ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT listInstances(const std::vector<CloudMachineState_T> &aMachineState,
                                  ComPtr<IStringArray> &aReturnNames,
                                  ComPtr<IStringArray> &aReturnIds,
                                  ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT listImages(const std::vector<CloudImageState_T> &aImageState,
                               ComPtr<IStringArray> &aReturnNames,
                               ComPtr<IStringArray> &aReturnIds,
                               ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT getInstanceInfo(const com::Utf8Str &aUid,
                                    const ComPtr<IVirtualSystemDescription> &aDescription,
                                    ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT startInstance(const com::Utf8Str &aUid,
                                  ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT pauseInstance(const com::Utf8Str &aUid,
                                  ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT terminateInstance(const com::Utf8Str &aUid,
                                      ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT createImage(const std::vector<com::Utf8Str> &aParameters,
                                ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT exportImage(const ComPtr<IMedium> &aImage,
                                const std::vector<com::Utf8Str> &aParameters,
                                ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT importImage(const com::Utf8Str &aUid,
                                const std::vector<com::Utf8Str> &aParameters,
                                ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT deleteImage(const com::Utf8Str &aUid,
                                ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT getImageInfo(const com::Utf8Str &aUid,
                                 ComPtr<IStringArray> &aInfoArray,
                                 ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT startCloudNetworkGateway(const ComPtr<ICloudNetwork> &aNetwork,
                                             const com::Utf8Str &aSshPublicKey,
                                             ComPtr<ICloudNetworkGatewayInfo> &aGatewayInfo,
                                             ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT setupCloudNetworkEnvironment(const com::Utf8Str &aTunnelNetworkName,
                                                 const com::Utf8Str &aTunnelNetworkRange,
                                                 const com::Utf8Str &aGatewayOsName,
                                                 const com::Utf8Str &aGatewayOsVersion,
                                                 const com::Utf8Str &aGatewayShape,
                                                 ComPtr<ICloudNetworkEnvironmentInfo> &aNetworkEnvironmentInfo,
                                                 ComPtr<IProgress> &aProgress) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(CloudClientWrap); /* Shuts up MSC warning C4625. */

};

#endif // !CloudClientWrap_H_

// ##### ENDFILE "CloudClientWrap.h"


// ##### BEGINFILE "CloudProfileWrap.h"
/** @file
 * VirtualBox API class wrapper header for ICloudProfile.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef CloudProfileWrap_H_
#define CloudProfileWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE CloudProfileWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(ICloudProfile)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(CloudProfileWrap, ICloudProfile)
    DECLARE_NOT_AGGREGATABLE(CloudProfileWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(CloudProfileWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(ICloudProfile)
        COM_INTERFACE_ENTRY2(IDispatch, ICloudProfile)
        VBOX_TWEAK_INTERFACE_ENTRY(ICloudProfile)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(CloudProfileWrap)

    /** @name Public ICloudProfile properties
     * @{ */
    STDMETHOD(COMGETTER(Name))(BSTR *aName);
    STDMETHOD(COMSETTER(Name))(IN_BSTR aName);
    STDMETHOD(COMGETTER(ProviderId))(BSTR *aProviderId);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1ICloudProfile))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2ICloudProfile))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3ICloudProfile))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4ICloudProfile))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5ICloudProfile))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6ICloudProfile))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7ICloudProfile))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8ICloudProfile))(ULONG *aReserved);
    /** @} */

    /** @name Public ICloudProfile methods
     * @{ */
    STDMETHOD(GetProperty)(IN_BSTR aName,
                           BSTR *aValue);
    STDMETHOD(SetProperty)(IN_BSTR aName,
                           IN_BSTR aValue);
    STDMETHOD(GetProperties)(IN_BSTR aNames,
                             ComSafeArrayOut(BSTR, aReturnNames),
                             ComSafeArrayOut(BSTR, aReturnValues));
    STDMETHOD(SetProperties)(ComSafeArrayIn(IN_BSTR, aNames),
                             ComSafeArrayIn(IN_BSTR, aValues));
    STDMETHOD(Remove)();
    STDMETHOD(CreateCloudClient)(ICloudClient **aCloudClient);
    STDMETHOD(InternalAndReservedMethod1ICloudProfile)();
    STDMETHOD(InternalAndReservedMethod2ICloudProfile)();
    STDMETHOD(InternalAndReservedMethod3ICloudProfile)();
    STDMETHOD(InternalAndReservedMethod4ICloudProfile)();
    /** @} */

private:
    /** @name Wrapped ICloudProfile properties
     * @{ */
    virtual HRESULT getName(com::Utf8Str &aName) = 0;
    virtual HRESULT setName(const com::Utf8Str &aName) = 0;
    virtual HRESULT getProviderId(com::Guid &aProviderId) = 0;
    /** @} */

    /** @name Wrapped ICloudProfile methods
     * @{ */
    virtual HRESULT getProperty(const com::Utf8Str &aName,
                                com::Utf8Str &aValue) = 0;
    virtual HRESULT setProperty(const com::Utf8Str &aName,
                                const com::Utf8Str &aValue) = 0;
    virtual HRESULT getProperties(const com::Utf8Str &aNames,
                                  std::vector<com::Utf8Str> &aReturnNames,
                                  std::vector<com::Utf8Str> &aReturnValues) = 0;
    virtual HRESULT setProperties(const std::vector<com::Utf8Str> &aNames,
                                  const std::vector<com::Utf8Str> &aValues) = 0;
    virtual HRESULT remove() = 0;
    virtual HRESULT createCloudClient(ComPtr<ICloudClient> &aCloudClient) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(CloudProfileWrap); /* Shuts up MSC warning C4625. */

};

#endif // !CloudProfileWrap_H_

// ##### ENDFILE "CloudProfileWrap.h"


// ##### BEGINFILE "CloudProviderWrap.h"
/** @file
 * VirtualBox API class wrapper header for ICloudProvider.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef CloudProviderWrap_H_
#define CloudProviderWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE CloudProviderWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(ICloudProvider)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(CloudProviderWrap, ICloudProvider)
    DECLARE_NOT_AGGREGATABLE(CloudProviderWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(CloudProviderWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(ICloudProvider)
        COM_INTERFACE_ENTRY2(IDispatch, ICloudProvider)
        VBOX_TWEAK_INTERFACE_ENTRY(ICloudProvider)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(CloudProviderWrap)

    /** @name Public ICloudProvider properties
     * @{ */
    STDMETHOD(COMGETTER(Name))(BSTR *aName);
    STDMETHOD(COMGETTER(ShortName))(BSTR *aShortName);
    STDMETHOD(COMGETTER(Id))(BSTR *aId);
    STDMETHOD(COMGETTER(Profiles))(ComSafeArrayOut(ICloudProfile *, aProfiles));
    STDMETHOD(COMGETTER(ProfileNames))(ComSafeArrayOut(BSTR, aProfileNames));
    STDMETHOD(COMGETTER(SupportedPropertyNames))(ComSafeArrayOut(BSTR, aSupportedPropertyNames));
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1ICloudProvider))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2ICloudProvider))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3ICloudProvider))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4ICloudProvider))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5ICloudProvider))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6ICloudProvider))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7ICloudProvider))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8ICloudProvider))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute9ICloudProvider))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute10ICloudProvider))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute11ICloudProvider))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute12ICloudProvider))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute13ICloudProvider))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute14ICloudProvider))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute15ICloudProvider))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute16ICloudProvider))(ULONG *aReserved);
    /** @} */

    /** @name Public ICloudProvider methods
     * @{ */
    STDMETHOD(GetPropertyDescription)(IN_BSTR aName,
                                      BSTR *aDescription);
    STDMETHOD(CreateProfile)(IN_BSTR aProfileName,
                             ComSafeArrayIn(IN_BSTR, aNames),
                             ComSafeArrayIn(IN_BSTR, aValues));
    STDMETHOD(ImportProfiles)();
    STDMETHOD(RestoreProfiles)();
    STDMETHOD(SaveProfiles)();
    STDMETHOD(GetProfileByName)(IN_BSTR aProfileName,
                                ICloudProfile **aProfile);
    STDMETHOD(PrepareUninstall)();
    STDMETHOD(InternalAndReservedMethod1ICloudProvider)();
    STDMETHOD(InternalAndReservedMethod2ICloudProvider)();
    STDMETHOD(InternalAndReservedMethod3ICloudProvider)();
    STDMETHOD(InternalAndReservedMethod4ICloudProvider)();
    STDMETHOD(InternalAndReservedMethod5ICloudProvider)();
    STDMETHOD(InternalAndReservedMethod6ICloudProvider)();
    STDMETHOD(InternalAndReservedMethod7ICloudProvider)();
    STDMETHOD(InternalAndReservedMethod8ICloudProvider)();
    /** @} */

private:
    /** @name Wrapped ICloudProvider properties
     * @{ */
    virtual HRESULT getName(com::Utf8Str &aName) = 0;
    virtual HRESULT getShortName(com::Utf8Str &aShortName) = 0;
    virtual HRESULT getId(com::Guid &aId) = 0;
    virtual HRESULT getProfiles(std::vector<ComPtr<ICloudProfile> > &aProfiles) = 0;
    virtual HRESULT getProfileNames(std::vector<com::Utf8Str> &aProfileNames) = 0;
    virtual HRESULT getSupportedPropertyNames(std::vector<com::Utf8Str> &aSupportedPropertyNames) = 0;
    /** @} */

    /** @name Wrapped ICloudProvider methods
     * @{ */
    virtual HRESULT getPropertyDescription(const com::Utf8Str &aName,
                                           com::Utf8Str &aDescription) = 0;
    virtual HRESULT createProfile(const com::Utf8Str &aProfileName,
                                  const std::vector<com::Utf8Str> &aNames,
                                  const std::vector<com::Utf8Str> &aValues) = 0;
    virtual HRESULT importProfiles() = 0;
    virtual HRESULT restoreProfiles() = 0;
    virtual HRESULT saveProfiles() = 0;
    virtual HRESULT getProfileByName(const com::Utf8Str &aProfileName,
                                     ComPtr<ICloudProfile> &aProfile) = 0;
    virtual HRESULT prepareUninstall(AutoCaller &aAutoCaller) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(CloudProviderWrap); /* Shuts up MSC warning C4625. */

};

#endif // !CloudProviderWrap_H_

// ##### ENDFILE "CloudProviderWrap.h"


// ##### BEGINFILE "CloudProviderManagerWrap.h"
/** @file
 * VirtualBox API class wrapper header for ICloudProviderManager.
 *
 * DO NOT EDIT! This is a generated file.
 * Generated from: src/VBox/Main/idl/VirtualBox.xidl
 * Generator: src/VBox/Main/idl/apiwrap-server.xsl
 */

/*
 * Copyright (C) 2010-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

#ifndef CloudProviderManagerWrap_H_
#define CloudProviderManagerWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

#include "VirtualBoxBase.h"
#include "Wrapper.h"

class ATL_NO_VTABLE CloudProviderManagerWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(ICloudProviderManager)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(CloudProviderManagerWrap, ICloudProviderManager)
    DECLARE_NOT_AGGREGATABLE(CloudProviderManagerWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(CloudProviderManagerWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(ICloudProviderManager)
        COM_INTERFACE_ENTRY2(IDispatch, ICloudProviderManager)
        VBOX_TWEAK_INTERFACE_ENTRY(ICloudProviderManager)
    END_COM_MAP()

    DECLARE_EMPTY_CTOR_DTOR(CloudProviderManagerWrap)

    /** @name Public ICloudProviderManager properties
     * @{ */
    STDMETHOD(COMGETTER(Providers))(ComSafeArrayOut(ICloudProvider *, aProviders));
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1ICloudProviderManager))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2ICloudProviderManager))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3ICloudProviderManager))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4ICloudProviderManager))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5ICloudProviderManager))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6ICloudProviderManager))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7ICloudProviderManager))(ULONG *aReserved);
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8ICloudProviderManager))(ULONG *aReserved);
    /** @} */

    /** @name Public ICloudProviderManager methods
     * @{ */
    STDMETHOD(GetProviderById)(IN_BSTR aProviderId,
                               ICloudProvider **aProvider);
    STDMETHOD(GetProviderByShortName)(IN_BSTR aProviderName,
                                      ICloudProvider **aProvider);
    STDMETHOD(GetProviderByName)(IN_BSTR aProviderName,
                                 ICloudProvider **aProvider);
    STDMETHOD(InternalAndReservedMethod1ICloudProviderManager)();
    STDMETHOD(InternalAndReservedMethod2ICloudProviderManager)();
    STDMETHOD(InternalAndReservedMethod3ICloudProviderManager)();
    STDMETHOD(InternalAndReservedMethod4ICloudProviderManager)();
    /** @} */

private:
    /** @name Wrapped ICloudProviderManager properties
     * @{ */
    virtual HRESULT getProviders(std::vector<ComPtr<ICloudProvider> > &aProviders) = 0;
    /** @} */

    /** @name Wrapped ICloudProviderManager methods
     * @{ */
    virtual HRESULT getProviderById(const com::Guid &aProviderId,
                                    ComPtr<ICloudProvider> &aProvider) = 0;
    virtual HRESULT getProviderByShortName(const com::Utf8Str &aProviderName,
                                           ComPtr<ICloudProvider> &aProvider) = 0;
    virtual HRESULT getProviderByName(const com::Utf8Str &aProviderName,
                                      ComPtr<ICloudProvider> &aProvider) = 0;
    /** @} */

private:
    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(CloudProviderManagerWrap); /* Shuts up MSC warning C4625. */

};

#endif // !CloudProviderManagerWrap_H_

// ##### ENDFILE "CloudProviderManagerWrap.h"
