

// ##### 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(NATNetworkWrap)

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

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

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 getLocalhostReachable(BOOL *aLocalhostReachable) = 0;
    virtual HRESULT setLocalhostReachable(BOOL aLocalhostReachable) = 0;
    virtual HRESULT getForwardBroadcast(BOOL *aForwardBroadcast) = 0;
    virtual HRESULT setForwardBroadcast(BOOL aForwardBroadcast) = 0;
    virtual HRESULT getNatMTU(ULONG *aNatMTU) = 0;
    virtual HRESULT setNatMTU(ULONG aNatMTU) = 0;
    virtual HRESULT getNatMRU(ULONG *aNatMRU) = 0;
    virtual HRESULT setNatMRU(ULONG aNatMRU) = 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(CloudNetworkWrap)

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

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

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 "HostOnlyNetworkWrap.h"
/** @file
 * VirtualBox API class wrapper header for IHostOnlyNetwork.
 *
 * 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#ifndef HostOnlyNetworkWrap_H_
#define HostOnlyNetworkWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

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

class ATL_NO_VTABLE HostOnlyNetworkWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IHostOnlyNetwork)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(HostOnlyNetworkWrap, IHostOnlyNetwork)
    DECLARE_NOT_AGGREGATABLE(HostOnlyNetworkWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(HostOnlyNetworkWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IHostOnlyNetwork)
        COM_INTERFACE_ENTRY2(IDispatch, IHostOnlyNetwork)
        VBOX_TWEAK_INTERFACE_ENTRY(IHostOnlyNetwork)
    END_COM_MAP()

    DECLARE_COMMON_CLASS_METHODS(HostOnlyNetworkWrap)

    /** @name Public IHostOnlyNetwork properties
     * @{ */
    STDMETHOD(COMGETTER(NetworkName))(BSTR *aNetworkName) RT_OVERRIDE;
    STDMETHOD(COMSETTER(NetworkName))(IN_BSTR aNetworkName) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Enabled))(BOOL *aEnabled) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Enabled))(BOOL aEnabled) RT_OVERRIDE;
    STDMETHOD(COMGETTER(NetworkMask))(BSTR *aNetworkMask) RT_OVERRIDE;
    STDMETHOD(COMSETTER(NetworkMask))(IN_BSTR aNetworkMask) RT_OVERRIDE;
    STDMETHOD(COMGETTER(HostIP))(BSTR *aHostIP) RT_OVERRIDE;
    STDMETHOD(COMGETTER(LowerIP))(BSTR *aLowerIP) RT_OVERRIDE;
    STDMETHOD(COMSETTER(LowerIP))(IN_BSTR aLowerIP) RT_OVERRIDE;
    STDMETHOD(COMGETTER(UpperIP))(BSTR *aUpperIP) RT_OVERRIDE;
    STDMETHOD(COMSETTER(UpperIP))(IN_BSTR aUpperIP) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Id))(BSTR *aId) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Id))(IN_BSTR aId) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IHostOnlyNetwork))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IHostOnlyNetwork))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IHostOnlyNetwork))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IHostOnlyNetwork))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IHostOnlyNetwork))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IHostOnlyNetwork))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IHostOnlyNetwork))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IHostOnlyNetwork))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IHostOnlyNetwork methods
     * @{ */
    STDMETHOD(InternalAndReservedMethod1IHostOnlyNetwork)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IHostOnlyNetwork)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3IHostOnlyNetwork)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4IHostOnlyNetwork)() RT_OVERRIDE;
    /** @} */

private:
    /** @name Wrapped IHostOnlyNetwork 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 getNetworkMask(com::Utf8Str &aNetworkMask) = 0;
    virtual HRESULT setNetworkMask(const com::Utf8Str &aNetworkMask) = 0;
    virtual HRESULT getHostIP(com::Utf8Str &aHostIP) = 0;
    virtual HRESULT getLowerIP(com::Utf8Str &aLowerIP) = 0;
    virtual HRESULT setLowerIP(const com::Utf8Str &aLowerIP) = 0;
    virtual HRESULT getUpperIP(com::Utf8Str &aUpperIP) = 0;
    virtual HRESULT setUpperIP(const com::Utf8Str &aUpperIP) = 0;
    virtual HRESULT getId(com::Guid &aId) = 0;
    virtual HRESULT setId(const com::Guid &aId) = 0;
    /** @} */

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

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

};

#endif // !HostOnlyNetworkWrap_H_

// ##### ENDFILE "HostOnlyNetworkWrap.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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(DHCPServerWrap)

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

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

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(DHCPConfigWrap)

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

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

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(DHCPGlobalConfigWrap)

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

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

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

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

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(DHCPGroupConditionWrap)

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

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

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(DHCPGroupConfigWrap)

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

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

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

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

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(DHCPIndividualConfigWrap)

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

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

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

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

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(VirtualBoxWrap)

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

    /** @name Public IVirtualBox methods
     * @{ */
    STDMETHOD(ComposeMachineFilename)(IN_BSTR aName,
                                      IN_BSTR aGroup,
                                      IN_BSTR aCreateFlags,
                                      IN_BSTR aBaseFolder,
                                      BSTR *aFile) RT_OVERRIDE;
    STDMETHOD(GetPlatformProperties)(PlatformArchitecture_T aArchitecture,
                                     IPlatformProperties **aProperties) RT_OVERRIDE;
    STDMETHOD(CreateMachine)(IN_BSTR aSettingsFile,
                             IN_BSTR aName,
                             PlatformArchitecture_T aPlatform,
                             ComSafeArrayIn(IN_BSTR, aGroups),
                             IN_BSTR aOsTypeId,
                             IN_BSTR aFlags,
                             IN_BSTR aCipher,
                             IN_BSTR aPasswordId,
                             IN_BSTR aPassword,
                             IMachine **aMachine) RT_OVERRIDE;
    STDMETHOD(OpenMachine)(IN_BSTR aSettingsFile,
                           IN_BSTR aPassword,
                           IMachine **aMachine) RT_OVERRIDE;
    STDMETHOD(RegisterMachine)(IMachine *aMachine) RT_OVERRIDE;
    STDMETHOD(FindMachine)(IN_BSTR aNameOrId,
                           IMachine **aMachine) RT_OVERRIDE;
    STDMETHOD(GetMachinesByGroups)(ComSafeArrayIn(IN_BSTR, aGroups),
                                   ComSafeArrayOut(IMachine *, aMachines)) RT_OVERRIDE;
    STDMETHOD(GetMachineStates)(ComSafeArrayIn(IMachine *, aMachines),
                                ComSafeArrayOut(MachineState_T, aStates)) RT_OVERRIDE;
    STDMETHOD(CreateAppliance)(IAppliance **aAppliance) RT_OVERRIDE;
    STDMETHOD(CreateUnattendedInstaller)(IUnattended **aUnattended) RT_OVERRIDE;
    STDMETHOD(CreateMedium)(IN_BSTR aFormat,
                            IN_BSTR aLocation,
                            AccessMode_T aAccessMode,
                            DeviceType_T aADeviceTypeType,
                            IMedium **aMedium) RT_OVERRIDE;
    STDMETHOD(OpenMedium)(IN_BSTR aLocation,
                          DeviceType_T aDeviceType,
                          AccessMode_T aAccessMode,
                          BOOL aForceNewUuid,
                          IMedium **aMedium) RT_OVERRIDE;
    STDMETHOD(GetGuestOSType)(IN_BSTR aId,
                              IGuestOSType **aType) RT_OVERRIDE;
    STDMETHOD(GetGuestOSSubtypesByFamilyId)(IN_BSTR aFamily,
                                            ComSafeArrayOut(BSTR, aOSsubtypes)) RT_OVERRIDE;
    STDMETHOD(GetGuestOSDescsBySubtype)(IN_BSTR aOSSubtype,
                                        ComSafeArrayOut(BSTR, aGuestOSDescs)) RT_OVERRIDE;
    STDMETHOD(CreateSharedFolder)(IN_BSTR aName,
                                  IN_BSTR aHostPath,
                                  BOOL aWritable,
                                  BOOL aAutomount,
                                  IN_BSTR aAutoMountPoint) RT_OVERRIDE;
    STDMETHOD(RemoveSharedFolder)(IN_BSTR aName) RT_OVERRIDE;
    STDMETHOD(GetExtraDataKeys)(ComSafeArrayOut(BSTR, aKeys)) RT_OVERRIDE;
    STDMETHOD(GetExtraData)(IN_BSTR aKey,
                            BSTR *aValue) RT_OVERRIDE;
    STDMETHOD(SetExtraData)(IN_BSTR aKey,
                            IN_BSTR aValue) RT_OVERRIDE;
    STDMETHOD(SetSettingsSecret)(IN_BSTR aPassword) RT_OVERRIDE;
    STDMETHOD(CreateDHCPServer)(IN_BSTR aName,
                                IDHCPServer **aServer) RT_OVERRIDE;
    STDMETHOD(FindDHCPServerByNetworkName)(IN_BSTR aName,
                                           IDHCPServer **aServer) RT_OVERRIDE;
    STDMETHOD(RemoveDHCPServer)(IDHCPServer *aServer) RT_OVERRIDE;
    STDMETHOD(CreateNATNetwork)(IN_BSTR aNetworkName,
                                INATNetwork **aNetwork) RT_OVERRIDE;
    STDMETHOD(FindNATNetworkByName)(IN_BSTR aNetworkName,
                                    INATNetwork **aNetwork) RT_OVERRIDE;
    STDMETHOD(RemoveNATNetwork)(INATNetwork *aNetwork) RT_OVERRIDE;
    STDMETHOD(CreateHostOnlyNetwork)(IN_BSTR aNetworkName,
                                     IHostOnlyNetwork **aNetwork) RT_OVERRIDE;
    STDMETHOD(FindHostOnlyNetworkByName)(IN_BSTR aNetworkName,
                                         IHostOnlyNetwork **aNetwork) RT_OVERRIDE;
    STDMETHOD(FindHostOnlyNetworkById)(IN_BSTR aId,
                                       IHostOnlyNetwork **aNetwork) RT_OVERRIDE;
    STDMETHOD(RemoveHostOnlyNetwork)(IHostOnlyNetwork *aNetwork) RT_OVERRIDE;
    STDMETHOD(CreateCloudNetwork)(IN_BSTR aNetworkName,
                                  ICloudNetwork **aNetwork) RT_OVERRIDE;
    STDMETHOD(FindCloudNetworkByName)(IN_BSTR aNetworkName,
                                      ICloudNetwork **aNetwork) RT_OVERRIDE;
    STDMETHOD(RemoveCloudNetwork)(ICloudNetwork *aNetwork) RT_OVERRIDE;
    STDMETHOD(CheckFirmwarePresent)(PlatformArchitecture_T aPlatformArchitecture,
                                    FirmwareType_T aFirmwareType,
                                    IN_BSTR aVersion,
                                    BSTR *aUrl,
                                    BSTR *aFile,
                                    BOOL *aResult) RT_OVERRIDE;
    STDMETHOD(FindProgressById)(IN_BSTR aId,
                                IProgress **aProgressObject) RT_OVERRIDE;
    STDMETHOD(GetTrackedObject)(IN_BSTR aTrObjId,
                                IUnknown **aPIface,
                                TrackedObjectState_T *aState,
                                LONG64 *aCreationTime,
                                LONG64 *aDeletionTime) RT_OVERRIDE;
    STDMETHOD(GetTrackedObjectIds)(IN_BSTR aName,
                                   ComSafeArrayOut(BSTR, aObjIdsList)) RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1IVirtualBox)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IVirtualBox)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3IVirtualBox)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4IVirtualBox)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod5IVirtualBox)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod6IVirtualBox)() RT_OVERRIDE;
    /** @} */

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 getGuestOSFamilies(std::vector<com::Utf8Str> &aGuestOSFamilies) = 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 getHostOnlyNetworks(std::vector<ComPtr<IHostOnlyNetwork> > &aHostOnlyNetworks) = 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 getPlatformProperties(PlatformArchitecture_T aArchitecture,
                                          ComPtr<IPlatformProperties> &aProperties) = 0;
    virtual HRESULT createMachine(const com::Utf8Str &aSettingsFile,
                                  const com::Utf8Str &aName,
                                  PlatformArchitecture_T aPlatform,
                                  const std::vector<com::Utf8Str> &aGroups,
                                  const com::Utf8Str &aOsTypeId,
                                  const com::Utf8Str &aFlags,
                                  const com::Utf8Str &aCipher,
                                  const com::Utf8Str &aPasswordId,
                                  const com::Utf8Str &aPassword,
                                  ComPtr<IMachine> &aMachine) = 0;
    virtual HRESULT openMachine(const com::Utf8Str &aSettingsFile,
                                const com::Utf8Str &aPassword,
                                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 getGuestOSSubtypesByFamilyId(const com::Utf8Str &aFamily,
                                                 std::vector<com::Utf8Str> &aOSsubtypes) = 0;
    virtual HRESULT getGuestOSDescsBySubtype(const com::Utf8Str &aOSSubtype,
                                             std::vector<com::Utf8Str> &aGuestOSDescs) = 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 createHostOnlyNetwork(const com::Utf8Str &aNetworkName,
                                          ComPtr<IHostOnlyNetwork> &aNetwork) = 0;
    virtual HRESULT findHostOnlyNetworkByName(const com::Utf8Str &aNetworkName,
                                              ComPtr<IHostOnlyNetwork> &aNetwork) = 0;
    virtual HRESULT findHostOnlyNetworkById(const com::Guid &aId,
                                            ComPtr<IHostOnlyNetwork> &aNetwork) = 0;
    virtual HRESULT removeHostOnlyNetwork(const ComPtr<IHostOnlyNetwork> &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(PlatformArchitecture_T aPlatformArchitecture,
                                         FirmwareType_T aFirmwareType,
                                         const com::Utf8Str &aVersion,
                                         com::Utf8Str &aUrl,
                                         com::Utf8Str &aFile,
                                         BOOL *aResult) = 0;
    virtual HRESULT findProgressById(const com::Guid &aId,
                                     ComPtr<IProgress> &aProgressObject) = 0;
    virtual HRESULT getTrackedObject(const com::Utf8Str &aTrObjId,
                                     ComPtr<IUnknown> &aPIface,
                                     TrackedObjectState_T *aState,
                                     LONG64 *aCreationTime,
                                     LONG64 *aDeletionTime) = 0;
    virtual HRESULT getTrackedObjectIds(const com::Utf8Str &aName,
                                        std::vector<com::Utf8Str> &aObjIdsList) = 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(VFSExplorerWrap)

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

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

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(CertificateWrap)

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

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

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(ApplianceWrap)

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

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

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(VirtualSystemDescriptionWrap)

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

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

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(UnattendedWrap)

    /** @name Public IUnattended properties
     * @{ */
    STDMETHOD(COMGETTER(IsoPath))(BSTR *aIsoPath) RT_OVERRIDE;
    STDMETHOD(COMSETTER(IsoPath))(IN_BSTR aIsoPath) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Machine))(IMachine **aMachine) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Machine))(IMachine *aMachine) RT_OVERRIDE;
    STDMETHOD(COMGETTER(User))(BSTR *aUser) RT_OVERRIDE;
    STDMETHOD(COMSETTER(User))(IN_BSTR aUser) RT_OVERRIDE;
    STDMETHOD(COMGETTER(UserPassword))(BSTR *aUserPassword) RT_OVERRIDE;
    STDMETHOD(COMSETTER(UserPassword))(IN_BSTR aUserPassword) RT_OVERRIDE;
    STDMETHOD(COMGETTER(AdminPassword))(BSTR *aAdminPassword) RT_OVERRIDE;
    STDMETHOD(COMSETTER(AdminPassword))(IN_BSTR aAdminPassword) RT_OVERRIDE;
    STDMETHOD(COMGETTER(FullUserName))(BSTR *aFullUserName) RT_OVERRIDE;
    STDMETHOD(COMSETTER(FullUserName))(IN_BSTR aFullUserName) RT_OVERRIDE;
    STDMETHOD(COMGETTER(ProductKey))(BSTR *aProductKey) RT_OVERRIDE;
    STDMETHOD(COMSETTER(ProductKey))(IN_BSTR aProductKey) RT_OVERRIDE;
    STDMETHOD(COMGETTER(AdditionsIsoPath))(BSTR *aAdditionsIsoPath) RT_OVERRIDE;
    STDMETHOD(COMSETTER(AdditionsIsoPath))(IN_BSTR aAdditionsIsoPath) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InstallGuestAdditions))(BOOL *aInstallGuestAdditions) RT_OVERRIDE;
    STDMETHOD(COMSETTER(InstallGuestAdditions))(BOOL aInstallGuestAdditions) RT_OVERRIDE;
    STDMETHOD(COMGETTER(ProductKeyRequired))(BOOL *aProductKeyRequired) RT_OVERRIDE;
    STDMETHOD(COMGETTER(ValidationKitIsoPath))(BSTR *aValidationKitIsoPath) RT_OVERRIDE;
    STDMETHOD(COMSETTER(ValidationKitIsoPath))(IN_BSTR aValidationKitIsoPath) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InstallTestExecService))(BOOL *aInstallTestExecService) RT_OVERRIDE;
    STDMETHOD(COMSETTER(InstallTestExecService))(BOOL aInstallTestExecService) RT_OVERRIDE;
    STDMETHOD(COMGETTER(UserPayloadIsoPath))(BSTR *aUserPayloadIsoPath) RT_OVERRIDE;
    STDMETHOD(COMSETTER(UserPayloadIsoPath))(IN_BSTR aUserPayloadIsoPath) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InstallUserPayload))(BOOL *aInstallUserPayload) RT_OVERRIDE;
    STDMETHOD(COMSETTER(InstallUserPayload))(BOOL aInstallUserPayload) RT_OVERRIDE;
    STDMETHOD(COMGETTER(TimeZone))(BSTR *aTimeZone) RT_OVERRIDE;
    STDMETHOD(COMSETTER(TimeZone))(IN_BSTR aTimeZone) RT_OVERRIDE;
    STDMETHOD(COMGETTER(KeyboardLayout))(BSTR *aKeyboardLayout) RT_OVERRIDE;
    STDMETHOD(COMSETTER(KeyboardLayout))(IN_BSTR aKeyboardLayout) RT_OVERRIDE;
    STDMETHOD(COMGETTER(KeyboardVariant))(BSTR *aKeyboardVariant) RT_OVERRIDE;
    STDMETHOD(COMSETTER(KeyboardVariant))(IN_BSTR aKeyboardVariant) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Locale))(BSTR *aLocale) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Locale))(IN_BSTR aLocale) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Language))(BSTR *aLanguage) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Language))(IN_BSTR aLanguage) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Country))(BSTR *aCountry) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Country))(IN_BSTR aCountry) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Proxy))(BSTR *aProxy) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Proxy))(IN_BSTR aProxy) RT_OVERRIDE;
    STDMETHOD(COMGETTER(PackageSelectionAdjustments))(BSTR *aPackageSelectionAdjustments) RT_OVERRIDE;
    STDMETHOD(COMSETTER(PackageSelectionAdjustments))(IN_BSTR aPackageSelectionAdjustments) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Hostname))(BSTR *aHostname) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Hostname))(IN_BSTR aHostname) RT_OVERRIDE;
    STDMETHOD(COMGETTER(AuxiliaryBasePath))(BSTR *aAuxiliaryBasePath) RT_OVERRIDE;
    STDMETHOD(COMSETTER(AuxiliaryBasePath))(IN_BSTR aAuxiliaryBasePath) RT_OVERRIDE;
    STDMETHOD(COMGETTER(ImageIndex))(ULONG *aImageIndex) RT_OVERRIDE;
    STDMETHOD(COMSETTER(ImageIndex))(ULONG aImageIndex) RT_OVERRIDE;
    STDMETHOD(COMGETTER(ScriptTemplatePath))(BSTR *aScriptTemplatePath) RT_OVERRIDE;
    STDMETHOD(COMSETTER(ScriptTemplatePath))(IN_BSTR aScriptTemplatePath) RT_OVERRIDE;
    STDMETHOD(COMGETTER(PostInstallScriptTemplatePath))(BSTR *aPostInstallScriptTemplatePath) RT_OVERRIDE;
    STDMETHOD(COMSETTER(PostInstallScriptTemplatePath))(IN_BSTR aPostInstallScriptTemplatePath) RT_OVERRIDE;
    STDMETHOD(COMGETTER(PostInstallCommand))(BSTR *aPostInstallCommand) RT_OVERRIDE;
    STDMETHOD(COMSETTER(PostInstallCommand))(IN_BSTR aPostInstallCommand) RT_OVERRIDE;
    STDMETHOD(COMGETTER(ExtraInstallKernelParameters))(BSTR *aExtraInstallKernelParameters) RT_OVERRIDE;
    STDMETHOD(COMSETTER(ExtraInstallKernelParameters))(IN_BSTR aExtraInstallKernelParameters) RT_OVERRIDE;
    STDMETHOD(COMGETTER(DetectedOSTypeId))(BSTR *aDetectedOSTypeId) RT_OVERRIDE;
    STDMETHOD(COMGETTER(DetectedOSVersion))(BSTR *aDetectedOSVersion) RT_OVERRIDE;
    STDMETHOD(COMGETTER(DetectedOSFlavor))(BSTR *aDetectedOSFlavor) RT_OVERRIDE;
    STDMETHOD(COMGETTER(DetectedOSLanguages))(BSTR *aDetectedOSLanguages) RT_OVERRIDE;
    STDMETHOD(COMGETTER(DetectedOSHints))(BSTR *aDetectedOSHints) RT_OVERRIDE;
    STDMETHOD(COMGETTER(DetectedImageNames))(ComSafeArrayOut(BSTR, aDetectedImageNames)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(DetectedImageIndices))(ComSafeArrayOut(ULONG, aDetectedImageIndices)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(IsUnattendedInstallSupported))(BOOL *aIsUnattendedInstallSupported) RT_OVERRIDE;
    STDMETHOD(COMGETTER(AvoidUpdatesOverNetwork))(BOOL *aAvoidUpdatesOverNetwork) RT_OVERRIDE;
    STDMETHOD(COMSETTER(AvoidUpdatesOverNetwork))(BOOL aAvoidUpdatesOverNetwork) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IUnattended))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IUnattended))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IUnattended))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IUnattended))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IUnattended))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IUnattended))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IUnattended))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IUnattended))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute9IUnattended))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute10IUnattended))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute11IUnattended))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute12IUnattended))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute13IUnattended))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute14IUnattended))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute15IUnattended))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute16IUnattended))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

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

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 getUserPassword(com::Utf8Str &aUserPassword) = 0;
    virtual HRESULT setUserPassword(const com::Utf8Str &aUserPassword) = 0;
    virtual HRESULT getAdminPassword(com::Utf8Str &aAdminPassword) = 0;
    virtual HRESULT setAdminPassword(const com::Utf8Str &aAdminPassword) = 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 getProductKeyRequired(BOOL *aProductKeyRequired) = 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 getUserPayloadIsoPath(com::Utf8Str &aUserPayloadIsoPath) = 0;
    virtual HRESULT setUserPayloadIsoPath(const com::Utf8Str &aUserPayloadIsoPath) = 0;
    virtual HRESULT getInstallUserPayload(BOOL *aInstallUserPayload) = 0;
    virtual HRESULT setInstallUserPayload(BOOL aInstallUserPayload) = 0;
    virtual HRESULT getTimeZone(com::Utf8Str &aTimeZone) = 0;
    virtual HRESULT setTimeZone(const com::Utf8Str &aTimeZone) = 0;
    virtual HRESULT getKeyboardLayout(com::Utf8Str &aKeyboardLayout) = 0;
    virtual HRESULT setKeyboardLayout(const com::Utf8Str &aKeyboardLayout) = 0;
    virtual HRESULT getKeyboardVariant(com::Utf8Str &aKeyboardVariant) = 0;
    virtual HRESULT setKeyboardVariant(const com::Utf8Str &aKeyboardVariant) = 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;
    virtual HRESULT getDetectedImageNames(std::vector<com::Utf8Str> &aDetectedImageNames) = 0;
    virtual HRESULT getDetectedImageIndices(std::vector<ULONG> &aDetectedImageIndices) = 0;
    virtual HRESULT getIsUnattendedInstallSupported(BOOL *aIsUnattendedInstallSupported) = 0;
    virtual HRESULT getAvoidUpdatesOverNetwork(BOOL *aAvoidUpdatesOverNetwork) = 0;
    virtual HRESULT setAvoidUpdatesOverNetwork(BOOL aAvoidUpdatesOverNetwork) = 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(GraphicsAdapterWrap)

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

    /** @name Public IGraphicsAdapter methods
     * @{ */
    STDMETHOD(SetFeature)(GraphicsFeature_T aFeature,
                          BOOL aEnabled) RT_OVERRIDE;
    STDMETHOD(IsFeatureEnabled)(GraphicsFeature_T aFeature,
                                BOOL *aEnabled) RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1IGraphicsAdapter)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IGraphicsAdapter)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3IGraphicsAdapter)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4IGraphicsAdapter)() RT_OVERRIDE;
    /** @} */

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 getMonitorCount(ULONG *aMonitorCount) = 0;
    virtual HRESULT setMonitorCount(ULONG aMonitorCount) = 0;
    /** @} */

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

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

};

#endif // !GraphicsAdapterWrap_H_

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


// ##### BEGINFILE "FirmwareSettingsWrap.h"
/** @file
 * VirtualBox API class wrapper header for IFirmwareSettings.
 *
 * 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#ifndef FirmwareSettingsWrap_H_
#define FirmwareSettingsWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

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

class ATL_NO_VTABLE FirmwareSettingsWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IFirmwareSettings)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(FirmwareSettingsWrap, IFirmwareSettings)
    DECLARE_NOT_AGGREGATABLE(FirmwareSettingsWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(FirmwareSettingsWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IFirmwareSettings)
        COM_INTERFACE_ENTRY2(IDispatch, IFirmwareSettings)
        VBOX_TWEAK_INTERFACE_ENTRY(IFirmwareSettings)
    END_COM_MAP()

    DECLARE_COMMON_CLASS_METHODS(FirmwareSettingsWrap)

    /** @name Public IFirmwareSettings properties
     * @{ */
    STDMETHOD(COMGETTER(FirmwareType))(FirmwareType_T *aFirmwareType) RT_OVERRIDE;
    STDMETHOD(COMSETTER(FirmwareType))(FirmwareType_T aFirmwareType) RT_OVERRIDE;
    STDMETHOD(COMGETTER(LogoFadeIn))(BOOL *aLogoFadeIn) RT_OVERRIDE;
    STDMETHOD(COMSETTER(LogoFadeIn))(BOOL aLogoFadeIn) RT_OVERRIDE;
    STDMETHOD(COMGETTER(LogoFadeOut))(BOOL *aLogoFadeOut) RT_OVERRIDE;
    STDMETHOD(COMSETTER(LogoFadeOut))(BOOL aLogoFadeOut) RT_OVERRIDE;
    STDMETHOD(COMGETTER(LogoDisplayTime))(ULONG *aLogoDisplayTime) RT_OVERRIDE;
    STDMETHOD(COMSETTER(LogoDisplayTime))(ULONG aLogoDisplayTime) RT_OVERRIDE;
    STDMETHOD(COMGETTER(LogoImagePath))(BSTR *aLogoImagePath) RT_OVERRIDE;
    STDMETHOD(COMSETTER(LogoImagePath))(IN_BSTR aLogoImagePath) RT_OVERRIDE;
    STDMETHOD(COMGETTER(BootMenuMode))(FirmwareBootMenuMode_T *aBootMenuMode) RT_OVERRIDE;
    STDMETHOD(COMSETTER(BootMenuMode))(FirmwareBootMenuMode_T aBootMenuMode) RT_OVERRIDE;
    STDMETHOD(COMGETTER(ACPIEnabled))(BOOL *aACPIEnabled) RT_OVERRIDE;
    STDMETHOD(COMSETTER(ACPIEnabled))(BOOL aACPIEnabled) RT_OVERRIDE;
    STDMETHOD(COMGETTER(IOAPICEnabled))(BOOL *aIOAPICEnabled) RT_OVERRIDE;
    STDMETHOD(COMSETTER(IOAPICEnabled))(BOOL aIOAPICEnabled) RT_OVERRIDE;
    STDMETHOD(COMGETTER(APICMode))(APICMode_T *aAPICMode) RT_OVERRIDE;
    STDMETHOD(COMSETTER(APICMode))(APICMode_T aAPICMode) RT_OVERRIDE;
    STDMETHOD(COMGETTER(TimeOffset))(LONG64 *aTimeOffset) RT_OVERRIDE;
    STDMETHOD(COMSETTER(TimeOffset))(LONG64 aTimeOffset) RT_OVERRIDE;
    STDMETHOD(COMGETTER(PXEDebugEnabled))(BOOL *aPXEDebugEnabled) RT_OVERRIDE;
    STDMETHOD(COMSETTER(PXEDebugEnabled))(BOOL aPXEDebugEnabled) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SMBIOSUuidLittleEndian))(BOOL *aSMBIOSUuidLittleEndian) RT_OVERRIDE;
    STDMETHOD(COMSETTER(SMBIOSUuidLittleEndian))(BOOL aSMBIOSUuidLittleEndian) RT_OVERRIDE;
    STDMETHOD(COMGETTER(AutoSerialNumGen))(BOOL *aAutoSerialNumGen) RT_OVERRIDE;
    STDMETHOD(COMSETTER(AutoSerialNumGen))(BOOL aAutoSerialNumGen) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IFirmwareSettings))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IFirmwareSettings))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IFirmwareSettings))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IFirmwareSettings))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IFirmwareSettings))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IFirmwareSettings))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IFirmwareSettings))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IFirmwareSettings))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IFirmwareSettings methods
     * @{ */
    STDMETHOD(InternalAndReservedMethod1IFirmwareSettings)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IFirmwareSettings)() RT_OVERRIDE;
    /** @} */

private:
    /** @name Wrapped IFirmwareSettings properties
     * @{ */
    virtual HRESULT getFirmwareType(FirmwareType_T *aFirmwareType) = 0;
    virtual HRESULT setFirmwareType(FirmwareType_T aFirmwareType) = 0;
    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(FirmwareBootMenuMode_T *aBootMenuMode) = 0;
    virtual HRESULT setBootMenuMode(FirmwareBootMenuMode_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 getSMBIOSUuidLittleEndian(BOOL *aSMBIOSUuidLittleEndian) = 0;
    virtual HRESULT setSMBIOSUuidLittleEndian(BOOL aSMBIOSUuidLittleEndian) = 0;
    virtual HRESULT getAutoSerialNumGen(BOOL *aAutoSerialNumGen) = 0;
    virtual HRESULT setAutoSerialNumGen(BOOL aAutoSerialNumGen) = 0;
    /** @} */

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

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

};

#endif // !FirmwareSettingsWrap_H_

// ##### ENDFILE "FirmwareSettingsWrap.h"


// ##### BEGINFILE "TrustedPlatformModuleWrap.h"
/** @file
 * VirtualBox API class wrapper header for ITrustedPlatformModule.
 *
 * 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#ifndef TrustedPlatformModuleWrap_H_
#define TrustedPlatformModuleWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

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

class ATL_NO_VTABLE TrustedPlatformModuleWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(ITrustedPlatformModule)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(TrustedPlatformModuleWrap, ITrustedPlatformModule)
    DECLARE_NOT_AGGREGATABLE(TrustedPlatformModuleWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(TrustedPlatformModuleWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(ITrustedPlatformModule)
        COM_INTERFACE_ENTRY2(IDispatch, ITrustedPlatformModule)
        VBOX_TWEAK_INTERFACE_ENTRY(ITrustedPlatformModule)
    END_COM_MAP()

    DECLARE_COMMON_CLASS_METHODS(TrustedPlatformModuleWrap)

    /** @name Public ITrustedPlatformModule properties
     * @{ */
    STDMETHOD(COMGETTER(Type))(TpmType_T *aType) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Type))(TpmType_T aType) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Location))(BSTR *aLocation) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Location))(IN_BSTR aLocation) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1ITrustedPlatformModule))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2ITrustedPlatformModule))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3ITrustedPlatformModule))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4ITrustedPlatformModule))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5ITrustedPlatformModule))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6ITrustedPlatformModule))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7ITrustedPlatformModule))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8ITrustedPlatformModule))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public ITrustedPlatformModule methods
     * @{ */
    STDMETHOD(InternalAndReservedMethod1ITrustedPlatformModule)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2ITrustedPlatformModule)() RT_OVERRIDE;
    /** @} */

private:
    /** @name Wrapped ITrustedPlatformModule properties
     * @{ */
    virtual HRESULT getType(TpmType_T *aType) = 0;
    virtual HRESULT setType(TpmType_T aType) = 0;
    virtual HRESULT getLocation(com::Utf8Str &aLocation) = 0;
    virtual HRESULT setLocation(const com::Utf8Str &aLocation) = 0;
    /** @} */

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

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

};

#endif // !TrustedPlatformModuleWrap_H_

