// C++/WinRT v3.0.260818.1

// SPDX-License-Identifier: MIT OR Apache-2.0
// SPDX-FileCopyrightText: Copyright (c) Microsoft Corporation
//
// Generated using .winmd files from https://github.com/microsoft/windows-rs
//

#pragma once
#ifndef WINRT_Windows_Devices_Pwm_Provider_H
#define WINRT_Windows_Devices_Pwm_Provider_H
#ifndef WINRT_IMPORT_MODULE

#ifndef WINRT_IMPL_BUILD_MODULE
#include "winrt/base.h"
static_assert(winrt::check_version(CPPWINRT_VERSION, "3.0.260818.1"), "Mismatched C++/WinRT headers.");
#define CPPWINRT_VERSION "3.0.260818.1"
#include "winrt/Windows.Devices.Pwm.h"
#include "winrt/impl/Windows.Foundation.Collections.2.h"
#include "winrt/impl/Windows.Devices.Pwm.Provider.2.h"
#endif // WINRT_IMPL_BUILD_MODULE
WINRT_EXPORT namespace winrt::impl
{
    template <typename D> auto consume_Windows_Devices_Pwm_Provider_IPwmControllerProvider<D>::PinCount() const
    {
        std::int32_t value{};
        consume_general<winrt::Windows::Devices::Pwm::Provider::IPwmControllerProvider, D>(static_cast<D const*>(this), &abi_t<winrt::Windows::Devices::Pwm::Provider::IPwmControllerProvider>::get_PinCount, &value);
        return value;
    }
    template <typename D> auto consume_Windows_Devices_Pwm_Provider_IPwmControllerProvider<D>::ActualFrequency() const
    {
        double value{};
        consume_general<winrt::Windows::Devices::Pwm::Provider::IPwmControllerProvider, D>(static_cast<D const*>(this), &abi_t<winrt::Windows::Devices::Pwm::Provider::IPwmControllerProvider>::get_ActualFrequency, &value);
        return value;
    }
    template <typename D> auto consume_Windows_Devices_Pwm_Provider_IPwmControllerProvider<D>::SetDesiredFrequency(double frequency) const
    {
        double result{};
        consume_general<winrt::Windows::Devices::Pwm::Provider::IPwmControllerProvider, D>(static_cast<D const*>(this), &abi_t<winrt::Windows::Devices::Pwm::Provider::IPwmControllerProvider>::SetDesiredFrequency, frequency, &result);
        return result;
    }
    template <typename D> auto consume_Windows_Devices_Pwm_Provider_IPwmControllerProvider<D>::MaxFrequency() const
    {
        double value{};
        consume_general<winrt::Windows::Devices::Pwm::Provider::IPwmControllerProvider, D>(static_cast<D const*>(this), &abi_t<winrt::Windows::Devices::Pwm::Provider::IPwmControllerProvider>::get_MaxFrequency, &value);
        return value;
    }
    template <typename D> auto consume_Windows_Devices_Pwm_Provider_IPwmControllerProvider<D>::MinFrequency() const
    {
        double value{};
        consume_general<winrt::Windows::Devices::Pwm::Provider::IPwmControllerProvider, D>(static_cast<D const*>(this), &abi_t<winrt::Windows::Devices::Pwm::Provider::IPwmControllerProvider>::get_MinFrequency, &value);
        return value;
    }
    template <typename D> auto consume_Windows_Devices_Pwm_Provider_IPwmControllerProvider<D>::AcquirePin(std::int32_t pin) const
    {
        consume_general<winrt::Windows::Devices::Pwm::Provider::IPwmControllerProvider, D>(static_cast<D const*>(this), &abi_t<winrt::Windows::Devices::Pwm::Provider::IPwmControllerProvider>::AcquirePin, pin);
    }
    template <typename D> auto consume_Windows_Devices_Pwm_Provider_IPwmControllerProvider<D>::ReleasePin(std::int32_t pin) const
    {
        consume_general<winrt::Windows::Devices::Pwm::Provider::IPwmControllerProvider, D>(static_cast<D const*>(this), &abi_t<winrt::Windows::Devices::Pwm::Provider::IPwmControllerProvider>::ReleasePin, pin);
    }
    template <typename D> auto consume_Windows_Devices_Pwm_Provider_IPwmControllerProvider<D>::EnablePin(std::int32_t pin) const
    {
        consume_general<winrt::Windows::Devices::Pwm::Provider::IPwmControllerProvider, D>(static_cast<D const*>(this), &abi_t<winrt::Windows::Devices::Pwm::Provider::IPwmControllerProvider>::EnablePin, pin);
    }
    template <typename D> auto consume_Windows_Devices_Pwm_Provider_IPwmControllerProvider<D>::DisablePin(std::int32_t pin) const
    {
        consume_general<winrt::Windows::Devices::Pwm::Provider::IPwmControllerProvider, D>(static_cast<D const*>(this), &abi_t<winrt::Windows::Devices::Pwm::Provider::IPwmControllerProvider>::DisablePin, pin);
    }
    template <typename D> auto consume_Windows_Devices_Pwm_Provider_IPwmControllerProvider<D>::SetPulseParameters(std::int32_t pin, double dutyCycle, bool invertPolarity) const
    {
        consume_general<winrt::Windows::Devices::Pwm::Provider::IPwmControllerProvider, D>(static_cast<D const*>(this), &abi_t<winrt::Windows::Devices::Pwm::Provider::IPwmControllerProvider>::SetPulseParameters, pin, dutyCycle, invertPolarity);
    }
    template <typename D> auto consume_Windows_Devices_Pwm_Provider_IPwmProvider<D>::GetControllers() const
    {
        void* result{};
        consume_general<winrt::Windows::Devices::Pwm::Provider::IPwmProvider, D>(static_cast<D const*>(this), &abi_t<winrt::Windows::Devices::Pwm::Provider::IPwmProvider>::GetControllers, &result);
        return winrt::Windows::Foundation::Collections::IVectorView<winrt::Windows::Devices::Pwm::Provider::IPwmControllerProvider>{ result, take_ownership_from_abi };
    }
    template <typename D>
    struct produce<D, winrt::Windows::Devices::Pwm::Provider::IPwmControllerProvider> : produce_base<D, winrt::Windows::Devices::Pwm::Provider::IPwmControllerProvider>
    {
        std::int32_t __stdcall get_PinCount(std::int32_t* value) noexcept final try
        {
            typename D::abi_guard guard(this->shim());
            *value = detach_from<std::int32_t>(this->shim().PinCount());
            return 0;
        }
        catch (...) { return to_hresult(); }
        std::int32_t __stdcall get_ActualFrequency(double* value) noexcept final try
        {
            typename D::abi_guard guard(this->shim());
            *value = detach_from<double>(this->shim().ActualFrequency());
            return 0;
        }
        catch (...) { return to_hresult(); }
        std::int32_t __stdcall SetDesiredFrequency(double frequency, double* result) noexcept final try
        {
            typename D::abi_guard guard(this->shim());
            *result = detach_from<double>(this->shim().SetDesiredFrequency(frequency));
            return 0;
        }
        catch (...) { return to_hresult(); }
        std::int32_t __stdcall get_MaxFrequency(double* value) noexcept final try
        {
            typename D::abi_guard guard(this->shim());
            *value = detach_from<double>(this->shim().MaxFrequency());
            return 0;
        }
        catch (...) { return to_hresult(); }
        std::int32_t __stdcall get_MinFrequency(double* value) noexcept final try
        {
            typename D::abi_guard guard(this->shim());
            *value = detach_from<double>(this->shim().MinFrequency());
            return 0;
        }
        catch (...) { return to_hresult(); }
        std::int32_t __stdcall AcquirePin(std::int32_t pin) noexcept final try
        {
            typename D::abi_guard guard(this->shim());
            this->shim().AcquirePin(pin);
            return 0;
        }
        catch (...) { return to_hresult(); }
        std::int32_t __stdcall ReleasePin(std::int32_t pin) noexcept final try
        {
            typename D::abi_guard guard(this->shim());
            this->shim().ReleasePin(pin);
            return 0;
        }
        catch (...) { return to_hresult(); }
        std::int32_t __stdcall EnablePin(std::int32_t pin) noexcept final try
        {
            typename D::abi_guard guard(this->shim());
            this->shim().EnablePin(pin);
            return 0;
        }
        catch (...) { return to_hresult(); }
        std::int32_t __stdcall DisablePin(std::int32_t pin) noexcept final try
        {
            typename D::abi_guard guard(this->shim());
            this->shim().DisablePin(pin);
            return 0;
        }
        catch (...) { return to_hresult(); }
        std::int32_t __stdcall SetPulseParameters(std::int32_t pin, double dutyCycle, bool invertPolarity) noexcept final try
        {
            typename D::abi_guard guard(this->shim());
            this->shim().SetPulseParameters(pin, dutyCycle, invertPolarity);
            return 0;
        }
        catch (...) { return to_hresult(); }
    };
    template <typename D>
    struct produce<D, winrt::Windows::Devices::Pwm::Provider::IPwmProvider> : produce_base<D, winrt::Windows::Devices::Pwm::Provider::IPwmProvider>
    {
        std::int32_t __stdcall GetControllers(void** result) noexcept final try
        {
            clear_abi(result);
            typename D::abi_guard guard(this->shim());
            *result = detach_from<winrt::Windows::Foundation::Collections::IVectorView<winrt::Windows::Devices::Pwm::Provider::IPwmControllerProvider>>(this->shim().GetControllers());
            return 0;
        }
        catch (...) { return to_hresult(); }
    };
}
WINRT_EXPORT namespace winrt::Windows::Devices::Pwm::Provider
{
}
namespace std
{
#ifndef WINRT_LEAN_AND_MEAN
    template<> struct hash<winrt::Windows::Devices::Pwm::Provider::IPwmControllerProvider> : winrt::impl::hash_base {};
    template<> struct hash<winrt::Windows::Devices::Pwm::Provider::IPwmProvider> : winrt::impl::hash_base {};
#endif // WINRT_LEAN_AND_MEAN
#ifdef __cpp_lib_format
#endif // __cpp_lib_format
}
#endif
#endif // WINRT_IMPORT_MODULE
