// C++/WinRT v2.0.190620.2

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.

#ifndef WINRT_Windows_Media_Protection_0_H
#define WINRT_Windows_Media_Protection_0_H
namespace winrt::Windows::Foundation
{
    struct EventRegistrationToken;
    template <typename TSender, typename TResult> struct TypedEventHandler;
}
namespace winrt::Windows::Foundation::Collections
{
    struct IPropertySet;
}
namespace winrt::Windows::Media::Playback
{
    struct MediaPlaybackItem;
}
namespace winrt::Windows::Media::Protection
{
    enum class GraphicsTrustStatus : int32_t
    {
        TrustNotRequired = 0,
        TrustEstablished = 1,
        EnvironmentNotSupported = 2,
        DriverNotSupported = 3,
        DriverSigningFailure = 4,
        UnknownFailure = 5,
    };
    enum class HdcpProtection : int32_t
    {
        Off = 0,
        On = 1,
        OnWithTypeEnforcement = 2,
    };
    enum class HdcpSetProtectionResult : int32_t
    {
        Success = 0,
        TimedOut = 1,
        NotSupported = 2,
        UnknownFailure = 3,
    };
    enum class ProtectionCapabilityResult : int32_t
    {
        NotSupported = 0,
        Maybe = 1,
        Probably = 2,
    };
    enum class RenewalStatus : int32_t
    {
        NotStarted = 0,
        UpdatesInProgress = 1,
        UserCancelled = 2,
        AppComponentsMayNeedUpdating = 3,
        NoComponentsFound = 4,
    };
    enum class RevocationAndRenewalReasons : uint32_t
    {
        UserModeComponentLoad = 0x1,
        KernelModeComponentLoad = 0x2,
        AppComponent = 0x4,
        GlobalRevocationListLoadFailed = 0x10,
        InvalidGlobalRevocationListSignature = 0x20,
        GlobalRevocationListAbsent = 0x1000,
        ComponentRevoked = 0x2000,
        InvalidComponentCertificateExtendedKeyUse = 0x4000,
        ComponentCertificateRevoked = 0x8000,
        InvalidComponentCertificateRoot = 0x10000,
        ComponentHighSecurityCertificateRevoked = 0x20000,
        ComponentLowSecurityCertificateRevoked = 0x40000,
        BootDriverVerificationFailed = 0x100000,
        ComponentSignedWithTestCertificate = 0x1000000,
        EncryptionFailure = 0x10000000,
    };
    struct IComponentLoadFailedEventArgs;
    struct IComponentRenewalStatics;
    struct IHdcpSession;
    struct IMediaProtectionManager;
    struct IMediaProtectionPMPServer;
    struct IMediaProtectionPMPServerFactory;
    struct IMediaProtectionServiceCompletion;
    struct IMediaProtectionServiceRequest;
    struct IProtectionCapabilities;
    struct IRevocationAndRenewalInformation;
    struct IRevocationAndRenewalItem;
    struct IServiceRequestedEventArgs;
    struct IServiceRequestedEventArgs2;
    struct ComponentLoadFailedEventArgs;
    struct ComponentRenewal;
    struct HdcpSession;
    struct MediaProtectionManager;
    struct MediaProtectionPMPServer;
    struct MediaProtectionServiceCompletion;
    struct ProtectionCapabilities;
    struct RevocationAndRenewalInformation;
    struct RevocationAndRenewalItem;
    struct ServiceRequestedEventArgs;
    struct ComponentLoadFailedEventHandler;
    struct RebootNeededEventHandler;
    struct ServiceRequestedEventHandler;
}
namespace winrt::impl
{
    template <> struct category<Windows::Media::Protection::IComponentLoadFailedEventArgs>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Media::Protection::IComponentRenewalStatics>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Media::Protection::IHdcpSession>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Media::Protection::IMediaProtectionManager>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Media::Protection::IMediaProtectionPMPServer>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Media::Protection::IMediaProtectionPMPServerFactory>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Media::Protection::IMediaProtectionServiceCompletion>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Media::Protection::IMediaProtectionServiceRequest>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Media::Protection::IProtectionCapabilities>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Media::Protection::IRevocationAndRenewalInformation>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Media::Protection::IRevocationAndRenewalItem>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Media::Protection::IServiceRequestedEventArgs>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Media::Protection::IServiceRequestedEventArgs2>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Media::Protection::ComponentLoadFailedEventArgs>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Media::Protection::ComponentRenewal>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Media::Protection::HdcpSession>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Media::Protection::MediaProtectionManager>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Media::Protection::MediaProtectionPMPServer>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Media::Protection::MediaProtectionServiceCompletion>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Media::Protection::ProtectionCapabilities>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Media::Protection::RevocationAndRenewalInformation>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Media::Protection::RevocationAndRenewalItem>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Media::Protection::ServiceRequestedEventArgs>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Media::Protection::GraphicsTrustStatus>
    {
        using type = enum_category;
    };
    template <> struct category<Windows::Media::Protection::HdcpProtection>
    {
        using type = enum_category;
    };
    template <> struct category<Windows::Media::Protection::HdcpSetProtectionResult>
    {
        using type = enum_category;
    };
    template <> struct category<Windows::Media::Protection::ProtectionCapabilityResult>
    {
        using type = enum_category;
    };
    template <> struct category<Windows::Media::Protection::RenewalStatus>
    {
        using type = enum_category;
    };
    template <> struct category<Windows::Media::Protection::RevocationAndRenewalReasons>
    {
        using type = enum_category;
    };
    template <> struct category<Windows::Media::Protection::ComponentLoadFailedEventHandler>
    {
        using type = delegate_category;
    };
    template <> struct category<Windows::Media::Protection::RebootNeededEventHandler>
    {
        using type = delegate_category;
    };
    template <> struct category<Windows::Media::Protection::ServiceRequestedEventHandler>
    {
        using type = delegate_category;
    };
    template <> struct name<Windows::Media::Protection::IComponentLoadFailedEventArgs>
    {
        static constexpr auto & value{ L"Windows.Media.Protection.IComponentLoadFailedEventArgs" };
    };
    template <> struct name<Windows::Media::Protection::IComponentRenewalStatics>
    {
        static constexpr auto & value{ L"Windows.Media.Protection.IComponentRenewalStatics" };
    };
    template <> struct name<Windows::Media::Protection::IHdcpSession>
    {
        static constexpr auto & value{ L"Windows.Media.Protection.IHdcpSession" };
    };
    template <> struct name<Windows::Media::Protection::IMediaProtectionManager>
    {
        static constexpr auto & value{ L"Windows.Media.Protection.IMediaProtectionManager" };
    };
    template <> struct name<Windows::Media::Protection::IMediaProtectionPMPServer>
    {
        static constexpr auto & value{ L"Windows.Media.Protection.IMediaProtectionPMPServer" };
    };
    template <> struct name<Windows::Media::Protection::IMediaProtectionPMPServerFactory>
    {
        static constexpr auto & value{ L"Windows.Media.Protection.IMediaProtectionPMPServerFactory" };
    };
    template <> struct name<Windows::Media::Protection::IMediaProtectionServiceCompletion>
    {
        static constexpr auto & value{ L"Windows.Media.Protection.IMediaProtectionServiceCompletion" };
    };
    template <> struct name<Windows::Media::Protection::IMediaProtectionServiceRequest>
    {
        static constexpr auto & value{ L"Windows.Media.Protection.IMediaProtectionServiceRequest" };
    };
    template <> struct name<Windows::Media::Protection::IProtectionCapabilities>
    {
        static constexpr auto & value{ L"Windows.Media.Protection.IProtectionCapabilities" };
    };
    template <> struct name<Windows::Media::Protection::IRevocationAndRenewalInformation>
    {
        static constexpr auto & value{ L"Windows.Media.Protection.IRevocationAndRenewalInformation" };
    };
    template <> struct name<Windows::Media::Protection::IRevocationAndRenewalItem>
    {
        static constexpr auto & value{ L"Windows.Media.Protection.IRevocationAndRenewalItem" };
    };
    template <> struct name<Windows::Media::Protection::IServiceRequestedEventArgs>
    {
        static constexpr auto & value{ L"Windows.Media.Protection.IServiceRequestedEventArgs" };
    };
    template <> struct name<Windows::Media::Protection::IServiceRequestedEventArgs2>
    {
        static constexpr auto & value{ L"Windows.Media.Protection.IServiceRequestedEventArgs2" };
    };
    template <> struct name<Windows::Media::Protection::ComponentLoadFailedEventArgs>
    {
        static constexpr auto & value{ L"Windows.Media.Protection.ComponentLoadFailedEventArgs" };
    };
    template <> struct name<Windows::Media::Protection::ComponentRenewal>
    {
        static constexpr auto & value{ L"Windows.Media.Protection.ComponentRenewal" };
    };
    template <> struct name<Windows::Media::Protection::HdcpSession>
    {
        static constexpr auto & value{ L"Windows.Media.Protection.HdcpSession" };
    };
    template <> struct name<Windows::Media::Protection::MediaProtectionManager>
    {
        static constexpr auto & value{ L"Windows.Media.Protection.MediaProtectionManager" };
    };
    template <> struct name<Windows::Media::Protection::MediaProtectionPMPServer>
    {
        static constexpr auto & value{ L"Windows.Media.Protection.MediaProtectionPMPServer" };
    };
    template <> struct name<Windows::Media::Protection::MediaProtectionServiceCompletion>
    {
        static constexpr auto & value{ L"Windows.Media.Protection.MediaProtectionServiceCompletion" };
    };
    template <> struct name<Windows::Media::Protection::ProtectionCapabilities>
    {
        static constexpr auto & value{ L"Windows.Media.Protection.ProtectionCapabilities" };
    };
    template <> struct name<Windows::Media::Protection::RevocationAndRenewalInformation>
    {
        static constexpr auto & value{ L"Windows.Media.Protection.RevocationAndRenewalInformation" };
    };
    template <> struct name<Windows::Media::Protection::RevocationAndRenewalItem>
    {
        static constexpr auto & value{ L"Windows.Media.Protection.RevocationAndRenewalItem" };
    };
    template <> struct name<Windows::Media::Protection::ServiceRequestedEventArgs>
    {
        static constexpr auto & value{ L"Windows.Media.Protection.ServiceRequestedEventArgs" };
    };
    template <> struct name<Windows::Media::Protection::GraphicsTrustStatus>
    {
        static constexpr auto & value{ L"Windows.Media.Protection.GraphicsTrustStatus" };
    };
    template <> struct name<Windows::Media::Protection::HdcpProtection>
    {
        static constexpr auto & value{ L"Windows.Media.Protection.HdcpProtection" };
    };
    template <> struct name<Windows::Media::Protection::HdcpSetProtectionResult>
    {
        static constexpr auto & value{ L"Windows.Media.Protection.HdcpSetProtectionResult" };
    };
    template <> struct name<Windows::Media::Protection::ProtectionCapabilityResult>
    {
        static constexpr auto & value{ L"Windows.Media.Protection.ProtectionCapabilityResult" };
    };
    template <> struct name<Windows::Media::Protection::RenewalStatus>
    {
        static constexpr auto & value{ L"Windows.Media.Protection.RenewalStatus" };
    };
    template <> struct name<Windows::Media::Protection::RevocationAndRenewalReasons>
    {
        static constexpr auto & value{ L"Windows.Media.Protection.RevocationAndRenewalReasons" };
    };
    template <> struct name<Windows::Media::Protection::ComponentLoadFailedEventHandler>
    {
        static constexpr auto & value{ L"Windows.Media.Protection.ComponentLoadFailedEventHandler" };
    };
    template <> struct name<Windows::Media::Protection::RebootNeededEventHandler>
    {
        static constexpr auto & value{ L"Windows.Media.Protection.RebootNeededEventHandler" };
    };
    template <> struct name<Windows::Media::Protection::ServiceRequestedEventHandler>
    {
        static constexpr auto & value{ L"Windows.Media.Protection.ServiceRequestedEventHandler" };
    };
    template <> struct guid_storage<Windows::Media::Protection::IComponentLoadFailedEventArgs>
    {
        static constexpr guid value{ 0x95972E93,0x7746,0x417E,{ 0x84,0x95,0xF0,0x31,0xBB,0xC5,0x86,0x2C } };
    };
    template <> struct guid_storage<Windows::Media::Protection::IComponentRenewalStatics>
    {
        static constexpr guid value{ 0x6FFBCD67,0xB795,0x48C5,{ 0x8B,0x7B,0xA7,0xC4,0xEF,0xE2,0x02,0xE3 } };
    };
    template <> struct guid_storage<Windows::Media::Protection::IHdcpSession>
    {
        static constexpr guid value{ 0x718845E9,0x64D7,0x426D,{ 0x80,0x9B,0x1B,0xE4,0x61,0x94,0x1A,0x2A } };
    };
    template <> struct guid_storage<Windows::Media::Protection::IMediaProtectionManager>
    {
        static constexpr guid value{ 0x45694947,0xC741,0x434B,{ 0xA7,0x9E,0x47,0x4C,0x12,0xD9,0x3D,0x2F } };
    };
    template <> struct guid_storage<Windows::Media::Protection::IMediaProtectionPMPServer>
    {
        static constexpr guid value{ 0x0C111226,0x7B26,0x4D31,{ 0x95,0xBB,0x9C,0x1B,0x08,0xEF,0x7F,0xC0 } };
    };
    template <> struct guid_storage<Windows::Media::Protection::IMediaProtectionPMPServerFactory>
    {
        static constexpr guid value{ 0x602C8E5E,0xF7D2,0x487E,{ 0xAF,0x91,0xDB,0xC4,0x25,0x2B,0x21,0x82 } };
    };
    template <> struct guid_storage<Windows::Media::Protection::IMediaProtectionServiceCompletion>
    {
        static constexpr guid value{ 0x8B5CCA18,0xCFD5,0x44EE,{ 0xA2,0xED,0xDF,0x76,0x01,0x0C,0x14,0xB5 } };
    };
    template <> struct guid_storage<Windows::Media::Protection::IMediaProtectionServiceRequest>
    {
        static constexpr guid value{ 0xB1DE0EA6,0x2094,0x478D,{ 0x87,0xA4,0x8B,0x95,0x20,0x0F,0x85,0xC6 } };
    };
    template <> struct guid_storage<Windows::Media::Protection::IProtectionCapabilities>
    {
        static constexpr guid value{ 0xC7AC5D7E,0x7480,0x4D29,{ 0xA4,0x64,0x7B,0xCD,0x91,0x3D,0xD8,0xE4 } };
    };
    template <> struct guid_storage<Windows::Media::Protection::IRevocationAndRenewalInformation>
    {
        static constexpr guid value{ 0xF3A1937B,0x2501,0x439E,{ 0xA6,0xE7,0x6F,0xC9,0x5E,0x17,0x5F,0xCF } };
    };
    template <> struct guid_storage<Windows::Media::Protection::IRevocationAndRenewalItem>
    {
        static constexpr guid value{ 0x3099C20C,0x3CF0,0x49EA,{ 0x90,0x2D,0xCA,0xF3,0x2D,0x2D,0xDE,0x2C } };
    };
    template <> struct guid_storage<Windows::Media::Protection::IServiceRequestedEventArgs>
    {
        static constexpr guid value{ 0x34283BAF,0xABB4,0x4FC1,{ 0xBD,0x89,0x93,0xF1,0x06,0x57,0x3A,0x49 } };
    };
    template <> struct guid_storage<Windows::Media::Protection::IServiceRequestedEventArgs2>
    {
        static constexpr guid value{ 0x553C69D6,0xFAFE,0x4128,{ 0x8D,0xFA,0x13,0x0E,0x39,0x8A,0x13,0xA7 } };
    };
    template <> struct guid_storage<Windows::Media::Protection::ComponentLoadFailedEventHandler>
    {
        static constexpr guid value{ 0x95DA643C,0x6DB9,0x424B,{ 0x86,0xCA,0x09,0x1A,0xF4,0x32,0x08,0x1C } };
    };
    template <> struct guid_storage<Windows::Media::Protection::RebootNeededEventHandler>
    {
        static constexpr guid value{ 0x64E12A45,0x973B,0x4A3A,{ 0xB2,0x60,0x91,0x89,0x8A,0x49,0xA8,0x2C } };
    };
    template <> struct guid_storage<Windows::Media::Protection::ServiceRequestedEventHandler>
    {
        static constexpr guid value{ 0xD2D690BA,0xCAC9,0x48E1,{ 0x95,0xC0,0xD3,0x84,0x95,0xA8,0x40,0x55 } };
    };
    template <> struct default_interface<Windows::Media::Protection::ComponentLoadFailedEventArgs>
    {
        using type = Windows::Media::Protection::IComponentLoadFailedEventArgs;
    };
    template <> struct default_interface<Windows::Media::Protection::HdcpSession>
    {
        using type = Windows::Media::Protection::IHdcpSession;
    };
    template <> struct default_interface<Windows::Media::Protection::MediaProtectionManager>
    {
        using type = Windows::Media::Protection::IMediaProtectionManager;
    };
    template <> struct default_interface<Windows::Media::Protection::MediaProtectionPMPServer>
    {
        using type = Windows::Media::Protection::IMediaProtectionPMPServer;
    };
    template <> struct default_interface<Windows::Media::Protection::MediaProtectionServiceCompletion>
    {
        using type = Windows::Media::Protection::IMediaProtectionServiceCompletion;
    };
    template <> struct default_interface<Windows::Media::Protection::ProtectionCapabilities>
    {
        using type = Windows::Media::Protection::IProtectionCapabilities;
    };
    template <> struct default_interface<Windows::Media::Protection::RevocationAndRenewalInformation>
    {
        using type = Windows::Media::Protection::IRevocationAndRenewalInformation;
    };
    template <> struct default_interface<Windows::Media::Protection::RevocationAndRenewalItem>
    {
        using type = Windows::Media::Protection::IRevocationAndRenewalItem;
    };
    template <> struct default_interface<Windows::Media::Protection::ServiceRequestedEventArgs>
    {
        using type = Windows::Media::Protection::IServiceRequestedEventArgs;
    };
    template <> struct abi<Windows::Media::Protection::IComponentLoadFailedEventArgs>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_Information(void**) noexcept = 0;
            virtual int32_t __stdcall get_Completion(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Media::Protection::IComponentRenewalStatics>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall RenewSystemComponentsAsync(void*, void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Media::Protection::IHdcpSession>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall IsEffectiveProtectionAtLeast(int32_t, bool*) noexcept = 0;
            virtual int32_t __stdcall GetEffectiveProtection(void**) noexcept = 0;
            virtual int32_t __stdcall SetDesiredMinProtectionAsync(int32_t, void**) noexcept = 0;
            virtual int32_t __stdcall add_ProtectionChanged(void*, winrt::event_token*) noexcept = 0;
            virtual int32_t __stdcall remove_ProtectionChanged(winrt::event_token) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Media::Protection::IMediaProtectionManager>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall add_ServiceRequested(void*, winrt::event_token*) noexcept = 0;
            virtual int32_t __stdcall remove_ServiceRequested(winrt::event_token) noexcept = 0;
            virtual int32_t __stdcall add_RebootNeeded(void*, winrt::event_token*) noexcept = 0;
            virtual int32_t __stdcall remove_RebootNeeded(winrt::event_token) noexcept = 0;
            virtual int32_t __stdcall add_ComponentLoadFailed(void*, winrt::event_token*) noexcept = 0;
            virtual int32_t __stdcall remove_ComponentLoadFailed(winrt::event_token) noexcept = 0;
            virtual int32_t __stdcall get_Properties(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Media::Protection::IMediaProtectionPMPServer>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_Properties(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Media::Protection::IMediaProtectionPMPServerFactory>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall CreatePMPServer(void*, void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Media::Protection::IMediaProtectionServiceCompletion>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall Complete(bool) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Media::Protection::IMediaProtectionServiceRequest>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_ProtectionSystem(winrt::guid*) noexcept = 0;
            virtual int32_t __stdcall get_Type(winrt::guid*) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Media::Protection::IProtectionCapabilities>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall IsTypeSupported(void*, void*, int32_t*) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Media::Protection::IRevocationAndRenewalInformation>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_Items(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Media::Protection::IRevocationAndRenewalItem>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_Reasons(uint32_t*) noexcept = 0;
            virtual int32_t __stdcall get_HeaderHash(void**) noexcept = 0;
            virtual int32_t __stdcall get_PublicKeyHash(void**) noexcept = 0;
            virtual int32_t __stdcall get_Name(void**) noexcept = 0;
            virtual int32_t __stdcall get_RenewalId(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Media::Protection::IServiceRequestedEventArgs>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_Request(void**) noexcept = 0;
            virtual int32_t __stdcall get_Completion(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Media::Protection::IServiceRequestedEventArgs2>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_MediaPlaybackItem(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Media::Protection::ComponentLoadFailedEventHandler>
    {
        struct __declspec(novtable) type : unknown_abi
        {
            virtual int32_t __stdcall Invoke(void*, void*) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Media::Protection::RebootNeededEventHandler>
    {
        struct __declspec(novtable) type : unknown_abi
        {
            virtual int32_t __stdcall Invoke(void*) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Media::Protection::ServiceRequestedEventHandler>
    {
        struct __declspec(novtable) type : unknown_abi
        {
            virtual int32_t __stdcall Invoke(void*, void*) noexcept = 0;
        };
    };
    template <typename D>
    struct consume_Windows_Media_Protection_IComponentLoadFailedEventArgs
    {
        [[nodiscard]] auto Information() const;
        [[nodiscard]] auto Completion() const;
    };
    template <> struct consume<Windows::Media::Protection::IComponentLoadFailedEventArgs>
    {
        template <typename D> using type = consume_Windows_Media_Protection_IComponentLoadFailedEventArgs<D>;
    };
    template <typename D>
    struct consume_Windows_Media_Protection_IComponentRenewalStatics
    {
        auto RenewSystemComponentsAsync(Windows::Media::Protection::RevocationAndRenewalInformation const& information) const;
    };
    template <> struct consume<Windows::Media::Protection::IComponentRenewalStatics>
    {
        template <typename D> using type = consume_Windows_Media_Protection_IComponentRenewalStatics<D>;
    };
    template <typename D>
    struct consume_Windows_Media_Protection_IHdcpSession
    {
        auto IsEffectiveProtectionAtLeast(Windows::Media::Protection::HdcpProtection const& protection) const;
        auto GetEffectiveProtection() const;
        auto SetDesiredMinProtectionAsync(Windows::Media::Protection::HdcpProtection const& protection) const;
        auto ProtectionChanged(Windows::Foundation::TypedEventHandler<Windows::Media::Protection::HdcpSession, Windows::Foundation::IInspectable> const& handler) const;
        using ProtectionChanged_revoker = impl::event_revoker<Windows::Media::Protection::IHdcpSession, &impl::abi_t<Windows::Media::Protection::IHdcpSession>::remove_ProtectionChanged>;
        ProtectionChanged_revoker ProtectionChanged(auto_revoke_t, Windows::Foundation::TypedEventHandler<Windows::Media::Protection::HdcpSession, Windows::Foundation::IInspectable> const& handler) const;
        auto ProtectionChanged(winrt::event_token const& token) const noexcept;
    };
    template <> struct consume<Windows::Media::Protection::IHdcpSession>
    {
        template <typename D> using type = consume_Windows_Media_Protection_IHdcpSession<D>;
    };
    template <typename D>
    struct consume_Windows_Media_Protection_IMediaProtectionManager
    {
        auto ServiceRequested(Windows::Media::Protection::ServiceRequestedEventHandler const& handler) const;
        using ServiceRequested_revoker = impl::event_revoker<Windows::Media::Protection::IMediaProtectionManager, &impl::abi_t<Windows::Media::Protection::IMediaProtectionManager>::remove_ServiceRequested>;
        ServiceRequested_revoker ServiceRequested(auto_revoke_t, Windows::Media::Protection::ServiceRequestedEventHandler const& handler) const;
        auto ServiceRequested(winrt::event_token const& cookie) const noexcept;
        auto RebootNeeded(Windows::Media::Protection::RebootNeededEventHandler const& handler) const;
        using RebootNeeded_revoker = impl::event_revoker<Windows::Media::Protection::IMediaProtectionManager, &impl::abi_t<Windows::Media::Protection::IMediaProtectionManager>::remove_RebootNeeded>;
        RebootNeeded_revoker RebootNeeded(auto_revoke_t, Windows::Media::Protection::RebootNeededEventHandler const& handler) const;
        auto RebootNeeded(winrt::event_token const& cookie) const noexcept;
        auto ComponentLoadFailed(Windows::Media::Protection::ComponentLoadFailedEventHandler const& handler) const;
        using ComponentLoadFailed_revoker = impl::event_revoker<Windows::Media::Protection::IMediaProtectionManager, &impl::abi_t<Windows::Media::Protection::IMediaProtectionManager>::remove_ComponentLoadFailed>;
        ComponentLoadFailed_revoker ComponentLoadFailed(auto_revoke_t, Windows::Media::Protection::ComponentLoadFailedEventHandler const& handler) const;
        auto ComponentLoadFailed(winrt::event_token const& cookie) const noexcept;
        [[nodiscard]] auto Properties() const;
    };
    template <> struct consume<Windows::Media::Protection::IMediaProtectionManager>
    {
        template <typename D> using type = consume_Windows_Media_Protection_IMediaProtectionManager<D>;
    };
    template <typename D>
    struct consume_Windows_Media_Protection_IMediaProtectionPMPServer
    {
        [[nodiscard]] auto Properties() const;
    };
    template <> struct consume<Windows::Media::Protection::IMediaProtectionPMPServer>
    {
        template <typename D> using type = consume_Windows_Media_Protection_IMediaProtectionPMPServer<D>;
    };
    template <typename D>
    struct consume_Windows_Media_Protection_IMediaProtectionPMPServerFactory
    {
        auto CreatePMPServer(Windows::Foundation::Collections::IPropertySet const& pProperties) const;
    };
    template <> struct consume<Windows::Media::Protection::IMediaProtectionPMPServerFactory>
    {
        template <typename D> using type = consume_Windows_Media_Protection_IMediaProtectionPMPServerFactory<D>;
    };
    template <typename D>
    struct consume_Windows_Media_Protection_IMediaProtectionServiceCompletion
    {
        auto Complete(bool success) const;
    };
    template <> struct consume<Windows::Media::Protection::IMediaProtectionServiceCompletion>
    {
        template <typename D> using type = consume_Windows_Media_Protection_IMediaProtectionServiceCompletion<D>;
    };
    template <typename D>
    struct consume_Windows_Media_Protection_IMediaProtectionServiceRequest
    {
        [[nodiscard]] auto ProtectionSystem() const;
        [[nodiscard]] auto Type() const;
    };
    template <> struct consume<Windows::Media::Protection::IMediaProtectionServiceRequest>
    {
        template <typename D> using type = consume_Windows_Media_Protection_IMediaProtectionServiceRequest<D>;
    };
    template <typename D>
    struct consume_Windows_Media_Protection_IProtectionCapabilities
    {
        auto IsTypeSupported(param::hstring const& type, param::hstring const& keySystem) const;
    };
    template <> struct consume<Windows::Media::Protection::IProtectionCapabilities>
    {
        template <typename D> using type = consume_Windows_Media_Protection_IProtectionCapabilities<D>;
    };
    template <typename D>
    struct consume_Windows_Media_Protection_IRevocationAndRenewalInformation
    {
        [[nodiscard]] auto Items() const;
    };
    template <> struct consume<Windows::Media::Protection::IRevocationAndRenewalInformation>
    {
        template <typename D> using type = consume_Windows_Media_Protection_IRevocationAndRenewalInformation<D>;
    };
    template <typename D>
    struct consume_Windows_Media_Protection_IRevocationAndRenewalItem
    {
        [[nodiscard]] auto Reasons() const;
        [[nodiscard]] auto HeaderHash() const;
        [[nodiscard]] auto PublicKeyHash() const;
        [[nodiscard]] auto Name() const;
        [[nodiscard]] auto RenewalId() const;
    };
    template <> struct consume<Windows::Media::Protection::IRevocationAndRenewalItem>
    {
        template <typename D> using type = consume_Windows_Media_Protection_IRevocationAndRenewalItem<D>;
    };
    template <typename D>
    struct consume_Windows_Media_Protection_IServiceRequestedEventArgs
    {
        [[nodiscard]] auto Request() const;
        [[nodiscard]] auto Completion() const;
    };
    template <> struct consume<Windows::Media::Protection::IServiceRequestedEventArgs>
    {
        template <typename D> using type = consume_Windows_Media_Protection_IServiceRequestedEventArgs<D>;
    };
    template <typename D>
    struct consume_Windows_Media_Protection_IServiceRequestedEventArgs2
    {
        [[nodiscard]] auto MediaPlaybackItem() const;
    };
    template <> struct consume<Windows::Media::Protection::IServiceRequestedEventArgs2>
    {
        template <typename D> using type = consume_Windows_Media_Protection_IServiceRequestedEventArgs2<D>;
    };
}
#endif