// ##### ENDFILE "TrustedPlatformModuleWrap.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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(RecordingScreenSettingsWrap)

    /** @name Public IRecordingScreenSettings properties
     * @{ */
    STDMETHOD(COMGETTER(Id))(ULONG *aId) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Enabled))(BOOL *aEnabled) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Enabled))(BOOL aEnabled) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Features))(ComSafeArrayOut(RecordingFeature_T, aFeatures)) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Features))(ComSafeArrayIn(RecordingFeature_T, aFeatures)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Destination))(RecordingDestination_T *aDestination) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Destination))(RecordingDestination_T aDestination) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Filename))(BSTR *aFilename) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Filename))(IN_BSTR aFilename) RT_OVERRIDE;
    STDMETHOD(COMGETTER(MaxTime))(ULONG *aMaxTime) RT_OVERRIDE;
    STDMETHOD(COMSETTER(MaxTime))(ULONG aMaxTime) RT_OVERRIDE;
    STDMETHOD(COMGETTER(MaxFileSize))(ULONG *aMaxFileSize) RT_OVERRIDE;
    STDMETHOD(COMSETTER(MaxFileSize))(ULONG aMaxFileSize) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Options))(BSTR *aOptions) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Options))(IN_BSTR aOptions) RT_OVERRIDE;
    STDMETHOD(COMGETTER(AudioCodec))(RecordingAudioCodec_T *aAudioCodec) RT_OVERRIDE;
    STDMETHOD(COMSETTER(AudioCodec))(RecordingAudioCodec_T aAudioCodec) RT_OVERRIDE;
    STDMETHOD(COMGETTER(AudioRateControlMode))(RecordingRateControlMode_T *aAudioRateControlMode) RT_OVERRIDE;
    STDMETHOD(COMSETTER(AudioRateControlMode))(RecordingRateControlMode_T aAudioRateControlMode) RT_OVERRIDE;
    STDMETHOD(COMGETTER(AudioDeadline))(RecordingCodecDeadline_T *aAudioDeadline) RT_OVERRIDE;
    STDMETHOD(COMSETTER(AudioDeadline))(RecordingCodecDeadline_T aAudioDeadline) RT_OVERRIDE;
    STDMETHOD(COMGETTER(AudioHz))(ULONG *aAudioHz) RT_OVERRIDE;
    STDMETHOD(COMSETTER(AudioHz))(ULONG aAudioHz) RT_OVERRIDE;
    STDMETHOD(COMGETTER(AudioBits))(ULONG *aAudioBits) RT_OVERRIDE;
    STDMETHOD(COMSETTER(AudioBits))(ULONG aAudioBits) RT_OVERRIDE;
    STDMETHOD(COMGETTER(AudioChannels))(ULONG *aAudioChannels) RT_OVERRIDE;
    STDMETHOD(COMSETTER(AudioChannels))(ULONG aAudioChannels) RT_OVERRIDE;
    STDMETHOD(COMGETTER(VideoCodec))(RecordingVideoCodec_T *aVideoCodec) RT_OVERRIDE;
    STDMETHOD(COMSETTER(VideoCodec))(RecordingVideoCodec_T aVideoCodec) RT_OVERRIDE;
    STDMETHOD(COMGETTER(VideoDeadline))(RecordingCodecDeadline_T *aVideoDeadline) RT_OVERRIDE;
    STDMETHOD(COMSETTER(VideoDeadline))(RecordingCodecDeadline_T aVideoDeadline) RT_OVERRIDE;
    STDMETHOD(COMGETTER(VideoWidth))(ULONG *aVideoWidth) RT_OVERRIDE;
    STDMETHOD(COMSETTER(VideoWidth))(ULONG aVideoWidth) RT_OVERRIDE;
    STDMETHOD(COMGETTER(VideoHeight))(ULONG *aVideoHeight) RT_OVERRIDE;
    STDMETHOD(COMSETTER(VideoHeight))(ULONG aVideoHeight) RT_OVERRIDE;
    STDMETHOD(COMGETTER(VideoRate))(ULONG *aVideoRate) RT_OVERRIDE;
    STDMETHOD(COMSETTER(VideoRate))(ULONG aVideoRate) RT_OVERRIDE;
    STDMETHOD(COMGETTER(VideoRateControlMode))(RecordingRateControlMode_T *aVideoRateControlMode) RT_OVERRIDE;
    STDMETHOD(COMSETTER(VideoRateControlMode))(RecordingRateControlMode_T aVideoRateControlMode) RT_OVERRIDE;
    STDMETHOD(COMGETTER(VideoFPS))(ULONG *aVideoFPS) RT_OVERRIDE;
    STDMETHOD(COMSETTER(VideoFPS))(ULONG aVideoFPS) RT_OVERRIDE;
    STDMETHOD(COMGETTER(VideoScalingMode))(RecordingVideoScalingMode_T *aVideoScalingMode) RT_OVERRIDE;
    STDMETHOD(COMSETTER(VideoScalingMode))(RecordingVideoScalingMode_T aVideoScalingMode) RT_OVERRIDE;
    /** @} */

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

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(std::vector<RecordingFeature_T> &aFeatures) = 0;
    virtual HRESULT setFeatures(const std::vector<RecordingFeature_T> &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 getAudioRateControlMode(RecordingRateControlMode_T *aAudioRateControlMode) = 0;
    virtual HRESULT setAudioRateControlMode(RecordingRateControlMode_T aAudioRateControlMode) = 0;
    virtual HRESULT getAudioDeadline(RecordingCodecDeadline_T *aAudioDeadline) = 0;
    virtual HRESULT setAudioDeadline(RecordingCodecDeadline_T aAudioDeadline) = 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 getVideoDeadline(RecordingCodecDeadline_T *aVideoDeadline) = 0;
    virtual HRESULT setVideoDeadline(RecordingCodecDeadline_T aVideoDeadline) = 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(RecordingRateControlMode_T *aVideoRateControlMode) = 0;
    virtual HRESULT setVideoRateControlMode(RecordingRateControlMode_T aVideoRateControlMode) = 0;
    virtual HRESULT getVideoFPS(ULONG *aVideoFPS) = 0;
    virtual HRESULT setVideoFPS(ULONG aVideoFPS) = 0;
    virtual HRESULT getVideoScalingMode(RecordingVideoScalingMode_T *aVideoScalingMode) = 0;
    virtual HRESULT setVideoScalingMode(RecordingVideoScalingMode_T aVideoScalingMode) = 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(RecordingSettingsWrap)

    /** @name Public IRecordingSettings properties
     * @{ */
    STDMETHOD(COMGETTER(Paused))(BOOL *aPaused) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Paused))(BOOL aPaused) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Enabled))(BOOL *aEnabled) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Enabled))(BOOL aEnabled) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Screens))(ComSafeArrayOut(IRecordingScreenSettings *, aScreens)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Progress))(IProgress **aProgress) RT_OVERRIDE;
    /** @} */

    /** @name Public IRecordingSettings methods
     * @{ */
    STDMETHOD(GetScreenSettings)(ULONG aScreenId,
                                 IRecordingScreenSettings **aRecordScreenSettings) RT_OVERRIDE;
    STDMETHOD(Start)(IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(Resume)() RT_OVERRIDE;
    /** @} */

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

    /** @name Wrapped IRecordingSettings methods
     * @{ */
    virtual HRESULT getScreenSettings(ULONG aScreenId,
                                      ComPtr<IRecordingScreenSettings> &aRecordScreenSettings) = 0;
    virtual HRESULT start(ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT resume() = 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(PCIAddressWrap)

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

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

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(PCIDeviceAttachmentWrap)

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

    /** @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 "UefiVariableStoreWrap.h"
/** @file
 * VirtualBox API class wrapper header for IUefiVariableStore.
 *
 * 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#ifndef UefiVariableStoreWrap_H_
#define UefiVariableStoreWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

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

class ATL_NO_VTABLE UefiVariableStoreWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IUefiVariableStore)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(UefiVariableStoreWrap, IUefiVariableStore)
    DECLARE_NOT_AGGREGATABLE(UefiVariableStoreWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(UefiVariableStoreWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IUefiVariableStore)
        COM_INTERFACE_ENTRY2(IDispatch, IUefiVariableStore)
        VBOX_TWEAK_INTERFACE_ENTRY(IUefiVariableStore)
    END_COM_MAP()

    DECLARE_COMMON_CLASS_METHODS(UefiVariableStoreWrap)

    /** @name Public IUefiVariableStore properties
     * @{ */
    STDMETHOD(COMGETTER(SecureBootEnabled))(BOOL *aSecureBootEnabled) RT_OVERRIDE;
    STDMETHOD(COMSETTER(SecureBootEnabled))(BOOL aSecureBootEnabled) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IUefiVariableStore))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IUefiVariableStore))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IUefiVariableStore))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IUefiVariableStore))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IUefiVariableStore))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IUefiVariableStore methods
     * @{ */
    STDMETHOD(AddVariable)(IN_BSTR aName,
                           IN_BSTR aOwner,
                           ComSafeArrayIn(UefiVariableAttributes_T, aAttributes),
                           ComSafeArrayIn(BYTE, aData)) RT_OVERRIDE;
    STDMETHOD(DeleteVariable)(IN_BSTR aName,
                              IN_BSTR aOwner) RT_OVERRIDE;
    STDMETHOD(ChangeVariable)(IN_BSTR aName,
                              ComSafeArrayIn(BYTE, aData)) RT_OVERRIDE;
    STDMETHOD(QueryVariableByName)(IN_BSTR aName,
                                   BSTR *aOwner,
                                   ComSafeArrayOut(UefiVariableAttributes_T, aAttributes),
                                   ComSafeArrayOut(BYTE, aData)) RT_OVERRIDE;
    STDMETHOD(QueryVariables)(ComSafeArrayOut(BSTR, aNames),
                              ComSafeArrayOut(BSTR, aOwners)) RT_OVERRIDE;
    STDMETHOD(EnrollOraclePlatformKey)() RT_OVERRIDE;
    STDMETHOD(EnrollPlatformKey)(ComSafeArrayIn(BYTE, aPlatformKey),
                                 IN_BSTR aOwner) RT_OVERRIDE;
    STDMETHOD(AddKek)(ComSafeArrayIn(BYTE, aKeyEncryptionKey),
                      IN_BSTR aOwner,
                      SignatureType_T aSignatureType) RT_OVERRIDE;
    STDMETHOD(AddSignatureToDb)(ComSafeArrayIn(BYTE, aSignature),
                                IN_BSTR aOwner,
                                SignatureType_T aSignatureType) RT_OVERRIDE;
    STDMETHOD(AddSignatureToDbx)(ComSafeArrayIn(BYTE, aSignature),
                                 IN_BSTR aOwner,
                                 SignatureType_T aSignatureType) RT_OVERRIDE;
    STDMETHOD(EnrollDefaultMsSignatures)() RT_OVERRIDE;
    STDMETHOD(AddSignatureToMok)(ComSafeArrayIn(BYTE, aSignature),
                                 IN_BSTR aOwner,
                                 SignatureType_T aSignatureType) RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1IUefiVariableStore)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IUefiVariableStore)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3IUefiVariableStore)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4IUefiVariableStore)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod5IUefiVariableStore)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod6IUefiVariableStore)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod7IUefiVariableStore)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod8IUefiVariableStore)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod9IUefiVariableStore)() RT_OVERRIDE;
    /** @} */

private:
    /** @name Wrapped IUefiVariableStore properties
     * @{ */
    virtual HRESULT getSecureBootEnabled(BOOL *aSecureBootEnabled) = 0;
    virtual HRESULT setSecureBootEnabled(BOOL aSecureBootEnabled) = 0;
    /** @} */

    /** @name Wrapped IUefiVariableStore methods
     * @{ */
    virtual HRESULT addVariable(const com::Utf8Str &aName,
                                const com::Guid &aOwner,
                                const std::vector<UefiVariableAttributes_T> &aAttributes,
                                const std::vector<BYTE> &aData) = 0;
    virtual HRESULT deleteVariable(const com::Utf8Str &aName,
                                   const com::Guid &aOwner) = 0;
    virtual HRESULT changeVariable(const com::Utf8Str &aName,
                                   const std::vector<BYTE> &aData) = 0;
    virtual HRESULT queryVariableByName(const com::Utf8Str &aName,
                                        com::Guid &aOwner,
                                        std::vector<UefiVariableAttributes_T> &aAttributes,
                                        std::vector<BYTE> &aData) = 0;
    virtual HRESULT queryVariables(std::vector<com::Utf8Str> &aNames,
                                   std::vector<com::Guid> &aOwners) = 0;
    virtual HRESULT enrollOraclePlatformKey() = 0;
    virtual HRESULT enrollPlatformKey(const std::vector<BYTE> &aPlatformKey,
                                      const com::Guid &aOwner) = 0;
    virtual HRESULT addKek(const std::vector<BYTE> &aKeyEncryptionKey,
                           const com::Guid &aOwner,
                           SignatureType_T aSignatureType) = 0;
    virtual HRESULT addSignatureToDb(const std::vector<BYTE> &aSignature,
                                     const com::Guid &aOwner,
                                     SignatureType_T aSignatureType) = 0;
    virtual HRESULT addSignatureToDbx(const std::vector<BYTE> &aSignature,
                                      const com::Guid &aOwner,
                                      SignatureType_T aSignatureType) = 0;
    virtual HRESULT enrollDefaultMsSignatures() = 0;
    virtual HRESULT addSignatureToMok(const std::vector<BYTE> &aSignature,
                                      const com::Guid &aOwner,
                                      SignatureType_T aSignatureType) = 0;
    /** @} */

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

};

#endif // !UefiVariableStoreWrap_H_

// ##### ENDFILE "UefiVariableStoreWrap.h"


// ##### BEGINFILE "NvramStoreWrap.h"
/** @file
 * VirtualBox API class wrapper header for INvramStore.
 *
 * 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#ifndef NvramStoreWrap_H_
#define NvramStoreWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

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

class ATL_NO_VTABLE NvramStoreWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(INvramStore)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(NvramStoreWrap, INvramStore)
    DECLARE_NOT_AGGREGATABLE(NvramStoreWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(NvramStoreWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(INvramStore)
        COM_INTERFACE_ENTRY2(IDispatch, INvramStore)
        VBOX_TWEAK_INTERFACE_ENTRY(INvramStore)
    END_COM_MAP()

    DECLARE_COMMON_CLASS_METHODS(NvramStoreWrap)

    /** @name Public INvramStore properties
     * @{ */
    STDMETHOD(COMGETTER(NonVolatileStorageFile))(BSTR *aNonVolatileStorageFile) RT_OVERRIDE;
    STDMETHOD(COMGETTER(UefiVariableStore))(IUefiVariableStore **aUefiVariableStore) RT_OVERRIDE;
    STDMETHOD(COMGETTER(KeyId))(BSTR *aKeyId) RT_OVERRIDE;
    STDMETHOD(COMGETTER(KeyStore))(BSTR *aKeyStore) RT_OVERRIDE;
    /** @} */

    /** @name Public INvramStore methods
     * @{ */
    STDMETHOD(InitUefiVariableStore)(ULONG aSize) RT_OVERRIDE;
    /** @} */

private:
    /** @name Wrapped INvramStore properties
     * @{ */
    virtual HRESULT getNonVolatileStorageFile(com::Utf8Str &aNonVolatileStorageFile) = 0;
    virtual HRESULT getUefiVariableStore(ComPtr<IUefiVariableStore> &aUefiVariableStore) = 0;
    virtual HRESULT getKeyId(com::Utf8Str &aKeyId) = 0;
    virtual HRESULT getKeyStore(com::Utf8Str &aKeyStore) = 0;
    /** @} */

    /** @name Wrapped INvramStore methods
     * @{ */
    virtual HRESULT initUefiVariableStore(ULONG aSize) = 0;
    /** @} */

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

};

#endif // !NvramStoreWrap_H_

// ##### ENDFILE "NvramStoreWrap.h"


// ##### BEGINFILE "ResourceStoreWrap.h"
/** @file
 * VirtualBox API class wrapper header for IResourceStore.
 *
 * 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#ifndef ResourceStoreWrap_H_
#define ResourceStoreWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

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

class ATL_NO_VTABLE ResourceStoreWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IResourceStore)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(ResourceStoreWrap, IResourceStore)
    DECLARE_NOT_AGGREGATABLE(ResourceStoreWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(ResourceStoreWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IResourceStore)
        COM_INTERFACE_ENTRY2(IDispatch, IResourceStore)
        VBOX_TWEAK_INTERFACE_ENTRY(IResourceStore)
    END_COM_MAP()

    DECLARE_COMMON_CLASS_METHODS(ResourceStoreWrap)

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

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

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

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

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

};

#endif // !ResourceStoreWrap_H_

// ##### ENDFILE "ResourceStoreWrap.h"


// ##### BEGINFILE "PlatformWrap.h"
/** @file
 * VirtualBox API class wrapper header for IPlatform.
 *
 * 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#ifndef PlatformWrap_H_
#define PlatformWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

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

class ATL_NO_VTABLE PlatformWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IPlatform)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(PlatformWrap, IPlatform)
    DECLARE_NOT_AGGREGATABLE(PlatformWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(PlatformWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IPlatform)
        COM_INTERFACE_ENTRY2(IDispatch, IPlatform)
        VBOX_TWEAK_INTERFACE_ENTRY(IPlatform)
    END_COM_MAP()

    DECLARE_COMMON_CLASS_METHODS(PlatformWrap)

    /** @name Public IPlatform properties
     * @{ */
    STDMETHOD(COMGETTER(Architecture))(PlatformArchitecture_T *aArchitecture) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Architecture))(PlatformArchitecture_T aArchitecture) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Properties))(IPlatformProperties **aProperties) RT_OVERRIDE;
    STDMETHOD(COMGETTER(X86))(IPlatformX86 **aX86) RT_OVERRIDE;
    STDMETHOD(COMGETTER(ARM))(IPlatformARM **aARM) RT_OVERRIDE;
    STDMETHOD(COMGETTER(ChipsetType))(ChipsetType_T *aChipsetType) RT_OVERRIDE;
    STDMETHOD(COMSETTER(ChipsetType))(ChipsetType_T aChipsetType) RT_OVERRIDE;
    STDMETHOD(COMGETTER(IommuType))(IommuType_T *aIommuType) RT_OVERRIDE;
    STDMETHOD(COMSETTER(IommuType))(IommuType_T aIommuType) RT_OVERRIDE;
    STDMETHOD(COMGETTER(RTCUseUTC))(BOOL *aRTCUseUTC) RT_OVERRIDE;
    STDMETHOD(COMSETTER(RTCUseUTC))(BOOL aRTCUseUTC) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IPlatform))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IPlatform))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IPlatform))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IPlatform))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IPlatform))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IPlatform))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IPlatform))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IPlatform))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute9IPlatform))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute10IPlatform))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute11IPlatform))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute12IPlatform))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute13IPlatform))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute14IPlatform))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute15IPlatform))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute16IPlatform))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IPlatform methods
     * @{ */
    STDMETHOD(InternalAndReservedMethod1IPlatform)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IPlatform)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3IPlatform)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4IPlatform)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod5IPlatform)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod6IPlatform)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod7IPlatform)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod8IPlatform)() RT_OVERRIDE;
    /** @} */

private:
    /** @name Wrapped IPlatform properties
     * @{ */
    virtual HRESULT getArchitecture(PlatformArchitecture_T *aArchitecture) = 0;
    virtual HRESULT setArchitecture(PlatformArchitecture_T aArchitecture) = 0;
    virtual HRESULT getProperties(ComPtr<IPlatformProperties> &aProperties) = 0;
    virtual HRESULT getX86(ComPtr<IPlatformX86> &aX86) = 0;
    virtual HRESULT getARM(ComPtr<IPlatformARM> &aARM) = 0;
    virtual HRESULT getChipsetType(ChipsetType_T *aChipsetType) = 0;
    virtual HRESULT setChipsetType(ChipsetType_T aChipsetType) = 0;
    virtual HRESULT getIommuType(IommuType_T *aIommuType) = 0;
    virtual HRESULT setIommuType(IommuType_T aIommuType) = 0;
    virtual HRESULT getRTCUseUTC(BOOL *aRTCUseUTC) = 0;
    virtual HRESULT setRTCUseUTC(BOOL aRTCUseUTC) = 0;
    /** @} */

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

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

};

#endif // !PlatformWrap_H_

// ##### ENDFILE "PlatformWrap.h"


// ##### BEGINFILE "PlatformX86Wrap.h"
/** @file
 * VirtualBox API class wrapper header for IPlatformX86.
 *
 * 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#ifndef PlatformX86Wrap_H_
#define PlatformX86Wrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

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

class ATL_NO_VTABLE PlatformX86Wrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IPlatformX86)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(PlatformX86Wrap, IPlatformX86)
    DECLARE_NOT_AGGREGATABLE(PlatformX86Wrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(PlatformX86Wrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IPlatformX86)
        COM_INTERFACE_ENTRY2(IDispatch, IPlatformX86)
        VBOX_TWEAK_INTERFACE_ENTRY(IPlatformX86)
    END_COM_MAP()

    DECLARE_COMMON_CLASS_METHODS(PlatformX86Wrap)

    /** @name Public IPlatformX86 properties
     * @{ */
    STDMETHOD(COMGETTER(HPETEnabled))(BOOL *aHPETEnabled) RT_OVERRIDE;
    STDMETHOD(COMSETTER(HPETEnabled))(BOOL aHPETEnabled) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IPlatformX86))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IPlatformX86))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IPlatformX86))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IPlatformX86))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IPlatformX86))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IPlatformX86))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IPlatformX86))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IPlatformX86))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute9IPlatformX86))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute10IPlatformX86))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute11IPlatformX86))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute12IPlatformX86))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute13IPlatformX86))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute14IPlatformX86))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute15IPlatformX86))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute16IPlatformX86))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IPlatformX86 methods
     * @{ */
    STDMETHOD(GetCPUProperty)(CPUPropertyTypeX86_T aProperty,
                              BOOL *aValue) RT_OVERRIDE;
    STDMETHOD(SetCPUProperty)(CPUPropertyTypeX86_T aProperty,
                              BOOL aValue) RT_OVERRIDE;
    STDMETHOD(GetCPUIDLeafByOrdinal)(ULONG aOrdinal,
                                     ULONG *aIdx,
                                     ULONG *aIdxSub,
                                     ULONG *aValEax,
                                     ULONG *aValEbx,
                                     ULONG *aValEcx,
                                     ULONG *aValEdx) RT_OVERRIDE;
    STDMETHOD(GetCPUIDLeaf)(ULONG aIdx,
                            ULONG aIdxSub,
                            ULONG *aValEax,
                            ULONG *aValEbx,
                            ULONG *aValEcx,
                            ULONG *aValEdx) RT_OVERRIDE;
    STDMETHOD(SetCPUIDLeaf)(ULONG aIdx,
                            ULONG aIdxSub,
                            ULONG aValEax,
                            ULONG aValEbx,
                            ULONG aValEcx,
                            ULONG aValEdx) RT_OVERRIDE;
    STDMETHOD(RemoveCPUIDLeaf)(ULONG aIdx,
                               ULONG aIdxSub) RT_OVERRIDE;
    STDMETHOD(RemoveAllCPUIDLeaves)() RT_OVERRIDE;
    STDMETHOD(GetHWVirtExProperty)(HWVirtExPropertyType_T aProperty,
                                   BOOL *aValue) RT_OVERRIDE;
    STDMETHOD(SetHWVirtExProperty)(HWVirtExPropertyType_T aProperty,
                                   BOOL aValue) RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1IPlatformX86)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IPlatformX86)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3IPlatformX86)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4IPlatformX86)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod5IPlatformX86)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod6IPlatformX86)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod7IPlatformX86)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod8IPlatformX86)() RT_OVERRIDE;
    /** @} */

private:
    /** @name Wrapped IPlatformX86 properties
     * @{ */
    virtual HRESULT getHPETEnabled(BOOL *aHPETEnabled) = 0;
    virtual HRESULT setHPETEnabled(BOOL aHPETEnabled) = 0;
    /** @} */

    /** @name Wrapped IPlatformX86 methods
     * @{ */
    virtual HRESULT getCPUProperty(CPUPropertyTypeX86_T aProperty,
                                   BOOL *aValue) = 0;
    virtual HRESULT setCPUProperty(CPUPropertyTypeX86_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;
    /** @} */

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

};

#endif // !PlatformX86Wrap_H_

// ##### ENDFILE "PlatformX86Wrap.h"


// ##### BEGINFILE "PlatformARMWrap.h"
/** @file
 * VirtualBox API class wrapper header for IPlatformARM.
 *
 * 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#ifndef PlatformARMWrap_H_
#define PlatformARMWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

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

class ATL_NO_VTABLE PlatformARMWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IPlatformARM)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(PlatformARMWrap, IPlatformARM)
    DECLARE_NOT_AGGREGATABLE(PlatformARMWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(PlatformARMWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IPlatformARM)
        COM_INTERFACE_ENTRY2(IDispatch, IPlatformARM)
        VBOX_TWEAK_INTERFACE_ENTRY(IPlatformARM)
    END_COM_MAP()

    DECLARE_COMMON_CLASS_METHODS(PlatformARMWrap)

    /** @name Public IPlatformARM properties
     * @{ */
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IPlatformARM))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IPlatformARM))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IPlatformARM))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IPlatformARM))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IPlatformARM))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IPlatformARM))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IPlatformARM))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IPlatformARM))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute9IPlatformARM))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute10IPlatformARM))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute11IPlatformARM))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute12IPlatformARM))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute13IPlatformARM))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute14IPlatformARM))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute15IPlatformARM))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute16IPlatformARM))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IPlatformARM methods
     * @{ */
    STDMETHOD(GetCPUProperty)(CPUPropertyTypeARM_T aProperty,
                              BOOL *aValue) RT_OVERRIDE;
    STDMETHOD(SetCPUProperty)(CPUPropertyTypeARM_T aProperty,
                              BOOL aValue) RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1IPlatformARM)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IPlatformARM)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3IPlatformARM)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4IPlatformARM)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod5IPlatformARM)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod6IPlatformARM)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod7IPlatformARM)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod8IPlatformARM)() RT_OVERRIDE;
    /** @} */

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

    /** @name Wrapped IPlatformARM methods
     * @{ */
    virtual HRESULT getCPUProperty(CPUPropertyTypeARM_T aProperty,
                                   BOOL *aValue) = 0;
    virtual HRESULT setCPUProperty(CPUPropertyTypeARM_T aProperty,
                                   BOOL aValue) = 0;
    /** @} */

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

};

#endif // !PlatformARMWrap_H_

// ##### ENDFILE "PlatformARMWrap.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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(MachineWrap)

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

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

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

    /** @name Public IInternalMachineControl methods
     * @{ */
    STDMETHOD(UpdateState)(MachineState_T aState) RT_OVERRIDE;
    STDMETHOD(BeginPowerUp)(IProgress *aProgress) RT_OVERRIDE;
    STDMETHOD(EndPowerUp)(LONG aResult) RT_OVERRIDE;
    STDMETHOD(BeginPoweringDown)(IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(EndPoweringDown)(LONG aResult,
                               IN_BSTR aErrMsg) RT_OVERRIDE;
    STDMETHOD(RunUSBDeviceFilters)(IUSBDevice *aDevice,
                                   BOOL *aMatched,
                                   ULONG *aMaskedInterfaces) RT_OVERRIDE;
    STDMETHOD(CaptureUSBDevice)(IN_BSTR aId,
                                IN_BSTR aCaptureFilename) RT_OVERRIDE;
    STDMETHOD(DetachUSBDevice)(IN_BSTR aId,
                               BOOL aDone) RT_OVERRIDE;
    STDMETHOD(AutoCaptureUSBDevices)() RT_OVERRIDE;
    STDMETHOD(DetachAllUSBDevices)(BOOL aDone) RT_OVERRIDE;
    STDMETHOD(OnSessionEnd)(ISession *aSession,
                            IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(FinishOnlineMergeMedium)() RT_OVERRIDE;
    STDMETHOD(PullGuestProperties)(ComSafeArrayOut(BSTR, aNames),
                                   ComSafeArrayOut(BSTR, aValues),
                                   ComSafeArrayOut(LONG64, aTimestamps),
                                   ComSafeArrayOut(BSTR, aFlags)) RT_OVERRIDE;
    STDMETHOD(PushGuestProperty)(IN_BSTR aName,
                                 IN_BSTR aValue,
                                 LONG64 aTimestamp,
                                 IN_BSTR aFlags,
                                 BOOL aFWasDeleted) RT_OVERRIDE;
    STDMETHOD(LockMedia)() RT_OVERRIDE;
    STDMETHOD(UnlockMedia)() RT_OVERRIDE;
    STDMETHOD(EjectMedium)(IMediumAttachment *aAttachment,
                           IMediumAttachment **aNewAttachment) RT_OVERRIDE;
    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) RT_OVERRIDE;
    STDMETHOD(AuthenticateExternal)(ComSafeArrayIn(IN_BSTR, aAuthParams),
                                    BSTR *aResult) RT_OVERRIDE;
    /** @} */

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 getPlatform(ComPtr<IPlatform> &aPlatform) = 0;
    virtual HRESULT getFirmwareSettings(ComPtr<IFirmwareSettings> &aFirmwareSettings) = 0;
    virtual HRESULT getTrustedPlatformModule(ComPtr<ITrustedPlatformModule> &aTrustedPlatformModule) = 0;
    virtual HRESULT getNonVolatileStore(ComPtr<INvramStore> &aNonVolatileStore) = 0;
    virtual HRESULT getRecordingSettings(ComPtr<IRecordingSettings> &aRecordingSettings) = 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 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 getAudioSettings(ComPtr<IAudioSettings> &aAudioSettings) = 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 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 getVMExecutionEngine(VMExecutionEngine_T *aVMExecutionEngine) = 0;
    virtual HRESULT setVMExecutionEngine(VMExecutionEngine_T aVMExecutionEngine) = 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;
    virtual HRESULT getStateKeyId(com::Utf8Str &aStateKeyId) = 0;
    virtual HRESULT getStateKeyStore(com::Utf8Str &aStateKeyStore) = 0;
    virtual HRESULT getLogKeyId(com::Utf8Str &aLogKeyId) = 0;
    virtual HRESULT getLogKeyStore(com::Utf8Str &aLogKeyStore) = 0;
    virtual HRESULT getGuestDebugControl(ComPtr<IGuestDebugControl> &aGuestDebugControl) = 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 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;
    virtual HRESULT changeEncryption(const com::Utf8Str &aCurrentPassword,
                                     const com::Utf8Str &aCipher,
                                     const com::Utf8Str &aNewPassword,
                                     const com::Utf8Str &aNewPasswordId,
                                     BOOL aForce,
                                     ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT getEncryptionSettings(com::Utf8Str &aCipher,
                                          com::Utf8Str &aPasswordId) = 0;
    virtual HRESULT checkEncryptionPassword(const com::Utf8Str &aPassword) = 0;
    virtual HRESULT addEncryptionPassword(const com::Utf8Str &aId,
                                          const com::Utf8Str &aPassword) = 0;
    virtual HRESULT addEncryptionPasswords(const std::vector<com::Utf8Str> &aIds,
                                           const std::vector<com::Utf8Str> &aPasswords) = 0;
    virtual HRESULT removeEncryptionPassword(AutoCaller &aAutoCaller,
                                             const com::Utf8Str &aId) = 0;
    virtual HRESULT clearAllEncryptionPasswords(AutoCaller &aAutoCaller) = 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 pushGuestProperty(const com::Utf8Str &aName,
                                      const com::Utf8Str &aValue,
                                      LONG64 aTimestamp,
                                      const com::Utf8Str &aFlags,
                                      BOOL aFWasDeleted) = 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(EmulatedUSBWrap)

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

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

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(VRDEServerInfoWrap)

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

    /** @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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(ConsoleWrap)

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

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

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 addEncryptionPassword(const com::Utf8Str &aId,
                                          const com::Utf8Str &aPassword,
                                          BOOL aClearOnSuspend) = 0;
    virtual HRESULT addEncryptionPasswords(const std::vector<com::Utf8Str> &aIds,
                                           const std::vector<com::Utf8Str> &aPasswords,
                                           BOOL aClearOnSuspend) = 0;
    virtual HRESULT removeEncryptionPassword(const com::Utf8Str &aId) = 0;
    virtual HRESULT clearAllEncryptionPasswords() = 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(HostNetworkInterfaceWrap)

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

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

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(HostVideoInputDeviceWrap)

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

    /** @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 "UpdateAgentWrap.h"
/** @file
 * VirtualBox API class wrapper header for IUpdateAgent.
 *
 * 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#ifndef UpdateAgentWrap_H_
#define UpdateAgentWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

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

class ATL_NO_VTABLE UpdateAgentWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IUpdateAgent)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(UpdateAgentWrap, IUpdateAgent)
    DECLARE_NOT_AGGREGATABLE(UpdateAgentWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(UpdateAgentWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IUpdateAgent)
        COM_INTERFACE_ENTRY2(IDispatch, IUpdateAgent)
        VBOX_TWEAK_INTERFACE_ENTRY(IUpdateAgent)
    END_COM_MAP()

    DECLARE_COMMON_CLASS_METHODS(UpdateAgentWrap)

    /** @name Public IUpdateAgent properties
     * @{ */
    STDMETHOD(COMGETTER(Name))(BSTR *aName) RT_OVERRIDE;
    STDMETHOD(COMGETTER(EventSource))(IEventSource **aEventSource) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Order))(ULONG *aOrder) RT_OVERRIDE;
    STDMETHOD(COMGETTER(DependsOn))(ComSafeArrayOut(BSTR, aDependsOn)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Version))(BSTR *aVersion) RT_OVERRIDE;
    STDMETHOD(COMGETTER(DownloadUrl))(BSTR *aDownloadUrl) RT_OVERRIDE;
    STDMETHOD(COMGETTER(WebUrl))(BSTR *aWebUrl) RT_OVERRIDE;
    STDMETHOD(COMGETTER(ReleaseNotes))(BSTR *aReleaseNotes) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Enabled))(BOOL *aEnabled) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Enabled))(BOOL aEnabled) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Hidden))(BOOL *aHidden) RT_OVERRIDE;
    STDMETHOD(COMGETTER(State))(UpdateState_T *aState) RT_OVERRIDE;
    STDMETHOD(COMGETTER(CheckFrequency))(ULONG *aCheckFrequency) RT_OVERRIDE;
    STDMETHOD(COMSETTER(CheckFrequency))(ULONG aCheckFrequency) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Channel))(UpdateChannel_T *aChannel) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Channel))(UpdateChannel_T aChannel) RT_OVERRIDE;
    STDMETHOD(COMGETTER(RepositoryURL))(BSTR *aRepositoryURL) RT_OVERRIDE;
    STDMETHOD(COMSETTER(RepositoryURL))(IN_BSTR aRepositoryURL) RT_OVERRIDE;
    STDMETHOD(COMGETTER(LastCheckDate))(BSTR *aLastCheckDate) RT_OVERRIDE;
    STDMETHOD(COMGETTER(CheckCount))(ULONG *aCheckCount) RT_OVERRIDE;
    STDMETHOD(COMGETTER(IsCheckNeeded))(BOOL *aIsCheckNeeded) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportedChannels))(ComSafeArrayOut(UpdateChannel_T, aSupportedChannels)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IUpdateAgent))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IUpdateAgent))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IUpdateAgent))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IUpdateAgent))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IUpdateAgent methods
     * @{ */
    STDMETHOD(CheckFor)(IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(Download)(IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(Install)(IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(Rollback)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1IUpdateAgent)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IUpdateAgent)() RT_OVERRIDE;
    /** @} */

private:
    /** @name Wrapped IUpdateAgent properties
     * @{ */
    virtual HRESULT getName(com::Utf8Str &aName) = 0;
    virtual HRESULT getEventSource(ComPtr<IEventSource> &aEventSource) = 0;
    virtual HRESULT getOrder(ULONG *aOrder) = 0;
    virtual HRESULT getDependsOn(std::vector<com::Utf8Str> &aDependsOn) = 0;
    virtual HRESULT getVersion(com::Utf8Str &aVersion) = 0;
    virtual HRESULT getDownloadUrl(com::Utf8Str &aDownloadUrl) = 0;
    virtual HRESULT getWebUrl(com::Utf8Str &aWebUrl) = 0;
    virtual HRESULT getReleaseNotes(com::Utf8Str &aReleaseNotes) = 0;
    virtual HRESULT getEnabled(BOOL *aEnabled) = 0;
    virtual HRESULT setEnabled(BOOL aEnabled) = 0;
    virtual HRESULT getHidden(BOOL *aHidden) = 0;
    virtual HRESULT getState(UpdateState_T *aState) = 0;
    virtual HRESULT getCheckFrequency(ULONG *aCheckFrequency) = 0;
    virtual HRESULT setCheckFrequency(ULONG aCheckFrequency) = 0;
    virtual HRESULT getChannel(UpdateChannel_T *aChannel) = 0;
    virtual HRESULT setChannel(UpdateChannel_T aChannel) = 0;
    virtual HRESULT getRepositoryURL(com::Utf8Str &aRepositoryURL) = 0;
    virtual HRESULT setRepositoryURL(const com::Utf8Str &aRepositoryURL) = 0;
    virtual HRESULT getLastCheckDate(com::Utf8Str &aLastCheckDate) = 0;
    virtual HRESULT getCheckCount(ULONG *aCheckCount) = 0;
    virtual HRESULT getIsCheckNeeded(BOOL *aIsCheckNeeded) = 0;
    virtual HRESULT getSupportedChannels(std::vector<UpdateChannel_T> &aSupportedChannels) = 0;
    /** @} */

    /** @name Wrapped IUpdateAgent methods
     * @{ */
    virtual HRESULT checkFor(ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT download(ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT install(ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT rollback() = 0;
    /** @} */

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

};

#endif // !UpdateAgentWrap_H_

// ##### ENDFILE "UpdateAgentWrap.h"


// ##### BEGINFILE "HostUpdateAgentWrap.h"
/** @file
 * VirtualBox API class wrapper header for IHostUpdateAgent.
 *
 * 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#ifndef HostUpdateAgentWrap_H_
#define HostUpdateAgentWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

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

class ATL_NO_VTABLE HostUpdateAgentWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IHostUpdateAgent)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(HostUpdateAgentWrap, IHostUpdateAgent)
    DECLARE_NOT_AGGREGATABLE(HostUpdateAgentWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(HostUpdateAgentWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IHostUpdateAgent)
        COM_INTERFACE_ENTRY(IUpdateAgent)
        COM_INTERFACE_ENTRY2(IDispatch, IHostUpdateAgent)
        VBOX_TWEAK_INTERFACE_ENTRY(IHostUpdateAgent)
    END_COM_MAP()

    DECLARE_COMMON_CLASS_METHODS(HostUpdateAgentWrap)

    /** @name Public IUpdateAgent properties
     * @{ */
    STDMETHOD(COMGETTER(Name))(BSTR *aName) RT_OVERRIDE;
    STDMETHOD(COMGETTER(EventSource))(IEventSource **aEventSource) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Order))(ULONG *aOrder) RT_OVERRIDE;
    STDMETHOD(COMGETTER(DependsOn))(ComSafeArrayOut(BSTR, aDependsOn)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Version))(BSTR *aVersion) RT_OVERRIDE;
    STDMETHOD(COMGETTER(DownloadUrl))(BSTR *aDownloadUrl) RT_OVERRIDE;
    STDMETHOD(COMGETTER(WebUrl))(BSTR *aWebUrl) RT_OVERRIDE;
    STDMETHOD(COMGETTER(ReleaseNotes))(BSTR *aReleaseNotes) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Enabled))(BOOL *aEnabled) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Enabled))(BOOL aEnabled) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Hidden))(BOOL *aHidden) RT_OVERRIDE;
    STDMETHOD(COMGETTER(State))(UpdateState_T *aState) RT_OVERRIDE;
    STDMETHOD(COMGETTER(CheckFrequency))(ULONG *aCheckFrequency) RT_OVERRIDE;
    STDMETHOD(COMSETTER(CheckFrequency))(ULONG aCheckFrequency) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Channel))(UpdateChannel_T *aChannel) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Channel))(UpdateChannel_T aChannel) RT_OVERRIDE;
    STDMETHOD(COMGETTER(RepositoryURL))(BSTR *aRepositoryURL) RT_OVERRIDE;
    STDMETHOD(COMSETTER(RepositoryURL))(IN_BSTR aRepositoryURL) RT_OVERRIDE;
    STDMETHOD(COMGETTER(LastCheckDate))(BSTR *aLastCheckDate) RT_OVERRIDE;
    STDMETHOD(COMGETTER(CheckCount))(ULONG *aCheckCount) RT_OVERRIDE;
    STDMETHOD(COMGETTER(IsCheckNeeded))(BOOL *aIsCheckNeeded) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportedChannels))(ComSafeArrayOut(UpdateChannel_T, aSupportedChannels)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IUpdateAgent))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IUpdateAgent))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IUpdateAgent))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IUpdateAgent))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IHostUpdateAgent properties
     * @{ */
    STDMETHOD(COMGETTER(MidlDoesNotLikeEmptyInterfaces))(BOOL *aMidlDoesNotLikeEmptyInterfaces) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IHostUpdateAgent))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IHostUpdateAgent))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IHostUpdateAgent))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IHostUpdateAgent))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IUpdateAgent methods
     * @{ */
    STDMETHOD(CheckFor)(IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(Download)(IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(Install)(IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(Rollback)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1IUpdateAgent)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IUpdateAgent)() RT_OVERRIDE;
    /** @} */

    /** @name Public IHostUpdateAgent methods
     * @{ */
    STDMETHOD(InternalAndReservedMethod1IHostUpdateAgent)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IHostUpdateAgent)() RT_OVERRIDE;
    /** @} */

private:
    /** @name Wrapped IUpdateAgent properties
     * @{ */
    virtual HRESULT getName(com::Utf8Str &aName) = 0;
    virtual HRESULT getEventSource(ComPtr<IEventSource> &aEventSource) = 0;
    virtual HRESULT getOrder(ULONG *aOrder) = 0;
    virtual HRESULT getDependsOn(std::vector<com::Utf8Str> &aDependsOn) = 0;
    virtual HRESULT getVersion(com::Utf8Str &aVersion) = 0;
    virtual HRESULT getDownloadUrl(com::Utf8Str &aDownloadUrl) = 0;
    virtual HRESULT getWebUrl(com::Utf8Str &aWebUrl) = 0;
    virtual HRESULT getReleaseNotes(com::Utf8Str &aReleaseNotes) = 0;
    virtual HRESULT getEnabled(BOOL *aEnabled) = 0;
    virtual HRESULT setEnabled(BOOL aEnabled) = 0;
    virtual HRESULT getHidden(BOOL *aHidden) = 0;
    virtual HRESULT getState(UpdateState_T *aState) = 0;
    virtual HRESULT getCheckFrequency(ULONG *aCheckFrequency) = 0;
    virtual HRESULT setCheckFrequency(ULONG aCheckFrequency) = 0;
    virtual HRESULT getChannel(UpdateChannel_T *aChannel) = 0;
    virtual HRESULT setChannel(UpdateChannel_T aChannel) = 0;
    virtual HRESULT getRepositoryURL(com::Utf8Str &aRepositoryURL) = 0;
    virtual HRESULT setRepositoryURL(const com::Utf8Str &aRepositoryURL) = 0;
    virtual HRESULT getLastCheckDate(com::Utf8Str &aLastCheckDate) = 0;
    virtual HRESULT getCheckCount(ULONG *aCheckCount) = 0;
    virtual HRESULT getIsCheckNeeded(BOOL *aIsCheckNeeded) = 0;
    virtual HRESULT getSupportedChannels(std::vector<UpdateChannel_T> &aSupportedChannels) = 0;
    /** @} */

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

    /** @name Wrapped IUpdateAgent methods
     * @{ */
    virtual HRESULT checkFor(ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT download(ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT install(ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT rollback() = 0;
    /** @} */

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

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

};

#endif // !HostUpdateAgentWrap_H_

// ##### ENDFILE "HostUpdateAgentWrap.h"


// ##### BEGINFILE "HostDrivePartitionWrap.h"
/** @file
 * VirtualBox API class wrapper header for IHostDrivePartition.
 *
 * 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#ifndef HostDrivePartitionWrap_H_
#define HostDrivePartitionWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

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

class ATL_NO_VTABLE HostDrivePartitionWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IHostDrivePartition)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(HostDrivePartitionWrap, IHostDrivePartition)
    DECLARE_NOT_AGGREGATABLE(HostDrivePartitionWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(HostDrivePartitionWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IHostDrivePartition)
        COM_INTERFACE_ENTRY2(IDispatch, IHostDrivePartition)
        VBOX_TWEAK_INTERFACE_ENTRY(IHostDrivePartition)
    END_COM_MAP()

    DECLARE_COMMON_CLASS_METHODS(HostDrivePartitionWrap)

    /** @name Public IHostDrivePartition properties
     * @{ */
    STDMETHOD(COMGETTER(Number))(ULONG *aNumber) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Size))(LONG64 *aSize) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Start))(LONG64 *aStart) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Type))(PartitionType_T *aType) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Active))(BOOL *aActive) RT_OVERRIDE;
    STDMETHOD(COMGETTER(TypeMBR))(ULONG *aTypeMBR) RT_OVERRIDE;
    STDMETHOD(COMGETTER(StartCylinder))(ULONG *aStartCylinder) RT_OVERRIDE;
    STDMETHOD(COMGETTER(StartHead))(ULONG *aStartHead) RT_OVERRIDE;
    STDMETHOD(COMGETTER(StartSector))(ULONG *aStartSector) RT_OVERRIDE;
    STDMETHOD(COMGETTER(EndCylinder))(ULONG *aEndCylinder) RT_OVERRIDE;
    STDMETHOD(COMGETTER(EndHead))(ULONG *aEndHead) RT_OVERRIDE;
    STDMETHOD(COMGETTER(EndSector))(ULONG *aEndSector) RT_OVERRIDE;
    STDMETHOD(COMGETTER(TypeUuid))(BSTR *aTypeUuid) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Uuid))(BSTR *aUuid) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Name))(BSTR *aName) RT_OVERRIDE;
    /** @} */

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

private:
    /** @name Wrapped IHostDrivePartition properties
     * @{ */
    virtual HRESULT getNumber(ULONG *aNumber) = 0;
    virtual HRESULT getSize(LONG64 *aSize) = 0;
    virtual HRESULT getStart(LONG64 *aStart) = 0;
    virtual HRESULT getType(PartitionType_T *aType) = 0;
    virtual HRESULT getActive(BOOL *aActive) = 0;
    virtual HRESULT getTypeMBR(ULONG *aTypeMBR) = 0;
    virtual HRESULT getStartCylinder(ULONG *aStartCylinder) = 0;
    virtual HRESULT getStartHead(ULONG *aStartHead) = 0;
    virtual HRESULT getStartSector(ULONG *aStartSector) = 0;
    virtual HRESULT getEndCylinder(ULONG *aEndCylinder) = 0;
    virtual HRESULT getEndHead(ULONG *aEndHead) = 0;
    virtual HRESULT getEndSector(ULONG *aEndSector) = 0;
    virtual HRESULT getTypeUuid(com::Guid &aTypeUuid) = 0;
    virtual HRESULT getUuid(com::Guid &aUuid) = 0;
    virtual HRESULT getName(com::Utf8Str &aName) = 0;
    /** @} */

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

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

};

#endif // !HostDrivePartitionWrap_H_

// ##### ENDFILE "HostDrivePartitionWrap.h"


// ##### BEGINFILE "HostDriveWrap.h"
/** @file
 * VirtualBox API class wrapper header for IHostDrive.
 *
 * 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#ifndef HostDriveWrap_H_
#define HostDriveWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

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

class ATL_NO_VTABLE HostDriveWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IHostDrive)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(HostDriveWrap, IHostDrive)
    DECLARE_NOT_AGGREGATABLE(HostDriveWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(HostDriveWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IHostDrive)
        COM_INTERFACE_ENTRY2(IDispatch, IHostDrive)
        VBOX_TWEAK_INTERFACE_ENTRY(IHostDrive)
    END_COM_MAP()

    DECLARE_COMMON_CLASS_METHODS(HostDriveWrap)

    /** @name Public IHostDrive properties
     * @{ */
    STDMETHOD(COMGETTER(DrivePath))(BSTR *aDrivePath) RT_OVERRIDE;
    STDMETHOD(COMGETTER(PartitioningType))(PartitioningType_T *aPartitioningType) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Uuid))(BSTR *aUuid) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SectorSize))(ULONG *aSectorSize) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Size))(LONG64 *aSize) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Model))(BSTR *aModel) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Partitions))(ComSafeArrayOut(IHostDrivePartition *, aPartitions)) RT_OVERRIDE;
    /** @} */

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

private:
    /** @name Wrapped IHostDrive properties
     * @{ */
    virtual HRESULT getDrivePath(com::Utf8Str &aDrivePath) = 0;
    virtual HRESULT getPartitioningType(PartitioningType_T *aPartitioningType) = 0;
    virtual HRESULT getUuid(com::Guid &aUuid) = 0;
    virtual HRESULT getSectorSize(ULONG *aSectorSize) = 0;
    virtual HRESULT getSize(LONG64 *aSize) = 0;
    virtual HRESULT getModel(com::Utf8Str &aModel) = 0;
    virtual HRESULT getPartitions(std::vector<ComPtr<IHostDrivePartition> > &aPartitions) = 0;
    /** @} */

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

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

};

#endif // !HostDriveWrap_H_

// ##### ENDFILE "HostDriveWrap.h"


// ##### BEGINFILE "HostX86Wrap.h"
/** @file
 * VirtualBox API class wrapper header for IHostX86.
 *
 * 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#ifndef HostX86Wrap_H_
#define HostX86Wrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

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

class ATL_NO_VTABLE HostX86Wrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IHostX86)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(HostX86Wrap, IHostX86)
    DECLARE_NOT_AGGREGATABLE(HostX86Wrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(HostX86Wrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IHostX86)
        COM_INTERFACE_ENTRY2(IDispatch, IHostX86)
        VBOX_TWEAK_INTERFACE_ENTRY(IHostX86)
    END_COM_MAP()

    DECLARE_COMMON_CLASS_METHODS(HostX86Wrap)

    /** @name Public IHostX86 properties
     * @{ */
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IHostX86))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IHostX86))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IHostX86))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IHostX86))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IHostX86))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IHostX86))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IHostX86))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IHostX86))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute9IHostX86))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute10IHostX86))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute11IHostX86))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute12IHostX86))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IHostX86 methods
     * @{ */
    STDMETHOD(GetProcessorCPUIDLeaf)(ULONG aCpuId,
                                     ULONG aLeaf,
                                     ULONG aSubLeaf,
                                     ULONG *aValEax,
                                     ULONG *aValEbx,
                                     ULONG *aValEcx,
                                     ULONG *aValEdx) RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1IHostX86)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IHostX86)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3IHostX86)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4IHostX86)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod5IHostX86)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod6IHostX86)() RT_OVERRIDE;
    /** @} */

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

    /** @name Wrapped IHostX86 methods
     * @{ */
    virtual HRESULT getProcessorCPUIDLeaf(ULONG aCpuId,
                                          ULONG aLeaf,
                                          ULONG aSubLeaf,
                                          ULONG *aValEax,
                                          ULONG *aValEbx,
                                          ULONG *aValEcx,
                                          ULONG *aValEdx) = 0;
    /** @} */

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

};

#endif // !HostX86Wrap_H_

// ##### ENDFILE "HostX86Wrap.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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(HostWrap)

    /** @name Public IHost properties
     * @{ */
    STDMETHOD(COMGETTER(Architecture))(PlatformArchitecture_T *aArchitecture) RT_OVERRIDE;
    STDMETHOD(COMGETTER(X86))(IHostX86 **aX86) RT_OVERRIDE;
    STDMETHOD(COMGETTER(DVDDrives))(ComSafeArrayOut(IMedium *, aDVDDrives)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(FloppyDrives))(ComSafeArrayOut(IMedium *, aFloppyDrives)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(AudioDevices))(ComSafeArrayOut(IHostAudioDevice *, aAudioDevices)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(USBDevices))(ComSafeArrayOut(IHostUSBDevice *, aUSBDevices)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(USBDeviceFilters))(ComSafeArrayOut(IHostUSBDeviceFilter *, aUSBDeviceFilters)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(NetworkInterfaces))(ComSafeArrayOut(IHostNetworkInterface *, aNetworkInterfaces)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(NameServers))(ComSafeArrayOut(BSTR, aNameServers)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(DomainName))(BSTR *aDomainName) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SearchStrings))(ComSafeArrayOut(BSTR, aSearchStrings)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(ProcessorCount))(ULONG *aProcessorCount) RT_OVERRIDE;
    STDMETHOD(COMGETTER(ProcessorOnlineCount))(ULONG *aProcessorOnlineCount) RT_OVERRIDE;
    STDMETHOD(COMGETTER(ProcessorCoreCount))(ULONG *aProcessorCoreCount) RT_OVERRIDE;
    STDMETHOD(COMGETTER(ProcessorOnlineCoreCount))(ULONG *aProcessorOnlineCoreCount) RT_OVERRIDE;
    STDMETHOD(COMGETTER(HostDrives))(ComSafeArrayOut(IHostDrive *, aHostDrives)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(MemorySize))(ULONG *aMemorySize) RT_OVERRIDE;
    STDMETHOD(COMGETTER(MemoryAvailable))(ULONG *aMemoryAvailable) RT_OVERRIDE;
    STDMETHOD(COMGETTER(OperatingSystem))(BSTR *aOperatingSystem) RT_OVERRIDE;
    STDMETHOD(COMGETTER(OSVersion))(BSTR *aOSVersion) RT_OVERRIDE;
    STDMETHOD(COMGETTER(UTCTime))(LONG64 *aUTCTime) RT_OVERRIDE;
    STDMETHOD(COMGETTER(VideoInputDevices))(ComSafeArrayOut(IHostVideoInputDevice *, aVideoInputDevices)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(UpdateHost))(IUpdateAgent **aUpdateHost) RT_OVERRIDE;
    STDMETHOD(COMGETTER(UpdateExtPack))(IUpdateAgent **aUpdateExtPack) RT_OVERRIDE;
    STDMETHOD(COMGETTER(UpdateGuestAdditions))(IUpdateAgent **aUpdateGuestAdditions) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IHost))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IHost))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IHost))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IHost))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IHost))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IHost))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IHost))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IHost))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute9IHost))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute10IHost))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute11IHost))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute12IHost))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

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

private:
    /** @name Wrapped IHost properties
     * @{ */
    virtual HRESULT getArchitecture(PlatformArchitecture_T *aArchitecture) = 0;
    virtual HRESULT getX86(ComPtr<IHostX86> &aX86) = 0;
    virtual HRESULT getDVDDrives(std::vector<ComPtr<IMedium> > &aDVDDrives) = 0;
    virtual HRESULT getFloppyDrives(std::vector<ComPtr<IMedium> > &aFloppyDrives) = 0;
    virtual HRESULT getAudioDevices(std::vector<ComPtr<IHostAudioDevice> > &aAudioDevices) = 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 getHostDrives(std::vector<ComPtr<IHostDrive> > &aHostDrives) = 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 getVideoInputDevices(std::vector<ComPtr<IHostVideoInputDevice> > &aVideoInputDevices) = 0;
    virtual HRESULT getUpdateHost(ComPtr<IUpdateAgent> &aUpdateHost) = 0;
    virtual HRESULT getUpdateExtPack(ComPtr<IUpdateAgent> &aUpdateExtPack) = 0;
    virtual HRESULT getUpdateGuestAdditions(ComPtr<IUpdateAgent> &aUpdateGuestAdditions) = 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 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;
    virtual HRESULT isExecutionEngineSupported(CPUArchitecture_T aCpuArchitecture,
                                               VMExecutionEngine_T aExecutionEngine,
                                               BOOL *aIsSupported) = 0;
    /** @} */

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

};

#endif // !HostWrap_H_

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


// ##### BEGINFILE "CPUProfileWrap.h"
/** @file
 * VirtualBox API class wrapper header for ICPUProfile.
 *
 * 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#ifndef CPUProfileWrap_H_
#define CPUProfileWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

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

class ATL_NO_VTABLE CPUProfileWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(ICPUProfile)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(CPUProfileWrap, ICPUProfile)
    DECLARE_NOT_AGGREGATABLE(CPUProfileWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(CPUProfileWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(ICPUProfile)
        COM_INTERFACE_ENTRY2(IDispatch, ICPUProfile)
        VBOX_TWEAK_INTERFACE_ENTRY(ICPUProfile)
    END_COM_MAP()

    DECLARE_COMMON_CLASS_METHODS(CPUProfileWrap)

    /** @name Public ICPUProfile properties
     * @{ */
    STDMETHOD(COMGETTER(Name))(BSTR *aName) RT_OVERRIDE;
    STDMETHOD(COMGETTER(FullName))(BSTR *aFullName) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Architecture))(CPUArchitecture_T *aArchitecture) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1ICPUProfile))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2ICPUProfile))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3ICPUProfile))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4ICPUProfile))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5ICPUProfile))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6ICPUProfile))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7ICPUProfile))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8ICPUProfile))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public ICPUProfile methods
     * @{ */
    STDMETHOD(InternalAndReservedMethod1ICPUProfile)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2ICPUProfile)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3ICPUProfile)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4ICPUProfile)() RT_OVERRIDE;
    /** @} */

private:
    /** @name Wrapped ICPUProfile properties
     * @{ */
    virtual HRESULT getName(com::Utf8Str &aName) = 0;
    virtual HRESULT getFullName(com::Utf8Str &aFullName) = 0;
    virtual HRESULT getArchitecture(CPUArchitecture_T *aArchitecture) = 0;
    /** @} */

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

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

};

#endif // !CPUProfileWrap_H_

// ##### ENDFILE "CPUProfileWrap.h"


// ##### BEGINFILE "PlatformPropertiesWrap.h"
/** @file
 * VirtualBox API class wrapper header for IPlatformProperties.
 *
 * 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#ifndef PlatformPropertiesWrap_H_
#define PlatformPropertiesWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

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

class ATL_NO_VTABLE PlatformPropertiesWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IPlatformProperties)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(PlatformPropertiesWrap, IPlatformProperties)
    DECLARE_NOT_AGGREGATABLE(PlatformPropertiesWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(PlatformPropertiesWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IPlatformProperties)
        COM_INTERFACE_ENTRY2(IDispatch, IPlatformProperties)
        VBOX_TWEAK_INTERFACE_ENTRY(IPlatformProperties)
    END_COM_MAP()

    DECLARE_COMMON_CLASS_METHODS(PlatformPropertiesWrap)

    /** @name Public IPlatformProperties properties
     * @{ */
    STDMETHOD(COMGETTER(RawModeSupported))(BOOL *aRawModeSupported) RT_OVERRIDE;
    STDMETHOD(COMGETTER(ExclusiveHwVirt))(BOOL *aExclusiveHwVirt) RT_OVERRIDE;
    STDMETHOD(COMSETTER(ExclusiveHwVirt))(BOOL aExclusiveHwVirt) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SerialPortCount))(ULONG *aSerialPortCount) RT_OVERRIDE;
    STDMETHOD(COMGETTER(ParallelPortCount))(ULONG *aParallelPortCount) RT_OVERRIDE;
    STDMETHOD(COMGETTER(MaxBootPosition))(ULONG *aMaxBootPosition) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportedParavirtProviders))(ComSafeArrayOut(ParavirtProvider_T, aSupportedParavirtProviders)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportedFirmwareTypes))(ComSafeArrayOut(FirmwareType_T, aSupportedFirmwareTypes)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportedGuestOSTypes))(ComSafeArrayOut(IGuestOSType *, aSupportedGuestOSTypes)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportedGfxControllerTypes))(ComSafeArrayOut(GraphicsControllerType_T, aSupportedGfxControllerTypes)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportedNetAdpPromiscModePols))(ComSafeArrayOut(NetworkAdapterPromiscModePolicy_T, aSupportedNetAdpPromiscModePols)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportedNetworkAdapterTypes))(ComSafeArrayOut(NetworkAdapterType_T, aSupportedNetworkAdapterTypes)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportedUartTypes))(ComSafeArrayOut(UartType_T, aSupportedUartTypes)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportedUSBControllerTypes))(ComSafeArrayOut(USBControllerType_T, aSupportedUSBControllerTypes)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportedAudioControllerTypes))(ComSafeArrayOut(AudioControllerType_T, aSupportedAudioControllerTypes)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportedBootDevices))(ComSafeArrayOut(DeviceType_T, aSupportedBootDevices)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportedStorageBuses))(ComSafeArrayOut(StorageBus_T, aSupportedStorageBuses)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportedStorageControllerTypes))(ComSafeArrayOut(StorageControllerType_T, aSupportedStorageControllerTypes)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportedChipsetTypes))(ComSafeArrayOut(ChipsetType_T, aSupportedChipsetTypes)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportedIommuTypes))(ComSafeArrayOut(IommuType_T, aSupportedIommuTypes)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportedTpmTypes))(ComSafeArrayOut(TpmType_T, aSupportedTpmTypes)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IPlatformProperties))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IPlatformProperties))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IPlatformProperties))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IPlatformProperties))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IPlatformProperties))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IPlatformProperties))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IPlatformProperties))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IPlatformProperties))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute9IPlatformProperties))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute10IPlatformProperties))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute11IPlatformProperties))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute12IPlatformProperties))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute13IPlatformProperties))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute14IPlatformProperties))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute15IPlatformProperties))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute16IPlatformProperties))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IPlatformProperties methods
     * @{ */
    STDMETHOD(GetMaxNetworkAdapters)(ChipsetType_T aChipset,
                                     ULONG *aMaxNetworkAdapters) RT_OVERRIDE;
    STDMETHOD(GetMaxNetworkAdaptersOfType)(ChipsetType_T aChipset,
                                           NetworkAttachmentType_T aType,
                                           ULONG *aMaxNetworkAdapters) RT_OVERRIDE;
    STDMETHOD(GetMaxDevicesPerPortForStorageBus)(StorageBus_T aBus,
                                                 ULONG *aMaxDevicesPerPort) RT_OVERRIDE;
    STDMETHOD(GetMinPortCountForStorageBus)(StorageBus_T aBus,
                                            ULONG *aMinPortCount) RT_OVERRIDE;
    STDMETHOD(GetMaxPortCountForStorageBus)(StorageBus_T aBus,
                                            ULONG *aMaxPortCount) RT_OVERRIDE;
    STDMETHOD(GetMaxInstancesOfStorageBus)(ChipsetType_T aChipset,
                                           StorageBus_T aBus,
                                           ULONG *aMaxInstances) RT_OVERRIDE;
    STDMETHOD(GetSupportedVRAMRange)(GraphicsControllerType_T aGraphicsControllerType,
                                     BOOL aAccelerate3DEnabled,
                                     ULONG *aMinMB,
                                     ULONG *aMaxMB,
                                     ULONG *aStrideSizeMB) RT_OVERRIDE;
    STDMETHOD(GetSupportedGfxFeaturesForType)(GraphicsControllerType_T aGraphicsControllerType,
                                              ComSafeArrayOut(GraphicsFeature_T, aSupportedControllerFeatures)) RT_OVERRIDE;
    STDMETHOD(GetDeviceTypesForStorageBus)(StorageBus_T aBus,
                                           ComSafeArrayOut(DeviceType_T, aDeviceTypes)) RT_OVERRIDE;
    STDMETHOD(GetStorageBusForControllerType)(StorageControllerType_T aStorageControllerType,
                                              StorageBus_T *aStorageBus) RT_OVERRIDE;
    STDMETHOD(GetStorageControllerTypesForBus)(StorageBus_T aStorageBus,
                                               ComSafeArrayOut(StorageControllerType_T, aStorageControllerType)) RT_OVERRIDE;
    STDMETHOD(GetStorageControllerHotplugCapable)(StorageControllerType_T aControllerType,
                                                  BOOL *aHotplugCapable) RT_OVERRIDE;
    STDMETHOD(GetMaxInstancesOfUSBControllerType)(ChipsetType_T aChipset,
                                                  USBControllerType_T aType,
                                                  ULONG *aMaxInstances) RT_OVERRIDE;
    STDMETHOD(GetMinGuestRAM)(FirmwareType_T aFirmware,
                              ULONG *aMinMegabytes) RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1IPlatformProperties)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IPlatformProperties)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3IPlatformProperties)() RT_OVERRIDE;
    /** @} */

private:
    /** @name Wrapped IPlatformProperties properties
     * @{ */
    virtual HRESULT getRawModeSupported(BOOL *aRawModeSupported) = 0;
    virtual HRESULT getExclusiveHwVirt(BOOL *aExclusiveHwVirt) = 0;
    virtual HRESULT setExclusiveHwVirt(BOOL aExclusiveHwVirt) = 0;
    virtual HRESULT getSerialPortCount(ULONG *aSerialPortCount) = 0;
    virtual HRESULT getParallelPortCount(ULONG *aParallelPortCount) = 0;
    virtual HRESULT getMaxBootPosition(ULONG *aMaxBootPosition) = 0;
    virtual HRESULT getSupportedParavirtProviders(std::vector<ParavirtProvider_T> &aSupportedParavirtProviders) = 0;
    virtual HRESULT getSupportedFirmwareTypes(std::vector<FirmwareType_T> &aSupportedFirmwareTypes) = 0;
    virtual HRESULT getSupportedGuestOSTypes(std::vector<ComPtr<IGuestOSType> > &aSupportedGuestOSTypes) = 0;
    virtual HRESULT getSupportedGfxControllerTypes(std::vector<GraphicsControllerType_T> &aSupportedGfxControllerTypes) = 0;
    virtual HRESULT getSupportedNetAdpPromiscModePols(std::vector<NetworkAdapterPromiscModePolicy_T> &aSupportedNetAdpPromiscModePols) = 0;
    virtual HRESULT getSupportedNetworkAdapterTypes(std::vector<NetworkAdapterType_T> &aSupportedNetworkAdapterTypes) = 0;
    virtual HRESULT getSupportedUartTypes(std::vector<UartType_T> &aSupportedUartTypes) = 0;
    virtual HRESULT getSupportedUSBControllerTypes(std::vector<USBControllerType_T> &aSupportedUSBControllerTypes) = 0;
    virtual HRESULT getSupportedAudioControllerTypes(std::vector<AudioControllerType_T> &aSupportedAudioControllerTypes) = 0;
    virtual HRESULT getSupportedBootDevices(std::vector<DeviceType_T> &aSupportedBootDevices) = 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;
    virtual HRESULT getSupportedIommuTypes(std::vector<IommuType_T> &aSupportedIommuTypes) = 0;
    virtual HRESULT getSupportedTpmTypes(std::vector<TpmType_T> &aSupportedTpmTypes) = 0;
    /** @} */

    /** @name Wrapped IPlatformProperties 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 getSupportedVRAMRange(GraphicsControllerType_T aGraphicsControllerType,
                                          BOOL aAccelerate3DEnabled,
                                          ULONG *aMinMB,
                                          ULONG *aMaxMB,
                                          ULONG *aStrideSizeMB) = 0;
    virtual HRESULT getSupportedGfxFeaturesForType(GraphicsControllerType_T aGraphicsControllerType,
                                                   std::vector<GraphicsFeature_T> &aSupportedControllerFeatures) = 0;
    virtual HRESULT getDeviceTypesForStorageBus(StorageBus_T aBus,
                                                std::vector<DeviceType_T> &aDeviceTypes) = 0;
    virtual HRESULT getStorageBusForControllerType(StorageControllerType_T aStorageControllerType,
                                                   StorageBus_T *aStorageBus) = 0;
    virtual HRESULT getStorageControllerTypesForBus(StorageBus_T aStorageBus,
                                                    std::vector<StorageControllerType_T> &aStorageControllerType) = 0;
    virtual HRESULT getStorageControllerHotplugCapable(StorageControllerType_T aControllerType,
                                                       BOOL *aHotplugCapable) = 0;
    virtual HRESULT getMaxInstancesOfUSBControllerType(ChipsetType_T aChipset,
                                                       USBControllerType_T aType,
                                                       ULONG *aMaxInstances) = 0;
    virtual HRESULT getMinGuestRAM(FirmwareType_T aFirmware,
                                   ULONG *aMinMegabytes) = 0;
    /** @} */

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

};

#endif // !PlatformPropertiesWrap_H_

// ##### ENDFILE "PlatformPropertiesWrap.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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(SystemPropertiesWrap)

    /** @name Public ISystemProperties properties
     * @{ */
    STDMETHOD(COMGETTER(Platform))(IPlatformProperties **aPlatform) RT_OVERRIDE;
    STDMETHOD(COMGETTER(MinGuestRAM))(ULONG *aMinGuestRAM) RT_OVERRIDE;
    STDMETHOD(COMGETTER(MaxGuestRAM))(ULONG *aMaxGuestRAM) RT_OVERRIDE;
    STDMETHOD(COMGETTER(MinGuestVRAM))(ULONG *aMinGuestVRAM) RT_OVERRIDE;
    STDMETHOD(COMGETTER(MaxGuestVRAM))(ULONG *aMaxGuestVRAM) RT_OVERRIDE;
    STDMETHOD(COMGETTER(MinGuestCPUCount))(ULONG *aMinGuestCPUCount) RT_OVERRIDE;
    STDMETHOD(COMGETTER(MaxGuestCPUCount))(ULONG *aMaxGuestCPUCount) RT_OVERRIDE;
    STDMETHOD(COMGETTER(MaxGuestMonitors))(ULONG *aMaxGuestMonitors) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InfoVDSize))(LONG64 *aInfoVDSize) RT_OVERRIDE;
    STDMETHOD(COMGETTER(DefaultMachineFolder))(BSTR *aDefaultMachineFolder) RT_OVERRIDE;
    STDMETHOD(COMSETTER(DefaultMachineFolder))(IN_BSTR aDefaultMachineFolder) RT_OVERRIDE;
    STDMETHOD(COMGETTER(LoggingLevel))(BSTR *aLoggingLevel) RT_OVERRIDE;
    STDMETHOD(COMSETTER(LoggingLevel))(IN_BSTR aLoggingLevel) RT_OVERRIDE;
    STDMETHOD(COMGETTER(MediumFormats))(ComSafeArrayOut(IMediumFormat *, aMediumFormats)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(DefaultHardDiskFormat))(BSTR *aDefaultHardDiskFormat) RT_OVERRIDE;
    STDMETHOD(COMSETTER(DefaultHardDiskFormat))(IN_BSTR aDefaultHardDiskFormat) RT_OVERRIDE;
    STDMETHOD(COMGETTER(FreeDiskSpaceWarning))(LONG64 *aFreeDiskSpaceWarning) RT_OVERRIDE;
    STDMETHOD(COMSETTER(FreeDiskSpaceWarning))(LONG64 aFreeDiskSpaceWarning) RT_OVERRIDE;
    STDMETHOD(COMGETTER(FreeDiskSpacePercentWarning))(ULONG *aFreeDiskSpacePercentWarning) RT_OVERRIDE;
    STDMETHOD(COMSETTER(FreeDiskSpacePercentWarning))(ULONG aFreeDiskSpacePercentWarning) RT_OVERRIDE;
    STDMETHOD(COMGETTER(FreeDiskSpaceError))(LONG64 *aFreeDiskSpaceError) RT_OVERRIDE;
    STDMETHOD(COMSETTER(FreeDiskSpaceError))(LONG64 aFreeDiskSpaceError) RT_OVERRIDE;
    STDMETHOD(COMGETTER(FreeDiskSpacePercentError))(ULONG *aFreeDiskSpacePercentError) RT_OVERRIDE;
    STDMETHOD(COMSETTER(FreeDiskSpacePercentError))(ULONG aFreeDiskSpacePercentError) RT_OVERRIDE;
    STDMETHOD(COMGETTER(VRDEAuthLibrary))(BSTR *aVRDEAuthLibrary) RT_OVERRIDE;
    STDMETHOD(COMSETTER(VRDEAuthLibrary))(IN_BSTR aVRDEAuthLibrary) RT_OVERRIDE;
    STDMETHOD(COMGETTER(WebServiceAuthLibrary))(BSTR *aWebServiceAuthLibrary) RT_OVERRIDE;
    STDMETHOD(COMSETTER(WebServiceAuthLibrary))(IN_BSTR aWebServiceAuthLibrary) RT_OVERRIDE;
    STDMETHOD(COMGETTER(DefaultVRDEExtPack))(BSTR *aDefaultVRDEExtPack) RT_OVERRIDE;
    STDMETHOD(COMSETTER(DefaultVRDEExtPack))(IN_BSTR aDefaultVRDEExtPack) RT_OVERRIDE;
    STDMETHOD(COMGETTER(DefaultCryptoExtPack))(BSTR *aDefaultCryptoExtPack) RT_OVERRIDE;
    STDMETHOD(COMSETTER(DefaultCryptoExtPack))(IN_BSTR aDefaultCryptoExtPack) RT_OVERRIDE;
    STDMETHOD(COMGETTER(LogHistoryCount))(ULONG *aLogHistoryCount) RT_OVERRIDE;
    STDMETHOD(COMSETTER(LogHistoryCount))(ULONG aLogHistoryCount) RT_OVERRIDE;
    STDMETHOD(COMGETTER(DefaultAudioDriver))(AudioDriverType_T *aDefaultAudioDriver) RT_OVERRIDE;
    STDMETHOD(COMGETTER(AutostartDatabasePath))(BSTR *aAutostartDatabasePath) RT_OVERRIDE;
    STDMETHOD(COMSETTER(AutostartDatabasePath))(IN_BSTR aAutostartDatabasePath) RT_OVERRIDE;
    STDMETHOD(COMGETTER(DefaultAdditionsISO))(BSTR *aDefaultAdditionsISO) RT_OVERRIDE;
    STDMETHOD(COMSETTER(DefaultAdditionsISO))(IN_BSTR aDefaultAdditionsISO) RT_OVERRIDE;
    STDMETHOD(COMGETTER(DefaultFrontend))(BSTR *aDefaultFrontend) RT_OVERRIDE;
    STDMETHOD(COMSETTER(DefaultFrontend))(IN_BSTR aDefaultFrontend) RT_OVERRIDE;
    STDMETHOD(COMGETTER(ScreenShotFormats))(ComSafeArrayOut(BitmapFormat_T, aScreenShotFormats)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(ProxyMode))(ProxyMode_T *aProxyMode) RT_OVERRIDE;
    STDMETHOD(COMSETTER(ProxyMode))(ProxyMode_T aProxyMode) RT_OVERRIDE;
    STDMETHOD(COMGETTER(ProxyURL))(BSTR *aProxyURL) RT_OVERRIDE;
    STDMETHOD(COMSETTER(ProxyURL))(IN_BSTR aProxyURL) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportedPlatformArchitectures))(ComSafeArrayOut(PlatformArchitecture_T, aSupportedPlatformArchitectures)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportedClipboardModes))(ComSafeArrayOut(ClipboardMode_T, aSupportedClipboardModes)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportedDnDModes))(ComSafeArrayOut(DnDMode_T, aSupportedDnDModes)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportedPointingHIDTypes))(ComSafeArrayOut(PointingHIDType_T, aSupportedPointingHIDTypes)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportedKeyboardHIDTypes))(ComSafeArrayOut(KeyboardHIDType_T, aSupportedKeyboardHIDTypes)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportedVFSTypes))(ComSafeArrayOut(VFSType_T, aSupportedVFSTypes)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportedImportOptions))(ComSafeArrayOut(ImportOptions_T, aSupportedImportOptions)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportedExportOptions))(ComSafeArrayOut(ExportOptions_T, aSupportedExportOptions)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportedGraphicsFeatures))(ComSafeArrayOut(GraphicsFeature_T, aSupportedGraphicsFeatures)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportedRecordingFeatures))(ComSafeArrayOut(RecordingFeature_T, aSupportedRecordingFeatures)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportedRecordingAudioCodecs))(ComSafeArrayOut(RecordingAudioCodec_T, aSupportedRecordingAudioCodecs)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportedRecordingVideoCodecs))(ComSafeArrayOut(RecordingVideoCodec_T, aSupportedRecordingVideoCodecs)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportedRecordingVSModes))(ComSafeArrayOut(RecordingVideoScalingMode_T, aSupportedRecordingVSModes)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportedRecordingARCModes))(ComSafeArrayOut(RecordingRateControlMode_T, aSupportedRecordingARCModes)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportedRecordingVRCModes))(ComSafeArrayOut(RecordingRateControlMode_T, aSupportedRecordingVRCModes)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportedCloneOptions))(ComSafeArrayOut(CloneOptions_T, aSupportedCloneOptions)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportedAutostopTypes))(ComSafeArrayOut(AutostopType_T, aSupportedAutostopTypes)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportedVMProcPriorities))(ComSafeArrayOut(VMProcPriority_T, aSupportedVMProcPriorities)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportedNetworkAttachmentTypes))(ComSafeArrayOut(NetworkAttachmentType_T, aSupportedNetworkAttachmentTypes)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportedPortModes))(ComSafeArrayOut(PortMode_T, aSupportedPortModes)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportedAudioDriverTypes))(ComSafeArrayOut(AudioDriverType_T, aSupportedAudioDriverTypes)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(LanguageId))(BSTR *aLanguageId) RT_OVERRIDE;
    STDMETHOD(COMSETTER(LanguageId))(IN_BSTR aLanguageId) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1ISystemProperties))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2ISystemProperties))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3ISystemProperties))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4ISystemProperties))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5ISystemProperties))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6ISystemProperties))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7ISystemProperties))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8ISystemProperties))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute9ISystemProperties))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute10ISystemProperties))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute11ISystemProperties))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute12ISystemProperties))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute13ISystemProperties))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute14ISystemProperties))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute15ISystemProperties))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute16ISystemProperties))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public ISystemProperties methods
     * @{ */
    STDMETHOD(GetDefaultIoCacheSettingForStorageController)(StorageControllerType_T aControllerType,
                                                            BOOL *aEnabled) RT_OVERRIDE;
    STDMETHOD(GetCPUProfiles)(CPUArchitecture_T aArchitecture,
                              IN_BSTR aNamePattern,
                              ComSafeArrayOut(ICPUProfile *, aProfiles)) RT_OVERRIDE;
    STDMETHOD(GetExecutionEnginesForVmCpuArchitecture)(CPUArchitecture_T aCpuArchitecture,
                                                       ComSafeArrayOut(VMExecutionEngine_T, aExecutionEngine)) RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1ISystemProperties)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2ISystemProperties)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3ISystemProperties)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4ISystemProperties)() RT_OVERRIDE;
    /** @} */

private:
    /** @name Wrapped ISystemProperties properties
     * @{ */
    virtual HRESULT getPlatform(ComPtr<IPlatformProperties> &aPlatform) = 0;
    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 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 getDefaultCryptoExtPack(com::Utf8Str &aDefaultCryptoExtPack) = 0;
    virtual HRESULT setDefaultCryptoExtPack(const com::Utf8Str &aDefaultCryptoExtPack) = 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 getSupportedPlatformArchitectures(std::vector<PlatformArchitecture_T> &aSupportedPlatformArchitectures) = 0;
    virtual HRESULT getSupportedClipboardModes(std::vector<ClipboardMode_T> &aSupportedClipboardModes) = 0;
    virtual HRESULT getSupportedDnDModes(std::vector<DnDMode_T> &aSupportedDnDModes) = 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 getSupportedGraphicsFeatures(std::vector<GraphicsFeature_T> &aSupportedGraphicsFeatures) = 0;
    virtual HRESULT getSupportedRecordingFeatures(std::vector<RecordingFeature_T> &aSupportedRecordingFeatures) = 0;
    virtual HRESULT getSupportedRecordingAudioCodecs(std::vector<RecordingAudioCodec_T> &aSupportedRecordingAudioCodecs) = 0;
    virtual HRESULT getSupportedRecordingVideoCodecs(std::vector<RecordingVideoCodec_T> &aSupportedRecordingVideoCodecs) = 0;
    virtual HRESULT getSupportedRecordingVSModes(std::vector<RecordingVideoScalingMode_T> &aSupportedRecordingVSModes) = 0;
    virtual HRESULT getSupportedRecordingARCModes(std::vector<RecordingRateControlMode_T> &aSupportedRecordingARCModes) = 0;
    virtual HRESULT getSupportedRecordingVRCModes(std::vector<RecordingRateControlMode_T> &aSupportedRecordingVRCModes) = 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 getSupportedPortModes(std::vector<PortMode_T> &aSupportedPortModes) = 0;
    virtual HRESULT getSupportedAudioDriverTypes(std::vector<AudioDriverType_T> &aSupportedAudioDriverTypes) = 0;
    virtual HRESULT getLanguageId(com::Utf8Str &aLanguageId) = 0;
    virtual HRESULT setLanguageId(const com::Utf8Str &aLanguageId) = 0;
    /** @} */

    /** @name Wrapped ISystemProperties methods
     * @{ */
    virtual HRESULT getDefaultIoCacheSettingForStorageController(StorageControllerType_T aControllerType,
                                                                 BOOL *aEnabled) = 0;
    virtual HRESULT getCPUProfiles(CPUArchitecture_T aArchitecture,
                                   const com::Utf8Str &aNamePattern,
                                   std::vector<ComPtr<ICPUProfile> > &aProfiles) = 0;
    virtual HRESULT getExecutionEnginesForVmCpuArchitecture(CPUArchitecture_T aCpuArchitecture,
                                                            std::vector<VMExecutionEngine_T> &aExecutionEngine) = 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(GuestOSTypeWrap)

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

    /** @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 getSubtype(com::Utf8Str &aSubtype) = 0;
    virtual HRESULT getDescription(com::Utf8Str &aDescription) = 0;
    virtual HRESULT getIs64Bit(BOOL *aIs64Bit) = 0;
    virtual HRESULT getPlatformArchitecture(PlatformArchitecture_T *aPlatformArchitecture) = 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 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 getRecommendedIommuType(IommuType_T *aRecommendedIommuType) = 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;
    virtual HRESULT getRecommendedTpmType(TpmType_T *aRecommendedTpmType) = 0;
    virtual HRESULT getRecommendedSecureBoot(BOOL *aRecommendedSecureBoot) = 0;
    virtual HRESULT getRecommendedWDDMGraphics(BOOL *aRecommendedWDDMGraphics) = 0;
    virtual HRESULT getGuestAdditionsInstallPackageName(com::Utf8Str &aGuestAdditionsInstallPackageName) = 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(AdditionsFacilityWrap)

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

    /** @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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(DnDBaseWrap)

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

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

private:
    /** @name Wrapped IDnDBase properties
     * @{ */
    virtual HRESULT getFormats(std::vector<com::Utf8Str> &aFormats) = 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(DnDSourceWrap)

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

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

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

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

private:
    /** @name Wrapped IDnDBase properties
     * @{ */
    virtual HRESULT getFormats(std::vector<com::Utf8Str> &aFormats) = 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(GuestDnDSourceWrap)

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

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

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

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

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

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

private:
    /** @name Wrapped IDnDBase properties
     * @{ */
    virtual HRESULT getFormats(std::vector<com::Utf8Str> &aFormats) = 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(DnDTargetWrap)

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

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

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

    /** @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) RT_OVERRIDE;
    STDMETHOD(Move)(ULONG aScreenId,
                    ULONG aX,
                    ULONG aY,
                    DnDAction_T aDefaultAction,
                    ComSafeArrayIn(DnDAction_T, aAllowedActions),
                    ComSafeArrayIn(IN_BSTR, aFormats),
                    DnDAction_T *aResultAction) RT_OVERRIDE;
    STDMETHOD(Leave)(ULONG aScreenId) RT_OVERRIDE;
    STDMETHOD(Drop)(ULONG aScreenId,
                    ULONG aX,
                    ULONG aY,
                    DnDAction_T aDefaultAction,
                    ComSafeArrayIn(DnDAction_T, aAllowedActions),
                    ComSafeArrayIn(IN_BSTR, aFormats),
                    BSTR *aFormat,
                    DnDAction_T *aResultAction) RT_OVERRIDE;
    STDMETHOD(SendData)(ULONG aScreenId,
                        IN_BSTR aFormat,
                        ComSafeArrayIn(BYTE, aData),
                        IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(Cancel)(BOOL *aVeto) RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1IDnDTarget)() RT_OVERRIDE;
    /** @} */

private:
    /** @name Wrapped IDnDBase properties
     * @{ */
    virtual HRESULT getFormats(std::vector<com::Utf8Str> &aFormats) = 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(GuestDnDTargetWrap)

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

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

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

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

    /** @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) RT_OVERRIDE;
    STDMETHOD(Move)(ULONG aScreenId,
                    ULONG aX,
                    ULONG aY,
                    DnDAction_T aDefaultAction,
                    ComSafeArrayIn(DnDAction_T, aAllowedActions),
                    ComSafeArrayIn(IN_BSTR, aFormats),
                    DnDAction_T *aResultAction) RT_OVERRIDE;
    STDMETHOD(Leave)(ULONG aScreenId) RT_OVERRIDE;
    STDMETHOD(Drop)(ULONG aScreenId,
                    ULONG aX,
                    ULONG aY,
                    DnDAction_T aDefaultAction,
                    ComSafeArrayIn(DnDAction_T, aAllowedActions),
                    ComSafeArrayIn(IN_BSTR, aFormats),
                    BSTR *aFormat,
                    DnDAction_T *aResultAction) RT_OVERRIDE;
    STDMETHOD(SendData)(ULONG aScreenId,
                        IN_BSTR aFormat,
                        ComSafeArrayIn(BYTE, aData),
                        IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(Cancel)(BOOL *aVeto) RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1IDnDTarget)() RT_OVERRIDE;
    /** @} */

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

private:
    /** @name Wrapped IDnDBase properties
     * @{ */
    virtual HRESULT getFormats(std::vector<com::Utf8Str> &aFormats) = 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(GuestSessionWrap)

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

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

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 getMountPoints(std::vector<com::Utf8Str> &aMountPoints) = 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 fsQueryFreeSpace(const com::Utf8Str &aPath,
                                     LONG64 *aFreeSpace) = 0;
    virtual HRESULT fsQueryInfo(const com::Utf8Str &aPath,
                                ComPtr<IGuestFsInfo> &aInfo) = 0;
    virtual HRESULT processCreate(const com::Utf8Str &aExecutable,
                                  const std::vector<com::Utf8Str> &aArguments,
                                  const com::Utf8Str &aCwd,
                                  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 com::Utf8Str &aCwd,
                                    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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(ProcessWrap)

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

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

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(GuestProcessWrap)

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

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

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

    /** @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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(DirectoryWrap)

    /** @name Public IDirectory properties
     * @{ */
    STDMETHOD(COMGETTER(DirectoryName))(BSTR *aDirectoryName) RT_OVERRIDE;
    STDMETHOD(COMGETTER(EventSource))(IEventSource **aEventSource) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Filter))(BSTR *aFilter) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Id))(ULONG *aId) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Status))(DirectoryStatus_T *aStatus) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IDirectory))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IDirectory))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IDirectory))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IDirectory))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IDirectory))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IDirectory))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IDirectory))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IDirectory))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IDirectory methods
     * @{ */
    STDMETHOD(Close)() RT_OVERRIDE;
    STDMETHOD(List)(ULONG aMaxEntries,
                    ComSafeArrayOut(IFsObjInfo *, aObjInfo)) RT_OVERRIDE;
    STDMETHOD(Read)(IFsObjInfo **aObjInfo) RT_OVERRIDE;
    STDMETHOD(Rewind)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1IDirectory)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IDirectory)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3IDirectory)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4IDirectory)() RT_OVERRIDE;
    /** @} */

private:
    /** @name Wrapped IDirectory properties
     * @{ */
    virtual HRESULT getDirectoryName(com::Utf8Str &aDirectoryName) = 0;
    virtual HRESULT getEventSource(ComPtr<IEventSource> &aEventSource) = 0;
    virtual HRESULT getFilter(com::Utf8Str &aFilter) = 0;
    virtual HRESULT getId(ULONG *aId) = 0;
    virtual HRESULT getStatus(DirectoryStatus_T *aStatus) = 0;
    /** @} */

    /** @name Wrapped IDirectory methods
     * @{ */
    virtual HRESULT close() = 0;
    virtual HRESULT list(ULONG aMaxEntries,
                         std::vector<ComPtr<IFsObjInfo> > &aObjInfo) = 0;
    virtual HRESULT read(ComPtr<IFsObjInfo> &aObjInfo) = 0;
    virtual HRESULT rewind() = 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(GuestDirectoryWrap)

    /** @name Public IDirectory properties
     * @{ */
    STDMETHOD(COMGETTER(DirectoryName))(BSTR *aDirectoryName) RT_OVERRIDE;
    STDMETHOD(COMGETTER(EventSource))(IEventSource **aEventSource) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Filter))(BSTR *aFilter) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Id))(ULONG *aId) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Status))(DirectoryStatus_T *aStatus) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IDirectory))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IDirectory))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IDirectory))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IDirectory))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IDirectory))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IDirectory))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IDirectory))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IDirectory))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

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

    /** @name Public IDirectory methods
     * @{ */
    STDMETHOD(Close)() RT_OVERRIDE;
    STDMETHOD(List)(ULONG aMaxEntries,
                    ComSafeArrayOut(IFsObjInfo *, aObjInfo)) RT_OVERRIDE;
    STDMETHOD(Read)(IFsObjInfo **aObjInfo) RT_OVERRIDE;
    STDMETHOD(Rewind)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1IDirectory)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IDirectory)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3IDirectory)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4IDirectory)() RT_OVERRIDE;
    /** @} */

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

private:
    /** @name Wrapped IDirectory properties
     * @{ */
    virtual HRESULT getDirectoryName(com::Utf8Str &aDirectoryName) = 0;
    virtual HRESULT getEventSource(ComPtr<IEventSource> &aEventSource) = 0;
    virtual HRESULT getFilter(com::Utf8Str &aFilter) = 0;
    virtual HRESULT getId(ULONG *aId) = 0;
    virtual HRESULT getStatus(DirectoryStatus_T *aStatus) = 0;
    /** @} */

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

    /** @name Wrapped IDirectory methods
     * @{ */
    virtual HRESULT close() = 0;
    virtual HRESULT list(ULONG aMaxEntries,
                         std::vector<ComPtr<IFsObjInfo> > &aObjInfo) = 0;
    virtual HRESULT read(ComPtr<IFsObjInfo> &aObjInfo) = 0;
    virtual HRESULT rewind() = 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(FileWrap)

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

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

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(GuestFileWrap)

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

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

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

    /** @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 "FsInfoWrap.h"
/** @file
 * VirtualBox API class wrapper header for IFsInfo.
 *
 * 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#ifndef FsInfoWrap_H_
#define FsInfoWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

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

class ATL_NO_VTABLE FsInfoWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IFsInfo)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(FsInfoWrap, IFsInfo)
    DECLARE_NOT_AGGREGATABLE(FsInfoWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(FsInfoWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IFsInfo)
        COM_INTERFACE_ENTRY2(IDispatch, IFsInfo)
        VBOX_TWEAK_INTERFACE_ENTRY(IFsInfo)
    END_COM_MAP()

    DECLARE_COMMON_CLASS_METHODS(FsInfoWrap)

    /** @name Public IFsInfo properties
     * @{ */
    STDMETHOD(COMGETTER(FreeSize))(LONG64 *aFreeSize) RT_OVERRIDE;
    STDMETHOD(COMGETTER(TotalSize))(LONG64 *aTotalSize) RT_OVERRIDE;
    STDMETHOD(COMGETTER(BlockSize))(ULONG *aBlockSize) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SectorSize))(ULONG *aSectorSize) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SerialNumber))(ULONG *aSerialNumber) RT_OVERRIDE;
    STDMETHOD(COMGETTER(IsRemote))(BOOL *aIsRemote) RT_OVERRIDE;
    STDMETHOD(COMGETTER(IsCaseSensitive))(BOOL *aIsCaseSensitive) RT_OVERRIDE;
    STDMETHOD(COMGETTER(IsReadOnly))(BOOL *aIsReadOnly) RT_OVERRIDE;
    STDMETHOD(COMGETTER(IsCompressed))(BOOL *aIsCompressed) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportsFileCompression))(BOOL *aSupportsFileCompression) RT_OVERRIDE;
    STDMETHOD(COMGETTER(MaxComponent))(ULONG *aMaxComponent) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Type))(BSTR *aType) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Label))(BSTR *aLabel) RT_OVERRIDE;
    STDMETHOD(COMGETTER(MountPoint))(BSTR *aMountPoint) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IFsInfo))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IFsInfo))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IFsInfo))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IFsInfo))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IFsInfo))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IFsInfo))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IFsInfo))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IFsInfo))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

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

private:
    /** @name Wrapped IFsInfo properties
     * @{ */
    virtual HRESULT getFreeSize(LONG64 *aFreeSize) = 0;
    virtual HRESULT getTotalSize(LONG64 *aTotalSize) = 0;
    virtual HRESULT getBlockSize(ULONG *aBlockSize) = 0;
    virtual HRESULT getSectorSize(ULONG *aSectorSize) = 0;
    virtual HRESULT getSerialNumber(ULONG *aSerialNumber) = 0;
    virtual HRESULT getIsRemote(BOOL *aIsRemote) = 0;
    virtual HRESULT getIsCaseSensitive(BOOL *aIsCaseSensitive) = 0;
    virtual HRESULT getIsReadOnly(BOOL *aIsReadOnly) = 0;
    virtual HRESULT getIsCompressed(BOOL *aIsCompressed) = 0;
    virtual HRESULT getSupportsFileCompression(BOOL *aSupportsFileCompression) = 0;
    virtual HRESULT getMaxComponent(ULONG *aMaxComponent) = 0;
    virtual HRESULT getType(com::Utf8Str &aType) = 0;
    virtual HRESULT getLabel(com::Utf8Str &aLabel) = 0;
    virtual HRESULT getMountPoint(com::Utf8Str &aMountPoint) = 0;
    /** @} */

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

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

};

#endif // !FsInfoWrap_H_

// ##### ENDFILE "FsInfoWrap.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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(FsObjInfoWrap)

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

    /** @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 "GuestFsInfoWrap.h"
/** @file
 * VirtualBox API class wrapper header for IGuestFsInfo.
 *
 * 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#ifndef GuestFsInfoWrap_H_
#define GuestFsInfoWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

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

class ATL_NO_VTABLE GuestFsInfoWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IGuestFsInfo)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(GuestFsInfoWrap, IGuestFsInfo)
    DECLARE_NOT_AGGREGATABLE(GuestFsInfoWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(GuestFsInfoWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IGuestFsInfo)
        COM_INTERFACE_ENTRY(IFsInfo)
        COM_INTERFACE_ENTRY2(IDispatch, IGuestFsInfo)
        VBOX_TWEAK_INTERFACE_ENTRY(IGuestFsInfo)
    END_COM_MAP()

    DECLARE_COMMON_CLASS_METHODS(GuestFsInfoWrap)

    /** @name Public IFsInfo properties
     * @{ */
    STDMETHOD(COMGETTER(FreeSize))(LONG64 *aFreeSize) RT_OVERRIDE;
    STDMETHOD(COMGETTER(TotalSize))(LONG64 *aTotalSize) RT_OVERRIDE;
    STDMETHOD(COMGETTER(BlockSize))(ULONG *aBlockSize) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SectorSize))(ULONG *aSectorSize) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SerialNumber))(ULONG *aSerialNumber) RT_OVERRIDE;
    STDMETHOD(COMGETTER(IsRemote))(BOOL *aIsRemote) RT_OVERRIDE;
    STDMETHOD(COMGETTER(IsCaseSensitive))(BOOL *aIsCaseSensitive) RT_OVERRIDE;
    STDMETHOD(COMGETTER(IsReadOnly))(BOOL *aIsReadOnly) RT_OVERRIDE;
    STDMETHOD(COMGETTER(IsCompressed))(BOOL *aIsCompressed) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportsFileCompression))(BOOL *aSupportsFileCompression) RT_OVERRIDE;
    STDMETHOD(COMGETTER(MaxComponent))(ULONG *aMaxComponent) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Type))(BSTR *aType) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Label))(BSTR *aLabel) RT_OVERRIDE;
    STDMETHOD(COMGETTER(MountPoint))(BSTR *aMountPoint) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IFsInfo))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IFsInfo))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IFsInfo))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IFsInfo))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IFsInfo))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IFsInfo))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IFsInfo))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IFsInfo))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

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

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

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

private:
    /** @name Wrapped IFsInfo properties
     * @{ */
    virtual HRESULT getFreeSize(LONG64 *aFreeSize) = 0;
    virtual HRESULT getTotalSize(LONG64 *aTotalSize) = 0;
    virtual HRESULT getBlockSize(ULONG *aBlockSize) = 0;
    virtual HRESULT getSectorSize(ULONG *aSectorSize) = 0;
    virtual HRESULT getSerialNumber(ULONG *aSerialNumber) = 0;
    virtual HRESULT getIsRemote(BOOL *aIsRemote) = 0;
    virtual HRESULT getIsCaseSensitive(BOOL *aIsCaseSensitive) = 0;
    virtual HRESULT getIsReadOnly(BOOL *aIsReadOnly) = 0;
    virtual HRESULT getIsCompressed(BOOL *aIsCompressed) = 0;
    virtual HRESULT getSupportsFileCompression(BOOL *aSupportsFileCompression) = 0;
    virtual HRESULT getMaxComponent(ULONG *aMaxComponent) = 0;
    virtual HRESULT getType(com::Utf8Str &aType) = 0;
    virtual HRESULT getLabel(com::Utf8Str &aLabel) = 0;
    virtual HRESULT getMountPoint(com::Utf8Str &aMountPoint) = 0;
    /** @} */

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

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

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

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

};

#endif // !GuestFsInfoWrap_H_

// ##### ENDFILE "GuestFsInfoWrap.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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(GuestFsObjInfoWrap)

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

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

    /** @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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(GuestWrap)

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

    /** @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) RT_OVERRIDE;
    STDMETHOD(GetFacilityStatus)(AdditionsFacilityType_T aFacility,
                                 LONG64 *aTimestamp,
                                 AdditionsFacilityStatus_T *aStatus) RT_OVERRIDE;
    STDMETHOD(GetAdditionsStatus)(AdditionsRunLevelType_T aLevel,
                                  BOOL *aActive) RT_OVERRIDE;
    STDMETHOD(SetCredentials)(IN_BSTR aUserName,
                              IN_BSTR aPassword,
                              IN_BSTR aDomain,
                              BOOL aAllowInteractiveLogon) RT_OVERRIDE;
    STDMETHOD(CreateSession)(IN_BSTR aUser,
                             IN_BSTR aPassword,
                             IN_BSTR aDomain,
                             IN_BSTR aSessionName,
                             IGuestSession **aGuestSession) RT_OVERRIDE;
    STDMETHOD(FindSession)(IN_BSTR aSessionName,
                           ComSafeArrayOut(IGuestSession *, aSessions)) RT_OVERRIDE;
    STDMETHOD(Shutdown)(ComSafeArrayIn(GuestShutdownFlag_T, aFlags)) RT_OVERRIDE;
    STDMETHOD(UpdateGuestAdditions)(IN_BSTR aSource,
                                    ComSafeArrayIn(IN_BSTR, aArguments),
                                    ComSafeArrayIn(AdditionsUpdateFlag_T, aFlags),
                                    IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1IGuest)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IGuest)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3IGuest)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4IGuest)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod5IGuest)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod6IGuest)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod7IGuest)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod8IGuest)() RT_OVERRIDE;
    /** @} */

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 shutdown(const std::vector<GuestShutdownFlag_T> &aFlags) = 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(ProgressWrap)

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

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

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

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

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(SnapshotWrap)

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

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

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(MediumAttachmentWrap)

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

    /** @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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(MediumWrap)

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

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

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;
    virtual HRESULT resizeAndCloneTo(const ComPtr<IMedium> &aTarget,
                                     LONG64 aLogicalSize,
                                     const std::vector<MediumVariant_T> &aVariant,
                                     const ComPtr<IMedium> &aParent,
                                     ComPtr<IProgress> &aProgress) = 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(MediumFormatWrap)

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

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

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(DataStreamWrap)

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

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

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(MediumIOWrap)

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

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

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(TokenWrap)

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

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

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(KeyboardWrap)

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

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

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(MousePointerShapeWrap)

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

    /** @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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(MouseWrap)

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

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

private:
    /** @name Wrapped IMouse properties
     * @{ */
    virtual HRESULT getAbsoluteSupported(BOOL *aAbsoluteSupported) = 0;
    virtual HRESULT getRelativeSupported(BOOL *aRelativeSupported) = 0;
    virtual HRESULT getTouchScreenSupported(BOOL *aTouchScreenSupported) = 0;
    virtual HRESULT getTouchPadSupported(BOOL *aTouchPadSupported) = 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,
                                       BOOL aIsTouchScreen,
                                       ULONG aScanTime) = 0;
    virtual HRESULT putEventMultiTouchString(LONG aCount,
                                             const com::Utf8Str &aContacts,
                                             BOOL aIsTouchScreen,
                                             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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(DisplaySourceBitmapWrap)

    /** @name Public IDisplaySourceBitmap properties
     * @{ */
    STDMETHOD(COMGETTER(ScreenId))(ULONG *aScreenId) RT_OVERRIDE;
    /** @} */

    /** @name Public IDisplaySourceBitmap methods
     * @{ */
    STDMETHOD(QueryBitmapInfo)(BYTE **aAddress,
                               ULONG *aWidth,
                               ULONG *aHeight,
                               ULONG *aBitsPerPixel,
                               ULONG *aBytesPerLine,
                               BitmapFormat_T *aBitmapFormat) RT_OVERRIDE;
    /** @} */

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(FramebufferWrap)

    /** @name Public IFramebuffer properties
     * @{ */
    STDMETHOD(COMGETTER(Width))(ULONG *aWidth) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Height))(ULONG *aHeight) RT_OVERRIDE;
    STDMETHOD(COMGETTER(BitsPerPixel))(ULONG *aBitsPerPixel) RT_OVERRIDE;
    STDMETHOD(COMGETTER(BytesPerLine))(ULONG *aBytesPerLine) RT_OVERRIDE;
    STDMETHOD(COMGETTER(PixelFormat))(BitmapFormat_T *aPixelFormat) RT_OVERRIDE;
    STDMETHOD(COMGETTER(HeightReduction))(ULONG *aHeightReduction) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Overlay))(IFramebufferOverlay **aOverlay) RT_OVERRIDE;
    STDMETHOD(COMGETTER(WinId))(LONG64 *aWinId) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Capabilities))(ComSafeArrayOut(FramebufferCapabilities_T, aCapabilities)) RT_OVERRIDE;
    /** @} */

    /** @name Public IFramebuffer methods
     * @{ */
    STDMETHOD(NotifyUpdate)(ULONG aX,
                            ULONG aY,
                            ULONG aWidth,
                            ULONG aHeight) RT_OVERRIDE;
    STDMETHOD(NotifyUpdateImage)(ULONG aX,
                                 ULONG aY,
                                 ULONG aWidth,
                                 ULONG aHeight,
                                 ComSafeArrayIn(BYTE, aImage)) RT_OVERRIDE;
    STDMETHOD(NotifyChange)(ULONG aScreenId,
                            ULONG aXOrigin,
                            ULONG aYOrigin,
                            ULONG aWidth,
                            ULONG aHeight) RT_OVERRIDE;
    STDMETHOD(VideoModeSupported)(ULONG aWidth,
                                  ULONG aHeight,
                                  ULONG aBpp,
                                  BOOL *aSupported) RT_OVERRIDE;
    STDMETHOD(GetVisibleRegion)(BYTE *aRectangles,
                                ULONG aCount,
                                ULONG *aCountCopied) RT_OVERRIDE;
    STDMETHOD(SetVisibleRegion)(BYTE *aRectangles,
                                ULONG aCount) RT_OVERRIDE;
    STDMETHOD(ProcessVHWACommand)(BYTE *aCommand,
                                  LONG aEnmCmd,
                                  BOOL aFromGuest) RT_OVERRIDE;
    STDMETHOD(Notify3DEvent)(ULONG aType,
                             ComSafeArrayIn(BYTE, aData)) RT_OVERRIDE;
    /** @} */

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(FramebufferOverlayWrap)

    /** @name Public IFramebuffer properties
     * @{ */
    STDMETHOD(COMGETTER(Width))(ULONG *aWidth) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Height))(ULONG *aHeight) RT_OVERRIDE;
    STDMETHOD(COMGETTER(BitsPerPixel))(ULONG *aBitsPerPixel) RT_OVERRIDE;
    STDMETHOD(COMGETTER(BytesPerLine))(ULONG *aBytesPerLine) RT_OVERRIDE;
    STDMETHOD(COMGETTER(PixelFormat))(BitmapFormat_T *aPixelFormat) RT_OVERRIDE;
    STDMETHOD(COMGETTER(HeightReduction))(ULONG *aHeightReduction) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Overlay))(IFramebufferOverlay **aOverlay) RT_OVERRIDE;
    STDMETHOD(COMGETTER(WinId))(LONG64 *aWinId) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Capabilities))(ComSafeArrayOut(FramebufferCapabilities_T, aCapabilities)) RT_OVERRIDE;
    /** @} */

    /** @name Public IFramebufferOverlay properties
     * @{ */
    STDMETHOD(COMGETTER(X))(ULONG *aX) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Y))(ULONG *aY) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Visible))(BOOL *aVisible) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Visible))(BOOL aVisible) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Alpha))(ULONG *aAlpha) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Alpha))(ULONG aAlpha) RT_OVERRIDE;
    /** @} */

    /** @name Public IFramebuffer methods
     * @{ */
    STDMETHOD(NotifyUpdate)(ULONG aX,
                            ULONG aY,
                            ULONG aWidth,
                            ULONG aHeight) RT_OVERRIDE;
    STDMETHOD(NotifyUpdateImage)(ULONG aX,
                                 ULONG aY,
                                 ULONG aWidth,
                                 ULONG aHeight,
                                 ComSafeArrayIn(BYTE, aImage)) RT_OVERRIDE;
    STDMETHOD(NotifyChange)(ULONG aScreenId,
                            ULONG aXOrigin,
                            ULONG aYOrigin,
                            ULONG aWidth,
                            ULONG aHeight) RT_OVERRIDE;
    STDMETHOD(VideoModeSupported)(ULONG aWidth,
                                  ULONG aHeight,
                                  ULONG aBpp,
                                  BOOL *aSupported) RT_OVERRIDE;
    STDMETHOD(GetVisibleRegion)(BYTE *aRectangles,
                                ULONG aCount,
                                ULONG *aCountCopied) RT_OVERRIDE;
    STDMETHOD(SetVisibleRegion)(BYTE *aRectangles,
                                ULONG aCount) RT_OVERRIDE;
    STDMETHOD(ProcessVHWACommand)(BYTE *aCommand,
                                  LONG aEnmCmd,
                                  BOOL aFromGuest) RT_OVERRIDE;
    STDMETHOD(Notify3DEvent)(ULONG aType,
                             ComSafeArrayIn(BYTE, aData)) RT_OVERRIDE;
    /** @} */

    /** @name Public IFramebufferOverlay methods
     * @{ */
    STDMETHOD(Move)(ULONG aX,
                    ULONG aY) RT_OVERRIDE;
    /** @} */

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(GuestScreenInfoWrap)

    /** @name Public IGuestScreenInfo properties
     * @{ */
    STDMETHOD(COMGETTER(ScreenId))(ULONG *aScreenId) RT_OVERRIDE;
    STDMETHOD(COMGETTER(GuestMonitorStatus))(GuestMonitorStatus_T *aGuestMonitorStatus) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Primary))(BOOL *aPrimary) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Origin))(BOOL *aOrigin) RT_OVERRIDE;
    STDMETHOD(COMGETTER(OriginX))(LONG *aOriginX) RT_OVERRIDE;
    STDMETHOD(COMGETTER(OriginY))(LONG *aOriginY) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Width))(ULONG *aWidth) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Height))(ULONG *aHeight) RT_OVERRIDE;
    STDMETHOD(COMGETTER(BitsPerPixel))(ULONG *aBitsPerPixel) RT_OVERRIDE;
    STDMETHOD(COMGETTER(ExtendedInfo))(BSTR *aExtendedInfo) RT_OVERRIDE;
    /** @} */

    /** @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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(DisplayWrap)

    /** @name Public IDisplay properties
     * @{ */
    STDMETHOD(COMGETTER(GuestScreenLayout))(ComSafeArrayOut(IGuestScreenInfo *, aGuestScreenLayout)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IDisplay))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IDisplay))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IDisplay))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IDisplay))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IDisplay))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IDisplay))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IDisplay))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IDisplay))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute9IDisplay))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute10IDisplay))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute11IDisplay))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute12IDisplay))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute13IDisplay))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute14IDisplay))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute15IDisplay))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute16IDisplay))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IDisplay methods
     * @{ */
    STDMETHOD(GetScreenResolution)(ULONG aScreenId,
                                   ULONG *aWidth,
                                   ULONG *aHeight,
                                   ULONG *aBitsPerPixel,
                                   LONG *aXOrigin,
                                   LONG *aYOrigin,
                                   GuestMonitorStatus_T *aGuestMonitorStatus) RT_OVERRIDE;
    STDMETHOD(AttachFramebuffer)(ULONG aScreenId,
                                 IFramebuffer *aFramebuffer,
                                 BSTR *aId) RT_OVERRIDE;
    STDMETHOD(DetachFramebuffer)(ULONG aScreenId,
                                 IN_BSTR aId) RT_OVERRIDE;
    STDMETHOD(QueryFramebuffer)(ULONG aScreenId,
                                IFramebuffer **aFramebuffer) RT_OVERRIDE;
    STDMETHOD(SetVideoModeHint)(ULONG aDisplay,
                                BOOL aEnabled,
                                BOOL aChangeOrigin,
                                LONG aOriginX,
                                LONG aOriginY,
                                ULONG aWidth,
                                ULONG aHeight,
                                ULONG aBitsPerPixel,
                                BOOL aNotify) RT_OVERRIDE;
    STDMETHOD(GetVideoModeHint)(ULONG aDisplay,
                                BOOL *aEnabled,
                                BOOL *aChangeOrigin,
                                LONG *aOriginX,
                                LONG *aOriginY,
                                ULONG *aWidth,
                                ULONG *aHeight,
                                ULONG *aBitsPerPixel) RT_OVERRIDE;
    STDMETHOD(SetSeamlessMode)(BOOL aEnabled) RT_OVERRIDE;
    STDMETHOD(TakeScreenShot)(ULONG aScreenId,
                              BYTE *aAddress,
                              ULONG aWidth,
                              ULONG aHeight,
                              BitmapFormat_T aBitmapFormat) RT_OVERRIDE;
    STDMETHOD(TakeScreenShotToArray)(ULONG aScreenId,
                                     ULONG aWidth,
                                     ULONG aHeight,
                                     BitmapFormat_T aBitmapFormat,
                                     ComSafeArrayOut(BYTE, aScreenData)) RT_OVERRIDE;
    STDMETHOD(DrawToScreen)(ULONG aScreenId,
                            BYTE *aAddress,
                            ULONG aX,
                            ULONG aY,
                            ULONG aWidth,
                            ULONG aHeight) RT_OVERRIDE;
    STDMETHOD(InvalidateAndUpdate)() RT_OVERRIDE;
    STDMETHOD(InvalidateAndUpdateScreen)(ULONG aScreenId) RT_OVERRIDE;
    STDMETHOD(ViewportChanged)(ULONG aScreenId,
                               ULONG aX,
                               ULONG aY,
                               ULONG aWidth,
                               ULONG aHeight) RT_OVERRIDE;
    STDMETHOD(QuerySourceBitmap)(ULONG aScreenId,
                                 IDisplaySourceBitmap **aDisplaySourceBitmap) RT_OVERRIDE;
    STDMETHOD(NotifyScaleFactorChange)(ULONG aScreenId,
                                       ULONG aU32ScaleFactorWMultiplied,
                                       ULONG aU32ScaleFactorHMultiplied) RT_OVERRIDE;
    STDMETHOD(NotifyHiDPIOutputPolicyChange)(BOOL aFUnscaledHiDPI) RT_OVERRIDE;
    STDMETHOD(SetScreenLayout)(ScreenLayoutMode_T aScreenLayoutMode,
                               ComSafeArrayIn(IGuestScreenInfo *, aGuestScreenInfo)) RT_OVERRIDE;
    STDMETHOD(DetachScreens)(ComSafeArrayIn(LONG, aScreenIds)) RT_OVERRIDE;
    STDMETHOD(CreateGuestScreenInfo)(ULONG aDisplay,
                                     GuestMonitorStatus_T aStatus,
                                     BOOL aPrimary,
                                     BOOL aChangeOrigin,
                                     LONG aOriginX,
                                     LONG aOriginY,
                                     ULONG aWidth,
                                     ULONG aHeight,
                                     ULONG aBitsPerPixel,
                                     IGuestScreenInfo **aGuestScreenInfo) RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1IDisplay)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IDisplay)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3IDisplay)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4IDisplay)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod5IDisplay)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod6IDisplay)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod7IDisplay)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod8IDisplay)() RT_OVERRIDE;
    /** @} */

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

    /** @name Public IEventListener methods
     * @{ */
    STDMETHOD(HandleEvent)(IEvent *aEvent) RT_OVERRIDE;
    /** @} */

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 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(NetworkAdapterWrap)

    /** @name Public INetworkAdapter properties
     * @{ */
    STDMETHOD(COMGETTER(AdapterType))(NetworkAdapterType_T *aAdapterType) RT_OVERRIDE;
    STDMETHOD(COMSETTER(AdapterType))(NetworkAdapterType_T aAdapterType) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Slot))(ULONG *aSlot) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Enabled))(BOOL *aEnabled) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Enabled))(BOOL aEnabled) RT_OVERRIDE;
    STDMETHOD(COMGETTER(MACAddress))(BSTR *aMACAddress) RT_OVERRIDE;
    STDMETHOD(COMSETTER(MACAddress))(IN_BSTR aMACAddress) RT_OVERRIDE;
    STDMETHOD(COMGETTER(AttachmentType))(NetworkAttachmentType_T *aAttachmentType) RT_OVERRIDE;
    STDMETHOD(COMSETTER(AttachmentType))(NetworkAttachmentType_T aAttachmentType) RT_OVERRIDE;
    STDMETHOD(COMGETTER(BridgedInterface))(BSTR *aBridgedInterface) RT_OVERRIDE;
    STDMETHOD(COMSETTER(BridgedInterface))(IN_BSTR aBridgedInterface) RT_OVERRIDE;
    STDMETHOD(COMGETTER(HostOnlyInterface))(BSTR *aHostOnlyInterface) RT_OVERRIDE;
    STDMETHOD(COMSETTER(HostOnlyInterface))(IN_BSTR aHostOnlyInterface) RT_OVERRIDE;
    STDMETHOD(COMGETTER(HostOnlyNetwork))(BSTR *aHostOnlyNetwork) RT_OVERRIDE;
    STDMETHOD(COMSETTER(HostOnlyNetwork))(IN_BSTR aHostOnlyNetwork) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalNetwork))(BSTR *aInternalNetwork) RT_OVERRIDE;
    STDMETHOD(COMSETTER(InternalNetwork))(IN_BSTR aInternalNetwork) RT_OVERRIDE;
    STDMETHOD(COMGETTER(NATNetwork))(BSTR *aNATNetwork) RT_OVERRIDE;
    STDMETHOD(COMSETTER(NATNetwork))(IN_BSTR aNATNetwork) RT_OVERRIDE;
    STDMETHOD(COMGETTER(GenericDriver))(BSTR *aGenericDriver) RT_OVERRIDE;
    STDMETHOD(COMSETTER(GenericDriver))(IN_BSTR aGenericDriver) RT_OVERRIDE;
    STDMETHOD(COMGETTER(CloudNetwork))(BSTR *aCloudNetwork) RT_OVERRIDE;
    STDMETHOD(COMSETTER(CloudNetwork))(IN_BSTR aCloudNetwork) RT_OVERRIDE;
    STDMETHOD(COMGETTER(CableConnected))(BOOL *aCableConnected) RT_OVERRIDE;
    STDMETHOD(COMSETTER(CableConnected))(BOOL aCableConnected) RT_OVERRIDE;
    STDMETHOD(COMGETTER(LineSpeed))(ULONG *aLineSpeed) RT_OVERRIDE;
    STDMETHOD(COMSETTER(LineSpeed))(ULONG aLineSpeed) RT_OVERRIDE;
    STDMETHOD(COMGETTER(PromiscModePolicy))(NetworkAdapterPromiscModePolicy_T *aPromiscModePolicy) RT_OVERRIDE;
    STDMETHOD(COMSETTER(PromiscModePolicy))(NetworkAdapterPromiscModePolicy_T aPromiscModePolicy) RT_OVERRIDE;
    STDMETHOD(COMGETTER(TraceEnabled))(BOOL *aTraceEnabled) RT_OVERRIDE;
    STDMETHOD(COMSETTER(TraceEnabled))(BOOL aTraceEnabled) RT_OVERRIDE;
    STDMETHOD(COMGETTER(TraceFile))(BSTR *aTraceFile) RT_OVERRIDE;
    STDMETHOD(COMSETTER(TraceFile))(IN_BSTR aTraceFile) RT_OVERRIDE;
    STDMETHOD(COMGETTER(NATEngine))(INATEngine **aNATEngine) RT_OVERRIDE;
    STDMETHOD(COMGETTER(BootPriority))(ULONG *aBootPriority) RT_OVERRIDE;
    STDMETHOD(COMSETTER(BootPriority))(ULONG aBootPriority) RT_OVERRIDE;
    STDMETHOD(COMGETTER(BandwidthGroup))(IBandwidthGroup **aBandwidthGroup) RT_OVERRIDE;
    STDMETHOD(COMSETTER(BandwidthGroup))(IBandwidthGroup *aBandwidthGroup) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1INetworkAdapter))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2INetworkAdapter))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3INetworkAdapter))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4INetworkAdapter))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5INetworkAdapter))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6INetworkAdapter))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7INetworkAdapter))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8INetworkAdapter))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public INetworkAdapter methods
     * @{ */
    STDMETHOD(GetProperty)(IN_BSTR aKey,
                           BSTR *aValue) RT_OVERRIDE;
    STDMETHOD(SetProperty)(IN_BSTR aKey,
                           IN_BSTR aValue) RT_OVERRIDE;
    STDMETHOD(GetProperties)(IN_BSTR aNames,
                             ComSafeArrayOut(BSTR, aReturnNames),
                             ComSafeArrayOut(BSTR, aReturnValues)) RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1INetworkAdapter)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2INetworkAdapter)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3INetworkAdapter)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4INetworkAdapter)() RT_OVERRIDE;
    /** @} */

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 getHostOnlyNetwork(com::Utf8Str &aHostOnlyNetwork) = 0;
    virtual HRESULT setHostOnlyNetwork(const com::Utf8Str &aHostOnlyNetwork) = 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(SerialPortWrap)

    /** @name Public ISerialPort properties
     * @{ */
    STDMETHOD(COMGETTER(Slot))(ULONG *aSlot) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Enabled))(BOOL *aEnabled) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Enabled))(BOOL aEnabled) RT_OVERRIDE;
    STDMETHOD(COMGETTER(IOAddress))(ULONG *aIOAddress) RT_OVERRIDE;
    STDMETHOD(COMSETTER(IOAddress))(ULONG aIOAddress) RT_OVERRIDE;
    STDMETHOD(COMGETTER(IRQ))(ULONG *aIRQ) RT_OVERRIDE;
    STDMETHOD(COMSETTER(IRQ))(ULONG aIRQ) RT_OVERRIDE;
    STDMETHOD(COMGETTER(HostMode))(PortMode_T *aHostMode) RT_OVERRIDE;
    STDMETHOD(COMSETTER(HostMode))(PortMode_T aHostMode) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Server))(BOOL *aServer) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Server))(BOOL aServer) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Path))(BSTR *aPath) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Path))(IN_BSTR aPath) RT_OVERRIDE;
    STDMETHOD(COMGETTER(UartType))(UartType_T *aUartType) RT_OVERRIDE;
    STDMETHOD(COMSETTER(UartType))(UartType_T aUartType) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1ISerialPort))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2ISerialPort))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3ISerialPort))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4ISerialPort))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @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 getIOAddress(ULONG *aIOAddress) = 0;
    virtual HRESULT setIOAddress(ULONG aIOAddress) = 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(ParallelPortWrap)

    /** @name Public IParallelPort properties
     * @{ */
    STDMETHOD(COMGETTER(Slot))(ULONG *aSlot) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Enabled))(BOOL *aEnabled) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Enabled))(BOOL aEnabled) RT_OVERRIDE;
    STDMETHOD(COMGETTER(IOBase))(ULONG *aIOBase) RT_OVERRIDE;
    STDMETHOD(COMSETTER(IOBase))(ULONG aIOBase) RT_OVERRIDE;
    STDMETHOD(COMGETTER(IRQ))(ULONG *aIRQ) RT_OVERRIDE;
    STDMETHOD(COMSETTER(IRQ))(ULONG aIRQ) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Path))(BSTR *aPath) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Path))(IN_BSTR aPath) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IParallelPort))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IParallelPort))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IParallelPort))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IParallelPort))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(MachineDebuggerWrap)

    /** @name Public IMachineDebugger properties
     * @{ */
    STDMETHOD(COMGETTER(SingleStep))(BOOL *aSingleStep) RT_OVERRIDE;
    STDMETHOD(COMSETTER(SingleStep))(BOOL aSingleStep) RT_OVERRIDE;
    STDMETHOD(COMGETTER(ExecuteAllInIEM))(BOOL *aExecuteAllInIEM) RT_OVERRIDE;
    STDMETHOD(COMSETTER(ExecuteAllInIEM))(BOOL aExecuteAllInIEM) RT_OVERRIDE;
    STDMETHOD(COMGETTER(LogEnabled))(BOOL *aLogEnabled) RT_OVERRIDE;
    STDMETHOD(COMSETTER(LogEnabled))(BOOL aLogEnabled) RT_OVERRIDE;
    STDMETHOD(COMGETTER(LogDbgFlags))(BSTR *aLogDbgFlags) RT_OVERRIDE;
    STDMETHOD(COMGETTER(LogDbgGroups))(BSTR *aLogDbgGroups) RT_OVERRIDE;
    STDMETHOD(COMGETTER(LogDbgDestinations))(BSTR *aLogDbgDestinations) RT_OVERRIDE;
    STDMETHOD(COMGETTER(LogRelFlags))(BSTR *aLogRelFlags) RT_OVERRIDE;
    STDMETHOD(COMGETTER(LogRelGroups))(BSTR *aLogRelGroups) RT_OVERRIDE;
    STDMETHOD(COMGETTER(LogRelDestinations))(BSTR *aLogRelDestinations) RT_OVERRIDE;
    STDMETHOD(COMGETTER(ExecutionEngine))(VMExecutionEngine_T *aExecutionEngine) RT_OVERRIDE;
    STDMETHOD(COMGETTER(HWVirtExNestedPagingEnabled))(BOOL *aHWVirtExNestedPagingEnabled) RT_OVERRIDE;
    STDMETHOD(COMGETTER(HWVirtExVPIDEnabled))(BOOL *aHWVirtExVPIDEnabled) RT_OVERRIDE;
    STDMETHOD(COMGETTER(HWVirtExUXEnabled))(BOOL *aHWVirtExUXEnabled) RT_OVERRIDE;
    STDMETHOD(COMGETTER(OSName))(BSTR *aOSName) RT_OVERRIDE;
    STDMETHOD(COMGETTER(OSVersion))(BSTR *aOSVersion) RT_OVERRIDE;
    STDMETHOD(COMGETTER(PAEEnabled))(BOOL *aPAEEnabled) RT_OVERRIDE;
    STDMETHOD(COMGETTER(VirtualTimeRate))(ULONG *aVirtualTimeRate) RT_OVERRIDE;
    STDMETHOD(COMSETTER(VirtualTimeRate))(ULONG aVirtualTimeRate) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Uptime))(LONG64 *aUptime) RT_OVERRIDE;
    STDMETHOD(COMGETTER(RecompiledIEMExecution))(BOOL *aRecompiledIEMExecution) RT_OVERRIDE;
    STDMETHOD(COMSETTER(RecompiledIEMExecution))(BOOL aRecompiledIEMExecution) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IMachineDebugger))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IMachineDebugger))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IMachineDebugger))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IMachineDebugger))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IMachineDebugger))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IMachineDebugger))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IMachineDebugger))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IMachineDebugger))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute9IMachineDebugger))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute10IMachineDebugger))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute11IMachineDebugger))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute12IMachineDebugger))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute13IMachineDebugger))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute14IMachineDebugger))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IMachineDebugger methods
     * @{ */
    STDMETHOD(DumpGuestCore)(IN_BSTR aFilename,
                             IN_BSTR aCompression) RT_OVERRIDE;
    STDMETHOD(DumpHostProcessCore)(IN_BSTR aFilename,
                                   IN_BSTR aCompression) RT_OVERRIDE;
    STDMETHOD(Info)(IN_BSTR aName,
                    IN_BSTR aArgs,
                    BSTR *aInfo) RT_OVERRIDE;
    STDMETHOD(InjectNMI)() RT_OVERRIDE;
    STDMETHOD(ModifyLogGroups)(IN_BSTR aSettings) RT_OVERRIDE;
    STDMETHOD(ModifyLogFlags)(IN_BSTR aSettings) RT_OVERRIDE;
    STDMETHOD(ModifyLogDestinations)(IN_BSTR aSettings) RT_OVERRIDE;
    STDMETHOD(ReadPhysicalMemory)(LONG64 aAddress,
                                  ULONG aSize,
                                  ComSafeArrayOut(BYTE, aBytes)) RT_OVERRIDE;
    STDMETHOD(WritePhysicalMemory)(LONG64 aAddress,
                                   ULONG aSize,
                                   ComSafeArrayIn(BYTE, aBytes)) RT_OVERRIDE;
    STDMETHOD(ReadVirtualMemory)(ULONG aCpuId,
                                 LONG64 aAddress,
                                 ULONG aSize,
                                 ComSafeArrayOut(BYTE, aBytes)) RT_OVERRIDE;
    STDMETHOD(WriteVirtualMemory)(ULONG aCpuId,
                                  LONG64 aAddress,
                                  ULONG aSize,
                                  ComSafeArrayIn(BYTE, aBytes)) RT_OVERRIDE;
    STDMETHOD(LoadPlugIn)(IN_BSTR aName,
                          BSTR *aPlugInName) RT_OVERRIDE;
    STDMETHOD(UnloadPlugIn)(IN_BSTR aName) RT_OVERRIDE;
    STDMETHOD(DetectOS)(BSTR *aOs) RT_OVERRIDE;
    STDMETHOD(QueryOSKernelLog)(ULONG aMaxMessages,
                                BSTR *aDmesg) RT_OVERRIDE;
    STDMETHOD(GetRegister)(ULONG aCpuId,
                           IN_BSTR aName,
                           BSTR *aValue) RT_OVERRIDE;
    STDMETHOD(GetRegisters)(ULONG aCpuId,
                            ComSafeArrayOut(BSTR, aNames),
                            ComSafeArrayOut(BSTR, aValues)) RT_OVERRIDE;
    STDMETHOD(SetRegister)(ULONG aCpuId,
                           IN_BSTR aName,
                           IN_BSTR aValue) RT_OVERRIDE;
    STDMETHOD(SetRegisters)(ULONG aCpuId,
                            ComSafeArrayIn(IN_BSTR, aNames),
                            ComSafeArrayIn(IN_BSTR, aValues)) RT_OVERRIDE;
    STDMETHOD(DumpGuestStack)(ULONG aCpuId,
                              BSTR *aStack) RT_OVERRIDE;
    STDMETHOD(ResetStats)(IN_BSTR aPattern) RT_OVERRIDE;
    STDMETHOD(DumpStats)(IN_BSTR aPattern) RT_OVERRIDE;
    STDMETHOD(GetStats)(IN_BSTR aPattern,
                        BOOL aWithDescriptions,
                        BSTR *aStats) RT_OVERRIDE;
    STDMETHOD(GetCPULoad)(ULONG aCpuId,
                          ULONG *aPctExecuting,
                          ULONG *aPctHalted,
                          ULONG *aPctOther,
                          LONG64 *aMsInterval) RT_OVERRIDE;
    STDMETHOD(TakeGuestSample)(IN_BSTR aFilename,
                               ULONG aUsInterval,
                               LONG64 aUsSampleTime,
                               IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(GetUVMAndVMMFunctionTable)(LONG64 aMagicVersion,
                                         LONG64 *aVMMFunctionTable,
                                         LONG64 *aUVM) RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1IMachineDebugger)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IMachineDebugger)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3IMachineDebugger)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4IMachineDebugger)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod5IMachineDebugger)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod6IMachineDebugger)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod7IMachineDebugger)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod8IMachineDebugger)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod9IMachineDebugger)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod10IMachineDebugger)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod11IMachineDebugger)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod12IMachineDebugger)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod13IMachineDebugger)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod14IMachineDebugger)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod15IMachineDebugger)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod16IMachineDebugger)() RT_OVERRIDE;
    /** @} */

private:
    /** @name Wrapped IMachineDebugger properties
     * @{ */
    virtual HRESULT getSingleStep(BOOL *aSingleStep) = 0;
    virtual HRESULT setSingleStep(BOOL aSingleStep) = 0;
    virtual HRESULT getExecuteAllInIEM(BOOL *aExecuteAllInIEM) = 0;
    virtual HRESULT setExecuteAllInIEM(BOOL aExecuteAllInIEM) = 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 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 getUptime(LONG64 *aUptime) = 0;
    virtual HRESULT getRecompiledIEMExecution(BOOL *aRecompiledIEMExecution) = 0;
    virtual HRESULT setRecompiledIEMExecution(BOOL aRecompiledIEMExecution) = 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;
    virtual HRESULT takeGuestSample(const com::Utf8Str &aFilename,
                                    ULONG aUsInterval,
                                    LONG64 aUsSampleTime,
                                    ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT getUVMAndVMMFunctionTable(LONG64 aMagicVersion,
                                              LONG64 *aVMMFunctionTable,
                                              LONG64 *aUVM) = 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(USBDeviceFiltersWrap)

    /** @name Public IUSBDeviceFilters properties
     * @{ */
    STDMETHOD(COMGETTER(DeviceFilters))(ComSafeArrayOut(IUSBDeviceFilter *, aDeviceFilters)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IUSBDeviceFilters))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IUSBDeviceFilters))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IUSBDeviceFilters methods
     * @{ */
    STDMETHOD(CreateDeviceFilter)(IN_BSTR aName,
                                  IUSBDeviceFilter **aFilter) RT_OVERRIDE;
    STDMETHOD(InsertDeviceFilter)(ULONG aPosition,
                                  IUSBDeviceFilter *aFilter) RT_OVERRIDE;
    STDMETHOD(RemoveDeviceFilter)(ULONG aPosition,
                                  IUSBDeviceFilter **aFilter) RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1IUSBDeviceFilters)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IUSBDeviceFilters)() RT_OVERRIDE;
    /** @} */

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(USBControllerWrap)

    /** @name Public IUSBController properties
     * @{ */
    STDMETHOD(COMGETTER(Name))(BSTR *aName) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Name))(IN_BSTR aName) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Type))(USBControllerType_T *aType) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Type))(USBControllerType_T aType) RT_OVERRIDE;
    STDMETHOD(COMGETTER(USBStandard))(USHORT *aUSBStandard) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IUSBController))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IUSBController))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IUSBController))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IUSBController))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(USBDeviceWrap)

    /** @name Public IUSBDevice properties
     * @{ */
    STDMETHOD(COMGETTER(Id))(BSTR *aId) RT_OVERRIDE;
    STDMETHOD(COMGETTER(VendorId))(USHORT *aVendorId) RT_OVERRIDE;
    STDMETHOD(COMGETTER(ProductId))(USHORT *aProductId) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Revision))(USHORT *aRevision) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Manufacturer))(BSTR *aManufacturer) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Product))(BSTR *aProduct) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SerialNumber))(BSTR *aSerialNumber) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Address))(BSTR *aAddress) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Port))(USHORT *aPort) RT_OVERRIDE;
    STDMETHOD(COMGETTER(PortPath))(BSTR *aPortPath) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Version))(USHORT *aVersion) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Speed))(USBConnectionSpeed_T *aSpeed) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Remote))(BOOL *aRemote) RT_OVERRIDE;
    STDMETHOD(COMGETTER(DeviceInfo))(ComSafeArrayOut(BSTR, aDeviceInfo)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Backend))(BSTR *aBackend) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IUSBDevice))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IUSBDevice))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IUSBDevice))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IUSBDevice))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(USBDeviceFilterWrap)

    /** @name Public IUSBDeviceFilter properties
     * @{ */
    STDMETHOD(COMGETTER(Name))(BSTR *aName) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Name))(IN_BSTR aName) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Active))(BOOL *aActive) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Active))(BOOL aActive) RT_OVERRIDE;
    STDMETHOD(COMGETTER(VendorId))(BSTR *aVendorId) RT_OVERRIDE;
    STDMETHOD(COMSETTER(VendorId))(IN_BSTR aVendorId) RT_OVERRIDE;
    STDMETHOD(COMGETTER(ProductId))(BSTR *aProductId) RT_OVERRIDE;
    STDMETHOD(COMSETTER(ProductId))(IN_BSTR aProductId) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Revision))(BSTR *aRevision) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Revision))(IN_BSTR aRevision) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Manufacturer))(BSTR *aManufacturer) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Manufacturer))(IN_BSTR aManufacturer) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Product))(BSTR *aProduct) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Product))(IN_BSTR aProduct) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SerialNumber))(BSTR *aSerialNumber) RT_OVERRIDE;
    STDMETHOD(COMSETTER(SerialNumber))(IN_BSTR aSerialNumber) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Port))(BSTR *aPort) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Port))(IN_BSTR aPort) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Remote))(BSTR *aRemote) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Remote))(IN_BSTR aRemote) RT_OVERRIDE;
    STDMETHOD(COMGETTER(MaskedInterfaces))(ULONG *aMaskedInterfaces) RT_OVERRIDE;
    STDMETHOD(COMSETTER(MaskedInterfaces))(ULONG aMaskedInterfaces) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IUSBDeviceFilter))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IUSBDeviceFilter))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IUSBDeviceFilter))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IUSBDeviceFilter))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IUSBDeviceFilter))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IUSBDeviceFilter))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IUSBDeviceFilter))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IUSBDeviceFilter))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(HostUSBDeviceWrap)

    /** @name Public IUSBDevice properties
     * @{ */
    STDMETHOD(COMGETTER(Id))(BSTR *aId) RT_OVERRIDE;
    STDMETHOD(COMGETTER(VendorId))(USHORT *aVendorId) RT_OVERRIDE;
    STDMETHOD(COMGETTER(ProductId))(USHORT *aProductId) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Revision))(USHORT *aRevision) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Manufacturer))(BSTR *aManufacturer) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Product))(BSTR *aProduct) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SerialNumber))(BSTR *aSerialNumber) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Address))(BSTR *aAddress) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Port))(USHORT *aPort) RT_OVERRIDE;
    STDMETHOD(COMGETTER(PortPath))(BSTR *aPortPath) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Version))(USHORT *aVersion) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Speed))(USBConnectionSpeed_T *aSpeed) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Remote))(BOOL *aRemote) RT_OVERRIDE;
    STDMETHOD(COMGETTER(DeviceInfo))(ComSafeArrayOut(BSTR, aDeviceInfo)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Backend))(BSTR *aBackend) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IUSBDevice))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IUSBDevice))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IUSBDevice))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IUSBDevice))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IHostUSBDevice properties
     * @{ */
    STDMETHOD(COMGETTER(State))(USBDeviceState_T *aState) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IHostUSBDevice))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IHostUSBDevice))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IHostUSBDevice))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IHostUSBDevice))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(HostUSBDeviceFilterWrap)

    /** @name Public IUSBDeviceFilter properties
     * @{ */
    STDMETHOD(COMGETTER(Name))(BSTR *aName) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Name))(IN_BSTR aName) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Active))(BOOL *aActive) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Active))(BOOL aActive) RT_OVERRIDE;
    STDMETHOD(COMGETTER(VendorId))(BSTR *aVendorId) RT_OVERRIDE;
    STDMETHOD(COMSETTER(VendorId))(IN_BSTR aVendorId) RT_OVERRIDE;
    STDMETHOD(COMGETTER(ProductId))(BSTR *aProductId) RT_OVERRIDE;
    STDMETHOD(COMSETTER(ProductId))(IN_BSTR aProductId) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Revision))(BSTR *aRevision) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Revision))(IN_BSTR aRevision) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Manufacturer))(BSTR *aManufacturer) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Manufacturer))(IN_BSTR aManufacturer) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Product))(BSTR *aProduct) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Product))(IN_BSTR aProduct) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SerialNumber))(BSTR *aSerialNumber) RT_OVERRIDE;
    STDMETHOD(COMSETTER(SerialNumber))(IN_BSTR aSerialNumber) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Port))(BSTR *aPort) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Port))(IN_BSTR aPort) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Remote))(BSTR *aRemote) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Remote))(IN_BSTR aRemote) RT_OVERRIDE;
    STDMETHOD(COMGETTER(MaskedInterfaces))(ULONG *aMaskedInterfaces) RT_OVERRIDE;
    STDMETHOD(COMSETTER(MaskedInterfaces))(ULONG aMaskedInterfaces) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IUSBDeviceFilter))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IUSBDeviceFilter))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IUSBDeviceFilter))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IUSBDeviceFilter))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IUSBDeviceFilter))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IUSBDeviceFilter))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IUSBDeviceFilter))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IUSBDeviceFilter))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IHostUSBDeviceFilter properties
     * @{ */
    STDMETHOD(COMGETTER(Action))(USBDeviceFilterAction_T *aAction) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Action))(USBDeviceFilterAction_T aAction) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IHostUSBDeviceFilter))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IHostUSBDeviceFilter))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IHostUSBDeviceFilter))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IHostUSBDeviceFilter))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IHostUSBDeviceFilter))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IHostUSBDeviceFilter))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IHostUSBDeviceFilter))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IHostUSBDeviceFilter))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(USBProxyBackendWrap)

    /** @name Public IUSBProxyBackend properties
     * @{ */
    STDMETHOD(COMGETTER(Name))(BSTR *aName) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Type))(BSTR *aType) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IUSBProxyBackend))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IUSBProxyBackend))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IUSBProxyBackend))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IUSBProxyBackend))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IUSBProxyBackend))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IUSBProxyBackend))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IUSBProxyBackend))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IUSBProxyBackend))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IUSBProxyBackend methods
     * @{ */
    STDMETHOD(InternalAndReservedMethod1IUSBProxyBackend)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IUSBProxyBackend)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3IUSBProxyBackend)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4IUSBProxyBackend)() RT_OVERRIDE;
    /** @} */

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(AudioAdapterWrap)

    /** @name Public IAudioAdapter properties
     * @{ */
    STDMETHOD(COMGETTER(Enabled))(BOOL *aEnabled) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Enabled))(BOOL aEnabled) RT_OVERRIDE;
    STDMETHOD(COMGETTER(EnabledIn))(BOOL *aEnabledIn) RT_OVERRIDE;
    STDMETHOD(COMSETTER(EnabledIn))(BOOL aEnabledIn) RT_OVERRIDE;
    STDMETHOD(COMGETTER(EnabledOut))(BOOL *aEnabledOut) RT_OVERRIDE;
    STDMETHOD(COMSETTER(EnabledOut))(BOOL aEnabledOut) RT_OVERRIDE;
    STDMETHOD(COMGETTER(AudioController))(AudioControllerType_T *aAudioController) RT_OVERRIDE;
    STDMETHOD(COMSETTER(AudioController))(AudioControllerType_T aAudioController) RT_OVERRIDE;
    STDMETHOD(COMGETTER(AudioCodec))(AudioCodecType_T *aAudioCodec) RT_OVERRIDE;
    STDMETHOD(COMSETTER(AudioCodec))(AudioCodecType_T aAudioCodec) RT_OVERRIDE;
    STDMETHOD(COMGETTER(AudioDriver))(AudioDriverType_T *aAudioDriver) RT_OVERRIDE;
    STDMETHOD(COMSETTER(AudioDriver))(AudioDriverType_T aAudioDriver) RT_OVERRIDE;
    STDMETHOD(COMGETTER(PropertiesList))(ComSafeArrayOut(BSTR, aPropertiesList)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IAudioAdapter))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IAudioAdapter))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IAudioAdapter))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IAudioAdapter))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IAudioAdapter))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IAudioAdapter))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IAudioAdapter))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IAudioAdapter))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IAudioAdapter methods
     * @{ */
    STDMETHOD(SetProperty)(IN_BSTR aKey,
                           IN_BSTR aValue) RT_OVERRIDE;
    STDMETHOD(GetProperty)(IN_BSTR aKey,
                           BSTR *aValue) RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1IAudioAdapter)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IAudioAdapter)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3IAudioAdapter)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4IAudioAdapter)() RT_OVERRIDE;
    /** @} */

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 "HostAudioDeviceWrap.h"
/** @file
 * VirtualBox API class wrapper header for IHostAudioDevice.
 *
 * 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#ifndef HostAudioDeviceWrap_H_
#define HostAudioDeviceWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

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

class ATL_NO_VTABLE HostAudioDeviceWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IHostAudioDevice)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(HostAudioDeviceWrap, IHostAudioDevice)
    DECLARE_NOT_AGGREGATABLE(HostAudioDeviceWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(HostAudioDeviceWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IHostAudioDevice)
        COM_INTERFACE_ENTRY2(IDispatch, IHostAudioDevice)
        VBOX_TWEAK_INTERFACE_ENTRY(IHostAudioDevice)
    END_COM_MAP()

    DECLARE_COMMON_CLASS_METHODS(HostAudioDeviceWrap)

    /** @name Public IHostAudioDevice properties
     * @{ */
    STDMETHOD(COMGETTER(Id))(BSTR *aId) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Name))(BSTR *aName) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Name))(IN_BSTR aName) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Type))(AudioDeviceType_T *aType) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Type))(AudioDeviceType_T aType) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Usage))(AudioDirection_T *aUsage) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Usage))(AudioDirection_T aUsage) RT_OVERRIDE;
    STDMETHOD(COMGETTER(DefaultIn))(BOOL *aDefaultIn) RT_OVERRIDE;
    STDMETHOD(COMSETTER(DefaultIn))(BOOL aDefaultIn) RT_OVERRIDE;
    STDMETHOD(COMGETTER(DefaultOut))(BOOL *aDefaultOut) RT_OVERRIDE;
    STDMETHOD(COMSETTER(DefaultOut))(BOOL aDefaultOut) RT_OVERRIDE;
    STDMETHOD(COMGETTER(IsHotPlug))(BOOL *aIsHotPlug) RT_OVERRIDE;
    STDMETHOD(COMSETTER(IsHotPlug))(BOOL aIsHotPlug) RT_OVERRIDE;
    STDMETHOD(COMGETTER(State))(AudioDeviceState_T *aState) RT_OVERRIDE;
    STDMETHOD(COMSETTER(State))(AudioDeviceState_T aState) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IHostAudioDevice))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IHostAudioDevice))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IHostAudioDevice))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IHostAudioDevice))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IHostAudioDevice))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IHostAudioDevice))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IHostAudioDevice))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IHostAudioDevice))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IHostAudioDevice methods
     * @{ */
    STDMETHOD(GetProperty)(IN_BSTR aKey,
                           BSTR *aValue) RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1IHostAudioDevice)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IHostAudioDevice)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3IHostAudioDevice)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4IHostAudioDevice)() RT_OVERRIDE;
    /** @} */

private:
    /** @name Wrapped IHostAudioDevice 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 getType(AudioDeviceType_T *aType) = 0;
    virtual HRESULT setType(AudioDeviceType_T aType) = 0;
    virtual HRESULT getUsage(AudioDirection_T *aUsage) = 0;
    virtual HRESULT setUsage(AudioDirection_T aUsage) = 0;
    virtual HRESULT getDefaultIn(BOOL *aDefaultIn) = 0;
    virtual HRESULT setDefaultIn(BOOL aDefaultIn) = 0;
    virtual HRESULT getDefaultOut(BOOL *aDefaultOut) = 0;
    virtual HRESULT setDefaultOut(BOOL aDefaultOut) = 0;
    virtual HRESULT getIsHotPlug(BOOL *aIsHotPlug) = 0;
    virtual HRESULT setIsHotPlug(BOOL aIsHotPlug) = 0;
    virtual HRESULT getState(AudioDeviceState_T *aState) = 0;
    virtual HRESULT setState(AudioDeviceState_T aState) = 0;
    /** @} */

    /** @name Wrapped IHostAudioDevice methods
     * @{ */
    virtual HRESULT getProperty(const com::Utf8Str &aKey,
                                com::Utf8Str &aValue) = 0;
    /** @} */

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

};

#endif // !HostAudioDeviceWrap_H_

// ##### ENDFILE "HostAudioDeviceWrap.h"


// ##### BEGINFILE "AudioSettingsWrap.h"
/** @file
 * VirtualBox API class wrapper header for IAudioSettings.
 *
 * 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#ifndef AudioSettingsWrap_H_
#define AudioSettingsWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

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

class ATL_NO_VTABLE AudioSettingsWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IAudioSettings)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(AudioSettingsWrap, IAudioSettings)
    DECLARE_NOT_AGGREGATABLE(AudioSettingsWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(AudioSettingsWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IAudioSettings)
        COM_INTERFACE_ENTRY2(IDispatch, IAudioSettings)
        VBOX_TWEAK_INTERFACE_ENTRY(IAudioSettings)
    END_COM_MAP()

    DECLARE_COMMON_CLASS_METHODS(AudioSettingsWrap)

    /** @name Public IAudioSettings properties
     * @{ */
    STDMETHOD(COMGETTER(Adapter))(IAudioAdapter **aAdapter) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IAudioSettings))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IAudioSettings))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IAudioSettings))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IAudioSettings))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IAudioSettings))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IAudioSettings))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IAudioSettings))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IAudioSettings))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IAudioSettings methods
     * @{ */
    STDMETHOD(GetHostAudioDevice)(AudioDirection_T aUsage,
                                  IHostAudioDevice **aDevice) RT_OVERRIDE;
    STDMETHOD(SetHostAudioDevice)(IHostAudioDevice *aDevice,
                                  AudioDirection_T aUsage) RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1IAudioSettings)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IAudioSettings)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3IAudioSettings)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4IAudioSettings)() RT_OVERRIDE;
    /** @} */

private:
    /** @name Wrapped IAudioSettings properties
     * @{ */
    virtual HRESULT getAdapter(ComPtr<IAudioAdapter> &aAdapter) = 0;
    /** @} */

    /** @name Wrapped IAudioSettings methods
     * @{ */
    virtual HRESULT getHostAudioDevice(AudioDirection_T aUsage,
                                       ComPtr<IHostAudioDevice> &aDevice) = 0;
    virtual HRESULT setHostAudioDevice(const ComPtr<IHostAudioDevice> &aDevice,
                                       AudioDirection_T aUsage) = 0;
    /** @} */

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

};

#endif // !AudioSettingsWrap_H_

// ##### ENDFILE "AudioSettingsWrap.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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(VRDEServerWrap)

    /** @name Public IVRDEServer properties
     * @{ */
    STDMETHOD(COMGETTER(Enabled))(BOOL *aEnabled) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Enabled))(BOOL aEnabled) RT_OVERRIDE;
    STDMETHOD(COMGETTER(AuthType))(AuthType_T *aAuthType) RT_OVERRIDE;
    STDMETHOD(COMSETTER(AuthType))(AuthType_T aAuthType) RT_OVERRIDE;
    STDMETHOD(COMGETTER(AuthTimeout))(ULONG *aAuthTimeout) RT_OVERRIDE;
    STDMETHOD(COMSETTER(AuthTimeout))(ULONG aAuthTimeout) RT_OVERRIDE;
    STDMETHOD(COMGETTER(AllowMultiConnection))(BOOL *aAllowMultiConnection) RT_OVERRIDE;
    STDMETHOD(COMSETTER(AllowMultiConnection))(BOOL aAllowMultiConnection) RT_OVERRIDE;
    STDMETHOD(COMGETTER(ReuseSingleConnection))(BOOL *aReuseSingleConnection) RT_OVERRIDE;
    STDMETHOD(COMSETTER(ReuseSingleConnection))(BOOL aReuseSingleConnection) RT_OVERRIDE;
    STDMETHOD(COMGETTER(VRDEExtPack))(BSTR *aVRDEExtPack) RT_OVERRIDE;
    STDMETHOD(COMSETTER(VRDEExtPack))(IN_BSTR aVRDEExtPack) RT_OVERRIDE;
    STDMETHOD(COMGETTER(AuthLibrary))(BSTR *aAuthLibrary) RT_OVERRIDE;
    STDMETHOD(COMSETTER(AuthLibrary))(IN_BSTR aAuthLibrary) RT_OVERRIDE;
    STDMETHOD(COMGETTER(VRDEProperties))(ComSafeArrayOut(BSTR, aVRDEProperties)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IVRDEServer))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IVRDEServer))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IVRDEServer))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IVRDEServer))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IVRDEServer methods
     * @{ */
    STDMETHOD(SetVRDEProperty)(IN_BSTR aKey,
                               IN_BSTR aValue) RT_OVERRIDE;
    STDMETHOD(GetVRDEProperty)(IN_BSTR aKey,
                               BSTR *aValue) RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1IVRDEServer)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IVRDEServer)() RT_OVERRIDE;
    /** @} */

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(SharedFolderWrap)

    /** @name Public ISharedFolder properties
     * @{ */
    STDMETHOD(COMGETTER(Name))(BSTR *aName) RT_OVERRIDE;
    STDMETHOD(COMGETTER(HostPath))(BSTR *aHostPath) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Accessible))(BOOL *aAccessible) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Writable))(BOOL *aWritable) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Writable))(BOOL aWritable) RT_OVERRIDE;
    STDMETHOD(COMGETTER(AutoMount))(BOOL *aAutoMount) RT_OVERRIDE;
    STDMETHOD(COMSETTER(AutoMount))(BOOL aAutoMount) RT_OVERRIDE;
    STDMETHOD(COMGETTER(AutoMountPoint))(BSTR *aAutoMountPoint) RT_OVERRIDE;
    STDMETHOD(COMSETTER(AutoMountPoint))(IN_BSTR aAutoMountPoint) RT_OVERRIDE;
    STDMETHOD(COMGETTER(LastAccessError))(BSTR *aLastAccessError) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SymlinkPolicy))(SymlinkPolicy_T *aSymlinkPolicy) RT_OVERRIDE;
    STDMETHOD(COMSETTER(SymlinkPolicy))(SymlinkPolicy_T aSymlinkPolicy) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1ISharedFolder))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2ISharedFolder))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3ISharedFolder))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4ISharedFolder))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5ISharedFolder))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6ISharedFolder))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7ISharedFolder))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8ISharedFolder))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @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;
    virtual HRESULT getSymlinkPolicy(SymlinkPolicy_T *aSymlinkPolicy) = 0;
    virtual HRESULT setSymlinkPolicy(SymlinkPolicy_T aSymlinkPolicy) = 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(SessionWrap)

    /** @name Public ISession properties
     * @{ */
    STDMETHOD(COMGETTER(State))(SessionState_T *aState) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Type))(SessionType_T *aType) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Name))(BSTR *aName) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Name))(IN_BSTR aName) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Machine))(IMachine **aMachine) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Console))(IConsole **aConsole) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1ISession))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2ISession))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3ISession))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4ISession))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5ISession))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6ISession))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7ISession))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8ISession))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public ISession methods
     * @{ */
    STDMETHOD(UnlockMachine)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1ISession)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2ISession)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3ISession)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4ISession)() RT_OVERRIDE;
    /** @} */

    /** @name Public IInternalSessionControl properties
     * @{ */
    STDMETHOD(COMGETTER(PID))(ULONG *aPID) RT_OVERRIDE;
    STDMETHOD(COMGETTER(RemoteConsole))(IConsole **aRemoteConsole) RT_OVERRIDE;
    STDMETHOD(COMGETTER(NominalState))(MachineState_T *aNominalState) RT_OVERRIDE;
    /** @} */

    /** @name Public IInternalSessionControl methods
     * @{ */
#ifndef VBOX_WITH_XPCOM
    STDMETHOD(AssignMachine)(IMachine *aMachine,
                             LockType_T aLockType,
                             IN_BSTR aTokenId) RT_OVERRIDE;
#endif /* !VBOX_WITH_XPCOM */
#ifdef VBOX_WITH_XPCOM
    STDMETHOD(AssignMachine)(IMachine *aMachine,
                             LockType_T aLockType,
                             IToken *aToken) RT_OVERRIDE;
#endif /* VBOX_WITH_XPCOM */
    STDMETHOD(AssignRemoteMachine)(IMachine *aMachine,
                                   IConsole *aConsole) RT_OVERRIDE;
    STDMETHOD(UpdateMachineState)(MachineState_T aMachineState) RT_OVERRIDE;
    STDMETHOD(Uninitialize)() RT_OVERRIDE;
    STDMETHOD(OnNetworkAdapterChange)(INetworkAdapter *aNetworkAdapter,
                                      BOOL aChangeAdapter) RT_OVERRIDE;
    STDMETHOD(OnAudioAdapterChange)(IAudioAdapter *aAudioAdapter) RT_OVERRIDE;
    STDMETHOD(OnHostAudioDeviceChange)(IHostAudioDevice *aDevice,
                                       BOOL aIsNew,
                                       AudioDeviceState_T aState,
                                       IVirtualBoxErrorInfo *aErrorInfo) RT_OVERRIDE;
    STDMETHOD(OnSerialPortChange)(ISerialPort *aSerialPort) RT_OVERRIDE;
    STDMETHOD(OnParallelPortChange)(IParallelPort *aParallelPort) RT_OVERRIDE;
    STDMETHOD(OnStorageControllerChange)(IN_BSTR aMachineId,
                                         IN_BSTR aControllerName) RT_OVERRIDE;
    STDMETHOD(OnMediumChange)(IMediumAttachment *aMediumAttachment,
                              BOOL aForce) RT_OVERRIDE;
    STDMETHOD(OnStorageDeviceChange)(IMediumAttachment *aMediumAttachment,
                                     BOOL aRemove,
                                     BOOL aSilent) RT_OVERRIDE;
    STDMETHOD(OnVMProcessPriorityChange)(VMProcPriority_T aPriority) RT_OVERRIDE;
    STDMETHOD(OnClipboardModeChange)(ClipboardMode_T aClipboardMode) RT_OVERRIDE;
    STDMETHOD(OnClipboardFileTransferModeChange)(BOOL aEnabled) RT_OVERRIDE;
    STDMETHOD(OnDnDModeChange)(DnDMode_T aDndMode) RT_OVERRIDE;
    STDMETHOD(OnCPUChange)(ULONG aCpu,
                           BOOL aAdd) RT_OVERRIDE;
    STDMETHOD(OnCPUExecutionCapChange)(ULONG aExecutionCap) RT_OVERRIDE;
    STDMETHOD(OnVRDEServerChange)(BOOL aRestart) RT_OVERRIDE;
    STDMETHOD(OnRecordingStateChange)(RecordingState_T aState,
                                      IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(OnRecordingScreenStateChange)(RecordingState_T aState,
                                            ULONG aScreen) RT_OVERRIDE;
    STDMETHOD(OnUSBControllerChange)() RT_OVERRIDE;
    STDMETHOD(OnSharedFolderChange)(BOOL aGlobal) RT_OVERRIDE;
    STDMETHOD(OnGuestDebugControlChange)(IGuestDebugControl *aGuestDebugControl) RT_OVERRIDE;
    STDMETHOD(OnUSBDeviceAttach)(IUSBDevice *aDevice,
                                 IVirtualBoxErrorInfo *aError,
                                 ULONG aMaskedInterfaces,
                                 IN_BSTR aCaptureFilename) RT_OVERRIDE;
    STDMETHOD(OnUSBDeviceDetach)(IN_BSTR aId,
                                 IVirtualBoxErrorInfo *aError) RT_OVERRIDE;
    STDMETHOD(OnShowWindow)(BOOL aCheck,
                            BOOL *aCanShow,
                            LONG64 *aWinId) RT_OVERRIDE;
    STDMETHOD(OnBandwidthGroupChange)(IBandwidthGroup *aBandwidthGroup) RT_OVERRIDE;
    STDMETHOD(AccessGuestProperty)(IN_BSTR aName,
                                   IN_BSTR aValue,
                                   IN_BSTR aFlags,
                                   ULONG aAccessMode,
                                   BSTR *aRetValue,
                                   LONG64 *aRetTimestamp,
                                   BSTR *aRetFlags) RT_OVERRIDE;
    STDMETHOD(EnumerateGuestProperties)(IN_BSTR aPatterns,
                                        ComSafeArrayOut(BSTR, aKeys),
                                        ComSafeArrayOut(BSTR, aValues),
                                        ComSafeArrayOut(LONG64, aTimestamps),
                                        ComSafeArrayOut(BSTR, aFlags)) RT_OVERRIDE;
    STDMETHOD(OnlineMergeMedium)(IMediumAttachment *aMediumAttachment,
                                 ULONG aSourceIdx,
                                 ULONG aTargetIdx,
                                 IProgress *aProgress) RT_OVERRIDE;
    STDMETHOD(ReconfigureMediumAttachments)(ComSafeArrayIn(IMediumAttachment *, aAttachments)) RT_OVERRIDE;
    STDMETHOD(EnableVMMStatistics)(BOOL aEnable) RT_OVERRIDE;
    STDMETHOD(PauseWithReason)(Reason_T aReason) RT_OVERRIDE;
    STDMETHOD(ResumeWithReason)(Reason_T aReason) RT_OVERRIDE;
    STDMETHOD(SaveStateWithReason)(Reason_T aReason,
                                   IProgress *aProgress,
                                   ISnapshot *aSnapshot,
                                   IN_BSTR aStateFilePath,
                                   BOOL aPauseVM,
                                   BOOL *aLeftPaused) RT_OVERRIDE;
    STDMETHOD(CancelSaveStateWithReason)() RT_OVERRIDE;
    /** @} */

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 onHostAudioDeviceChange(const ComPtr<IHostAudioDevice> &aDevice,
                                            BOOL aIsNew,
                                            AudioDeviceState_T aState,
                                            const ComPtr<IVirtualBoxErrorInfo> &aErrorInfo) = 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 onRecordingStateChange(RecordingState_T aState,
                                           ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT onRecordingScreenStateChange(RecordingState_T aState,
                                                 ULONG aScreen) = 0;
    virtual HRESULT onUSBControllerChange() = 0;
    virtual HRESULT onSharedFolderChange(BOOL aGlobal) = 0;
    virtual HRESULT onGuestDebugControlChange(const ComPtr<IGuestDebugControl> &aGuestDebugControl) = 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(StorageControllerWrap)

    /** @name Public IStorageController properties
     * @{ */
    STDMETHOD(COMGETTER(Name))(BSTR *aName) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Name))(IN_BSTR aName) RT_OVERRIDE;
    STDMETHOD(COMGETTER(MaxDevicesPerPortCount))(ULONG *aMaxDevicesPerPortCount) RT_OVERRIDE;
    STDMETHOD(COMGETTER(MinPortCount))(ULONG *aMinPortCount) RT_OVERRIDE;
    STDMETHOD(COMGETTER(MaxPortCount))(ULONG *aMaxPortCount) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Instance))(ULONG *aInstance) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Instance))(ULONG aInstance) RT_OVERRIDE;
    STDMETHOD(COMGETTER(PortCount))(ULONG *aPortCount) RT_OVERRIDE;
    STDMETHOD(COMSETTER(PortCount))(ULONG aPortCount) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Bus))(StorageBus_T *aBus) RT_OVERRIDE;
    STDMETHOD(COMGETTER(ControllerType))(StorageControllerType_T *aControllerType) RT_OVERRIDE;
    STDMETHOD(COMSETTER(ControllerType))(StorageControllerType_T aControllerType) RT_OVERRIDE;
    STDMETHOD(COMGETTER(UseHostIOCache))(BOOL *aUseHostIOCache) RT_OVERRIDE;
    STDMETHOD(COMSETTER(UseHostIOCache))(BOOL aUseHostIOCache) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Bootable))(BOOL *aBootable) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IStorageController))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IStorageController))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IStorageController))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IStorageController))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IStorageController))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IStorageController))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IStorageController))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IStorageController))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IStorageController methods
     * @{ */
    STDMETHOD(InternalAndReservedMethod1IStorageController)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IStorageController)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3IStorageController)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4IStorageController)() RT_OVERRIDE;
    /** @} */

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(PerformanceMetricWrap)

    /** @name Public IPerformanceMetric properties
     * @{ */
    STDMETHOD(COMGETTER(MetricName))(BSTR *aMetricName) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Object))(IUnknown **aObject) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Description))(BSTR *aDescription) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Period))(ULONG *aPeriod) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Count))(ULONG *aCount) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Unit))(BSTR *aUnit) RT_OVERRIDE;
    STDMETHOD(COMGETTER(MinimumValue))(LONG *aMinimumValue) RT_OVERRIDE;
    STDMETHOD(COMGETTER(MaximumValue))(LONG *aMaximumValue) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IPerformanceMetric))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IPerformanceMetric))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IPerformanceMetric))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IPerformanceMetric))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IPerformanceMetric))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IPerformanceMetric))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IPerformanceMetric))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IPerformanceMetric))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(PerformanceCollectorWrap)

    /** @name Public IPerformanceCollector properties
     * @{ */
    STDMETHOD(COMGETTER(MetricNames))(ComSafeArrayOut(BSTR, aMetricNames)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IPerformanceCollector))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IPerformanceCollector))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IPerformanceCollector))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IPerformanceCollector))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IPerformanceCollector))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IPerformanceCollector))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IPerformanceCollector))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IPerformanceCollector))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IPerformanceCollector methods
     * @{ */
    STDMETHOD(GetMetrics)(ComSafeArrayIn(IN_BSTR, aMetricNames),
                          ComSafeArrayIn(IUnknown *, aObjects),
                          ComSafeArrayOut(IPerformanceMetric *, aMetrics)) RT_OVERRIDE;
    STDMETHOD(SetupMetrics)(ComSafeArrayIn(IN_BSTR, aMetricNames),
                            ComSafeArrayIn(IUnknown *, aObjects),
                            ULONG aPeriod,
                            ULONG aCount,
                            ComSafeArrayOut(IPerformanceMetric *, aAffectedMetrics)) RT_OVERRIDE;
    STDMETHOD(EnableMetrics)(ComSafeArrayIn(IN_BSTR, aMetricNames),
                             ComSafeArrayIn(IUnknown *, aObjects),
                             ComSafeArrayOut(IPerformanceMetric *, aAffectedMetrics)) RT_OVERRIDE;
    STDMETHOD(DisableMetrics)(ComSafeArrayIn(IN_BSTR, aMetricNames),
                              ComSafeArrayIn(IUnknown *, aObjects),
                              ComSafeArrayOut(IPerformanceMetric *, aAffectedMetrics)) RT_OVERRIDE;
    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)) RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1IPerformanceCollector)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IPerformanceCollector)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3IPerformanceCollector)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4IPerformanceCollector)() RT_OVERRIDE;
    /** @} */

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(NATEngineWrap)

    /** @name Public INATEngine properties
     * @{ */
    STDMETHOD(COMGETTER(Network))(BSTR *aNetwork) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Network))(IN_BSTR aNetwork) RT_OVERRIDE;
    STDMETHOD(COMGETTER(HostIP))(BSTR *aHostIP) RT_OVERRIDE;
    STDMETHOD(COMSETTER(HostIP))(IN_BSTR aHostIP) RT_OVERRIDE;
    STDMETHOD(COMGETTER(TFTPPrefix))(BSTR *aTFTPPrefix) RT_OVERRIDE;
    STDMETHOD(COMSETTER(TFTPPrefix))(IN_BSTR aTFTPPrefix) RT_OVERRIDE;
    STDMETHOD(COMGETTER(TFTPBootFile))(BSTR *aTFTPBootFile) RT_OVERRIDE;
    STDMETHOD(COMSETTER(TFTPBootFile))(IN_BSTR aTFTPBootFile) RT_OVERRIDE;
    STDMETHOD(COMGETTER(TFTPNextServer))(BSTR *aTFTPNextServer) RT_OVERRIDE;
    STDMETHOD(COMSETTER(TFTPNextServer))(IN_BSTR aTFTPNextServer) RT_OVERRIDE;
    STDMETHOD(COMGETTER(AliasMode))(ULONG *aAliasMode) RT_OVERRIDE;
    STDMETHOD(COMSETTER(AliasMode))(ULONG aAliasMode) RT_OVERRIDE;
    STDMETHOD(COMGETTER(DNSPassDomain))(BOOL *aDNSPassDomain) RT_OVERRIDE;
    STDMETHOD(COMSETTER(DNSPassDomain))(BOOL aDNSPassDomain) RT_OVERRIDE;
    STDMETHOD(COMGETTER(DNSProxy))(BOOL *aDNSProxy) RT_OVERRIDE;
    STDMETHOD(COMSETTER(DNSProxy))(BOOL aDNSProxy) RT_OVERRIDE;
    STDMETHOD(COMGETTER(DNSUseHostResolver))(BOOL *aDNSUseHostResolver) RT_OVERRIDE;
    STDMETHOD(COMSETTER(DNSUseHostResolver))(BOOL aDNSUseHostResolver) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Redirects))(ComSafeArrayOut(BSTR, aRedirects)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(LocalhostReachable))(BOOL *aLocalhostReachable) RT_OVERRIDE;
    STDMETHOD(COMSETTER(LocalhostReachable))(BOOL aLocalhostReachable) RT_OVERRIDE;
    STDMETHOD(COMGETTER(ForwardBroadcast))(BOOL *aForwardBroadcast) RT_OVERRIDE;
    STDMETHOD(COMSETTER(ForwardBroadcast))(BOOL aForwardBroadcast) RT_OVERRIDE;
    STDMETHOD(COMGETTER(EnableTFTP))(BOOL *aEnableTFTP) RT_OVERRIDE;
    STDMETHOD(COMSETTER(EnableTFTP))(BOOL aEnableTFTP) RT_OVERRIDE;
    STDMETHOD(COMGETTER(NatMRU))(ULONG *aNatMRU) RT_OVERRIDE;
    STDMETHOD(COMSETTER(NatMRU))(ULONG aNatMRU) RT_OVERRIDE;
    STDMETHOD(COMGETTER(IPv6Enabled))(BOOL *aIPv6Enabled) RT_OVERRIDE;
    STDMETHOD(COMSETTER(IPv6Enabled))(BOOL aIPv6Enabled) RT_OVERRIDE;
    STDMETHOD(COMGETTER(IPv6Prefix))(BSTR *aIPv6Prefix) RT_OVERRIDE;
    STDMETHOD(COMSETTER(IPv6Prefix))(IN_BSTR aIPv6Prefix) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1INATEngine))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2INATEngine))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3INATEngine))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4INATEngine))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5INATEngine))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6INATEngine))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public INATEngine methods
     * @{ */
    STDMETHOD(SetNetworkSettings)(ULONG aMtu,
                                  ULONG aSockSnd,
                                  ULONG aSockRcv,
                                  ULONG aTcpWndSnd,
                                  ULONG aTcpWndRcv) RT_OVERRIDE;
    STDMETHOD(GetNetworkSettings)(ULONG *aMtu,
                                  ULONG *aSockSnd,
                                  ULONG *aSockRcv,
                                  ULONG *aTcpWndSnd,
                                  ULONG *aTcpWndRcv) RT_OVERRIDE;
    STDMETHOD(AddRedirect)(IN_BSTR aName,
                           NATProtocol_T aProto,
                           IN_BSTR aHostIP,
                           USHORT aHostPort,
                           IN_BSTR aGuestIP,
                           USHORT aGuestPort) RT_OVERRIDE;
    STDMETHOD(RemoveRedirect)(IN_BSTR aName) RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1INATEngine)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2INATEngine)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3INATEngine)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4INATEngine)() RT_OVERRIDE;
    /** @} */

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;
    virtual HRESULT getLocalhostReachable(BOOL *aLocalhostReachable) = 0;
    virtual HRESULT setLocalhostReachable(BOOL aLocalhostReachable) = 0;
    virtual HRESULT getForwardBroadcast(BOOL *aForwardBroadcast) = 0;
    virtual HRESULT setForwardBroadcast(BOOL aForwardBroadcast) = 0;
    virtual HRESULT getEnableTFTP(BOOL *aEnableTFTP) = 0;
    virtual HRESULT setEnableTFTP(BOOL aEnableTFTP) = 0;
    virtual HRESULT getNatMRU(ULONG *aNatMRU) = 0;
    virtual HRESULT setNatMRU(ULONG aNatMRU) = 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;
    /** @} */

    /** @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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(ExtPackPlugInWrap)

    /** @name Public IExtPackPlugIn properties
     * @{ */
    STDMETHOD(COMGETTER(Name))(BSTR *aName) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Description))(BSTR *aDescription) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Frontend))(BSTR *aFrontend) RT_OVERRIDE;
    STDMETHOD(COMGETTER(ModulePath))(BSTR *aModulePath) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IExtPackPlugIn))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IExtPackPlugIn))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IExtPackPlugIn))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IExtPackPlugIn))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(ExtPackBaseWrap)

    /** @name Public IExtPackBase properties
     * @{ */
    STDMETHOD(COMGETTER(Name))(BSTR *aName) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Description))(BSTR *aDescription) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Version))(BSTR *aVersion) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Revision))(ULONG *aRevision) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Edition))(BSTR *aEdition) RT_OVERRIDE;
    STDMETHOD(COMGETTER(VRDEModule))(BSTR *aVRDEModule) RT_OVERRIDE;
    STDMETHOD(COMGETTER(CryptoModule))(BSTR *aCryptoModule) RT_OVERRIDE;
    STDMETHOD(COMGETTER(PlugIns))(ComSafeArrayOut(IExtPackPlugIn *, aPlugIns)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Usable))(BOOL *aUsable) RT_OVERRIDE;
    STDMETHOD(COMGETTER(WhyUnusable))(BSTR *aWhyUnusable) RT_OVERRIDE;
    STDMETHOD(COMGETTER(ShowLicense))(BOOL *aShowLicense) RT_OVERRIDE;
    STDMETHOD(COMGETTER(License))(BSTR *aLicense) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IExtPackBase))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IExtPackBase))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IExtPackBase))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IExtPackBase))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IExtPackBase))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IExtPackBase))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IExtPackBase))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IExtPackBase))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IExtPackBase methods
     * @{ */
    STDMETHOD(QueryLicense)(IN_BSTR aPreferredLocale,
                            IN_BSTR aPreferredLanguage,
                            IN_BSTR aFormat,
                            BSTR *aLicenseText) RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1IExtPackBase)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IExtPackBase)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3IExtPackBase)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4IExtPackBase)() RT_OVERRIDE;
    /** @} */

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 getCryptoModule(com::Utf8Str &aCryptoModule) = 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(ExtPackWrap)

    /** @name Public IExtPackBase properties
     * @{ */
    STDMETHOD(COMGETTER(Name))(BSTR *aName) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Description))(BSTR *aDescription) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Version))(BSTR *aVersion) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Revision))(ULONG *aRevision) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Edition))(BSTR *aEdition) RT_OVERRIDE;
    STDMETHOD(COMGETTER(VRDEModule))(BSTR *aVRDEModule) RT_OVERRIDE;
    STDMETHOD(COMGETTER(CryptoModule))(BSTR *aCryptoModule) RT_OVERRIDE;
    STDMETHOD(COMGETTER(PlugIns))(ComSafeArrayOut(IExtPackPlugIn *, aPlugIns)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Usable))(BOOL *aUsable) RT_OVERRIDE;
    STDMETHOD(COMGETTER(WhyUnusable))(BSTR *aWhyUnusable) RT_OVERRIDE;
    STDMETHOD(COMGETTER(ShowLicense))(BOOL *aShowLicense) RT_OVERRIDE;
    STDMETHOD(COMGETTER(License))(BSTR *aLicense) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IExtPackBase))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IExtPackBase))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IExtPackBase))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IExtPackBase))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IExtPackBase))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IExtPackBase))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IExtPackBase))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IExtPackBase))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

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

    /** @name Public IExtPackBase methods
     * @{ */
    STDMETHOD(QueryLicense)(IN_BSTR aPreferredLocale,
                            IN_BSTR aPreferredLanguage,
                            IN_BSTR aFormat,
                            BSTR *aLicenseText) RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1IExtPackBase)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IExtPackBase)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3IExtPackBase)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4IExtPackBase)() RT_OVERRIDE;
    /** @} */

    /** @name Public IExtPack methods
     * @{ */
    STDMETHOD(QueryObject)(IN_BSTR aObjUuid,
                           IUnknown **aReturnInterface) RT_OVERRIDE;
    /** @} */

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 getCryptoModule(com::Utf8Str &aCryptoModule) = 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(ExtPackFileWrap)

    /** @name Public IExtPackBase properties
     * @{ */
    STDMETHOD(COMGETTER(Name))(BSTR *aName) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Description))(BSTR *aDescription) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Version))(BSTR *aVersion) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Revision))(ULONG *aRevision) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Edition))(BSTR *aEdition) RT_OVERRIDE;
    STDMETHOD(COMGETTER(VRDEModule))(BSTR *aVRDEModule) RT_OVERRIDE;
    STDMETHOD(COMGETTER(CryptoModule))(BSTR *aCryptoModule) RT_OVERRIDE;
    STDMETHOD(COMGETTER(PlugIns))(ComSafeArrayOut(IExtPackPlugIn *, aPlugIns)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Usable))(BOOL *aUsable) RT_OVERRIDE;
    STDMETHOD(COMGETTER(WhyUnusable))(BSTR *aWhyUnusable) RT_OVERRIDE;
    STDMETHOD(COMGETTER(ShowLicense))(BOOL *aShowLicense) RT_OVERRIDE;
    STDMETHOD(COMGETTER(License))(BSTR *aLicense) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IExtPackBase))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IExtPackBase))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IExtPackBase))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IExtPackBase))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IExtPackBase))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IExtPackBase))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IExtPackBase))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IExtPackBase))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IExtPackFile properties
     * @{ */
    STDMETHOD(COMGETTER(FilePath))(BSTR *aFilePath) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IExtPackFile))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IExtPackFile))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IExtPackFile))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IExtPackFile))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IExtPackBase methods
     * @{ */
    STDMETHOD(QueryLicense)(IN_BSTR aPreferredLocale,
                            IN_BSTR aPreferredLanguage,
                            IN_BSTR aFormat,
                            BSTR *aLicenseText) RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1IExtPackBase)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IExtPackBase)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3IExtPackBase)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4IExtPackBase)() RT_OVERRIDE;
    /** @} */

    /** @name Public IExtPackFile methods
     * @{ */
    STDMETHOD(Install)(BOOL aReplace,
                       IN_BSTR aDisplayInfo,
                       IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1IExtPackFile)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IExtPackFile)() RT_OVERRIDE;
    /** @} */

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 getCryptoModule(com::Utf8Str &aCryptoModule) = 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> &aProgress) = 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(ExtPackManagerWrap)

    /** @name Public IExtPackManager properties
     * @{ */
    STDMETHOD(COMGETTER(InstalledExtPacks))(ComSafeArrayOut(IExtPack *, aInstalledExtPacks)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IExtPackManager))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IExtPackManager))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IExtPackManager))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IExtPackManager))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IExtPackManager))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IExtPackManager))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IExtPackManager))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IExtPackManager))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IExtPackManager methods
     * @{ */
    STDMETHOD(Find)(IN_BSTR aName,
                    IExtPack **aReturnData) RT_OVERRIDE;
    STDMETHOD(OpenExtPackFile)(IN_BSTR aPath,
                               IExtPackFile **aFile) RT_OVERRIDE;
    STDMETHOD(Uninstall)(IN_BSTR aName,
                         BOOL aForcedRemoval,
                         IN_BSTR aDisplayInfo,
                         IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(Cleanup)() RT_OVERRIDE;
    STDMETHOD(QueryAllPlugInsForFrontend)(IN_BSTR aFrontendName,
                                          ComSafeArrayOut(BSTR, aPlugInModules)) RT_OVERRIDE;
    STDMETHOD(IsExtPackUsable)(IN_BSTR aName,
                               BOOL *aUsable) RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1IExtPackManager)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IExtPackManager)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3IExtPackManager)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4IExtPackManager)() RT_OVERRIDE;
    /** @} */

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> &aProgress) = 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(BandwidthGroupWrap)

    /** @name Public IBandwidthGroup properties
     * @{ */
    STDMETHOD(COMGETTER(Name))(BSTR *aName) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Type))(BandwidthGroupType_T *aType) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Reference))(ULONG *aReference) RT_OVERRIDE;
    STDMETHOD(COMGETTER(MaxBytesPerSec))(LONG64 *aMaxBytesPerSec) RT_OVERRIDE;
    STDMETHOD(COMSETTER(MaxBytesPerSec))(LONG64 aMaxBytesPerSec) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IBandwidthGroup))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IBandwidthGroup))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IBandwidthGroup))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IBandwidthGroup))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(BandwidthControlWrap)

    /** @name Public IBandwidthControl properties
     * @{ */
    STDMETHOD(COMGETTER(NumGroups))(ULONG *aNumGroups) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IBandwidthControl))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IBandwidthControl))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IBandwidthControl methods
     * @{ */
    STDMETHOD(CreateBandwidthGroup)(IN_BSTR aName,
                                    BandwidthGroupType_T aType,
                                    LONG64 aMaxBytesPerSec) RT_OVERRIDE;
    STDMETHOD(DeleteBandwidthGroup)(IN_BSTR aName) RT_OVERRIDE;
    STDMETHOD(GetBandwidthGroup)(IN_BSTR aName,
                                 IBandwidthGroup **aBandwidthGroup) RT_OVERRIDE;
    STDMETHOD(GetAllBandwidthGroups)(ComSafeArrayOut(IBandwidthGroup *, aBandwidthGroups)) RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1IBandwidthControl)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IBandwidthControl)() RT_OVERRIDE;
    /** @} */

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 "GuestDebugControlWrap.h"
/** @file
 * VirtualBox API class wrapper header for IGuestDebugControl.
 *
 * 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#ifndef GuestDebugControlWrap_H_
#define GuestDebugControlWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

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

class ATL_NO_VTABLE GuestDebugControlWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IGuestDebugControl)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(GuestDebugControlWrap, IGuestDebugControl)
    DECLARE_NOT_AGGREGATABLE(GuestDebugControlWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(GuestDebugControlWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IGuestDebugControl)
        COM_INTERFACE_ENTRY2(IDispatch, IGuestDebugControl)
        VBOX_TWEAK_INTERFACE_ENTRY(IGuestDebugControl)
    END_COM_MAP()

    DECLARE_COMMON_CLASS_METHODS(GuestDebugControlWrap)

    /** @name Public IGuestDebugControl properties
     * @{ */
    STDMETHOD(COMGETTER(DebugProvider))(GuestDebugProvider_T *aDebugProvider) RT_OVERRIDE;
    STDMETHOD(COMSETTER(DebugProvider))(GuestDebugProvider_T aDebugProvider) RT_OVERRIDE;
    STDMETHOD(COMGETTER(DebugIoProvider))(GuestDebugIoProvider_T *aDebugIoProvider) RT_OVERRIDE;
    STDMETHOD(COMSETTER(DebugIoProvider))(GuestDebugIoProvider_T aDebugIoProvider) RT_OVERRIDE;
    STDMETHOD(COMGETTER(DebugAddress))(BSTR *aDebugAddress) RT_OVERRIDE;
    STDMETHOD(COMSETTER(DebugAddress))(IN_BSTR aDebugAddress) RT_OVERRIDE;
    STDMETHOD(COMGETTER(DebugPort))(ULONG *aDebugPort) RT_OVERRIDE;
    STDMETHOD(COMSETTER(DebugPort))(ULONG aDebugPort) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IGuestDebugControl))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IGuestDebugControl))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IGuestDebugControl methods
     * @{ */
    STDMETHOD(InternalAndReservedMethod1IGuestDebugControl)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IGuestDebugControl)() RT_OVERRIDE;
    /** @} */

private:
    /** @name Wrapped IGuestDebugControl properties
     * @{ */
    virtual HRESULT getDebugProvider(GuestDebugProvider_T *aDebugProvider) = 0;
    virtual HRESULT setDebugProvider(GuestDebugProvider_T aDebugProvider) = 0;
    virtual HRESULT getDebugIoProvider(GuestDebugIoProvider_T *aDebugIoProvider) = 0;
    virtual HRESULT setDebugIoProvider(GuestDebugIoProvider_T aDebugIoProvider) = 0;
    virtual HRESULT getDebugAddress(com::Utf8Str &aDebugAddress) = 0;
    virtual HRESULT setDebugAddress(const com::Utf8Str &aDebugAddress) = 0;
    virtual HRESULT getDebugPort(ULONG *aDebugPort) = 0;
    virtual HRESULT setDebugPort(ULONG aDebugPort) = 0;
    /** @} */

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

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

};

#endif // !GuestDebugControlWrap_H_

// ##### ENDFILE "GuestDebugControlWrap.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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(VirtualBoxClientWrap)

    /** @name Public IVirtualBoxClient properties
     * @{ */
    STDMETHOD(COMGETTER(VirtualBox))(IVirtualBox **aVirtualBox) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Session))(ISession **aSession) RT_OVERRIDE;
    STDMETHOD(COMGETTER(EventSource))(IEventSource **aEventSource) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IVirtualBoxClient))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IVirtualBoxClient))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IVirtualBoxClient))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IVirtualBoxClient))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IVirtualBoxClient methods
     * @{ */
    STDMETHOD(CheckMachineError)(IMachine *aMachine) RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1IVirtualBoxClient)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IVirtualBoxClient)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3IVirtualBoxClient)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4IVirtualBoxClient)() RT_OVERRIDE;
    /** @} */

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(EventSourceWrap)

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

    /** @name Public IEventSource methods
     * @{ */
    STDMETHOD(CreateListener)(IEventListener **aListener) RT_OVERRIDE;
    STDMETHOD(CreateAggregator)(ComSafeArrayIn(IEventSource *, aSubordinates),
                                IEventSource **aResult) RT_OVERRIDE;
    STDMETHOD(RegisterListener)(IEventListener *aListener,
                                ComSafeArrayIn(VBoxEventType_T, aInteresting),
                                BOOL aActive) RT_OVERRIDE;
    STDMETHOD(UnregisterListener)(IEventListener *aListener) RT_OVERRIDE;
    STDMETHOD(FireEvent)(IEvent *aEvent,
                         LONG aTimeout,
                         BOOL *aResult) RT_OVERRIDE;
    STDMETHOD(GetEvent)(IEventListener *aListener,
                        LONG aTimeout,
                        IEvent **aEvent) RT_OVERRIDE;
    STDMETHOD(EventProcessed)(IEventListener *aListener,
                              IEvent *aEvent) RT_OVERRIDE;
    /** @} */

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(EventListenerWrap)

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

    /** @name Public IEventListener methods
     * @{ */
    STDMETHOD(HandleEvent)(IEvent *aEvent) RT_OVERRIDE;
    /** @} */

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(EventWrap)

    /** @name Public IEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Type))(VBoxEventType_T *aType) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Source))(IEventSource **aSource) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Waitable))(BOOL *aWaitable) RT_OVERRIDE;
    /** @} */

    /** @name Public IEvent methods
     * @{ */
    STDMETHOD(SetProcessed)() RT_OVERRIDE;
    STDMETHOD(WaitProcessed)(LONG aTimeout,
                             BOOL *aResult) RT_OVERRIDE;
    /** @} */

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(ReusableEventWrap)

    /** @name Public IEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Type))(VBoxEventType_T *aType) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Source))(IEventSource **aSource) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Waitable))(BOOL *aWaitable) RT_OVERRIDE;
    /** @} */

    /** @name Public IReusableEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Generation))(ULONG *aGeneration) RT_OVERRIDE;
    /** @} */

    /** @name Public IEvent methods
     * @{ */
    STDMETHOD(SetProcessed)() RT_OVERRIDE;
    STDMETHOD(WaitProcessed)(LONG aTimeout,
                             BOOL *aResult) RT_OVERRIDE;
    /** @} */

    /** @name Public IReusableEvent methods
     * @{ */
    STDMETHOD(Reuse)() RT_OVERRIDE;
    /** @} */

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(MachineEventWrap)

    /** @name Public IEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Type))(VBoxEventType_T *aType) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Source))(IEventSource **aSource) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Waitable))(BOOL *aWaitable) RT_OVERRIDE;
    /** @} */

    /** @name Public IMachineEvent properties
     * @{ */
    STDMETHOD(COMGETTER(MachineId))(BSTR *aMachineId) RT_OVERRIDE;
    /** @} */

    /** @name Public IEvent methods
     * @{ */
    STDMETHOD(SetProcessed)() RT_OVERRIDE;
    STDMETHOD(WaitProcessed)(LONG aTimeout,
                             BOOL *aResult) RT_OVERRIDE;
    /** @} */

    /** @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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(SnapshotEventWrap)

    /** @name Public IEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Type))(VBoxEventType_T *aType) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Source))(IEventSource **aSource) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Waitable))(BOOL *aWaitable) RT_OVERRIDE;
    /** @} */

    /** @name Public IMachineEvent properties
     * @{ */
    STDMETHOD(COMGETTER(MachineId))(BSTR *aMachineId) RT_OVERRIDE;
    /** @} */

    /** @name Public ISnapshotEvent properties
     * @{ */
    STDMETHOD(COMGETTER(SnapshotId))(BSTR *aSnapshotId) RT_OVERRIDE;
    /** @} */

    /** @name Public IEvent methods
     * @{ */
    STDMETHOD(SetProcessed)() RT_OVERRIDE;
    STDMETHOD(WaitProcessed)(LONG aTimeout,
                             BOOL *aResult) RT_OVERRIDE;
    /** @} */

    /** @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 "ClipboardEventWrap.h"
/** @file
 * VirtualBox API class wrapper header for IClipboardEvent.
 *
 * 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#ifndef ClipboardEventWrap_H_
#define ClipboardEventWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

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

class ATL_NO_VTABLE ClipboardEventWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IClipboardEvent)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(ClipboardEventWrap, IClipboardEvent)
    DECLARE_NOT_AGGREGATABLE(ClipboardEventWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(ClipboardEventWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IClipboardEvent)
        COM_INTERFACE_ENTRY(IEvent)
        COM_INTERFACE_ENTRY2(IDispatch, IClipboardEvent)
        VBOX_TWEAK_INTERFACE_ENTRY(IClipboardEvent)
    END_COM_MAP()

    DECLARE_COMMON_CLASS_METHODS(ClipboardEventWrap)

    /** @name Public IEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Type))(VBoxEventType_T *aType) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Source))(IEventSource **aSource) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Waitable))(BOOL *aWaitable) RT_OVERRIDE;
    /** @} */

    /** @name Public IClipboardEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Id))(BSTR *aId) RT_OVERRIDE;
    /** @} */

    /** @name Public IEvent methods
     * @{ */
    STDMETHOD(SetProcessed)() RT_OVERRIDE;
    STDMETHOD(WaitProcessed)(LONG aTimeout,
                             BOOL *aResult) RT_OVERRIDE;
    /** @} */

    /** @name Public IClipboardEvent 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 IClipboardEvent properties
     * @{ */
    virtual HRESULT getId(com::Utf8Str &aId) = 0;
    /** @} */

    /** @name Wrapped IEvent methods
     * @{ */
    virtual HRESULT setProcessed() = 0;
    virtual HRESULT waitProcessed(LONG aTimeout,
                                  BOOL *aResult) = 0;
    /** @} */

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

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

};

#endif // !ClipboardEventWrap_H_

// ##### ENDFILE "ClipboardEventWrap.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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(GuestSessionEventWrap)

    /** @name Public IEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Type))(VBoxEventType_T *aType) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Source))(IEventSource **aSource) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Waitable))(BOOL *aWaitable) RT_OVERRIDE;
    /** @} */

    /** @name Public IGuestSessionEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Session))(IGuestSession **aSession) RT_OVERRIDE;
    /** @} */

    /** @name Public IEvent methods
     * @{ */
    STDMETHOD(SetProcessed)() RT_OVERRIDE;
    STDMETHOD(WaitProcessed)(LONG aTimeout,
                             BOOL *aResult) RT_OVERRIDE;
    /** @} */

    /** @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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(GuestProcessEventWrap)

    /** @name Public IEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Type))(VBoxEventType_T *aType) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Source))(IEventSource **aSource) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Waitable))(BOOL *aWaitable) RT_OVERRIDE;
    /** @} */

    /** @name Public IGuestSessionEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Session))(IGuestSession **aSession) RT_OVERRIDE;
    /** @} */

    /** @name Public IGuestProcessEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Process))(IGuestProcess **aProcess) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Pid))(ULONG *aPid) RT_OVERRIDE;
    /** @} */

    /** @name Public IEvent methods
     * @{ */
    STDMETHOD(SetProcessed)() RT_OVERRIDE;
    STDMETHOD(WaitProcessed)(LONG aTimeout,
                             BOOL *aResult) RT_OVERRIDE;
    /** @} */

    /** @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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(GuestProcessIOEventWrap)

    /** @name Public IEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Type))(VBoxEventType_T *aType) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Source))(IEventSource **aSource) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Waitable))(BOOL *aWaitable) RT_OVERRIDE;
    /** @} */

    /** @name Public IGuestSessionEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Session))(IGuestSession **aSession) RT_OVERRIDE;
    /** @} */

    /** @name Public IGuestProcessEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Process))(IGuestProcess **aProcess) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Pid))(ULONG *aPid) RT_OVERRIDE;
    /** @} */

    /** @name Public IGuestProcessIOEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Handle))(ULONG *aHandle) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Processed))(ULONG *aProcessed) RT_OVERRIDE;
    /** @} */

    /** @name Public IEvent methods
     * @{ */
    STDMETHOD(SetProcessed)() RT_OVERRIDE;
    STDMETHOD(WaitProcessed)(LONG aTimeout,
                             BOOL *aResult) RT_OVERRIDE;
    /** @} */

    /** @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 "GuestDirectoryEventWrap.h"
/** @file
 * VirtualBox API class wrapper header for IGuestDirectoryEvent.
 *
 * 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#ifndef GuestDirectoryEventWrap_H_
#define GuestDirectoryEventWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

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

class ATL_NO_VTABLE GuestDirectoryEventWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IGuestDirectoryEvent)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(GuestDirectoryEventWrap, IGuestDirectoryEvent)
    DECLARE_NOT_AGGREGATABLE(GuestDirectoryEventWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(GuestDirectoryEventWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IGuestDirectoryEvent)
        COM_INTERFACE_ENTRY(IGuestSessionEvent)
        COM_INTERFACE_ENTRY(IEvent)
        COM_INTERFACE_ENTRY2(IDispatch, IGuestDirectoryEvent)
        VBOX_TWEAK_INTERFACE_ENTRY(IGuestDirectoryEvent)
    END_COM_MAP()

    DECLARE_COMMON_CLASS_METHODS(GuestDirectoryEventWrap)

    /** @name Public IEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Type))(VBoxEventType_T *aType) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Source))(IEventSource **aSource) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Waitable))(BOOL *aWaitable) RT_OVERRIDE;
    /** @} */

    /** @name Public IGuestSessionEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Session))(IGuestSession **aSession) RT_OVERRIDE;
    /** @} */

    /** @name Public IGuestDirectoryEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Directory))(IGuestDirectory **aDirectory) RT_OVERRIDE;
    /** @} */

    /** @name Public IEvent methods
     * @{ */
    STDMETHOD(SetProcessed)() RT_OVERRIDE;
    STDMETHOD(WaitProcessed)(LONG aTimeout,
                             BOOL *aResult) RT_OVERRIDE;
    /** @} */

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

    /** @name Public IGuestDirectoryEvent 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 IGuestDirectoryEvent properties
     * @{ */
    virtual HRESULT getDirectory(ComPtr<IGuestDirectory> &aDirectory) = 0;
    /** @} */

    /** @name Wrapped IEvent methods
     * @{ */
    virtual HRESULT setProcessed() = 0;
    virtual HRESULT waitProcessed(LONG aTimeout,
                                  BOOL *aResult) = 0;
    /** @} */

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

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

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

};

#endif // !GuestDirectoryEventWrap_H_

// ##### ENDFILE "GuestDirectoryEventWrap.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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(GuestFileEventWrap)

    /** @name Public IEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Type))(VBoxEventType_T *aType) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Source))(IEventSource **aSource) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Waitable))(BOOL *aWaitable) RT_OVERRIDE;
    /** @} */

    /** @name Public IGuestSessionEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Session))(IGuestSession **aSession) RT_OVERRIDE;
    /** @} */

    /** @name Public IGuestFileEvent properties
     * @{ */
    STDMETHOD(COMGETTER(File))(IGuestFile **aFile) RT_OVERRIDE;
    /** @} */

    /** @name Public IEvent methods
     * @{ */
    STDMETHOD(SetProcessed)() RT_OVERRIDE;
    STDMETHOD(WaitProcessed)(LONG aTimeout,
                             BOOL *aResult) RT_OVERRIDE;
    /** @} */

    /** @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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(GuestFileIOEventWrap)

    /** @name Public IEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Type))(VBoxEventType_T *aType) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Source))(IEventSource **aSource) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Waitable))(BOOL *aWaitable) RT_OVERRIDE;
    /** @} */

    /** @name Public IGuestSessionEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Session))(IGuestSession **aSession) RT_OVERRIDE;
    /** @} */

    /** @name Public IGuestFileEvent properties
     * @{ */
    STDMETHOD(COMGETTER(File))(IGuestFile **aFile) RT_OVERRIDE;
    /** @} */

    /** @name Public IGuestFileIOEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Offset))(LONG64 *aOffset) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Processed))(ULONG *aProcessed) RT_OVERRIDE;
    /** @} */

    /** @name Public IEvent methods
     * @{ */
    STDMETHOD(SetProcessed)() RT_OVERRIDE;
    STDMETHOD(WaitProcessed)(LONG aTimeout,
                             BOOL *aResult) RT_OVERRIDE;
    /** @} */

    /** @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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(VetoEventWrap)

    /** @name Public IEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Type))(VBoxEventType_T *aType) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Source))(IEventSource **aSource) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Waitable))(BOOL *aWaitable) RT_OVERRIDE;
    /** @} */

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

    /** @name Public IEvent methods
     * @{ */
    STDMETHOD(SetProcessed)() RT_OVERRIDE;
    STDMETHOD(WaitProcessed)(LONG aTimeout,
                             BOOL *aResult) RT_OVERRIDE;
    /** @} */

    /** @name Public IVetoEvent methods
     * @{ */
    STDMETHOD(AddVeto)(IN_BSTR aReason) RT_OVERRIDE;
    STDMETHOD(IsVetoed)(BOOL *aResult) RT_OVERRIDE;
    STDMETHOD(GetVetos)(ComSafeArrayOut(BSTR, aResult)) RT_OVERRIDE;
    STDMETHOD(AddApproval)(IN_BSTR aReason) RT_OVERRIDE;
    STDMETHOD(IsApproved)(BOOL *aResult) RT_OVERRIDE;
    STDMETHOD(GetApprovals)(ComSafeArrayOut(BSTR, aResult)) RT_OVERRIDE;
    /** @} */

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(ProgressEventWrap)

    /** @name Public IEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Type))(VBoxEventType_T *aType) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Source))(IEventSource **aSource) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Waitable))(BOOL *aWaitable) RT_OVERRIDE;
    /** @} */

    /** @name Public IProgressEvent properties
     * @{ */
    STDMETHOD(COMGETTER(ProgressId))(BSTR *aProgressId) RT_OVERRIDE;
    /** @} */

    /** @name Public IEvent methods
     * @{ */
    STDMETHOD(SetProcessed)() RT_OVERRIDE;
    STDMETHOD(WaitProcessed)(LONG aTimeout,
                             BOOL *aResult) RT_OVERRIDE;
    /** @} */

    /** @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 "UpdateAgentEventWrap.h"
/** @file
 * VirtualBox API class wrapper header for IUpdateAgentEvent.
 *
 * 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#ifndef UpdateAgentEventWrap_H_
#define UpdateAgentEventWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

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

class ATL_NO_VTABLE UpdateAgentEventWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IUpdateAgentEvent)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(UpdateAgentEventWrap, IUpdateAgentEvent)
    DECLARE_NOT_AGGREGATABLE(UpdateAgentEventWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(UpdateAgentEventWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IUpdateAgentEvent)
        COM_INTERFACE_ENTRY(IEvent)
        COM_INTERFACE_ENTRY2(IDispatch, IUpdateAgentEvent)
        VBOX_TWEAK_INTERFACE_ENTRY(IUpdateAgentEvent)
    END_COM_MAP()

    DECLARE_COMMON_CLASS_METHODS(UpdateAgentEventWrap)

    /** @name Public IEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Type))(VBoxEventType_T *aType) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Source))(IEventSource **aSource) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Waitable))(BOOL *aWaitable) RT_OVERRIDE;
    /** @} */

    /** @name Public IUpdateAgentEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Agent))(IUpdateAgent **aAgent) RT_OVERRIDE;
    /** @} */

    /** @name Public IEvent methods
     * @{ */
    STDMETHOD(SetProcessed)() RT_OVERRIDE;
    STDMETHOD(WaitProcessed)(LONG aTimeout,
                             BOOL *aResult) RT_OVERRIDE;
    /** @} */

    /** @name Public IUpdateAgentEvent 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 IUpdateAgentEvent properties
     * @{ */
    virtual HRESULT getAgent(ComPtr<IUpdateAgent> &aAgent) = 0;
    /** @} */

    /** @name Wrapped IEvent methods
     * @{ */
    virtual HRESULT setProcessed() = 0;
    virtual HRESULT waitProcessed(LONG aTimeout,
                                  BOOL *aResult) = 0;
    /** @} */

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

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

};

#endif // !UpdateAgentEventWrap_H_

// ##### ENDFILE "UpdateAgentEventWrap.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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(StringArrayWrap)

    /** @name Public IStringArray properties
     * @{ */
    STDMETHOD(COMGETTER(Values))(ComSafeArrayOut(BSTR, aValues)) RT_OVERRIDE;
    /** @} */

    /** @name Public IStringArray methods
     * @{ */
    STDMETHOD(InternalAndReservedMethod1IStringArray)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IStringArray)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3IStringArray)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4IStringArray)() RT_OVERRIDE;
    /** @} */

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(FormValueWrap)

    /** @name Public IFormValue properties
     * @{ */
    STDMETHOD(COMGETTER(Type))(FormValueType_T *aType) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Generation))(LONG *aGeneration) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Enabled))(BOOL *aEnabled) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Visible))(BOOL *aVisible) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Label))(BSTR *aLabel) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Description))(BSTR *aDescription) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Help))(BSTR *aHelp) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IFormValue methods
     * @{ */
    STDMETHOD(InternalAndReservedMethod1IFormValue)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IFormValue)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3IFormValue)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4IFormValue)() RT_OVERRIDE;
    /** @} */

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(BooleanFormValueWrap)

    /** @name Public IFormValue properties
     * @{ */
    STDMETHOD(COMGETTER(Type))(FormValueType_T *aType) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Generation))(LONG *aGeneration) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Enabled))(BOOL *aEnabled) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Visible))(BOOL *aVisible) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Label))(BSTR *aLabel) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Description))(BSTR *aDescription) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Help))(BSTR *aHelp) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IBooleanFormValue properties
     * @{ */
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IBooleanFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IBooleanFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IBooleanFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IBooleanFormValue))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IFormValue methods
     * @{ */
    STDMETHOD(InternalAndReservedMethod1IFormValue)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IFormValue)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3IFormValue)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4IFormValue)() RT_OVERRIDE;
    /** @} */

    /** @name Public IBooleanFormValue methods
     * @{ */
    STDMETHOD(GetSelected)(BOOL *aSelected) RT_OVERRIDE;
    STDMETHOD(SetSelected)(BOOL aSelected,
                           IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1IBooleanFormValue)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IBooleanFormValue)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3IBooleanFormValue)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4IBooleanFormValue)() RT_OVERRIDE;
    /** @} */

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(RangedIntegerFormValueWrap)

    /** @name Public IFormValue properties
     * @{ */
    STDMETHOD(COMGETTER(Type))(FormValueType_T *aType) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Generation))(LONG *aGeneration) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Enabled))(BOOL *aEnabled) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Visible))(BOOL *aVisible) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Label))(BSTR *aLabel) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Description))(BSTR *aDescription) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Help))(BSTR *aHelp) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IRangedIntegerFormValue properties
     * @{ */
    STDMETHOD(COMGETTER(Suffix))(BSTR *aSuffix) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Minimum))(LONG *aMinimum) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Maximum))(LONG *aMaximum) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IRangedIntegerFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IRangedIntegerFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IRangedIntegerFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IRangedIntegerFormValue))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IFormValue methods
     * @{ */
    STDMETHOD(InternalAndReservedMethod1IFormValue)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IFormValue)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3IFormValue)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4IFormValue)() RT_OVERRIDE;
    /** @} */

    /** @name Public IRangedIntegerFormValue methods
     * @{ */
    STDMETHOD(GetInteger)(LONG *aValue) RT_OVERRIDE;
    STDMETHOD(SetInteger)(LONG aValue,
                          IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1IRangedIntegerFormValue)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IRangedIntegerFormValue)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3IRangedIntegerFormValue)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4IRangedIntegerFormValue)() RT_OVERRIDE;
    /** @} */

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 "RangedInteger64FormValueWrap.h"
/** @file
 * VirtualBox API class wrapper header for IRangedInteger64FormValue.
 *
 * 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#ifndef RangedInteger64FormValueWrap_H_
#define RangedInteger64FormValueWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

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

class ATL_NO_VTABLE RangedInteger64FormValueWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(IRangedInteger64FormValue)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(RangedInteger64FormValueWrap, IRangedInteger64FormValue)
    DECLARE_NOT_AGGREGATABLE(RangedInteger64FormValueWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(RangedInteger64FormValueWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(IRangedInteger64FormValue)
        COM_INTERFACE_ENTRY(IFormValue)
        COM_INTERFACE_ENTRY2(IDispatch, IRangedInteger64FormValue)
        VBOX_TWEAK_INTERFACE_ENTRY(IRangedInteger64FormValue)
    END_COM_MAP()

    DECLARE_COMMON_CLASS_METHODS(RangedInteger64FormValueWrap)

    /** @name Public IFormValue properties
     * @{ */
    STDMETHOD(COMGETTER(Type))(FormValueType_T *aType) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Generation))(LONG *aGeneration) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Enabled))(BOOL *aEnabled) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Visible))(BOOL *aVisible) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Label))(BSTR *aLabel) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Description))(BSTR *aDescription) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Help))(BSTR *aHelp) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IRangedInteger64FormValue properties
     * @{ */
    STDMETHOD(COMGETTER(Suffix))(BSTR *aSuffix) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Minimum))(LONG64 *aMinimum) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Maximum))(LONG64 *aMaximum) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IRangedInteger64FormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IRangedInteger64FormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IRangedInteger64FormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IRangedInteger64FormValue))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IFormValue methods
     * @{ */
    STDMETHOD(InternalAndReservedMethod1IFormValue)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IFormValue)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3IFormValue)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4IFormValue)() RT_OVERRIDE;
    /** @} */

    /** @name Public IRangedInteger64FormValue methods
     * @{ */
    STDMETHOD(GetInteger)(LONG64 *aValue) RT_OVERRIDE;
    STDMETHOD(SetInteger)(LONG64 aValue,
                          IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1IRangedInteger64FormValue)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IRangedInteger64FormValue)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3IRangedInteger64FormValue)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4IRangedInteger64FormValue)() RT_OVERRIDE;
    /** @} */

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 IRangedInteger64FormValue properties
     * @{ */
    virtual HRESULT getSuffix(com::Utf8Str &aSuffix) = 0;
    virtual HRESULT getMinimum(LONG64 *aMinimum) = 0;
    virtual HRESULT getMaximum(LONG64 *aMaximum) = 0;
    /** @} */

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

    /** @name Wrapped IRangedInteger64FormValue methods
     * @{ */
    virtual HRESULT getInteger(LONG64 *aValue) = 0;
    virtual HRESULT setInteger(LONG64 aValue,
                               ComPtr<IProgress> &aProgress) = 0;
    /** @} */

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

};

#endif // !RangedInteger64FormValueWrap_H_

// ##### ENDFILE "RangedInteger64FormValueWrap.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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(StringFormValueWrap)

    /** @name Public IFormValue properties
     * @{ */
    STDMETHOD(COMGETTER(Type))(FormValueType_T *aType) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Generation))(LONG *aGeneration) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Enabled))(BOOL *aEnabled) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Visible))(BOOL *aVisible) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Label))(BSTR *aLabel) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Description))(BSTR *aDescription) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Help))(BSTR *aHelp) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IStringFormValue properties
     * @{ */
    STDMETHOD(COMGETTER(Multiline))(BOOL *aMultiline) RT_OVERRIDE;
    STDMETHOD(COMGETTER(ClipboardString))(BSTR *aClipboardString) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IStringFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IStringFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IStringFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IStringFormValue))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IFormValue methods
     * @{ */
    STDMETHOD(InternalAndReservedMethod1IFormValue)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IFormValue)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3IFormValue)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4IFormValue)() RT_OVERRIDE;
    /** @} */

    /** @name Public IStringFormValue methods
     * @{ */
    STDMETHOD(GetString)(BSTR *aText) RT_OVERRIDE;
    STDMETHOD(SetString)(IN_BSTR aText,
                         IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1IStringFormValue)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IStringFormValue)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3IStringFormValue)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4IStringFormValue)() RT_OVERRIDE;
    /** @} */

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;
    virtual HRESULT getClipboardString(com::Utf8Str &aClipboardString) = 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(ChoiceFormValueWrap)

    /** @name Public IFormValue properties
     * @{ */
    STDMETHOD(COMGETTER(Type))(FormValueType_T *aType) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Generation))(LONG *aGeneration) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Enabled))(BOOL *aEnabled) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Visible))(BOOL *aVisible) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Label))(BSTR *aLabel) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Description))(BSTR *aDescription) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Help))(BSTR *aHelp) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8IFormValue))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IChoiceFormValue properties
     * @{ */
    STDMETHOD(COMGETTER(Values))(ComSafeArrayOut(BSTR, aValues)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IChoiceFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IChoiceFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IChoiceFormValue))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IChoiceFormValue))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IFormValue methods
     * @{ */
    STDMETHOD(InternalAndReservedMethod1IFormValue)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IFormValue)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3IFormValue)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4IFormValue)() RT_OVERRIDE;
    /** @} */

    /** @name Public IChoiceFormValue methods
     * @{ */
    STDMETHOD(GetSelectedIndex)(LONG *aIndex) RT_OVERRIDE;
    STDMETHOD(SetSelectedIndex)(LONG aIndex,
                                IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1IChoiceFormValue)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IChoiceFormValue)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3IChoiceFormValue)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4IChoiceFormValue)() RT_OVERRIDE;
    /** @} */

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(FormWrap)

    /** @name Public IForm properties
     * @{ */
    STDMETHOD(COMGETTER(Values))(ComSafeArrayOut(IFormValue *, aValues)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IForm))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IForm))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IForm))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IForm))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IForm methods
     * @{ */
    STDMETHOD(GetFieldGroup)(IN_BSTR aField,
                             ComSafeArrayOut(BSTR, aGroup)) RT_OVERRIDE;
    STDMETHOD(Apply)(IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1IForm)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IForm)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3IForm)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4IForm)() RT_OVERRIDE;
    /** @} */

private:
    /** @name Wrapped IForm properties
     * @{ */
    virtual HRESULT getValues(std::vector<ComPtr<IFormValue> > &aValues) = 0;
    /** @} */

    /** @name Wrapped IForm methods
     * @{ */
    virtual HRESULT getFieldGroup(const com::Utf8Str &aField,
                                  std::vector<com::Utf8Str> &aGroup) = 0;
    virtual HRESULT apply(ComPtr<IProgress> &aProgress) = 0;
    /** @} */

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(VirtualSystemDescriptionFormWrap)

    /** @name Public IForm properties
     * @{ */
    STDMETHOD(COMGETTER(Values))(ComSafeArrayOut(IFormValue *, aValues)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IForm))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IForm))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IForm))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IForm))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IVirtualSystemDescriptionForm properties
     * @{ */
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1IVirtualSystemDescriptionForm))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2IVirtualSystemDescriptionForm))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3IVirtualSystemDescriptionForm))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4IVirtualSystemDescriptionForm))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public IForm methods
     * @{ */
    STDMETHOD(GetFieldGroup)(IN_BSTR aField,
                             ComSafeArrayOut(BSTR, aGroup)) RT_OVERRIDE;
    STDMETHOD(Apply)(IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1IForm)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IForm)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3IForm)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4IForm)() RT_OVERRIDE;
    /** @} */

    /** @name Public IVirtualSystemDescriptionForm methods
     * @{ */
    STDMETHOD(GetVirtualSystemDescription)(IVirtualSystemDescription **aDescription) RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1IVirtualSystemDescriptionForm)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2IVirtualSystemDescriptionForm)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3IVirtualSystemDescriptionForm)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4IVirtualSystemDescriptionForm)() RT_OVERRIDE;
    /** @} */

private:
    /** @name Wrapped IForm properties
     * @{ */
    virtual HRESULT getValues(std::vector<ComPtr<IFormValue> > &aValues) = 0;
    /** @} */

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

    /** @name Wrapped IForm methods
     * @{ */
    virtual HRESULT getFieldGroup(const com::Utf8Str &aField,
                                  std::vector<com::Utf8Str> &aGroup) = 0;
    virtual HRESULT apply(ComPtr<IProgress> &aProgress) = 0;
    /** @} */

    /** @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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(CloudNetworkGatewayInfoWrap)

    /** @name Public ICloudNetworkGatewayInfo properties
     * @{ */
    STDMETHOD(COMGETTER(PublicIP))(BSTR *aPublicIP) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SecondaryPublicIP))(BSTR *aSecondaryPublicIP) RT_OVERRIDE;
    STDMETHOD(COMGETTER(MacAddress))(BSTR *aMacAddress) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InstanceId))(BSTR *aInstanceId) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1ICloudNetworkGatewayInfo))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2ICloudNetworkGatewayInfo))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3ICloudNetworkGatewayInfo))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4ICloudNetworkGatewayInfo))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5ICloudNetworkGatewayInfo))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(CloudNetworkEnvironmentInfoWrap)

    /** @name Public ICloudNetworkEnvironmentInfo properties
     * @{ */
    STDMETHOD(COMGETTER(TunnelNetworkId))(BSTR *aTunnelNetworkId) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1ICloudNetworkEnvironmentInfo))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2ICloudNetworkEnvironmentInfo))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3ICloudNetworkEnvironmentInfo))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4ICloudNetworkEnvironmentInfo))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5ICloudNetworkEnvironmentInfo))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6ICloudNetworkEnvironmentInfo))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7ICloudNetworkEnvironmentInfo))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @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 "CloudMachineWrap.h"
/** @file
 * VirtualBox API class wrapper header for ICloudMachine.
 *
 * 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#ifndef CloudMachineWrap_H_
#define CloudMachineWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

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

class ATL_NO_VTABLE CloudMachineWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(ICloudMachine)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(CloudMachineWrap, ICloudMachine)
    DECLARE_NOT_AGGREGATABLE(CloudMachineWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(CloudMachineWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(ICloudMachine)
        COM_INTERFACE_ENTRY2(IDispatch, ICloudMachine)
        VBOX_TWEAK_INTERFACE_ENTRY(ICloudMachine)
    END_COM_MAP()

    DECLARE_COMMON_CLASS_METHODS(CloudMachineWrap)

    /** @name Public ICloudMachine properties
     * @{ */
    STDMETHOD(COMGETTER(Id))(BSTR *aId) RT_OVERRIDE;
    STDMETHOD(COMGETTER(CloudId))(BSTR *aCloudId) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Accessible))(BOOL *aAccessible) RT_OVERRIDE;
    STDMETHOD(COMGETTER(AccessError))(IVirtualBoxErrorInfo **aAccessError) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Name))(BSTR *aName) RT_OVERRIDE;
    STDMETHOD(COMGETTER(OSTypeId))(BSTR *aOSTypeId) RT_OVERRIDE;
    STDMETHOD(COMGETTER(State))(CloudMachineState_T *aState) RT_OVERRIDE;
    STDMETHOD(COMGETTER(ConsoleConnectionFingerprint))(BSTR *aConsoleConnectionFingerprint) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SerialConsoleCommand))(BSTR *aSerialConsoleCommand) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SerialConsoleCommandWindows))(BSTR *aSerialConsoleCommandWindows) RT_OVERRIDE;
    STDMETHOD(COMGETTER(VNCConsoleCommand))(BSTR *aVNCConsoleCommand) RT_OVERRIDE;
    STDMETHOD(COMGETTER(VNCConsoleCommandWindows))(BSTR *aVNCConsoleCommandWindows) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1ICloudMachine))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2ICloudMachine))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3ICloudMachine))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4ICloudMachine))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5ICloudMachine))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6ICloudMachine))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7ICloudMachine))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public ICloudMachine methods
     * @{ */
    STDMETHOD(Refresh)(IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(GetDetailsForm)(IForm **aForm) RT_OVERRIDE;
    STDMETHOD(GetSettingsForm)(IForm **aForm,
                               IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(PowerUp)(IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(Reboot)(IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(Reset)(IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(Shutdown)(IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(PowerDown)(IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(Terminate)(IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(Unregister)(IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(Remove)(IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(GetConsoleHistory)(IDataStream **aStream,
                                 IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(CreateConsoleConnection)(IN_BSTR aSshPublicKey,
                                       IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(DeleteConsoleConnection)(IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(ListMetricNames)(IStringArray **aMetricNames,
                               IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(EnumerateMetricData)(MetricType_T aMetricType,
                                   ULONG aPointsNumber,
                                   IStringArray **aValues,
                                   IStringArray **aTimestamps,
                                   IStringArray **aUnit,
                                   IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1ICloudMachine)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2ICloudMachine)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3ICloudMachine)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4ICloudMachine)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod5ICloudMachine)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod6ICloudMachine)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod7ICloudMachine)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod8ICloudMachine)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod9ICloudMachine)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod10ICloudMachine)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod11ICloudMachine)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod12ICloudMachine)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod13ICloudMachine)() RT_OVERRIDE;
    /** @} */

private:
    /** @name Wrapped ICloudMachine properties
     * @{ */
    virtual HRESULT getId(com::Guid &aId) = 0;
    virtual HRESULT getCloudId(com::Utf8Str &aCloudId) = 0;
    virtual HRESULT getAccessible(BOOL *aAccessible) = 0;
    virtual HRESULT getAccessError(ComPtr<IVirtualBoxErrorInfo> &aAccessError) = 0;
    virtual HRESULT getName(com::Utf8Str &aName) = 0;
    virtual HRESULT getOSTypeId(com::Utf8Str &aOSTypeId) = 0;
    virtual HRESULT getState(CloudMachineState_T *aState) = 0;
    virtual HRESULT getConsoleConnectionFingerprint(com::Utf8Str &aConsoleConnectionFingerprint) = 0;
    virtual HRESULT getSerialConsoleCommand(com::Utf8Str &aSerialConsoleCommand) = 0;
    virtual HRESULT getSerialConsoleCommandWindows(com::Utf8Str &aSerialConsoleCommandWindows) = 0;
    virtual HRESULT getVNCConsoleCommand(com::Utf8Str &aVNCConsoleCommand) = 0;
    virtual HRESULT getVNCConsoleCommandWindows(com::Utf8Str &aVNCConsoleCommandWindows) = 0;
    /** @} */

    /** @name Wrapped ICloudMachine methods
     * @{ */
    virtual HRESULT refresh(ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT getDetailsForm(ComPtr<IForm> &aForm) = 0;
    virtual HRESULT getSettingsForm(ComPtr<IForm> &aForm,
                                    ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT powerUp(ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT reboot(ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT reset(ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT shutdown(ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT powerDown(ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT terminate(ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT unregister(AutoCaller &aAutoCaller,
                               ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT remove(AutoCaller &aAutoCaller,
                           ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT getConsoleHistory(ComPtr<IDataStream> &aStream,
                                      ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT createConsoleConnection(const com::Utf8Str &aSshPublicKey,
                                            ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT deleteConsoleConnection(ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT listMetricNames(ComPtr<IStringArray> &aMetricNames,
                                    ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT enumerateMetricData(MetricType_T aMetricType,
                                        ULONG aPointsNumber,
                                        ComPtr<IStringArray> &aValues,
                                        ComPtr<IStringArray> &aTimestamps,
                                        ComPtr<IStringArray> &aUnit,
                                        ComPtr<IProgress> &aProgress) = 0;
    /** @} */

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

};

#endif // !CloudMachineWrap_H_

// ##### ENDFILE "CloudMachineWrap.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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(CloudClientWrap)

    /** @name Public ICloudClient properties
     * @{ */
    STDMETHOD(COMGETTER(CloudMachineList))(ComSafeArrayOut(ICloudMachine *, aCloudMachineList)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(CloudMachineStubList))(ComSafeArrayOut(ICloudMachine *, aCloudMachineStubList)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1ICloudClient))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2ICloudClient))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3ICloudClient))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4ICloudClient))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5ICloudClient))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6ICloudClient))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7ICloudClient))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8ICloudClient))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public ICloudClient methods
     * @{ */
    STDMETHOD(GetExportDescriptionForm)(IVirtualSystemDescription *aDescription,
                                        IVirtualSystemDescriptionForm **aForm,
                                        IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(ExportVM)(IVirtualSystemDescription *aDescription,
                        IProgress *aProgress) RT_OVERRIDE;
    STDMETHOD(GetLaunchDescriptionForm)(IVirtualSystemDescription *aDescription,
                                        IVirtualSystemDescriptionForm **aForm,
                                        IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(LaunchVM)(IVirtualSystemDescription *aDescription,
                        IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(GetImportDescriptionForm)(IVirtualSystemDescription *aDescription,
                                        IVirtualSystemDescriptionForm **aForm,
                                        IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(ImportInstance)(IVirtualSystemDescription *aDescription,
                              IProgress *aProgress) RT_OVERRIDE;
    STDMETHOD(GetCloudMachine)(IN_BSTR aId,
                               ICloudMachine **aMachine) RT_OVERRIDE;
    STDMETHOD(ReadCloudMachineList)(IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(ReadCloudMachineStubList)(IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(AddCloudMachine)(IN_BSTR aInstanceId,
                               ICloudMachine **aMachine,
                               IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(CreateCloudMachine)(IVirtualSystemDescription *aDescription,
                                  ICloudMachine **aMachine,
                                  IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(ListInstances)(ComSafeArrayIn(CloudMachineState_T, aMachineState),
                             IStringArray **aReturnNames,
                             IStringArray **aReturnIds,
                             IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(ListSourceInstances)(IStringArray **aReturnNames,
                                   IStringArray **aReturnIds,
                                   IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(ListImages)(ComSafeArrayIn(CloudImageState_T, aImageState),
                          IStringArray **aReturnNames,
                          IStringArray **aReturnIds,
                          IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(ListBootVolumes)(IStringArray **aReturnNames,
                               IStringArray **aReturnIds,
                               IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(ListSourceBootVolumes)(IStringArray **aReturnNames,
                                     IStringArray **aReturnIds,
                                     IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(ListVnicAttachments)(ComSafeArrayIn(IN_BSTR, aParameters),
                                   IStringArray **aReturnVnicAttachmentIds,
                                   IStringArray **aReturnVnicIds,
                                   IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(GetInstanceInfo)(IN_BSTR aUid,
                               IVirtualSystemDescription *aDescription,
                               IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(StartInstance)(IN_BSTR aUid,
                             IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(PauseInstance)(IN_BSTR aUid,
                             IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(TerminateInstance)(IN_BSTR aUid,
                                 IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(ResetInstance)(IN_BSTR aUid,
                             IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(CloneInstance)(IN_BSTR aUid,
                             IN_BSTR aNewName,
                             ICloudMachine **aClone,
                             IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(CreateImage)(ComSafeArrayIn(IN_BSTR, aParameters),
                           IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(ExportImage)(IMedium *aImage,
                           ComSafeArrayIn(IN_BSTR, aParameters),
                           IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(ImportImage)(IN_BSTR aUid,
                           ComSafeArrayIn(IN_BSTR, aParameters),
                           IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(DeleteImage)(IN_BSTR aUid,
                           IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(GetImageInfo)(IN_BSTR aUid,
                            IStringArray **aInfoArray,
                            IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(StartCloudNetworkGateway)(ICloudNetwork *aNetwork,
                                        IN_BSTR aSshPublicKey,
                                        ICloudNetworkGatewayInfo **aGatewayInfo,
                                        IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(SetupCloudNetworkEnvironment)(IN_BSTR aTunnelNetworkName,
                                            IN_BSTR aTunnelNetworkRange,
                                            IN_BSTR aGatewayOsName,
                                            IN_BSTR aGatewayOsVersion,
                                            IN_BSTR aGatewayShape,
                                            ICloudNetworkEnvironmentInfo **aNetworkEnvironmentInfo,
                                            IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(GetVnicInfo)(IN_BSTR aUid,
                           IStringArray **aInfoArray,
                           IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(GetSubnetSelectionForm)(IVirtualSystemDescription *aDescription,
                                      IVirtualSystemDescriptionForm **aForm,
                                      IProgress **aProgress) RT_OVERRIDE;
    STDMETHOD(GetMetricTypeByName)(IN_BSTR aMetricName,
                                   MetricType_T *aMetricType) RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1ICloudClient)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2ICloudClient)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3ICloudClient)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4ICloudClient)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod5ICloudClient)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod6ICloudClient)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod7ICloudClient)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod8ICloudClient)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod9ICloudClient)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod10ICloudClient)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod11ICloudClient)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod12ICloudClient)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod13ICloudClient)() RT_OVERRIDE;
    /** @} */

private:
    /** @name Wrapped ICloudClient properties
     * @{ */
    virtual HRESULT getCloudMachineList(std::vector<ComPtr<ICloudMachine> > &aCloudMachineList) = 0;
    virtual HRESULT getCloudMachineStubList(std::vector<ComPtr<ICloudMachine> > &aCloudMachineStubList) = 0;
    /** @} */

    /** @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 getCloudMachine(const com::Guid &aId,
                                    ComPtr<ICloudMachine> &aMachine) = 0;
    virtual HRESULT readCloudMachineList(ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT readCloudMachineStubList(ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT addCloudMachine(const com::Utf8Str &aInstanceId,
                                    ComPtr<ICloudMachine> &aMachine,
                                    ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT createCloudMachine(const ComPtr<IVirtualSystemDescription> &aDescription,
                                       ComPtr<ICloudMachine> &aMachine,
                                       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 listSourceInstances(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 listBootVolumes(ComPtr<IStringArray> &aReturnNames,
                                    ComPtr<IStringArray> &aReturnIds,
                                    ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT listSourceBootVolumes(ComPtr<IStringArray> &aReturnNames,
                                          ComPtr<IStringArray> &aReturnIds,
                                          ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT listVnicAttachments(const std::vector<com::Utf8Str> &aParameters,
                                        ComPtr<IStringArray> &aReturnVnicAttachmentIds,
                                        ComPtr<IStringArray> &aReturnVnicIds,
                                        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 resetInstance(const com::Utf8Str &aUid,
                                  ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT cloneInstance(const com::Utf8Str &aUid,
                                  const com::Utf8Str &aNewName,
                                  ComPtr<ICloudMachine> &aClone,
                                  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;
    virtual HRESULT getVnicInfo(const com::Utf8Str &aUid,
                                ComPtr<IStringArray> &aInfoArray,
                                ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT getSubnetSelectionForm(const ComPtr<IVirtualSystemDescription> &aDescription,
                                           ComPtr<IVirtualSystemDescriptionForm> &aForm,
                                           ComPtr<IProgress> &aProgress) = 0;
    virtual HRESULT getMetricTypeByName(const com::Utf8Str &aMetricName,
                                        MetricType_T *aMetricType) = 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(CloudProfileWrap)

    /** @name Public ICloudProfile properties
     * @{ */
    STDMETHOD(COMGETTER(Name))(BSTR *aName) RT_OVERRIDE;
    STDMETHOD(COMSETTER(Name))(IN_BSTR aName) RT_OVERRIDE;
    STDMETHOD(COMGETTER(ProviderId))(BSTR *aProviderId) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1ICloudProfile))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2ICloudProfile))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3ICloudProfile))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4ICloudProfile))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5ICloudProfile))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6ICloudProfile))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7ICloudProfile))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8ICloudProfile))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public ICloudProfile methods
     * @{ */
    STDMETHOD(GetProperty)(IN_BSTR aName,
                           BSTR *aValue) RT_OVERRIDE;
    STDMETHOD(SetProperty)(IN_BSTR aName,
                           IN_BSTR aValue) RT_OVERRIDE;
    STDMETHOD(GetProperties)(IN_BSTR aNames,
                             ComSafeArrayOut(BSTR, aReturnNames),
                             ComSafeArrayOut(BSTR, aReturnValues)) RT_OVERRIDE;
    STDMETHOD(SetProperties)(ComSafeArrayIn(IN_BSTR, aNames),
                             ComSafeArrayIn(IN_BSTR, aValues)) RT_OVERRIDE;
    STDMETHOD(Remove)() RT_OVERRIDE;
    STDMETHOD(CreateCloudClient)(ICloudClient **aCloudClient) RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1ICloudProfile)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2ICloudProfile)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3ICloudProfile)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4ICloudProfile)() RT_OVERRIDE;
    /** @} */

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(CloudProviderWrap)

    /** @name Public ICloudProvider properties
     * @{ */
    STDMETHOD(COMGETTER(Name))(BSTR *aName) RT_OVERRIDE;
    STDMETHOD(COMGETTER(ShortName))(BSTR *aShortName) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Id))(BSTR *aId) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Profiles))(ComSafeArrayOut(ICloudProfile *, aProfiles)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(ProfileNames))(ComSafeArrayOut(BSTR, aProfileNames)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(SupportedPropertyNames))(ComSafeArrayOut(BSTR, aSupportedPropertyNames)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1ICloudProvider))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2ICloudProvider))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3ICloudProvider))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4ICloudProvider))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5ICloudProvider))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6ICloudProvider))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7ICloudProvider))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8ICloudProvider))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute9ICloudProvider))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute10ICloudProvider))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute11ICloudProvider))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute12ICloudProvider))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute13ICloudProvider))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute14ICloudProvider))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute15ICloudProvider))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute16ICloudProvider))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public ICloudProvider methods
     * @{ */
    STDMETHOD(GetPropertyDescription)(IN_BSTR aName,
                                      BSTR *aDescription) RT_OVERRIDE;
    STDMETHOD(CreateProfile)(IN_BSTR aProfileName,
                             ComSafeArrayIn(IN_BSTR, aNames),
                             ComSafeArrayIn(IN_BSTR, aValues)) RT_OVERRIDE;
    STDMETHOD(ImportProfiles)() RT_OVERRIDE;
    STDMETHOD(RestoreProfiles)() RT_OVERRIDE;
    STDMETHOD(SaveProfiles)() RT_OVERRIDE;
    STDMETHOD(GetProfileByName)(IN_BSTR aProfileName,
                                ICloudProfile **aProfile) RT_OVERRIDE;
    STDMETHOD(PrepareUninstall)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1ICloudProvider)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2ICloudProvider)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3ICloudProvider)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4ICloudProvider)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod5ICloudProvider)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod6ICloudProvider)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod7ICloudProvider)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod8ICloudProvider)() RT_OVERRIDE;
    /** @} */

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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#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_COMMON_CLASS_METHODS(CloudProviderManagerWrap)

    /** @name Public ICloudProviderManager properties
     * @{ */
    STDMETHOD(COMGETTER(Providers))(ComSafeArrayOut(ICloudProvider *, aProviders)) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute1ICloudProviderManager))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute2ICloudProviderManager))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute3ICloudProviderManager))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute4ICloudProviderManager))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute5ICloudProviderManager))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute6ICloudProviderManager))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute7ICloudProviderManager))(ULONG *aReserved) RT_OVERRIDE;
    STDMETHOD(COMGETTER(InternalAndReservedAttribute8ICloudProviderManager))(ULONG *aReserved) RT_OVERRIDE;
    /** @} */

    /** @name Public ICloudProviderManager methods
     * @{ */
    STDMETHOD(GetProviderById)(IN_BSTR aProviderId,
                               ICloudProvider **aProvider) RT_OVERRIDE;
    STDMETHOD(GetProviderByShortName)(IN_BSTR aProviderName,
                                      ICloudProvider **aProvider) RT_OVERRIDE;
    STDMETHOD(GetProviderByName)(IN_BSTR aProviderName,
                                 ICloudProvider **aProvider) RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod1ICloudProviderManager)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod2ICloudProviderManager)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod3ICloudProviderManager)() RT_OVERRIDE;
    STDMETHOD(InternalAndReservedMethod4ICloudProviderManager)() RT_OVERRIDE;
    /** @} */

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"


// ##### BEGINFILE "CloudProfileRegisteredEventWrap.h"
/** @file
 * VirtualBox API class wrapper header for ICloudProfileRegisteredEvent.
 *
 * 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#ifndef CloudProfileRegisteredEventWrap_H_
#define CloudProfileRegisteredEventWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

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

class ATL_NO_VTABLE CloudProfileRegisteredEventWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(ICloudProfileRegisteredEvent)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(CloudProfileRegisteredEventWrap, ICloudProfileRegisteredEvent)
    DECLARE_NOT_AGGREGATABLE(CloudProfileRegisteredEventWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(CloudProfileRegisteredEventWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(ICloudProfileRegisteredEvent)
        COM_INTERFACE_ENTRY(IEvent)
        COM_INTERFACE_ENTRY2(IDispatch, ICloudProfileRegisteredEvent)
        VBOX_TWEAK_INTERFACE_ENTRY(ICloudProfileRegisteredEvent)
    END_COM_MAP()

    DECLARE_COMMON_CLASS_METHODS(CloudProfileRegisteredEventWrap)

    /** @name Public IEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Type))(VBoxEventType_T *aType) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Source))(IEventSource **aSource) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Waitable))(BOOL *aWaitable) RT_OVERRIDE;
    /** @} */

    /** @name Public ICloudProfileRegisteredEvent properties
     * @{ */
    STDMETHOD(COMGETTER(ProviderId))(BSTR *aProviderId) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Name))(BSTR *aName) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Registered))(BOOL *aRegistered) RT_OVERRIDE;
    /** @} */

    /** @name Public IEvent methods
     * @{ */
    STDMETHOD(SetProcessed)() RT_OVERRIDE;
    STDMETHOD(WaitProcessed)(LONG aTimeout,
                             BOOL *aResult) RT_OVERRIDE;
    /** @} */

    /** @name Public ICloudProfileRegisteredEvent 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 ICloudProfileRegisteredEvent properties
     * @{ */
    virtual HRESULT getProviderId(com::Guid &aProviderId) = 0;
    virtual HRESULT getName(com::Utf8Str &aName) = 0;
    virtual HRESULT getRegistered(BOOL *aRegistered) = 0;
    /** @} */

    /** @name Wrapped IEvent methods
     * @{ */
    virtual HRESULT setProcessed() = 0;
    virtual HRESULT waitProcessed(LONG aTimeout,
                                  BOOL *aResult) = 0;
    /** @} */

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

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

};

#endif // !CloudProfileRegisteredEventWrap_H_

// ##### ENDFILE "CloudProfileRegisteredEventWrap.h"


// ##### BEGINFILE "CloudProfileChangedEventWrap.h"
/** @file
 * VirtualBox API class wrapper header for ICloudProfileChangedEvent.
 *
 * 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-2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * SPDX-License-Identifier: GPL-3.0-only
 */

#ifndef CloudProfileChangedEventWrap_H_
#define CloudProfileChangedEventWrap_H_
#ifndef RT_WITHOUT_PRAGMA_ONCE
# pragma once
#endif

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

class ATL_NO_VTABLE CloudProfileChangedEventWrap
    : public VirtualBoxBase
    , VBOX_SCRIPTABLE_IMPL(ICloudProfileChangedEvent)
{
    Q_OBJECT

public:
    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(CloudProfileChangedEventWrap, ICloudProfileChangedEvent)
    DECLARE_NOT_AGGREGATABLE(CloudProfileChangedEventWrap)
    DECLARE_PROTECT_FINAL_CONSTRUCT()

    BEGIN_COM_MAP(CloudProfileChangedEventWrap)
        COM_INTERFACE_ENTRY(ISupportErrorInfo)
        COM_INTERFACE_ENTRY(ICloudProfileChangedEvent)
        COM_INTERFACE_ENTRY(IEvent)
        COM_INTERFACE_ENTRY2(IDispatch, ICloudProfileChangedEvent)
        VBOX_TWEAK_INTERFACE_ENTRY(ICloudProfileChangedEvent)
    END_COM_MAP()

    DECLARE_COMMON_CLASS_METHODS(CloudProfileChangedEventWrap)

    /** @name Public IEvent properties
     * @{ */
    STDMETHOD(COMGETTER(Type))(VBoxEventType_T *aType) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Source))(IEventSource **aSource) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Waitable))(BOOL *aWaitable) RT_OVERRIDE;
    /** @} */

    /** @name Public ICloudProfileChangedEvent properties
     * @{ */
    STDMETHOD(COMGETTER(ProviderId))(BSTR *aProviderId) RT_OVERRIDE;
    STDMETHOD(COMGETTER(Name))(BSTR *aName) RT_OVERRIDE;
    /** @} */

    /** @name Public IEvent methods
     * @{ */
    STDMETHOD(SetProcessed)() RT_OVERRIDE;
    STDMETHOD(WaitProcessed)(LONG aTimeout,
                             BOOL *aResult) RT_OVERRIDE;
    /** @} */

    /** @name Public ICloudProfileChangedEvent 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 ICloudProfileChangedEvent properties
     * @{ */
    virtual HRESULT getProviderId(com::Guid &aProviderId) = 0;
    virtual HRESULT getName(com::Utf8Str &aName) = 0;
    /** @} */

    /** @name Wrapped IEvent methods
     * @{ */
    virtual HRESULT setProcessed() = 0;
    virtual HRESULT waitProcessed(LONG aTimeout,
                                  BOOL *aResult) = 0;
    /** @} */

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

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

};

#endif // !CloudProfileChangedEventWrap_H_

// ##### ENDFILE "CloudProfileChangedEventWrap.h"
