// C++/WinRT v2.0.190620.2

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

#ifndef WINRT_Windows_Devices_Sensors_0_H
#define WINRT_Windows_Devices_Sensors_0_H
namespace winrt::Windows::Foundation
{
    struct EventRegistrationToken;
    struct IClosable;
    template <typename TSender, typename TResult> struct TypedEventHandler;
}
namespace winrt::Windows::Graphics::Display
{
    enum class DisplayOrientations : uint32_t;
}
namespace winrt::Windows::Devices::Sensors
{
    enum class AccelerometerReadingType : int32_t
    {
        Standard = 0,
        Linear = 1,
        Gravity = 2,
    };
    enum class ActivitySensorReadingConfidence : int32_t
    {
        High = 0,
        Low = 1,
    };
    enum class ActivityType : int32_t
    {
        Unknown = 0,
        Idle = 1,
        Stationary = 2,
        Fidgeting = 3,
        Walking = 4,
        Running = 5,
        InVehicle = 6,
        Biking = 7,
    };
    enum class MagnetometerAccuracy : int32_t
    {
        Unknown = 0,
        Unreliable = 1,
        Approximate = 2,
        High = 3,
    };
    enum class PedometerStepKind : int32_t
    {
        Unknown = 0,
        Walking = 1,
        Running = 2,
    };
    enum class SensorOptimizationGoal : int32_t
    {
        Precision = 0,
        PowerEfficiency = 1,
    };
    enum class SensorReadingType : int32_t
    {
        Absolute = 0,
        Relative = 1,
    };
    enum class SensorType : int32_t
    {
        Accelerometer = 0,
        ActivitySensor = 1,
        Barometer = 2,
        Compass = 3,
        CustomSensor = 4,
        Gyroscope = 5,
        ProximitySensor = 6,
        Inclinometer = 7,
        LightSensor = 8,
        OrientationSensor = 9,
        Pedometer = 10,
        RelativeInclinometer = 11,
        RelativeOrientationSensor = 12,
        SimpleOrientationSensor = 13,
    };
    enum class SimpleOrientation : int32_t
    {
        NotRotated = 0,
        Rotated90DegreesCounterclockwise = 1,
        Rotated180DegreesCounterclockwise = 2,
        Rotated270DegreesCounterclockwise = 3,
        Faceup = 4,
        Facedown = 5,
    };
    struct IAccelerometer;
    struct IAccelerometer2;
    struct IAccelerometer3;
    struct IAccelerometer4;
    struct IAccelerometer5;
    struct IAccelerometerDataThreshold;
    struct IAccelerometerDeviceId;
    struct IAccelerometerReading;
    struct IAccelerometerReading2;
    struct IAccelerometerReadingChangedEventArgs;
    struct IAccelerometerShakenEventArgs;
    struct IAccelerometerStatics;
    struct IAccelerometerStatics2;
    struct IAccelerometerStatics3;
    struct IActivitySensor;
    struct IActivitySensorReading;
    struct IActivitySensorReadingChangeReport;
    struct IActivitySensorReadingChangedEventArgs;
    struct IActivitySensorStatics;
    struct IActivitySensorTriggerDetails;
    struct IAltimeter;
    struct IAltimeter2;
    struct IAltimeterReading;
    struct IAltimeterReading2;
    struct IAltimeterReadingChangedEventArgs;
    struct IAltimeterStatics;
    struct IBarometer;
    struct IBarometer2;
    struct IBarometer3;
    struct IBarometerDataThreshold;
    struct IBarometerReading;
    struct IBarometerReading2;
    struct IBarometerReadingChangedEventArgs;
    struct IBarometerStatics;
    struct IBarometerStatics2;
    struct ICompass;
    struct ICompass2;
    struct ICompass3;
    struct ICompass4;
    struct ICompassDataThreshold;
    struct ICompassDeviceId;
    struct ICompassReading;
    struct ICompassReading2;
    struct ICompassReadingChangedEventArgs;
    struct ICompassReadingHeadingAccuracy;
    struct ICompassStatics;
    struct ICompassStatics2;
    struct IGyrometer;
    struct IGyrometer2;
    struct IGyrometer3;
    struct IGyrometer4;
    struct IGyrometerDataThreshold;
    struct IGyrometerDeviceId;
    struct IGyrometerReading;
    struct IGyrometerReading2;
    struct IGyrometerReadingChangedEventArgs;
    struct IGyrometerStatics;
    struct IGyrometerStatics2;
    struct IHingeAngleReading;
    struct IHingeAngleSensor;
    struct IHingeAngleSensorReadingChangedEventArgs;
    struct IHingeAngleSensorStatics;
    struct IInclinometer;
    struct IInclinometer2;
    struct IInclinometer3;
    struct IInclinometer4;
    struct IInclinometerDataThreshold;
    struct IInclinometerDeviceId;
    struct IInclinometerReading;
    struct IInclinometerReading2;
    struct IInclinometerReadingChangedEventArgs;
    struct IInclinometerReadingYawAccuracy;
    struct IInclinometerStatics;
    struct IInclinometerStatics2;
    struct IInclinometerStatics3;
    struct IInclinometerStatics4;
    struct ILightSensor;
    struct ILightSensor2;
    struct ILightSensor3;
    struct ILightSensorDataThreshold;
    struct ILightSensorDeviceId;
    struct ILightSensorReading;
    struct ILightSensorReading2;
    struct ILightSensorReadingChangedEventArgs;
    struct ILightSensorStatics;
    struct ILightSensorStatics2;
    struct IMagnetometer;
    struct IMagnetometer2;
    struct IMagnetometer3;
    struct IMagnetometer4;
    struct IMagnetometerDataThreshold;
    struct IMagnetometerDeviceId;
    struct IMagnetometerReading;
    struct IMagnetometerReading2;
    struct IMagnetometerReadingChangedEventArgs;
    struct IMagnetometerStatics;
    struct IMagnetometerStatics2;
    struct IOrientationSensor;
    struct IOrientationSensor2;
    struct IOrientationSensor3;
    struct IOrientationSensorDeviceId;
    struct IOrientationSensorReading;
    struct IOrientationSensorReading2;
    struct IOrientationSensorReadingChangedEventArgs;
    struct IOrientationSensorReadingYawAccuracy;
    struct IOrientationSensorStatics;
    struct IOrientationSensorStatics2;
    struct IOrientationSensorStatics3;
    struct IOrientationSensorStatics4;
    struct IPedometer;
    struct IPedometer2;
    struct IPedometerDataThresholdFactory;
    struct IPedometerReading;
    struct IPedometerReadingChangedEventArgs;
    struct IPedometerStatics;
    struct IPedometerStatics2;
    struct IProximitySensor;
    struct IProximitySensorDataThresholdFactory;
    struct IProximitySensorReading;
    struct IProximitySensorReadingChangedEventArgs;
    struct IProximitySensorStatics;
    struct IProximitySensorStatics2;
    struct ISensorDataThreshold;
    struct ISensorDataThresholdTriggerDetails;
    struct ISensorQuaternion;
    struct ISensorRotationMatrix;
    struct ISimpleOrientationSensor;
    struct ISimpleOrientationSensor2;
    struct ISimpleOrientationSensorDeviceId;
    struct ISimpleOrientationSensorOrientationChangedEventArgs;
    struct ISimpleOrientationSensorStatics;
    struct ISimpleOrientationSensorStatics2;
    struct Accelerometer;
    struct AccelerometerDataThreshold;
    struct AccelerometerReading;
    struct AccelerometerReadingChangedEventArgs;
    struct AccelerometerShakenEventArgs;
    struct ActivitySensor;
    struct ActivitySensorReading;
    struct ActivitySensorReadingChangeReport;
    struct ActivitySensorReadingChangedEventArgs;
    struct ActivitySensorTriggerDetails;
    struct Altimeter;
    struct AltimeterReading;
    struct AltimeterReadingChangedEventArgs;
    struct Barometer;
    struct BarometerDataThreshold;
    struct BarometerReading;
    struct BarometerReadingChangedEventArgs;
    struct Compass;
    struct CompassDataThreshold;
    struct CompassReading;
    struct CompassReadingChangedEventArgs;
    struct Gyrometer;
    struct GyrometerDataThreshold;
    struct GyrometerReading;
    struct GyrometerReadingChangedEventArgs;
    struct HingeAngleReading;
    struct HingeAngleSensor;
    struct HingeAngleSensorReadingChangedEventArgs;
    struct Inclinometer;
    struct InclinometerDataThreshold;
    struct InclinometerReading;
    struct InclinometerReadingChangedEventArgs;
    struct LightSensor;
    struct LightSensorDataThreshold;
    struct LightSensorReading;
    struct LightSensorReadingChangedEventArgs;
    struct Magnetometer;
    struct MagnetometerDataThreshold;
    struct MagnetometerReading;
    struct MagnetometerReadingChangedEventArgs;
    struct OrientationSensor;
    struct OrientationSensorReading;
    struct OrientationSensorReadingChangedEventArgs;
    struct Pedometer;
    struct PedometerDataThreshold;
    struct PedometerReading;
    struct PedometerReadingChangedEventArgs;
    struct ProximitySensor;
    struct ProximitySensorDataThreshold;
    struct ProximitySensorDisplayOnOffController;
    struct ProximitySensorReading;
    struct ProximitySensorReadingChangedEventArgs;
    struct SensorDataThresholdTriggerDetails;
    struct SensorQuaternion;
    struct SensorRotationMatrix;
    struct SimpleOrientationSensor;
    struct SimpleOrientationSensorOrientationChangedEventArgs;
}
namespace winrt::impl
{
    template <> struct category<Windows::Devices::Sensors::IAccelerometer>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IAccelerometer2>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IAccelerometer3>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IAccelerometer4>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IAccelerometer5>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IAccelerometerDataThreshold>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IAccelerometerDeviceId>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IAccelerometerReading>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IAccelerometerReading2>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IAccelerometerReadingChangedEventArgs>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IAccelerometerShakenEventArgs>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IAccelerometerStatics>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IAccelerometerStatics2>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IAccelerometerStatics3>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IActivitySensor>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IActivitySensorReading>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IActivitySensorReadingChangeReport>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IActivitySensorReadingChangedEventArgs>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IActivitySensorStatics>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IActivitySensorTriggerDetails>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IAltimeter>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IAltimeter2>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IAltimeterReading>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IAltimeterReading2>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IAltimeterReadingChangedEventArgs>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IAltimeterStatics>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IBarometer>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IBarometer2>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IBarometer3>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IBarometerDataThreshold>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IBarometerReading>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IBarometerReading2>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IBarometerReadingChangedEventArgs>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IBarometerStatics>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IBarometerStatics2>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::ICompass>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::ICompass2>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::ICompass3>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::ICompass4>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::ICompassDataThreshold>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::ICompassDeviceId>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::ICompassReading>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::ICompassReading2>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::ICompassReadingChangedEventArgs>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::ICompassReadingHeadingAccuracy>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::ICompassStatics>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::ICompassStatics2>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IGyrometer>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IGyrometer2>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IGyrometer3>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IGyrometer4>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IGyrometerDataThreshold>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IGyrometerDeviceId>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IGyrometerReading>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IGyrometerReading2>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IGyrometerReadingChangedEventArgs>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IGyrometerStatics>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IGyrometerStatics2>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IHingeAngleReading>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IHingeAngleSensor>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IHingeAngleSensorReadingChangedEventArgs>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IHingeAngleSensorStatics>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IInclinometer>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IInclinometer2>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IInclinometer3>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IInclinometer4>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IInclinometerDataThreshold>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IInclinometerDeviceId>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IInclinometerReading>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IInclinometerReading2>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IInclinometerReadingChangedEventArgs>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IInclinometerReadingYawAccuracy>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IInclinometerStatics>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IInclinometerStatics2>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IInclinometerStatics3>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IInclinometerStatics4>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::ILightSensor>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::ILightSensor2>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::ILightSensor3>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::ILightSensorDataThreshold>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::ILightSensorDeviceId>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::ILightSensorReading>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::ILightSensorReading2>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::ILightSensorReadingChangedEventArgs>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::ILightSensorStatics>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::ILightSensorStatics2>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IMagnetometer>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IMagnetometer2>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IMagnetometer3>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IMagnetometer4>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IMagnetometerDataThreshold>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IMagnetometerDeviceId>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IMagnetometerReading>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IMagnetometerReading2>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IMagnetometerReadingChangedEventArgs>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IMagnetometerStatics>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IMagnetometerStatics2>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IOrientationSensor>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IOrientationSensor2>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IOrientationSensor3>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IOrientationSensorDeviceId>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IOrientationSensorReading>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IOrientationSensorReading2>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IOrientationSensorReadingChangedEventArgs>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IOrientationSensorReadingYawAccuracy>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IOrientationSensorStatics>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IOrientationSensorStatics2>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IOrientationSensorStatics3>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IOrientationSensorStatics4>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IPedometer>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IPedometer2>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IPedometerDataThresholdFactory>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IPedometerReading>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IPedometerReadingChangedEventArgs>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IPedometerStatics>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IPedometerStatics2>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IProximitySensor>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IProximitySensorDataThresholdFactory>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IProximitySensorReading>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IProximitySensorReadingChangedEventArgs>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IProximitySensorStatics>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::IProximitySensorStatics2>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::ISensorDataThreshold>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::ISensorDataThresholdTriggerDetails>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::ISensorQuaternion>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::ISensorRotationMatrix>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::ISimpleOrientationSensor>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::ISimpleOrientationSensor2>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::ISimpleOrientationSensorDeviceId>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::ISimpleOrientationSensorOrientationChangedEventArgs>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::ISimpleOrientationSensorStatics>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::ISimpleOrientationSensorStatics2>
    {
        using type = interface_category;
    };
    template <> struct category<Windows::Devices::Sensors::Accelerometer>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::AccelerometerDataThreshold>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::AccelerometerReading>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::AccelerometerReadingChangedEventArgs>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::AccelerometerShakenEventArgs>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::ActivitySensor>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::ActivitySensorReading>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::ActivitySensorReadingChangeReport>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::ActivitySensorReadingChangedEventArgs>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::ActivitySensorTriggerDetails>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::Altimeter>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::AltimeterReading>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::AltimeterReadingChangedEventArgs>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::Barometer>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::BarometerDataThreshold>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::BarometerReading>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::BarometerReadingChangedEventArgs>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::Compass>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::CompassDataThreshold>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::CompassReading>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::CompassReadingChangedEventArgs>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::Gyrometer>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::GyrometerDataThreshold>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::GyrometerReading>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::GyrometerReadingChangedEventArgs>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::HingeAngleReading>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::HingeAngleSensor>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::HingeAngleSensorReadingChangedEventArgs>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::Inclinometer>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::InclinometerDataThreshold>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::InclinometerReading>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::InclinometerReadingChangedEventArgs>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::LightSensor>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::LightSensorDataThreshold>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::LightSensorReading>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::LightSensorReadingChangedEventArgs>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::Magnetometer>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::MagnetometerDataThreshold>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::MagnetometerReading>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::MagnetometerReadingChangedEventArgs>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::OrientationSensor>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::OrientationSensorReading>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::OrientationSensorReadingChangedEventArgs>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::Pedometer>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::PedometerDataThreshold>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::PedometerReading>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::PedometerReadingChangedEventArgs>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::ProximitySensor>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::ProximitySensorDataThreshold>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::ProximitySensorDisplayOnOffController>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::ProximitySensorReading>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::ProximitySensorReadingChangedEventArgs>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::SensorDataThresholdTriggerDetails>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::SensorQuaternion>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::SensorRotationMatrix>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::SimpleOrientationSensor>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::SimpleOrientationSensorOrientationChangedEventArgs>
    {
        using type = class_category;
    };
    template <> struct category<Windows::Devices::Sensors::AccelerometerReadingType>
    {
        using type = enum_category;
    };
    template <> struct category<Windows::Devices::Sensors::ActivitySensorReadingConfidence>
    {
        using type = enum_category;
    };
    template <> struct category<Windows::Devices::Sensors::ActivityType>
    {
        using type = enum_category;
    };
    template <> struct category<Windows::Devices::Sensors::MagnetometerAccuracy>
    {
        using type = enum_category;
    };
    template <> struct category<Windows::Devices::Sensors::PedometerStepKind>
    {
        using type = enum_category;
    };
    template <> struct category<Windows::Devices::Sensors::SensorOptimizationGoal>
    {
        using type = enum_category;
    };
    template <> struct category<Windows::Devices::Sensors::SensorReadingType>
    {
        using type = enum_category;
    };
    template <> struct category<Windows::Devices::Sensors::SensorType>
    {
        using type = enum_category;
    };
    template <> struct category<Windows::Devices::Sensors::SimpleOrientation>
    {
        using type = enum_category;
    };
    template <> struct name<Windows::Devices::Sensors::IAccelerometer>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IAccelerometer" };
    };
    template <> struct name<Windows::Devices::Sensors::IAccelerometer2>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IAccelerometer2" };
    };
    template <> struct name<Windows::Devices::Sensors::IAccelerometer3>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IAccelerometer3" };
    };
    template <> struct name<Windows::Devices::Sensors::IAccelerometer4>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IAccelerometer4" };
    };
    template <> struct name<Windows::Devices::Sensors::IAccelerometer5>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IAccelerometer5" };
    };
    template <> struct name<Windows::Devices::Sensors::IAccelerometerDataThreshold>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IAccelerometerDataThreshold" };
    };
    template <> struct name<Windows::Devices::Sensors::IAccelerometerDeviceId>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IAccelerometerDeviceId" };
    };
    template <> struct name<Windows::Devices::Sensors::IAccelerometerReading>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IAccelerometerReading" };
    };
    template <> struct name<Windows::Devices::Sensors::IAccelerometerReading2>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IAccelerometerReading2" };
    };
    template <> struct name<Windows::Devices::Sensors::IAccelerometerReadingChangedEventArgs>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IAccelerometerReadingChangedEventArgs" };
    };
    template <> struct name<Windows::Devices::Sensors::IAccelerometerShakenEventArgs>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IAccelerometerShakenEventArgs" };
    };
    template <> struct name<Windows::Devices::Sensors::IAccelerometerStatics>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IAccelerometerStatics" };
    };
    template <> struct name<Windows::Devices::Sensors::IAccelerometerStatics2>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IAccelerometerStatics2" };
    };
    template <> struct name<Windows::Devices::Sensors::IAccelerometerStatics3>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IAccelerometerStatics3" };
    };
    template <> struct name<Windows::Devices::Sensors::IActivitySensor>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IActivitySensor" };
    };
    template <> struct name<Windows::Devices::Sensors::IActivitySensorReading>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IActivitySensorReading" };
    };
    template <> struct name<Windows::Devices::Sensors::IActivitySensorReadingChangeReport>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IActivitySensorReadingChangeReport" };
    };
    template <> struct name<Windows::Devices::Sensors::IActivitySensorReadingChangedEventArgs>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IActivitySensorReadingChangedEventArgs" };
    };
    template <> struct name<Windows::Devices::Sensors::IActivitySensorStatics>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IActivitySensorStatics" };
    };
    template <> struct name<Windows::Devices::Sensors::IActivitySensorTriggerDetails>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IActivitySensorTriggerDetails" };
    };
    template <> struct name<Windows::Devices::Sensors::IAltimeter>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IAltimeter" };
    };
    template <> struct name<Windows::Devices::Sensors::IAltimeter2>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IAltimeter2" };
    };
    template <> struct name<Windows::Devices::Sensors::IAltimeterReading>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IAltimeterReading" };
    };
    template <> struct name<Windows::Devices::Sensors::IAltimeterReading2>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IAltimeterReading2" };
    };
    template <> struct name<Windows::Devices::Sensors::IAltimeterReadingChangedEventArgs>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IAltimeterReadingChangedEventArgs" };
    };
    template <> struct name<Windows::Devices::Sensors::IAltimeterStatics>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IAltimeterStatics" };
    };
    template <> struct name<Windows::Devices::Sensors::IBarometer>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IBarometer" };
    };
    template <> struct name<Windows::Devices::Sensors::IBarometer2>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IBarometer2" };
    };
    template <> struct name<Windows::Devices::Sensors::IBarometer3>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IBarometer3" };
    };
    template <> struct name<Windows::Devices::Sensors::IBarometerDataThreshold>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IBarometerDataThreshold" };
    };
    template <> struct name<Windows::Devices::Sensors::IBarometerReading>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IBarometerReading" };
    };
    template <> struct name<Windows::Devices::Sensors::IBarometerReading2>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IBarometerReading2" };
    };
    template <> struct name<Windows::Devices::Sensors::IBarometerReadingChangedEventArgs>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IBarometerReadingChangedEventArgs" };
    };
    template <> struct name<Windows::Devices::Sensors::IBarometerStatics>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IBarometerStatics" };
    };
    template <> struct name<Windows::Devices::Sensors::IBarometerStatics2>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IBarometerStatics2" };
    };
    template <> struct name<Windows::Devices::Sensors::ICompass>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ICompass" };
    };
    template <> struct name<Windows::Devices::Sensors::ICompass2>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ICompass2" };
    };
    template <> struct name<Windows::Devices::Sensors::ICompass3>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ICompass3" };
    };
    template <> struct name<Windows::Devices::Sensors::ICompass4>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ICompass4" };
    };
    template <> struct name<Windows::Devices::Sensors::ICompassDataThreshold>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ICompassDataThreshold" };
    };
    template <> struct name<Windows::Devices::Sensors::ICompassDeviceId>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ICompassDeviceId" };
    };
    template <> struct name<Windows::Devices::Sensors::ICompassReading>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ICompassReading" };
    };
    template <> struct name<Windows::Devices::Sensors::ICompassReading2>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ICompassReading2" };
    };
    template <> struct name<Windows::Devices::Sensors::ICompassReadingChangedEventArgs>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ICompassReadingChangedEventArgs" };
    };
    template <> struct name<Windows::Devices::Sensors::ICompassReadingHeadingAccuracy>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ICompassReadingHeadingAccuracy" };
    };
    template <> struct name<Windows::Devices::Sensors::ICompassStatics>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ICompassStatics" };
    };
    template <> struct name<Windows::Devices::Sensors::ICompassStatics2>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ICompassStatics2" };
    };
    template <> struct name<Windows::Devices::Sensors::IGyrometer>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IGyrometer" };
    };
    template <> struct name<Windows::Devices::Sensors::IGyrometer2>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IGyrometer2" };
    };
    template <> struct name<Windows::Devices::Sensors::IGyrometer3>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IGyrometer3" };
    };
    template <> struct name<Windows::Devices::Sensors::IGyrometer4>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IGyrometer4" };
    };
    template <> struct name<Windows::Devices::Sensors::IGyrometerDataThreshold>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IGyrometerDataThreshold" };
    };
    template <> struct name<Windows::Devices::Sensors::IGyrometerDeviceId>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IGyrometerDeviceId" };
    };
    template <> struct name<Windows::Devices::Sensors::IGyrometerReading>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IGyrometerReading" };
    };
    template <> struct name<Windows::Devices::Sensors::IGyrometerReading2>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IGyrometerReading2" };
    };
    template <> struct name<Windows::Devices::Sensors::IGyrometerReadingChangedEventArgs>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IGyrometerReadingChangedEventArgs" };
    };
    template <> struct name<Windows::Devices::Sensors::IGyrometerStatics>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IGyrometerStatics" };
    };
    template <> struct name<Windows::Devices::Sensors::IGyrometerStatics2>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IGyrometerStatics2" };
    };
    template <> struct name<Windows::Devices::Sensors::IHingeAngleReading>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IHingeAngleReading" };
    };
    template <> struct name<Windows::Devices::Sensors::IHingeAngleSensor>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IHingeAngleSensor" };
    };
    template <> struct name<Windows::Devices::Sensors::IHingeAngleSensorReadingChangedEventArgs>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IHingeAngleSensorReadingChangedEventArgs" };
    };
    template <> struct name<Windows::Devices::Sensors::IHingeAngleSensorStatics>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IHingeAngleSensorStatics" };
    };
    template <> struct name<Windows::Devices::Sensors::IInclinometer>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IInclinometer" };
    };
    template <> struct name<Windows::Devices::Sensors::IInclinometer2>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IInclinometer2" };
    };
    template <> struct name<Windows::Devices::Sensors::IInclinometer3>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IInclinometer3" };
    };
    template <> struct name<Windows::Devices::Sensors::IInclinometer4>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IInclinometer4" };
    };
    template <> struct name<Windows::Devices::Sensors::IInclinometerDataThreshold>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IInclinometerDataThreshold" };
    };
    template <> struct name<Windows::Devices::Sensors::IInclinometerDeviceId>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IInclinometerDeviceId" };
    };
    template <> struct name<Windows::Devices::Sensors::IInclinometerReading>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IInclinometerReading" };
    };
    template <> struct name<Windows::Devices::Sensors::IInclinometerReading2>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IInclinometerReading2" };
    };
    template <> struct name<Windows::Devices::Sensors::IInclinometerReadingChangedEventArgs>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IInclinometerReadingChangedEventArgs" };
    };
    template <> struct name<Windows::Devices::Sensors::IInclinometerReadingYawAccuracy>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IInclinometerReadingYawAccuracy" };
    };
    template <> struct name<Windows::Devices::Sensors::IInclinometerStatics>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IInclinometerStatics" };
    };
    template <> struct name<Windows::Devices::Sensors::IInclinometerStatics2>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IInclinometerStatics2" };
    };
    template <> struct name<Windows::Devices::Sensors::IInclinometerStatics3>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IInclinometerStatics3" };
    };
    template <> struct name<Windows::Devices::Sensors::IInclinometerStatics4>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IInclinometerStatics4" };
    };
    template <> struct name<Windows::Devices::Sensors::ILightSensor>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ILightSensor" };
    };
    template <> struct name<Windows::Devices::Sensors::ILightSensor2>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ILightSensor2" };
    };
    template <> struct name<Windows::Devices::Sensors::ILightSensor3>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ILightSensor3" };
    };
    template <> struct name<Windows::Devices::Sensors::ILightSensorDataThreshold>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ILightSensorDataThreshold" };
    };
    template <> struct name<Windows::Devices::Sensors::ILightSensorDeviceId>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ILightSensorDeviceId" };
    };
    template <> struct name<Windows::Devices::Sensors::ILightSensorReading>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ILightSensorReading" };
    };
    template <> struct name<Windows::Devices::Sensors::ILightSensorReading2>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ILightSensorReading2" };
    };
    template <> struct name<Windows::Devices::Sensors::ILightSensorReadingChangedEventArgs>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ILightSensorReadingChangedEventArgs" };
    };
    template <> struct name<Windows::Devices::Sensors::ILightSensorStatics>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ILightSensorStatics" };
    };
    template <> struct name<Windows::Devices::Sensors::ILightSensorStatics2>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ILightSensorStatics2" };
    };
    template <> struct name<Windows::Devices::Sensors::IMagnetometer>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IMagnetometer" };
    };
    template <> struct name<Windows::Devices::Sensors::IMagnetometer2>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IMagnetometer2" };
    };
    template <> struct name<Windows::Devices::Sensors::IMagnetometer3>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IMagnetometer3" };
    };
    template <> struct name<Windows::Devices::Sensors::IMagnetometer4>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IMagnetometer4" };
    };
    template <> struct name<Windows::Devices::Sensors::IMagnetometerDataThreshold>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IMagnetometerDataThreshold" };
    };
    template <> struct name<Windows::Devices::Sensors::IMagnetometerDeviceId>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IMagnetometerDeviceId" };
    };
    template <> struct name<Windows::Devices::Sensors::IMagnetometerReading>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IMagnetometerReading" };
    };
    template <> struct name<Windows::Devices::Sensors::IMagnetometerReading2>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IMagnetometerReading2" };
    };
    template <> struct name<Windows::Devices::Sensors::IMagnetometerReadingChangedEventArgs>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IMagnetometerReadingChangedEventArgs" };
    };
    template <> struct name<Windows::Devices::Sensors::IMagnetometerStatics>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IMagnetometerStatics" };
    };
    template <> struct name<Windows::Devices::Sensors::IMagnetometerStatics2>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IMagnetometerStatics2" };
    };
    template <> struct name<Windows::Devices::Sensors::IOrientationSensor>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IOrientationSensor" };
    };
    template <> struct name<Windows::Devices::Sensors::IOrientationSensor2>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IOrientationSensor2" };
    };
    template <> struct name<Windows::Devices::Sensors::IOrientationSensor3>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IOrientationSensor3" };
    };
    template <> struct name<Windows::Devices::Sensors::IOrientationSensorDeviceId>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IOrientationSensorDeviceId" };
    };
    template <> struct name<Windows::Devices::Sensors::IOrientationSensorReading>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IOrientationSensorReading" };
    };
    template <> struct name<Windows::Devices::Sensors::IOrientationSensorReading2>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IOrientationSensorReading2" };
    };
    template <> struct name<Windows::Devices::Sensors::IOrientationSensorReadingChangedEventArgs>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IOrientationSensorReadingChangedEventArgs" };
    };
    template <> struct name<Windows::Devices::Sensors::IOrientationSensorReadingYawAccuracy>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IOrientationSensorReadingYawAccuracy" };
    };
    template <> struct name<Windows::Devices::Sensors::IOrientationSensorStatics>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IOrientationSensorStatics" };
    };
    template <> struct name<Windows::Devices::Sensors::IOrientationSensorStatics2>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IOrientationSensorStatics2" };
    };
    template <> struct name<Windows::Devices::Sensors::IOrientationSensorStatics3>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IOrientationSensorStatics3" };
    };
    template <> struct name<Windows::Devices::Sensors::IOrientationSensorStatics4>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IOrientationSensorStatics4" };
    };
    template <> struct name<Windows::Devices::Sensors::IPedometer>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IPedometer" };
    };
    template <> struct name<Windows::Devices::Sensors::IPedometer2>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IPedometer2" };
    };
    template <> struct name<Windows::Devices::Sensors::IPedometerDataThresholdFactory>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IPedometerDataThresholdFactory" };
    };
    template <> struct name<Windows::Devices::Sensors::IPedometerReading>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IPedometerReading" };
    };
    template <> struct name<Windows::Devices::Sensors::IPedometerReadingChangedEventArgs>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IPedometerReadingChangedEventArgs" };
    };
    template <> struct name<Windows::Devices::Sensors::IPedometerStatics>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IPedometerStatics" };
    };
    template <> struct name<Windows::Devices::Sensors::IPedometerStatics2>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IPedometerStatics2" };
    };
    template <> struct name<Windows::Devices::Sensors::IProximitySensor>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IProximitySensor" };
    };
    template <> struct name<Windows::Devices::Sensors::IProximitySensorDataThresholdFactory>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IProximitySensorDataThresholdFactory" };
    };
    template <> struct name<Windows::Devices::Sensors::IProximitySensorReading>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IProximitySensorReading" };
    };
    template <> struct name<Windows::Devices::Sensors::IProximitySensorReadingChangedEventArgs>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IProximitySensorReadingChangedEventArgs" };
    };
    template <> struct name<Windows::Devices::Sensors::IProximitySensorStatics>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IProximitySensorStatics" };
    };
    template <> struct name<Windows::Devices::Sensors::IProximitySensorStatics2>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.IProximitySensorStatics2" };
    };
    template <> struct name<Windows::Devices::Sensors::ISensorDataThreshold>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ISensorDataThreshold" };
    };
    template <> struct name<Windows::Devices::Sensors::ISensorDataThresholdTriggerDetails>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ISensorDataThresholdTriggerDetails" };
    };
    template <> struct name<Windows::Devices::Sensors::ISensorQuaternion>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ISensorQuaternion" };
    };
    template <> struct name<Windows::Devices::Sensors::ISensorRotationMatrix>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ISensorRotationMatrix" };
    };
    template <> struct name<Windows::Devices::Sensors::ISimpleOrientationSensor>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ISimpleOrientationSensor" };
    };
    template <> struct name<Windows::Devices::Sensors::ISimpleOrientationSensor2>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ISimpleOrientationSensor2" };
    };
    template <> struct name<Windows::Devices::Sensors::ISimpleOrientationSensorDeviceId>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ISimpleOrientationSensorDeviceId" };
    };
    template <> struct name<Windows::Devices::Sensors::ISimpleOrientationSensorOrientationChangedEventArgs>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ISimpleOrientationSensorOrientationChangedEventArgs" };
    };
    template <> struct name<Windows::Devices::Sensors::ISimpleOrientationSensorStatics>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ISimpleOrientationSensorStatics" };
    };
    template <> struct name<Windows::Devices::Sensors::ISimpleOrientationSensorStatics2>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ISimpleOrientationSensorStatics2" };
    };
    template <> struct name<Windows::Devices::Sensors::Accelerometer>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.Accelerometer" };
    };
    template <> struct name<Windows::Devices::Sensors::AccelerometerDataThreshold>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.AccelerometerDataThreshold" };
    };
    template <> struct name<Windows::Devices::Sensors::AccelerometerReading>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.AccelerometerReading" };
    };
    template <> struct name<Windows::Devices::Sensors::AccelerometerReadingChangedEventArgs>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.AccelerometerReadingChangedEventArgs" };
    };
    template <> struct name<Windows::Devices::Sensors::AccelerometerShakenEventArgs>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.AccelerometerShakenEventArgs" };
    };
    template <> struct name<Windows::Devices::Sensors::ActivitySensor>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ActivitySensor" };
    };
    template <> struct name<Windows::Devices::Sensors::ActivitySensorReading>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ActivitySensorReading" };
    };
    template <> struct name<Windows::Devices::Sensors::ActivitySensorReadingChangeReport>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ActivitySensorReadingChangeReport" };
    };
    template <> struct name<Windows::Devices::Sensors::ActivitySensorReadingChangedEventArgs>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ActivitySensorReadingChangedEventArgs" };
    };
    template <> struct name<Windows::Devices::Sensors::ActivitySensorTriggerDetails>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ActivitySensorTriggerDetails" };
    };
    template <> struct name<Windows::Devices::Sensors::Altimeter>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.Altimeter" };
    };
    template <> struct name<Windows::Devices::Sensors::AltimeterReading>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.AltimeterReading" };
    };
    template <> struct name<Windows::Devices::Sensors::AltimeterReadingChangedEventArgs>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.AltimeterReadingChangedEventArgs" };
    };
    template <> struct name<Windows::Devices::Sensors::Barometer>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.Barometer" };
    };
    template <> struct name<Windows::Devices::Sensors::BarometerDataThreshold>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.BarometerDataThreshold" };
    };
    template <> struct name<Windows::Devices::Sensors::BarometerReading>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.BarometerReading" };
    };
    template <> struct name<Windows::Devices::Sensors::BarometerReadingChangedEventArgs>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.BarometerReadingChangedEventArgs" };
    };
    template <> struct name<Windows::Devices::Sensors::Compass>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.Compass" };
    };
    template <> struct name<Windows::Devices::Sensors::CompassDataThreshold>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.CompassDataThreshold" };
    };
    template <> struct name<Windows::Devices::Sensors::CompassReading>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.CompassReading" };
    };
    template <> struct name<Windows::Devices::Sensors::CompassReadingChangedEventArgs>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.CompassReadingChangedEventArgs" };
    };
    template <> struct name<Windows::Devices::Sensors::Gyrometer>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.Gyrometer" };
    };
    template <> struct name<Windows::Devices::Sensors::GyrometerDataThreshold>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.GyrometerDataThreshold" };
    };
    template <> struct name<Windows::Devices::Sensors::GyrometerReading>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.GyrometerReading" };
    };
    template <> struct name<Windows::Devices::Sensors::GyrometerReadingChangedEventArgs>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.GyrometerReadingChangedEventArgs" };
    };
    template <> struct name<Windows::Devices::Sensors::HingeAngleReading>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.HingeAngleReading" };
    };
    template <> struct name<Windows::Devices::Sensors::HingeAngleSensor>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.HingeAngleSensor" };
    };
    template <> struct name<Windows::Devices::Sensors::HingeAngleSensorReadingChangedEventArgs>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.HingeAngleSensorReadingChangedEventArgs" };
    };
    template <> struct name<Windows::Devices::Sensors::Inclinometer>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.Inclinometer" };
    };
    template <> struct name<Windows::Devices::Sensors::InclinometerDataThreshold>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.InclinometerDataThreshold" };
    };
    template <> struct name<Windows::Devices::Sensors::InclinometerReading>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.InclinometerReading" };
    };
    template <> struct name<Windows::Devices::Sensors::InclinometerReadingChangedEventArgs>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.InclinometerReadingChangedEventArgs" };
    };
    template <> struct name<Windows::Devices::Sensors::LightSensor>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.LightSensor" };
    };
    template <> struct name<Windows::Devices::Sensors::LightSensorDataThreshold>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.LightSensorDataThreshold" };
    };
    template <> struct name<Windows::Devices::Sensors::LightSensorReading>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.LightSensorReading" };
    };
    template <> struct name<Windows::Devices::Sensors::LightSensorReadingChangedEventArgs>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.LightSensorReadingChangedEventArgs" };
    };
    template <> struct name<Windows::Devices::Sensors::Magnetometer>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.Magnetometer" };
    };
    template <> struct name<Windows::Devices::Sensors::MagnetometerDataThreshold>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.MagnetometerDataThreshold" };
    };
    template <> struct name<Windows::Devices::Sensors::MagnetometerReading>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.MagnetometerReading" };
    };
    template <> struct name<Windows::Devices::Sensors::MagnetometerReadingChangedEventArgs>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.MagnetometerReadingChangedEventArgs" };
    };
    template <> struct name<Windows::Devices::Sensors::OrientationSensor>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.OrientationSensor" };
    };
    template <> struct name<Windows::Devices::Sensors::OrientationSensorReading>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.OrientationSensorReading" };
    };
    template <> struct name<Windows::Devices::Sensors::OrientationSensorReadingChangedEventArgs>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.OrientationSensorReadingChangedEventArgs" };
    };
    template <> struct name<Windows::Devices::Sensors::Pedometer>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.Pedometer" };
    };
    template <> struct name<Windows::Devices::Sensors::PedometerDataThreshold>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.PedometerDataThreshold" };
    };
    template <> struct name<Windows::Devices::Sensors::PedometerReading>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.PedometerReading" };
    };
    template <> struct name<Windows::Devices::Sensors::PedometerReadingChangedEventArgs>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.PedometerReadingChangedEventArgs" };
    };
    template <> struct name<Windows::Devices::Sensors::ProximitySensor>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ProximitySensor" };
    };
    template <> struct name<Windows::Devices::Sensors::ProximitySensorDataThreshold>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ProximitySensorDataThreshold" };
    };
    template <> struct name<Windows::Devices::Sensors::ProximitySensorDisplayOnOffController>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ProximitySensorDisplayOnOffController" };
    };
    template <> struct name<Windows::Devices::Sensors::ProximitySensorReading>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ProximitySensorReading" };
    };
    template <> struct name<Windows::Devices::Sensors::ProximitySensorReadingChangedEventArgs>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ProximitySensorReadingChangedEventArgs" };
    };
    template <> struct name<Windows::Devices::Sensors::SensorDataThresholdTriggerDetails>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.SensorDataThresholdTriggerDetails" };
    };
    template <> struct name<Windows::Devices::Sensors::SensorQuaternion>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.SensorQuaternion" };
    };
    template <> struct name<Windows::Devices::Sensors::SensorRotationMatrix>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.SensorRotationMatrix" };
    };
    template <> struct name<Windows::Devices::Sensors::SimpleOrientationSensor>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.SimpleOrientationSensor" };
    };
    template <> struct name<Windows::Devices::Sensors::SimpleOrientationSensorOrientationChangedEventArgs>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.SimpleOrientationSensorOrientationChangedEventArgs" };
    };
    template <> struct name<Windows::Devices::Sensors::AccelerometerReadingType>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.AccelerometerReadingType" };
    };
    template <> struct name<Windows::Devices::Sensors::ActivitySensorReadingConfidence>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ActivitySensorReadingConfidence" };
    };
    template <> struct name<Windows::Devices::Sensors::ActivityType>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.ActivityType" };
    };
    template <> struct name<Windows::Devices::Sensors::MagnetometerAccuracy>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.MagnetometerAccuracy" };
    };
    template <> struct name<Windows::Devices::Sensors::PedometerStepKind>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.PedometerStepKind" };
    };
    template <> struct name<Windows::Devices::Sensors::SensorOptimizationGoal>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.SensorOptimizationGoal" };
    };
    template <> struct name<Windows::Devices::Sensors::SensorReadingType>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.SensorReadingType" };
    };
    template <> struct name<Windows::Devices::Sensors::SensorType>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.SensorType" };
    };
    template <> struct name<Windows::Devices::Sensors::SimpleOrientation>
    {
        static constexpr auto & value{ L"Windows.Devices.Sensors.SimpleOrientation" };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IAccelerometer>
    {
        static constexpr guid value{ 0xDF184548,0x2711,0x4DA7,{ 0x80,0x98,0x4B,0x82,0x20,0x5D,0x3C,0x7D } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IAccelerometer2>
    {
        static constexpr guid value{ 0xE8F092EE,0x4964,0x401A,{ 0xB6,0x02,0x22,0x0D,0x71,0x53,0xC6,0x0A } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IAccelerometer3>
    {
        static constexpr guid value{ 0x87E0022A,0xED80,0x49EB,{ 0xBF,0x8A,0xA4,0xEA,0x31,0xE5,0xCD,0x84 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IAccelerometer4>
    {
        static constexpr guid value{ 0x1D373C4F,0x42D3,0x45B2,{ 0x81,0x44,0xAB,0x7F,0xB6,0x65,0xEB,0x59 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IAccelerometer5>
    {
        static constexpr guid value{ 0x7E7E7021,0xDEF4,0x53A6,{ 0xAF,0x43,0x80,0x6F,0xD5,0x38,0xED,0xF6 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IAccelerometerDataThreshold>
    {
        static constexpr guid value{ 0xF92C1B68,0x6320,0x5577,{ 0x87,0x9E,0x99,0x42,0x62,0x1C,0x3D,0xD9 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IAccelerometerDeviceId>
    {
        static constexpr guid value{ 0x7EAC64A9,0x97D5,0x446D,{ 0xAB,0x5A,0x91,0x7D,0xF9,0xB9,0x6A,0x2C } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IAccelerometerReading>
    {
        static constexpr guid value{ 0xB9FE7ACB,0xD351,0x40AF,{ 0x8B,0xB6,0x7A,0xA9,0xAE,0x64,0x1F,0xB7 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IAccelerometerReading2>
    {
        static constexpr guid value{ 0x0A864AA2,0x15AE,0x4A40,{ 0xBE,0x55,0xDB,0x58,0xD7,0xDE,0x73,0x89 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IAccelerometerReadingChangedEventArgs>
    {
        static constexpr guid value{ 0x0095C65B,0xB6AC,0x475A,{ 0x9F,0x44,0x8B,0x32,0xD3,0x5A,0x3F,0x25 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IAccelerometerShakenEventArgs>
    {
        static constexpr guid value{ 0x95FF01D1,0x4A28,0x4F35,{ 0x98,0xE8,0x81,0x78,0xAA,0xE4,0x08,0x4A } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IAccelerometerStatics>
    {
        static constexpr guid value{ 0xA5E28B74,0x5A87,0x4A2D,{ 0xBE,0xCC,0x0F,0x90,0x6E,0xA0,0x61,0xDD } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IAccelerometerStatics2>
    {
        static constexpr guid value{ 0xC4C4842F,0xD86B,0x4685,{ 0xB2,0xD7,0x33,0x96,0xF7,0x98,0xD5,0x7B } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IAccelerometerStatics3>
    {
        static constexpr guid value{ 0x9DE218CF,0x455D,0x4CF3,{ 0x82,0x00,0x70,0xE1,0x41,0x03,0x40,0xF8 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IActivitySensor>
    {
        static constexpr guid value{ 0xCD7A630C,0xFB5F,0x48EB,{ 0xB0,0x9B,0xA2,0x70,0x8D,0x1C,0x61,0xEF } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IActivitySensorReading>
    {
        static constexpr guid value{ 0x85125A96,0x1472,0x40A2,{ 0xB2,0xAE,0xE1,0xEF,0x29,0x22,0x6C,0x78 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IActivitySensorReadingChangeReport>
    {
        static constexpr guid value{ 0x4F3C2915,0xD93B,0x47BD,{ 0x96,0x0A,0xF2,0x0F,0xB2,0xF3,0x22,0xB9 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IActivitySensorReadingChangedEventArgs>
    {
        static constexpr guid value{ 0xDE386717,0xAEB6,0x4EC7,{ 0x94,0x6A,0xD9,0xCC,0x19,0xB9,0x51,0xEC } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IActivitySensorStatics>
    {
        static constexpr guid value{ 0xA71E0E9D,0xEE8B,0x45D1,{ 0xB2,0x5B,0x08,0xCC,0x0D,0xF9,0x2A,0xB6 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IActivitySensorTriggerDetails>
    {
        static constexpr guid value{ 0x2C9E6612,0xB9CA,0x4677,{ 0xB2,0x63,0x24,0x32,0x97,0xF7,0x9D,0x3A } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IAltimeter>
    {
        static constexpr guid value{ 0x72F057FD,0x8F04,0x49F1,{ 0xB4,0xA7,0xF4,0xE3,0x63,0xB7,0x01,0xA2 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IAltimeter2>
    {
        static constexpr guid value{ 0xC9471BF9,0x2ADD,0x48F5,{ 0x9F,0x08,0x3D,0x0C,0x76,0x60,0xD9,0x38 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IAltimeterReading>
    {
        static constexpr guid value{ 0xFBE8EF73,0x7F5E,0x48C8,{ 0xAA,0x1A,0xF1,0xF3,0xBE,0xFC,0x11,0x44 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IAltimeterReading2>
    {
        static constexpr guid value{ 0x543A1BD9,0x6D0B,0x42B2,{ 0xBD,0x69,0xBC,0x8F,0xAE,0x0F,0x78,0x2C } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IAltimeterReadingChangedEventArgs>
    {
        static constexpr guid value{ 0x7069D077,0x446D,0x47F7,{ 0x99,0x8C,0xEB,0xC2,0x3B,0x45,0xE4,0xA2 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IAltimeterStatics>
    {
        static constexpr guid value{ 0x9EB4D7C3,0xE5AC,0x47CE,{ 0x8E,0xEF,0xD3,0x71,0x81,0x68,0xC0,0x1F } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IBarometer>
    {
        static constexpr guid value{ 0x934475A8,0x78BF,0x452F,{ 0xB0,0x17,0xF0,0x20,0x9C,0xE6,0xDA,0xB4 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IBarometer2>
    {
        static constexpr guid value{ 0x32BCC418,0x3EEB,0x4D04,{ 0x95,0x74,0x76,0x33,0xA8,0x78,0x1F,0x9F } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IBarometer3>
    {
        static constexpr guid value{ 0x0E35F0EA,0x02B5,0x5A04,{ 0xB0,0x3D,0x82,0x20,0x84,0x86,0x3A,0x54 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IBarometerDataThreshold>
    {
        static constexpr guid value{ 0x076B952C,0xCB62,0x5A90,{ 0xA0,0xD1,0xF8,0x5E,0x4A,0x93,0x63,0x94 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IBarometerReading>
    {
        static constexpr guid value{ 0xF5B9D2E6,0x1DF6,0x4A1A,{ 0xA7,0xAD,0x32,0x1D,0x4F,0x5D,0xB2,0x47 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IBarometerReading2>
    {
        static constexpr guid value{ 0x85A244EB,0x90C5,0x4875,{ 0x89,0x1C,0x38,0x65,0xB4,0xC3,0x57,0xE7 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IBarometerReadingChangedEventArgs>
    {
        static constexpr guid value{ 0x3D84945F,0x037B,0x404F,{ 0x9B,0xBB,0x62,0x32,0xD6,0x95,0x43,0xC3 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IBarometerStatics>
    {
        static constexpr guid value{ 0x286B270A,0x02E3,0x4F86,{ 0x84,0xFC,0xFD,0xD8,0x92,0xB5,0x94,0x0F } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IBarometerStatics2>
    {
        static constexpr guid value{ 0x8FC6B1E7,0x95FF,0x44AC,{ 0x87,0x8E,0xD6,0x5C,0x83,0x08,0xC3,0x4C } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::ICompass>
    {
        static constexpr guid value{ 0x292FFA94,0x1B45,0x403C,{ 0xBA,0x06,0xB1,0x06,0xDB,0xA6,0x9A,0x64 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::ICompass2>
    {
        static constexpr guid value{ 0x36F26D09,0xC7D7,0x434F,{ 0xB4,0x61,0x97,0x9D,0xDF,0xC2,0x32,0x2F } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::ICompass3>
    {
        static constexpr guid value{ 0xA424801B,0xC5EA,0x4D45,{ 0xA0,0xEC,0x4B,0x79,0x1F,0x04,0x1A,0x89 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::ICompass4>
    {
        static constexpr guid value{ 0x291E7F11,0xEC32,0x5DCC,{ 0xBF,0xCB,0x0B,0xB3,0x9E,0xBA,0x57,0x74 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::ICompassDataThreshold>
    {
        static constexpr guid value{ 0xD15B52B3,0xD39D,0x5EC8,{ 0xB2,0xE4,0xF1,0x93,0xE6,0xAB,0x34,0xED } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::ICompassDeviceId>
    {
        static constexpr guid value{ 0xD181CA29,0xB085,0x4B1D,{ 0x87,0x0A,0x4F,0xF5,0x7B,0xA7,0x4F,0xD4 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::ICompassReading>
    {
        static constexpr guid value{ 0x82911128,0x513D,0x4DC9,{ 0xB7,0x81,0x5E,0xED,0xFB,0xF0,0x2D,0x0C } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::ICompassReading2>
    {
        static constexpr guid value{ 0xB13A661E,0x51BB,0x4A12,{ 0xBE,0xDD,0xAD,0x47,0xFF,0x87,0xD2,0xE8 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::ICompassReadingChangedEventArgs>
    {
        static constexpr guid value{ 0x8F1549B0,0xE8BC,0x4C7E,{ 0xB0,0x09,0x4E,0x41,0xDF,0x13,0x70,0x72 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::ICompassReadingHeadingAccuracy>
    {
        static constexpr guid value{ 0xE761354E,0x8911,0x40F7,{ 0x9E,0x16,0x6E,0xCC,0x7D,0xAE,0xC5,0xDE } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::ICompassStatics>
    {
        static constexpr guid value{ 0x9ABC97DF,0x56EC,0x4C25,{ 0xB5,0x4D,0x40,0xA6,0x8B,0xB5,0xB2,0x69 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::ICompassStatics2>
    {
        static constexpr guid value{ 0x0ACE0EAD,0x3BAA,0x4990,{ 0x9C,0xE4,0xBE,0x09,0x13,0x75,0x4E,0xD2 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IGyrometer>
    {
        static constexpr guid value{ 0xFDB9A9C4,0x84B1,0x4CA2,{ 0x97,0x63,0x9B,0x58,0x95,0x06,0xC7,0x0C } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IGyrometer2>
    {
        static constexpr guid value{ 0x63DF2443,0x8CE8,0x41C3,{ 0xAC,0x44,0x86,0x98,0x81,0x0B,0x55,0x7F } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IGyrometer3>
    {
        static constexpr guid value{ 0x5D6F88D5,0x8FBC,0x4484,{ 0x91,0x4B,0x52,0x8A,0xDF,0xD9,0x47,0xB1 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IGyrometer4>
    {
        static constexpr guid value{ 0x0628A60C,0x4C4B,0x5096,{ 0x94,0xE6,0xC3,0x56,0xDF,0x68,0xBE,0xF7 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IGyrometerDataThreshold>
    {
        static constexpr guid value{ 0x8648B31E,0x6E52,0x5259,{ 0xBB,0xAD,0x24,0x2A,0x69,0xDC,0x38,0xC8 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IGyrometerDeviceId>
    {
        static constexpr guid value{ 0x1EE5E978,0x89A2,0x4275,{ 0x9E,0x95,0x71,0x26,0xF4,0x70,0x87,0x60 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IGyrometerReading>
    {
        static constexpr guid value{ 0xB3D6DE5C,0x1EE4,0x456F,{ 0x9D,0xE7,0xE2,0x49,0x3B,0x5C,0x8E,0x03 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IGyrometerReading2>
    {
        static constexpr guid value{ 0x16AFE13C,0x2B89,0x44BB,{ 0x82,0x2B,0xD1,0xE1,0x55,0x6F,0xF0,0x9B } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IGyrometerReadingChangedEventArgs>
    {
        static constexpr guid value{ 0x0FDF1895,0x6F9E,0x42CE,{ 0x8D,0x58,0x38,0x8C,0x0A,0xB8,0x35,0x6D } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IGyrometerStatics>
    {
        static constexpr guid value{ 0x83B6E7C9,0xE49D,0x4B39,{ 0x86,0xE6,0xCD,0x55,0x4B,0xE4,0xC5,0xC1 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IGyrometerStatics2>
    {
        static constexpr guid value{ 0xEF83F7A1,0xD700,0x4204,{ 0x96,0x13,0x79,0xC6,0xB1,0x61,0xDF,0x4E } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IHingeAngleReading>
    {
        static constexpr guid value{ 0xA3CD45B9,0x1BF1,0x4F65,{ 0xA7,0x04,0xE2,0xDA,0x04,0xF1,0x82,0xC0 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IHingeAngleSensor>
    {
        static constexpr guid value{ 0xE9D3BE02,0xBFDF,0x437F,{ 0x8C,0x29,0x88,0xC7,0x73,0x93,0xD3,0x09 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IHingeAngleSensorReadingChangedEventArgs>
    {
        static constexpr guid value{ 0x24D9558B,0xFAD0,0x42B8,{ 0xA8,0x54,0x78,0x92,0x30,0x49,0xA1,0xBA } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IHingeAngleSensorStatics>
    {
        static constexpr guid value{ 0xB7B63910,0xFBB1,0x4123,{ 0x89,0xCE,0x4E,0xA3,0x4E,0xB0,0xDF,0xCA } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IInclinometer>
    {
        static constexpr guid value{ 0x2648CA6F,0x2286,0x406F,{ 0x91,0x61,0xF0,0xC4,0xBD,0x80,0x6E,0xBF } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IInclinometer2>
    {
        static constexpr guid value{ 0x029F3393,0x28B2,0x45F8,{ 0xBB,0x16,0x61,0xE8,0x6A,0x7F,0xAE,0x6E } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IInclinometer3>
    {
        static constexpr guid value{ 0x3A095004,0xD765,0x4384,{ 0xA3,0xD7,0x02,0x83,0xF3,0xAB,0xE6,0xAE } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IInclinometer4>
    {
        static constexpr guid value{ 0x43852618,0x8FCA,0x548E,{ 0xBB,0xF5,0x5C,0x50,0x41,0x2B,0x6A,0xA4 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IInclinometerDataThreshold>
    {
        static constexpr guid value{ 0xF80A4783,0x7BFE,0x545E,{ 0xBB,0x60,0xA0,0xEB,0xC4,0x7B,0xD2,0xFB } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IInclinometerDeviceId>
    {
        static constexpr guid value{ 0x01E91982,0x41FF,0x4406,{ 0xAE,0x83,0x62,0x21,0x0F,0xF1,0x6F,0xE3 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IInclinometerReading>
    {
        static constexpr guid value{ 0x9F44F055,0xB6F6,0x497F,{ 0xB1,0x27,0x1A,0x77,0x5E,0x50,0x14,0x58 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IInclinometerReading2>
    {
        static constexpr guid value{ 0x4F164781,0xE90B,0x4658,{ 0x89,0x15,0x01,0x03,0xE0,0x8A,0x80,0x5A } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IInclinometerReadingChangedEventArgs>
    {
        static constexpr guid value{ 0x4AE91DC1,0xE7EB,0x4938,{ 0x85,0x11,0xAE,0x0D,0x6B,0x44,0x04,0x38 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IInclinometerReadingYawAccuracy>
    {
        static constexpr guid value{ 0xB453E880,0x1FE3,0x4986,{ 0xA2,0x57,0xE6,0xEC,0xE2,0x72,0x39,0x49 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IInclinometerStatics>
    {
        static constexpr guid value{ 0xF22EC551,0x9C30,0x453A,{ 0x8B,0x49,0x3C,0x3E,0xEB,0x33,0xCB,0x61 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IInclinometerStatics2>
    {
        static constexpr guid value{ 0x043F9775,0x6A1E,0x499C,{ 0x86,0xE0,0x63,0x8C,0x1A,0x86,0x4B,0x00 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IInclinometerStatics3>
    {
        static constexpr guid value{ 0xBD9A4280,0xB91A,0x4829,{ 0x93,0x92,0xAB,0xC0,0xB6,0xBD,0xF2,0xB4 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IInclinometerStatics4>
    {
        static constexpr guid value{ 0xE8BA96F9,0x6E85,0x4A83,{ 0xAE,0xD0,0xD7,0xCD,0xCC,0x98,0x56,0xC8 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::ILightSensor>
    {
        static constexpr guid value{ 0xF84C0718,0x0C54,0x47AE,{ 0x92,0x2E,0x78,0x9F,0x57,0xFB,0x03,0xA0 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::ILightSensor2>
    {
        static constexpr guid value{ 0x486B24E8,0xA94C,0x4090,{ 0x8F,0x48,0x09,0xF7,0x82,0xA9,0xF7,0xD5 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::ILightSensor3>
    {
        static constexpr guid value{ 0x4876D0FF,0x9F4C,0x5F72,{ 0xAD,0xBD,0xA3,0x47,0x1B,0x06,0x3C,0x00 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::ILightSensorDataThreshold>
    {
        static constexpr guid value{ 0xB160AFD1,0x878F,0x5492,{ 0x9F,0x2C,0x33,0xDC,0x3A,0xE5,0x84,0xA3 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::ILightSensorDeviceId>
    {
        static constexpr guid value{ 0x7FEE49F8,0x0AFB,0x4F51,{ 0x87,0xF0,0x6C,0x26,0x37,0x5C,0xE9,0x4F } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::ILightSensorReading>
    {
        static constexpr guid value{ 0xFFDF6300,0x227C,0x4D2B,{ 0xB3,0x02,0xFC,0x01,0x42,0x48,0x5C,0x68 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::ILightSensorReading2>
    {
        static constexpr guid value{ 0xB7512185,0x44A3,0x44C9,{ 0x81,0x90,0x9E,0xF6,0xDE,0x0A,0x8A,0x74 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::ILightSensorReadingChangedEventArgs>
    {
        static constexpr guid value{ 0xA3A2F4CF,0x258B,0x420C,{ 0xB8,0xAB,0x8E,0xDD,0x60,0x1E,0xCF,0x50 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::ILightSensorStatics>
    {
        static constexpr guid value{ 0x45DB8C84,0xC3A8,0x471E,{ 0x9A,0x53,0x64,0x57,0xFA,0xD8,0x7C,0x0E } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::ILightSensorStatics2>
    {
        static constexpr guid value{ 0x0EC0A650,0xDDC6,0x40AB,{ 0xAC,0xE3,0xEC,0x33,0x59,0xD4,0x2C,0x51 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IMagnetometer>
    {
        static constexpr guid value{ 0x484F626E,0xD3C9,0x4111,{ 0xB3,0xF6,0x2C,0xF1,0xFA,0xA4,0x18,0xD5 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IMagnetometer2>
    {
        static constexpr guid value{ 0xB4656C85,0x26F6,0x444B,{ 0xA9,0xE2,0xA2,0x3F,0x96,0x6C,0xD3,0x68 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IMagnetometer3>
    {
        static constexpr guid value{ 0xBE93DB7C,0xA625,0x48EF,{ 0xAC,0xF7,0xFA,0xC1,0x04,0x83,0x26,0x71 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IMagnetometer4>
    {
        static constexpr guid value{ 0xDFB17901,0x3E0F,0x508F,{ 0xB2,0x4B,0xF2,0xBB,0x75,0x01,0x5F,0x40 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IMagnetometerDataThreshold>
    {
        static constexpr guid value{ 0xD177CB01,0x9063,0x5FA5,{ 0xB5,0x96,0xB4,0x45,0xE9,0xDC,0x34,0x01 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IMagnetometerDeviceId>
    {
        static constexpr guid value{ 0x58B498C2,0x7E4B,0x404C,{ 0x9F,0xC5,0x5D,0xE8,0xB4,0x0E,0xBA,0xE3 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IMagnetometerReading>
    {
        static constexpr guid value{ 0x0C2CC40D,0xEBFD,0x4E5C,{ 0xBB,0x11,0xAF,0xC2,0x9B,0x3C,0xAE,0x61 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IMagnetometerReading2>
    {
        static constexpr guid value{ 0xD4C95C61,0x61D9,0x404B,{ 0xA3,0x28,0x06,0x6F,0x17,0x7A,0x14,0x09 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IMagnetometerReadingChangedEventArgs>
    {
        static constexpr guid value{ 0x17EAE872,0x2EB9,0x4EE7,{ 0x8A,0xD0,0x31,0x27,0x53,0x7D,0x94,0x9B } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IMagnetometerStatics>
    {
        static constexpr guid value{ 0x853C64CC,0x0698,0x4DDA,{ 0xA6,0xDF,0x9C,0xB9,0xCC,0x4A,0xB4,0x0A } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IMagnetometerStatics2>
    {
        static constexpr guid value{ 0x2C0819F0,0xFFC6,0x4F89,{ 0xA0,0x6F,0x18,0xFA,0x10,0x79,0x29,0x33 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IOrientationSensor>
    {
        static constexpr guid value{ 0x5E354635,0xCF6B,0x4C63,{ 0xAB,0xD8,0x10,0x25,0x2B,0x0B,0xF6,0xEC } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IOrientationSensor2>
    {
        static constexpr guid value{ 0x0D924CF9,0x2F1F,0x49C9,{ 0x80,0x42,0x4A,0x18,0x13,0xD6,0x77,0x60 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IOrientationSensor3>
    {
        static constexpr guid value{ 0x2CCE578D,0x646B,0x48C5,{ 0xB7,0xEE,0x44,0xFD,0xC4,0xC6,0xAA,0xFD } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IOrientationSensorDeviceId>
    {
        static constexpr guid value{ 0x5A69B648,0x4C29,0x49EC,{ 0xB2,0x8F,0xEA,0x1D,0x11,0x7B,0x66,0xF0 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IOrientationSensorReading>
    {
        static constexpr guid value{ 0x4756C993,0x6595,0x4897,{ 0xBC,0xC6,0xD5,0x37,0xEE,0x75,0x75,0x64 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IOrientationSensorReading2>
    {
        static constexpr guid value{ 0x00576E5F,0x49F8,0x4C05,{ 0x9E,0x07,0x24,0xFA,0xC7,0x94,0x08,0xC3 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IOrientationSensorReadingChangedEventArgs>
    {
        static constexpr guid value{ 0x012C1186,0xC3BA,0x46BC,{ 0xAE,0x65,0x7A,0x98,0x99,0x6C,0xBF,0xB8 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IOrientationSensorReadingYawAccuracy>
    {
        static constexpr guid value{ 0xD1AC9824,0x3F5A,0x49A2,{ 0xBC,0x7B,0x11,0x80,0xBC,0x38,0xCD,0x2B } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IOrientationSensorStatics>
    {
        static constexpr guid value{ 0x10EF8712,0xFB4C,0x428A,{ 0x89,0x8B,0x27,0x65,0xE4,0x09,0xE6,0x69 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IOrientationSensorStatics2>
    {
        static constexpr guid value{ 0x59DA0D0B,0xD40A,0x4C71,{ 0x92,0x76,0x8A,0x27,0x2A,0x0A,0x66,0x19 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IOrientationSensorStatics3>
    {
        static constexpr guid value{ 0xD82CE920,0x2777,0x40FF,{ 0x9F,0x59,0xD6,0x54,0xB0,0x85,0xF1,0x2F } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IOrientationSensorStatics4>
    {
        static constexpr guid value{ 0xA67FEB55,0x2C85,0x4B28,{ 0xA0,0xFE,0x58,0xC4,0xB2,0x04,0x95,0xF5 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IPedometer>
    {
        static constexpr guid value{ 0x9A1E013D,0x3D98,0x45F8,{ 0x89,0x20,0x8E,0x4E,0xCA,0xCA,0x5F,0x97 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IPedometer2>
    {
        static constexpr guid value{ 0xE5A406DF,0x2B81,0x4ADD,{ 0xB2,0xFF,0x77,0xAB,0x6C,0x98,0xBA,0x19 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IPedometerDataThresholdFactory>
    {
        static constexpr guid value{ 0xCBAD8F50,0x7A54,0x466B,{ 0x90,0x10,0x77,0xA1,0x62,0xFC,0xA5,0xD7 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IPedometerReading>
    {
        static constexpr guid value{ 0x2245DCF4,0xA8E1,0x432F,{ 0x89,0x6A,0xBE,0x0D,0xD9,0xB0,0x2D,0x24 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IPedometerReadingChangedEventArgs>
    {
        static constexpr guid value{ 0xF855E47E,0xABBC,0x4456,{ 0x86,0xA8,0x25,0xCF,0x2B,0x33,0x37,0x42 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IPedometerStatics>
    {
        static constexpr guid value{ 0x82980A2F,0x4083,0x4DFB,{ 0xB4,0x11,0x93,0x8E,0xA0,0xF4,0xB9,0x46 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IPedometerStatics2>
    {
        static constexpr guid value{ 0x79F5C6BB,0xCE0E,0x4133,{ 0xB4,0x7E,0x86,0x27,0xEA,0x72,0xF6,0x77 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IProximitySensor>
    {
        static constexpr guid value{ 0x54C076B8,0xECFB,0x4944,{ 0xB9,0x28,0x74,0xFC,0x50,0x4D,0x47,0xEE } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IProximitySensorDataThresholdFactory>
    {
        static constexpr guid value{ 0x905AC121,0x6D27,0x4AD3,{ 0x9D,0xB5,0x64,0x67,0xF2,0xA5,0xAD,0x9D } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IProximitySensorReading>
    {
        static constexpr guid value{ 0x71228D59,0x132D,0x4D5F,{ 0x8F,0xF9,0x2F,0x0D,0xB8,0x75,0x1C,0xED } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IProximitySensorReadingChangedEventArgs>
    {
        static constexpr guid value{ 0xCFC2F366,0xC3E8,0x40FD,{ 0x8C,0xC3,0x67,0xE2,0x89,0x00,0x49,0x38 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IProximitySensorStatics>
    {
        static constexpr guid value{ 0x29186649,0x6269,0x4E57,{ 0xA5,0xAD,0x82,0xBE,0x80,0x81,0x33,0x92 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::IProximitySensorStatics2>
    {
        static constexpr guid value{ 0xCBF473AE,0xE9CA,0x422F,{ 0xAD,0x67,0x4C,0x3D,0x25,0xDF,0x35,0x0C } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::ISensorDataThreshold>
    {
        static constexpr guid value{ 0x54DAEC61,0xFE4B,0x4E07,{ 0xB2,0x60,0x3A,0x4C,0xDF,0xBE,0x39,0x6E } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::ISensorDataThresholdTriggerDetails>
    {
        static constexpr guid value{ 0x9106F1B7,0xE88D,0x48B1,{ 0xBC,0x90,0x61,0x9C,0x7B,0x34,0x93,0x91 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::ISensorQuaternion>
    {
        static constexpr guid value{ 0xC9C5C827,0xC71C,0x46E7,{ 0x9D,0xA3,0x36,0xA1,0x93,0xB2,0x32,0xBC } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::ISensorRotationMatrix>
    {
        static constexpr guid value{ 0x0A3D5A67,0x22F4,0x4392,{ 0x95,0x38,0x65,0xD0,0xBD,0x06,0x4A,0xA6 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::ISimpleOrientationSensor>
    {
        static constexpr guid value{ 0x5FF53856,0x214A,0x4DEE,{ 0xA3,0xF9,0x61,0x6F,0x1A,0xB0,0x6F,0xFD } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::ISimpleOrientationSensor2>
    {
        static constexpr guid value{ 0xA277A798,0x8870,0x453E,{ 0x8B,0xD6,0xB8,0xF5,0xD8,0xD7,0x94,0x1B } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::ISimpleOrientationSensorDeviceId>
    {
        static constexpr guid value{ 0xFBC00ACB,0x3B76,0x41F6,{ 0x80,0x91,0x30,0xEF,0xE6,0x46,0xD3,0xCF } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::ISimpleOrientationSensorOrientationChangedEventArgs>
    {
        static constexpr guid value{ 0xBCD5C660,0x23D4,0x4B4C,{ 0xA2,0x2E,0xBA,0x81,0xAD,0xE0,0xC6,0x01 } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::ISimpleOrientationSensorStatics>
    {
        static constexpr guid value{ 0x72ED066F,0x70AA,0x40C6,{ 0x9B,0x1B,0x34,0x33,0xF7,0x45,0x9B,0x4E } };
    };
    template <> struct guid_storage<Windows::Devices::Sensors::ISimpleOrientationSensorStatics2>
    {
        static constexpr guid value{ 0x848F9C7F,0xB138,0x4E11,{ 0x89,0x10,0xA2,0xA2,0xA3,0xB5,0x6D,0x83 } };
    };
    template <> struct default_interface<Windows::Devices::Sensors::Accelerometer>
    {
        using type = Windows::Devices::Sensors::IAccelerometer;
    };
    template <> struct default_interface<Windows::Devices::Sensors::AccelerometerDataThreshold>
    {
        using type = Windows::Devices::Sensors::IAccelerometerDataThreshold;
    };
    template <> struct default_interface<Windows::Devices::Sensors::AccelerometerReading>
    {
        using type = Windows::Devices::Sensors::IAccelerometerReading;
    };
    template <> struct default_interface<Windows::Devices::Sensors::AccelerometerReadingChangedEventArgs>
    {
        using type = Windows::Devices::Sensors::IAccelerometerReadingChangedEventArgs;
    };
    template <> struct default_interface<Windows::Devices::Sensors::AccelerometerShakenEventArgs>
    {
        using type = Windows::Devices::Sensors::IAccelerometerShakenEventArgs;
    };
    template <> struct default_interface<Windows::Devices::Sensors::ActivitySensor>
    {
        using type = Windows::Devices::Sensors::IActivitySensor;
    };
    template <> struct default_interface<Windows::Devices::Sensors::ActivitySensorReading>
    {
        using type = Windows::Devices::Sensors::IActivitySensorReading;
    };
    template <> struct default_interface<Windows::Devices::Sensors::ActivitySensorReadingChangeReport>
    {
        using type = Windows::Devices::Sensors::IActivitySensorReadingChangeReport;
    };
    template <> struct default_interface<Windows::Devices::Sensors::ActivitySensorReadingChangedEventArgs>
    {
        using type = Windows::Devices::Sensors::IActivitySensorReadingChangedEventArgs;
    };
    template <> struct default_interface<Windows::Devices::Sensors::ActivitySensorTriggerDetails>
    {
        using type = Windows::Devices::Sensors::IActivitySensorTriggerDetails;
    };
    template <> struct default_interface<Windows::Devices::Sensors::Altimeter>
    {
        using type = Windows::Devices::Sensors::IAltimeter;
    };
    template <> struct default_interface<Windows::Devices::Sensors::AltimeterReading>
    {
        using type = Windows::Devices::Sensors::IAltimeterReading;
    };
    template <> struct default_interface<Windows::Devices::Sensors::AltimeterReadingChangedEventArgs>
    {
        using type = Windows::Devices::Sensors::IAltimeterReadingChangedEventArgs;
    };
    template <> struct default_interface<Windows::Devices::Sensors::Barometer>
    {
        using type = Windows::Devices::Sensors::IBarometer;
    };
    template <> struct default_interface<Windows::Devices::Sensors::BarometerDataThreshold>
    {
        using type = Windows::Devices::Sensors::IBarometerDataThreshold;
    };
    template <> struct default_interface<Windows::Devices::Sensors::BarometerReading>
    {
        using type = Windows::Devices::Sensors::IBarometerReading;
    };
    template <> struct default_interface<Windows::Devices::Sensors::BarometerReadingChangedEventArgs>
    {
        using type = Windows::Devices::Sensors::IBarometerReadingChangedEventArgs;
    };
    template <> struct default_interface<Windows::Devices::Sensors::Compass>
    {
        using type = Windows::Devices::Sensors::ICompass;
    };
    template <> struct default_interface<Windows::Devices::Sensors::CompassDataThreshold>
    {
        using type = Windows::Devices::Sensors::ICompassDataThreshold;
    };
    template <> struct default_interface<Windows::Devices::Sensors::CompassReading>
    {
        using type = Windows::Devices::Sensors::ICompassReading;
    };
    template <> struct default_interface<Windows::Devices::Sensors::CompassReadingChangedEventArgs>
    {
        using type = Windows::Devices::Sensors::ICompassReadingChangedEventArgs;
    };
    template <> struct default_interface<Windows::Devices::Sensors::Gyrometer>
    {
        using type = Windows::Devices::Sensors::IGyrometer;
    };
    template <> struct default_interface<Windows::Devices::Sensors::GyrometerDataThreshold>
    {
        using type = Windows::Devices::Sensors::IGyrometerDataThreshold;
    };
    template <> struct default_interface<Windows::Devices::Sensors::GyrometerReading>
    {
        using type = Windows::Devices::Sensors::IGyrometerReading;
    };
    template <> struct default_interface<Windows::Devices::Sensors::GyrometerReadingChangedEventArgs>
    {
        using type = Windows::Devices::Sensors::IGyrometerReadingChangedEventArgs;
    };
    template <> struct default_interface<Windows::Devices::Sensors::HingeAngleReading>
    {
        using type = Windows::Devices::Sensors::IHingeAngleReading;
    };
    template <> struct default_interface<Windows::Devices::Sensors::HingeAngleSensor>
    {
        using type = Windows::Devices::Sensors::IHingeAngleSensor;
    };
    template <> struct default_interface<Windows::Devices::Sensors::HingeAngleSensorReadingChangedEventArgs>
    {
        using type = Windows::Devices::Sensors::IHingeAngleSensorReadingChangedEventArgs;
    };
    template <> struct default_interface<Windows::Devices::Sensors::Inclinometer>
    {
        using type = Windows::Devices::Sensors::IInclinometer;
    };
    template <> struct default_interface<Windows::Devices::Sensors::InclinometerDataThreshold>
    {
        using type = Windows::Devices::Sensors::IInclinometerDataThreshold;
    };
    template <> struct default_interface<Windows::Devices::Sensors::InclinometerReading>
    {
        using type = Windows::Devices::Sensors::IInclinometerReading;
    };
    template <> struct default_interface<Windows::Devices::Sensors::InclinometerReadingChangedEventArgs>
    {
        using type = Windows::Devices::Sensors::IInclinometerReadingChangedEventArgs;
    };
    template <> struct default_interface<Windows::Devices::Sensors::LightSensor>
    {
        using type = Windows::Devices::Sensors::ILightSensor;
    };
    template <> struct default_interface<Windows::Devices::Sensors::LightSensorDataThreshold>
    {
        using type = Windows::Devices::Sensors::ILightSensorDataThreshold;
    };
    template <> struct default_interface<Windows::Devices::Sensors::LightSensorReading>
    {
        using type = Windows::Devices::Sensors::ILightSensorReading;
    };
    template <> struct default_interface<Windows::Devices::Sensors::LightSensorReadingChangedEventArgs>
    {
        using type = Windows::Devices::Sensors::ILightSensorReadingChangedEventArgs;
    };
    template <> struct default_interface<Windows::Devices::Sensors::Magnetometer>
    {
        using type = Windows::Devices::Sensors::IMagnetometer;
    };
    template <> struct default_interface<Windows::Devices::Sensors::MagnetometerDataThreshold>
    {
        using type = Windows::Devices::Sensors::IMagnetometerDataThreshold;
    };
    template <> struct default_interface<Windows::Devices::Sensors::MagnetometerReading>
    {
        using type = Windows::Devices::Sensors::IMagnetometerReading;
    };
    template <> struct default_interface<Windows::Devices::Sensors::MagnetometerReadingChangedEventArgs>
    {
        using type = Windows::Devices::Sensors::IMagnetometerReadingChangedEventArgs;
    };
    template <> struct default_interface<Windows::Devices::Sensors::OrientationSensor>
    {
        using type = Windows::Devices::Sensors::IOrientationSensor;
    };
    template <> struct default_interface<Windows::Devices::Sensors::OrientationSensorReading>
    {
        using type = Windows::Devices::Sensors::IOrientationSensorReading;
    };
    template <> struct default_interface<Windows::Devices::Sensors::OrientationSensorReadingChangedEventArgs>
    {
        using type = Windows::Devices::Sensors::IOrientationSensorReadingChangedEventArgs;
    };
    template <> struct default_interface<Windows::Devices::Sensors::Pedometer>
    {
        using type = Windows::Devices::Sensors::IPedometer;
    };
    template <> struct default_interface<Windows::Devices::Sensors::PedometerDataThreshold>
    {
        using type = Windows::Devices::Sensors::ISensorDataThreshold;
    };
    template <> struct default_interface<Windows::Devices::Sensors::PedometerReading>
    {
        using type = Windows::Devices::Sensors::IPedometerReading;
    };
    template <> struct default_interface<Windows::Devices::Sensors::PedometerReadingChangedEventArgs>
    {
        using type = Windows::Devices::Sensors::IPedometerReadingChangedEventArgs;
    };
    template <> struct default_interface<Windows::Devices::Sensors::ProximitySensor>
    {
        using type = Windows::Devices::Sensors::IProximitySensor;
    };
    template <> struct default_interface<Windows::Devices::Sensors::ProximitySensorDataThreshold>
    {
        using type = Windows::Devices::Sensors::ISensorDataThreshold;
    };
    template <> struct default_interface<Windows::Devices::Sensors::ProximitySensorDisplayOnOffController>
    {
        using type = Windows::Foundation::IClosable;
    };
    template <> struct default_interface<Windows::Devices::Sensors::ProximitySensorReading>
    {
        using type = Windows::Devices::Sensors::IProximitySensorReading;
    };
    template <> struct default_interface<Windows::Devices::Sensors::ProximitySensorReadingChangedEventArgs>
    {
        using type = Windows::Devices::Sensors::IProximitySensorReadingChangedEventArgs;
    };
    template <> struct default_interface<Windows::Devices::Sensors::SensorDataThresholdTriggerDetails>
    {
        using type = Windows::Devices::Sensors::ISensorDataThresholdTriggerDetails;
    };
    template <> struct default_interface<Windows::Devices::Sensors::SensorQuaternion>
    {
        using type = Windows::Devices::Sensors::ISensorQuaternion;
    };
    template <> struct default_interface<Windows::Devices::Sensors::SensorRotationMatrix>
    {
        using type = Windows::Devices::Sensors::ISensorRotationMatrix;
    };
    template <> struct default_interface<Windows::Devices::Sensors::SimpleOrientationSensor>
    {
        using type = Windows::Devices::Sensors::ISimpleOrientationSensor;
    };
    template <> struct default_interface<Windows::Devices::Sensors::SimpleOrientationSensorOrientationChangedEventArgs>
    {
        using type = Windows::Devices::Sensors::ISimpleOrientationSensorOrientationChangedEventArgs;
    };
    template <> struct abi<Windows::Devices::Sensors::IAccelerometer>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall GetCurrentReading(void**) noexcept = 0;
            virtual int32_t __stdcall get_MinimumReportInterval(uint32_t*) noexcept = 0;
            virtual int32_t __stdcall put_ReportInterval(uint32_t) noexcept = 0;
            virtual int32_t __stdcall get_ReportInterval(uint32_t*) noexcept = 0;
            virtual int32_t __stdcall add_ReadingChanged(void*, winrt::event_token*) noexcept = 0;
            virtual int32_t __stdcall remove_ReadingChanged(winrt::event_token) noexcept = 0;
            virtual int32_t __stdcall add_Shaken(void*, winrt::event_token*) noexcept = 0;
            virtual int32_t __stdcall remove_Shaken(winrt::event_token) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IAccelerometer2>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall put_ReadingTransform(uint32_t) noexcept = 0;
            virtual int32_t __stdcall get_ReadingTransform(uint32_t*) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IAccelerometer3>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall put_ReportLatency(uint32_t) noexcept = 0;
            virtual int32_t __stdcall get_ReportLatency(uint32_t*) noexcept = 0;
            virtual int32_t __stdcall get_MaxBatchSize(uint32_t*) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IAccelerometer4>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_ReadingType(int32_t*) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IAccelerometer5>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_ReportThreshold(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IAccelerometerDataThreshold>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_XAxisInGForce(double*) noexcept = 0;
            virtual int32_t __stdcall put_XAxisInGForce(double) noexcept = 0;
            virtual int32_t __stdcall get_YAxisInGForce(double*) noexcept = 0;
            virtual int32_t __stdcall put_YAxisInGForce(double) noexcept = 0;
            virtual int32_t __stdcall get_ZAxisInGForce(double*) noexcept = 0;
            virtual int32_t __stdcall put_ZAxisInGForce(double) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IAccelerometerDeviceId>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_DeviceId(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IAccelerometerReading>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_Timestamp(int64_t*) noexcept = 0;
            virtual int32_t __stdcall get_AccelerationX(double*) noexcept = 0;
            virtual int32_t __stdcall get_AccelerationY(double*) noexcept = 0;
            virtual int32_t __stdcall get_AccelerationZ(double*) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IAccelerometerReading2>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_PerformanceCount(void**) noexcept = 0;
            virtual int32_t __stdcall get_Properties(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IAccelerometerReadingChangedEventArgs>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_Reading(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IAccelerometerShakenEventArgs>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_Timestamp(int64_t*) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IAccelerometerStatics>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall GetDefault(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IAccelerometerStatics2>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall GetDefaultWithAccelerometerReadingType(int32_t, void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IAccelerometerStatics3>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall FromIdAsync(void*, void**) noexcept = 0;
            virtual int32_t __stdcall GetDeviceSelector(int32_t, void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IActivitySensor>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall GetCurrentReadingAsync(void**) noexcept = 0;
            virtual int32_t __stdcall get_SubscribedActivities(void**) noexcept = 0;
            virtual int32_t __stdcall get_PowerInMilliwatts(double*) noexcept = 0;
            virtual int32_t __stdcall get_DeviceId(void**) noexcept = 0;
            virtual int32_t __stdcall get_SupportedActivities(void**) noexcept = 0;
            virtual int32_t __stdcall get_MinimumReportInterval(uint32_t*) noexcept = 0;
            virtual int32_t __stdcall add_ReadingChanged(void*, winrt::event_token*) noexcept = 0;
            virtual int32_t __stdcall remove_ReadingChanged(winrt::event_token) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IActivitySensorReading>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_Timestamp(int64_t*) noexcept = 0;
            virtual int32_t __stdcall get_Activity(int32_t*) noexcept = 0;
            virtual int32_t __stdcall get_Confidence(int32_t*) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IActivitySensorReadingChangeReport>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_Reading(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IActivitySensorReadingChangedEventArgs>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_Reading(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IActivitySensorStatics>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall GetDefaultAsync(void**) noexcept = 0;
            virtual int32_t __stdcall GetDeviceSelector(void**) noexcept = 0;
            virtual int32_t __stdcall FromIdAsync(void*, void**) noexcept = 0;
            virtual int32_t __stdcall GetSystemHistoryAsync(int64_t, void**) noexcept = 0;
            virtual int32_t __stdcall GetSystemHistoryWithDurationAsync(int64_t, int64_t, void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IActivitySensorTriggerDetails>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall ReadReports(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IAltimeter>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall GetCurrentReading(void**) noexcept = 0;
            virtual int32_t __stdcall get_DeviceId(void**) noexcept = 0;
            virtual int32_t __stdcall get_MinimumReportInterval(uint32_t*) noexcept = 0;
            virtual int32_t __stdcall put_ReportInterval(uint32_t) noexcept = 0;
            virtual int32_t __stdcall get_ReportInterval(uint32_t*) noexcept = 0;
            virtual int32_t __stdcall add_ReadingChanged(void*, winrt::event_token*) noexcept = 0;
            virtual int32_t __stdcall remove_ReadingChanged(winrt::event_token) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IAltimeter2>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall put_ReportLatency(uint32_t) noexcept = 0;
            virtual int32_t __stdcall get_ReportLatency(uint32_t*) noexcept = 0;
            virtual int32_t __stdcall get_MaxBatchSize(uint32_t*) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IAltimeterReading>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_Timestamp(int64_t*) noexcept = 0;
            virtual int32_t __stdcall get_AltitudeChangeInMeters(double*) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IAltimeterReading2>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_PerformanceCount(void**) noexcept = 0;
            virtual int32_t __stdcall get_Properties(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IAltimeterReadingChangedEventArgs>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_Reading(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IAltimeterStatics>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall GetDefault(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IBarometer>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall GetCurrentReading(void**) noexcept = 0;
            virtual int32_t __stdcall get_DeviceId(void**) noexcept = 0;
            virtual int32_t __stdcall get_MinimumReportInterval(uint32_t*) noexcept = 0;
            virtual int32_t __stdcall put_ReportInterval(uint32_t) noexcept = 0;
            virtual int32_t __stdcall get_ReportInterval(uint32_t*) noexcept = 0;
            virtual int32_t __stdcall add_ReadingChanged(void*, winrt::event_token*) noexcept = 0;
            virtual int32_t __stdcall remove_ReadingChanged(winrt::event_token) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IBarometer2>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall put_ReportLatency(uint32_t) noexcept = 0;
            virtual int32_t __stdcall get_ReportLatency(uint32_t*) noexcept = 0;
            virtual int32_t __stdcall get_MaxBatchSize(uint32_t*) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IBarometer3>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_ReportThreshold(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IBarometerDataThreshold>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_Hectopascals(double*) noexcept = 0;
            virtual int32_t __stdcall put_Hectopascals(double) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IBarometerReading>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_Timestamp(int64_t*) noexcept = 0;
            virtual int32_t __stdcall get_StationPressureInHectopascals(double*) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IBarometerReading2>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_PerformanceCount(void**) noexcept = 0;
            virtual int32_t __stdcall get_Properties(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IBarometerReadingChangedEventArgs>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_Reading(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IBarometerStatics>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall GetDefault(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IBarometerStatics2>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall FromIdAsync(void*, void**) noexcept = 0;
            virtual int32_t __stdcall GetDeviceSelector(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::ICompass>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall GetCurrentReading(void**) noexcept = 0;
            virtual int32_t __stdcall get_MinimumReportInterval(uint32_t*) noexcept = 0;
            virtual int32_t __stdcall put_ReportInterval(uint32_t) noexcept = 0;
            virtual int32_t __stdcall get_ReportInterval(uint32_t*) noexcept = 0;
            virtual int32_t __stdcall add_ReadingChanged(void*, winrt::event_token*) noexcept = 0;
            virtual int32_t __stdcall remove_ReadingChanged(winrt::event_token) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::ICompass2>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall put_ReadingTransform(uint32_t) noexcept = 0;
            virtual int32_t __stdcall get_ReadingTransform(uint32_t*) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::ICompass3>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall put_ReportLatency(uint32_t) noexcept = 0;
            virtual int32_t __stdcall get_ReportLatency(uint32_t*) noexcept = 0;
            virtual int32_t __stdcall get_MaxBatchSize(uint32_t*) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::ICompass4>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_ReportThreshold(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::ICompassDataThreshold>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_Degrees(double*) noexcept = 0;
            virtual int32_t __stdcall put_Degrees(double) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::ICompassDeviceId>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_DeviceId(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::ICompassReading>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_Timestamp(int64_t*) noexcept = 0;
            virtual int32_t __stdcall get_HeadingMagneticNorth(double*) noexcept = 0;
            virtual int32_t __stdcall get_HeadingTrueNorth(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::ICompassReading2>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_PerformanceCount(void**) noexcept = 0;
            virtual int32_t __stdcall get_Properties(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::ICompassReadingChangedEventArgs>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_Reading(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::ICompassReadingHeadingAccuracy>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_HeadingAccuracy(int32_t*) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::ICompassStatics>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall GetDefault(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::ICompassStatics2>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall GetDeviceSelector(void**) noexcept = 0;
            virtual int32_t __stdcall FromIdAsync(void*, void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IGyrometer>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall GetCurrentReading(void**) noexcept = 0;
            virtual int32_t __stdcall get_MinimumReportInterval(uint32_t*) noexcept = 0;
            virtual int32_t __stdcall put_ReportInterval(uint32_t) noexcept = 0;
            virtual int32_t __stdcall get_ReportInterval(uint32_t*) noexcept = 0;
            virtual int32_t __stdcall add_ReadingChanged(void*, winrt::event_token*) noexcept = 0;
            virtual int32_t __stdcall remove_ReadingChanged(winrt::event_token) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IGyrometer2>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall put_ReadingTransform(uint32_t) noexcept = 0;
            virtual int32_t __stdcall get_ReadingTransform(uint32_t*) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IGyrometer3>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall put_ReportLatency(uint32_t) noexcept = 0;
            virtual int32_t __stdcall get_ReportLatency(uint32_t*) noexcept = 0;
            virtual int32_t __stdcall get_MaxBatchSize(uint32_t*) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IGyrometer4>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_ReportThreshold(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IGyrometerDataThreshold>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_XAxisInDegreesPerSecond(double*) noexcept = 0;
            virtual int32_t __stdcall put_XAxisInDegreesPerSecond(double) noexcept = 0;
            virtual int32_t __stdcall get_YAxisInDegreesPerSecond(double*) noexcept = 0;
            virtual int32_t __stdcall put_YAxisInDegreesPerSecond(double) noexcept = 0;
            virtual int32_t __stdcall get_ZAxisInDegreesPerSecond(double*) noexcept = 0;
            virtual int32_t __stdcall put_ZAxisInDegreesPerSecond(double) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IGyrometerDeviceId>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_DeviceId(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IGyrometerReading>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_Timestamp(int64_t*) noexcept = 0;
            virtual int32_t __stdcall get_AngularVelocityX(double*) noexcept = 0;
            virtual int32_t __stdcall get_AngularVelocityY(double*) noexcept = 0;
            virtual int32_t __stdcall get_AngularVelocityZ(double*) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IGyrometerReading2>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_PerformanceCount(void**) noexcept = 0;
            virtual int32_t __stdcall get_Properties(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IGyrometerReadingChangedEventArgs>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_Reading(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IGyrometerStatics>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall GetDefault(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IGyrometerStatics2>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall GetDeviceSelector(void**) noexcept = 0;
            virtual int32_t __stdcall FromIdAsync(void*, void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IHingeAngleReading>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_Timestamp(int64_t*) noexcept = 0;
            virtual int32_t __stdcall get_AngleInDegrees(double*) noexcept = 0;
            virtual int32_t __stdcall get_Properties(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IHingeAngleSensor>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall GetCurrentReadingAsync(void**) noexcept = 0;
            virtual int32_t __stdcall get_DeviceId(void**) noexcept = 0;
            virtual int32_t __stdcall get_MinReportThresholdInDegrees(double*) noexcept = 0;
            virtual int32_t __stdcall get_ReportThresholdInDegrees(double*) noexcept = 0;
            virtual int32_t __stdcall put_ReportThresholdInDegrees(double) noexcept = 0;
            virtual int32_t __stdcall add_ReadingChanged(void*, winrt::event_token*) noexcept = 0;
            virtual int32_t __stdcall remove_ReadingChanged(winrt::event_token) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IHingeAngleSensorReadingChangedEventArgs>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_Reading(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IHingeAngleSensorStatics>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall GetDeviceSelector(void**) noexcept = 0;
            virtual int32_t __stdcall GetDefaultAsync(void**) noexcept = 0;
            virtual int32_t __stdcall GetRelatedToAdjacentPanelsAsync(void*, void*, void**) noexcept = 0;
            virtual int32_t __stdcall FromIdAsync(void*, void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IInclinometer>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall GetCurrentReading(void**) noexcept = 0;
            virtual int32_t __stdcall get_MinimumReportInterval(uint32_t*) noexcept = 0;
            virtual int32_t __stdcall put_ReportInterval(uint32_t) noexcept = 0;
            virtual int32_t __stdcall get_ReportInterval(uint32_t*) noexcept = 0;
            virtual int32_t __stdcall add_ReadingChanged(void*, winrt::event_token*) noexcept = 0;
            virtual int32_t __stdcall remove_ReadingChanged(winrt::event_token) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IInclinometer2>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall put_ReadingTransform(uint32_t) noexcept = 0;
            virtual int32_t __stdcall get_ReadingTransform(uint32_t*) noexcept = 0;
            virtual int32_t __stdcall get_ReadingType(int32_t*) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IInclinometer3>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall put_ReportLatency(uint32_t) noexcept = 0;
            virtual int32_t __stdcall get_ReportLatency(uint32_t*) noexcept = 0;
            virtual int32_t __stdcall get_MaxBatchSize(uint32_t*) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IInclinometer4>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_ReportThreshold(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IInclinometerDataThreshold>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_PitchInDegrees(float*) noexcept = 0;
            virtual int32_t __stdcall put_PitchInDegrees(float) noexcept = 0;
            virtual int32_t __stdcall get_RollInDegrees(float*) noexcept = 0;
            virtual int32_t __stdcall put_RollInDegrees(float) noexcept = 0;
            virtual int32_t __stdcall get_YawInDegrees(float*) noexcept = 0;
            virtual int32_t __stdcall put_YawInDegrees(float) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IInclinometerDeviceId>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_DeviceId(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IInclinometerReading>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_Timestamp(int64_t*) noexcept = 0;
            virtual int32_t __stdcall get_PitchDegrees(float*) noexcept = 0;
            virtual int32_t __stdcall get_RollDegrees(float*) noexcept = 0;
            virtual int32_t __stdcall get_YawDegrees(float*) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IInclinometerReading2>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_PerformanceCount(void**) noexcept = 0;
            virtual int32_t __stdcall get_Properties(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IInclinometerReadingChangedEventArgs>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_Reading(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IInclinometerReadingYawAccuracy>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_YawAccuracy(int32_t*) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IInclinometerStatics>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall GetDefault(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IInclinometerStatics2>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall GetDefaultForRelativeReadings(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IInclinometerStatics3>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall GetDefaultWithSensorReadingType(int32_t, void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IInclinometerStatics4>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall GetDeviceSelector(int32_t, void**) noexcept = 0;
            virtual int32_t __stdcall FromIdAsync(void*, void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::ILightSensor>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall GetCurrentReading(void**) noexcept = 0;
            virtual int32_t __stdcall get_MinimumReportInterval(uint32_t*) noexcept = 0;
            virtual int32_t __stdcall put_ReportInterval(uint32_t) noexcept = 0;
            virtual int32_t __stdcall get_ReportInterval(uint32_t*) noexcept = 0;
            virtual int32_t __stdcall add_ReadingChanged(void*, winrt::event_token*) noexcept = 0;
            virtual int32_t __stdcall remove_ReadingChanged(winrt::event_token) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::ILightSensor2>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall put_ReportLatency(uint32_t) noexcept = 0;
            virtual int32_t __stdcall get_ReportLatency(uint32_t*) noexcept = 0;
            virtual int32_t __stdcall get_MaxBatchSize(uint32_t*) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::ILightSensor3>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_ReportThreshold(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::ILightSensorDataThreshold>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_LuxPercentage(float*) noexcept = 0;
            virtual int32_t __stdcall put_LuxPercentage(float) noexcept = 0;
            virtual int32_t __stdcall get_AbsoluteLux(float*) noexcept = 0;
            virtual int32_t __stdcall put_AbsoluteLux(float) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::ILightSensorDeviceId>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_DeviceId(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::ILightSensorReading>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_Timestamp(int64_t*) noexcept = 0;
            virtual int32_t __stdcall get_IlluminanceInLux(float*) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::ILightSensorReading2>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_PerformanceCount(void**) noexcept = 0;
            virtual int32_t __stdcall get_Properties(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::ILightSensorReadingChangedEventArgs>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_Reading(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::ILightSensorStatics>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall GetDefault(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::ILightSensorStatics2>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall GetDeviceSelector(void**) noexcept = 0;
            virtual int32_t __stdcall FromIdAsync(void*, void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IMagnetometer>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall GetCurrentReading(void**) noexcept = 0;
            virtual int32_t __stdcall get_MinimumReportInterval(uint32_t*) noexcept = 0;
            virtual int32_t __stdcall put_ReportInterval(uint32_t) noexcept = 0;
            virtual int32_t __stdcall get_ReportInterval(uint32_t*) noexcept = 0;
            virtual int32_t __stdcall add_ReadingChanged(void*, winrt::event_token*) noexcept = 0;
            virtual int32_t __stdcall remove_ReadingChanged(winrt::event_token) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IMagnetometer2>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall put_ReadingTransform(uint32_t) noexcept = 0;
            virtual int32_t __stdcall get_ReadingTransform(uint32_t*) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IMagnetometer3>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall put_ReportLatency(uint32_t) noexcept = 0;
            virtual int32_t __stdcall get_ReportLatency(uint32_t*) noexcept = 0;
            virtual int32_t __stdcall get_MaxBatchSize(uint32_t*) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IMagnetometer4>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_ReportThreshold(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IMagnetometerDataThreshold>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_XAxisMicroteslas(float*) noexcept = 0;
            virtual int32_t __stdcall put_XAxisMicroteslas(float) noexcept = 0;
            virtual int32_t __stdcall get_YAxisMicroteslas(float*) noexcept = 0;
            virtual int32_t __stdcall put_YAxisMicroteslas(float) noexcept = 0;
            virtual int32_t __stdcall get_ZAxisMicroteslas(float*) noexcept = 0;
            virtual int32_t __stdcall put_ZAxisMicroteslas(float) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IMagnetometerDeviceId>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_DeviceId(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IMagnetometerReading>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_Timestamp(int64_t*) noexcept = 0;
            virtual int32_t __stdcall get_MagneticFieldX(float*) noexcept = 0;
            virtual int32_t __stdcall get_MagneticFieldY(float*) noexcept = 0;
            virtual int32_t __stdcall get_MagneticFieldZ(float*) noexcept = 0;
            virtual int32_t __stdcall get_DirectionalAccuracy(int32_t*) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IMagnetometerReading2>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_PerformanceCount(void**) noexcept = 0;
            virtual int32_t __stdcall get_Properties(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IMagnetometerReadingChangedEventArgs>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_Reading(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IMagnetometerStatics>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall GetDefault(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IMagnetometerStatics2>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall GetDeviceSelector(void**) noexcept = 0;
            virtual int32_t __stdcall FromIdAsync(void*, void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IOrientationSensor>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall GetCurrentReading(void**) noexcept = 0;
            virtual int32_t __stdcall get_MinimumReportInterval(uint32_t*) noexcept = 0;
            virtual int32_t __stdcall put_ReportInterval(uint32_t) noexcept = 0;
            virtual int32_t __stdcall get_ReportInterval(uint32_t*) noexcept = 0;
            virtual int32_t __stdcall add_ReadingChanged(void*, winrt::event_token*) noexcept = 0;
            virtual int32_t __stdcall remove_ReadingChanged(winrt::event_token) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IOrientationSensor2>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall put_ReadingTransform(uint32_t) noexcept = 0;
            virtual int32_t __stdcall get_ReadingTransform(uint32_t*) noexcept = 0;
            virtual int32_t __stdcall get_ReadingType(int32_t*) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IOrientationSensor3>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall put_ReportLatency(uint32_t) noexcept = 0;
            virtual int32_t __stdcall get_ReportLatency(uint32_t*) noexcept = 0;
            virtual int32_t __stdcall get_MaxBatchSize(uint32_t*) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IOrientationSensorDeviceId>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_DeviceId(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IOrientationSensorReading>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_Timestamp(int64_t*) noexcept = 0;
            virtual int32_t __stdcall get_RotationMatrix(void**) noexcept = 0;
            virtual int32_t __stdcall get_Quaternion(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IOrientationSensorReading2>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_PerformanceCount(void**) noexcept = 0;
            virtual int32_t __stdcall get_Properties(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IOrientationSensorReadingChangedEventArgs>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_Reading(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IOrientationSensorReadingYawAccuracy>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_YawAccuracy(int32_t*) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IOrientationSensorStatics>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall GetDefault(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IOrientationSensorStatics2>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall GetDefaultForRelativeReadings(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IOrientationSensorStatics3>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall GetDefaultWithSensorReadingType(int32_t, void**) noexcept = 0;
            virtual int32_t __stdcall GetDefaultWithSensorReadingTypeAndSensorOptimizationGoal(int32_t, int32_t, void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IOrientationSensorStatics4>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall GetDeviceSelector(int32_t, void**) noexcept = 0;
            virtual int32_t __stdcall GetDeviceSelectorWithSensorReadingTypeAndSensorOptimizationGoal(int32_t, int32_t, void**) noexcept = 0;
            virtual int32_t __stdcall FromIdAsync(void*, void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IPedometer>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_DeviceId(void**) noexcept = 0;
            virtual int32_t __stdcall get_PowerInMilliwatts(double*) noexcept = 0;
            virtual int32_t __stdcall get_MinimumReportInterval(uint32_t*) noexcept = 0;
            virtual int32_t __stdcall put_ReportInterval(uint32_t) noexcept = 0;
            virtual int32_t __stdcall get_ReportInterval(uint32_t*) noexcept = 0;
            virtual int32_t __stdcall add_ReadingChanged(void*, winrt::event_token*) noexcept = 0;
            virtual int32_t __stdcall remove_ReadingChanged(winrt::event_token) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IPedometer2>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall GetCurrentReadings(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IPedometerDataThresholdFactory>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall Create(void*, int32_t, void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IPedometerReading>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_StepKind(int32_t*) noexcept = 0;
            virtual int32_t __stdcall get_CumulativeSteps(int32_t*) noexcept = 0;
            virtual int32_t __stdcall get_Timestamp(int64_t*) noexcept = 0;
            virtual int32_t __stdcall get_CumulativeStepsDuration(int64_t*) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IPedometerReadingChangedEventArgs>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_Reading(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IPedometerStatics>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall FromIdAsync(void*, void**) noexcept = 0;
            virtual int32_t __stdcall GetDefaultAsync(void**) noexcept = 0;
            virtual int32_t __stdcall GetDeviceSelector(void**) noexcept = 0;
            virtual int32_t __stdcall GetSystemHistoryAsync(int64_t, void**) noexcept = 0;
            virtual int32_t __stdcall GetSystemHistoryWithDurationAsync(int64_t, int64_t, void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IPedometerStatics2>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall GetReadingsFromTriggerDetails(void*, void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IProximitySensor>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_DeviceId(void**) noexcept = 0;
            virtual int32_t __stdcall get_MaxDistanceInMillimeters(void**) noexcept = 0;
            virtual int32_t __stdcall get_MinDistanceInMillimeters(void**) noexcept = 0;
            virtual int32_t __stdcall GetCurrentReading(void**) noexcept = 0;
            virtual int32_t __stdcall add_ReadingChanged(void*, winrt::event_token*) noexcept = 0;
            virtual int32_t __stdcall remove_ReadingChanged(winrt::event_token) noexcept = 0;
            virtual int32_t __stdcall CreateDisplayOnOffController(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IProximitySensorDataThresholdFactory>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall Create(void*, void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IProximitySensorReading>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_Timestamp(int64_t*) noexcept = 0;
            virtual int32_t __stdcall get_IsDetected(bool*) noexcept = 0;
            virtual int32_t __stdcall get_DistanceInMillimeters(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IProximitySensorReadingChangedEventArgs>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_Reading(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IProximitySensorStatics>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall GetDeviceSelector(void**) noexcept = 0;
            virtual int32_t __stdcall FromId(void*, void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::IProximitySensorStatics2>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall GetReadingsFromTriggerDetails(void*, void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::ISensorDataThreshold>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
        };
    };
    template <> struct abi<Windows::Devices::Sensors::ISensorDataThresholdTriggerDetails>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_DeviceId(void**) noexcept = 0;
            virtual int32_t __stdcall get_SensorType(int32_t*) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::ISensorQuaternion>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_W(float*) noexcept = 0;
            virtual int32_t __stdcall get_X(float*) noexcept = 0;
            virtual int32_t __stdcall get_Y(float*) noexcept = 0;
            virtual int32_t __stdcall get_Z(float*) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::ISensorRotationMatrix>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_M11(float*) noexcept = 0;
            virtual int32_t __stdcall get_M12(float*) noexcept = 0;
            virtual int32_t __stdcall get_M13(float*) noexcept = 0;
            virtual int32_t __stdcall get_M21(float*) noexcept = 0;
            virtual int32_t __stdcall get_M22(float*) noexcept = 0;
            virtual int32_t __stdcall get_M23(float*) noexcept = 0;
            virtual int32_t __stdcall get_M31(float*) noexcept = 0;
            virtual int32_t __stdcall get_M32(float*) noexcept = 0;
            virtual int32_t __stdcall get_M33(float*) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::ISimpleOrientationSensor>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall GetCurrentOrientation(int32_t*) noexcept = 0;
            virtual int32_t __stdcall add_OrientationChanged(void*, winrt::event_token*) noexcept = 0;
            virtual int32_t __stdcall remove_OrientationChanged(winrt::event_token) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::ISimpleOrientationSensor2>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall put_ReadingTransform(uint32_t) noexcept = 0;
            virtual int32_t __stdcall get_ReadingTransform(uint32_t*) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::ISimpleOrientationSensorDeviceId>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_DeviceId(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::ISimpleOrientationSensorOrientationChangedEventArgs>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall get_Timestamp(int64_t*) noexcept = 0;
            virtual int32_t __stdcall get_Orientation(int32_t*) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::ISimpleOrientationSensorStatics>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall GetDefault(void**) noexcept = 0;
        };
    };
    template <> struct abi<Windows::Devices::Sensors::ISimpleOrientationSensorStatics2>
    {
        struct __declspec(novtable) type : inspectable_abi
        {
            virtual int32_t __stdcall GetDeviceSelector(void**) noexcept = 0;
            virtual int32_t __stdcall FromIdAsync(void*, void**) noexcept = 0;
        };
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IAccelerometer
    {
        auto GetCurrentReading() const;
        [[nodiscard]] auto MinimumReportInterval() const;
        auto ReportInterval(uint32_t value) const;
        [[nodiscard]] auto ReportInterval() const;
        auto ReadingChanged(Windows::Foundation::TypedEventHandler<Windows::Devices::Sensors::Accelerometer, Windows::Devices::Sensors::AccelerometerReadingChangedEventArgs> const& handler) const;
        using ReadingChanged_revoker = impl::event_revoker<Windows::Devices::Sensors::IAccelerometer, &impl::abi_t<Windows::Devices::Sensors::IAccelerometer>::remove_ReadingChanged>;
        ReadingChanged_revoker ReadingChanged(auto_revoke_t, Windows::Foundation::TypedEventHandler<Windows::Devices::Sensors::Accelerometer, Windows::Devices::Sensors::AccelerometerReadingChangedEventArgs> const& handler) const;
        auto ReadingChanged(winrt::event_token const& token) const noexcept;
        auto Shaken(Windows::Foundation::TypedEventHandler<Windows::Devices::Sensors::Accelerometer, Windows::Devices::Sensors::AccelerometerShakenEventArgs> const& handler) const;
        using Shaken_revoker = impl::event_revoker<Windows::Devices::Sensors::IAccelerometer, &impl::abi_t<Windows::Devices::Sensors::IAccelerometer>::remove_Shaken>;
        Shaken_revoker Shaken(auto_revoke_t, Windows::Foundation::TypedEventHandler<Windows::Devices::Sensors::Accelerometer, Windows::Devices::Sensors::AccelerometerShakenEventArgs> const& handler) const;
        auto Shaken(winrt::event_token const& token) const noexcept;
    };
    template <> struct consume<Windows::Devices::Sensors::IAccelerometer>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IAccelerometer<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IAccelerometer2
    {
        auto ReadingTransform(Windows::Graphics::Display::DisplayOrientations const& value) const;
        [[nodiscard]] auto ReadingTransform() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IAccelerometer2>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IAccelerometer2<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IAccelerometer3
    {
        auto ReportLatency(uint32_t value) const;
        [[nodiscard]] auto ReportLatency() const;
        [[nodiscard]] auto MaxBatchSize() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IAccelerometer3>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IAccelerometer3<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IAccelerometer4
    {
        [[nodiscard]] auto ReadingType() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IAccelerometer4>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IAccelerometer4<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IAccelerometer5
    {
        [[nodiscard]] auto ReportThreshold() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IAccelerometer5>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IAccelerometer5<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IAccelerometerDataThreshold
    {
        [[nodiscard]] auto XAxisInGForce() const;
        auto XAxisInGForce(double value) const;
        [[nodiscard]] auto YAxisInGForce() const;
        auto YAxisInGForce(double value) const;
        [[nodiscard]] auto ZAxisInGForce() const;
        auto ZAxisInGForce(double value) const;
    };
    template <> struct consume<Windows::Devices::Sensors::IAccelerometerDataThreshold>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IAccelerometerDataThreshold<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IAccelerometerDeviceId
    {
        [[nodiscard]] auto DeviceId() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IAccelerometerDeviceId>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IAccelerometerDeviceId<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IAccelerometerReading
    {
        [[nodiscard]] auto Timestamp() const;
        [[nodiscard]] auto AccelerationX() const;
        [[nodiscard]] auto AccelerationY() const;
        [[nodiscard]] auto AccelerationZ() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IAccelerometerReading>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IAccelerometerReading<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IAccelerometerReading2
    {
        [[nodiscard]] auto PerformanceCount() const;
        [[nodiscard]] auto Properties() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IAccelerometerReading2>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IAccelerometerReading2<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IAccelerometerReadingChangedEventArgs
    {
        [[nodiscard]] auto Reading() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IAccelerometerReadingChangedEventArgs>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IAccelerometerReadingChangedEventArgs<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IAccelerometerShakenEventArgs
    {
        [[nodiscard]] auto Timestamp() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IAccelerometerShakenEventArgs>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IAccelerometerShakenEventArgs<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IAccelerometerStatics
    {
        auto GetDefault() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IAccelerometerStatics>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IAccelerometerStatics<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IAccelerometerStatics2
    {
        auto GetDefault(Windows::Devices::Sensors::AccelerometerReadingType const& readingType) const;
    };
    template <> struct consume<Windows::Devices::Sensors::IAccelerometerStatics2>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IAccelerometerStatics2<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IAccelerometerStatics3
    {
        auto FromIdAsync(param::hstring const& deviceId) const;
        auto GetDeviceSelector(Windows::Devices::Sensors::AccelerometerReadingType const& readingType) const;
    };
    template <> struct consume<Windows::Devices::Sensors::IAccelerometerStatics3>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IAccelerometerStatics3<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IActivitySensor
    {
        auto GetCurrentReadingAsync() const;
        [[nodiscard]] auto SubscribedActivities() const;
        [[nodiscard]] auto PowerInMilliwatts() const;
        [[nodiscard]] auto DeviceId() const;
        [[nodiscard]] auto SupportedActivities() const;
        [[nodiscard]] auto MinimumReportInterval() const;
        auto ReadingChanged(Windows::Foundation::TypedEventHandler<Windows::Devices::Sensors::ActivitySensor, Windows::Devices::Sensors::ActivitySensorReadingChangedEventArgs> const& handler) const;
        using ReadingChanged_revoker = impl::event_revoker<Windows::Devices::Sensors::IActivitySensor, &impl::abi_t<Windows::Devices::Sensors::IActivitySensor>::remove_ReadingChanged>;
        ReadingChanged_revoker ReadingChanged(auto_revoke_t, Windows::Foundation::TypedEventHandler<Windows::Devices::Sensors::ActivitySensor, Windows::Devices::Sensors::ActivitySensorReadingChangedEventArgs> const& handler) const;
        auto ReadingChanged(winrt::event_token const& token) const noexcept;
    };
    template <> struct consume<Windows::Devices::Sensors::IActivitySensor>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IActivitySensor<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IActivitySensorReading
    {
        [[nodiscard]] auto Timestamp() const;
        [[nodiscard]] auto Activity() const;
        [[nodiscard]] auto Confidence() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IActivitySensorReading>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IActivitySensorReading<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IActivitySensorReadingChangeReport
    {
        [[nodiscard]] auto Reading() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IActivitySensorReadingChangeReport>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IActivitySensorReadingChangeReport<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IActivitySensorReadingChangedEventArgs
    {
        [[nodiscard]] auto Reading() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IActivitySensorReadingChangedEventArgs>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IActivitySensorReadingChangedEventArgs<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IActivitySensorStatics
    {
        auto GetDefaultAsync() const;
        auto GetDeviceSelector() const;
        auto FromIdAsync(param::hstring const& deviceId) const;
        auto GetSystemHistoryAsync(Windows::Foundation::DateTime const& fromTime) const;
        auto GetSystemHistoryAsync(Windows::Foundation::DateTime const& fromTime, Windows::Foundation::TimeSpan const& duration) const;
    };
    template <> struct consume<Windows::Devices::Sensors::IActivitySensorStatics>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IActivitySensorStatics<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IActivitySensorTriggerDetails
    {
        auto ReadReports() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IActivitySensorTriggerDetails>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IActivitySensorTriggerDetails<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IAltimeter
    {
        auto GetCurrentReading() const;
        [[nodiscard]] auto DeviceId() const;
        [[nodiscard]] auto MinimumReportInterval() const;
        auto ReportInterval(uint32_t value) const;
        [[nodiscard]] auto ReportInterval() const;
        auto ReadingChanged(Windows::Foundation::TypedEventHandler<Windows::Devices::Sensors::Altimeter, Windows::Devices::Sensors::AltimeterReadingChangedEventArgs> const& handler) const;
        using ReadingChanged_revoker = impl::event_revoker<Windows::Devices::Sensors::IAltimeter, &impl::abi_t<Windows::Devices::Sensors::IAltimeter>::remove_ReadingChanged>;
        ReadingChanged_revoker ReadingChanged(auto_revoke_t, Windows::Foundation::TypedEventHandler<Windows::Devices::Sensors::Altimeter, Windows::Devices::Sensors::AltimeterReadingChangedEventArgs> const& handler) const;
        auto ReadingChanged(winrt::event_token const& token) const noexcept;
    };
    template <> struct consume<Windows::Devices::Sensors::IAltimeter>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IAltimeter<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IAltimeter2
    {
        auto ReportLatency(uint32_t value) const;
        [[nodiscard]] auto ReportLatency() const;
        [[nodiscard]] auto MaxBatchSize() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IAltimeter2>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IAltimeter2<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IAltimeterReading
    {
        [[nodiscard]] auto Timestamp() const;
        [[nodiscard]] auto AltitudeChangeInMeters() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IAltimeterReading>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IAltimeterReading<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IAltimeterReading2
    {
        [[nodiscard]] auto PerformanceCount() const;
        [[nodiscard]] auto Properties() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IAltimeterReading2>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IAltimeterReading2<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IAltimeterReadingChangedEventArgs
    {
        [[nodiscard]] auto Reading() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IAltimeterReadingChangedEventArgs>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IAltimeterReadingChangedEventArgs<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IAltimeterStatics
    {
        auto GetDefault() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IAltimeterStatics>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IAltimeterStatics<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IBarometer
    {
        auto GetCurrentReading() const;
        [[nodiscard]] auto DeviceId() const;
        [[nodiscard]] auto MinimumReportInterval() const;
        auto ReportInterval(uint32_t value) const;
        [[nodiscard]] auto ReportInterval() const;
        auto ReadingChanged(Windows::Foundation::TypedEventHandler<Windows::Devices::Sensors::Barometer, Windows::Devices::Sensors::BarometerReadingChangedEventArgs> const& handler) const;
        using ReadingChanged_revoker = impl::event_revoker<Windows::Devices::Sensors::IBarometer, &impl::abi_t<Windows::Devices::Sensors::IBarometer>::remove_ReadingChanged>;
        ReadingChanged_revoker ReadingChanged(auto_revoke_t, Windows::Foundation::TypedEventHandler<Windows::Devices::Sensors::Barometer, Windows::Devices::Sensors::BarometerReadingChangedEventArgs> const& handler) const;
        auto ReadingChanged(winrt::event_token const& token) const noexcept;
    };
    template <> struct consume<Windows::Devices::Sensors::IBarometer>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IBarometer<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IBarometer2
    {
        auto ReportLatency(uint32_t value) const;
        [[nodiscard]] auto ReportLatency() const;
        [[nodiscard]] auto MaxBatchSize() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IBarometer2>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IBarometer2<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IBarometer3
    {
        [[nodiscard]] auto ReportThreshold() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IBarometer3>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IBarometer3<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IBarometerDataThreshold
    {
        [[nodiscard]] auto Hectopascals() const;
        auto Hectopascals(double value) const;
    };
    template <> struct consume<Windows::Devices::Sensors::IBarometerDataThreshold>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IBarometerDataThreshold<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IBarometerReading
    {
        [[nodiscard]] auto Timestamp() const;
        [[nodiscard]] auto StationPressureInHectopascals() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IBarometerReading>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IBarometerReading<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IBarometerReading2
    {
        [[nodiscard]] auto PerformanceCount() const;
        [[nodiscard]] auto Properties() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IBarometerReading2>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IBarometerReading2<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IBarometerReadingChangedEventArgs
    {
        [[nodiscard]] auto Reading() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IBarometerReadingChangedEventArgs>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IBarometerReadingChangedEventArgs<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IBarometerStatics
    {
        auto GetDefault() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IBarometerStatics>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IBarometerStatics<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IBarometerStatics2
    {
        auto FromIdAsync(param::hstring const& deviceId) const;
        auto GetDeviceSelector() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IBarometerStatics2>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IBarometerStatics2<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_ICompass
    {
        auto GetCurrentReading() const;
        [[nodiscard]] auto MinimumReportInterval() const;
        auto ReportInterval(uint32_t value) const;
        [[nodiscard]] auto ReportInterval() const;
        auto ReadingChanged(Windows::Foundation::TypedEventHandler<Windows::Devices::Sensors::Compass, Windows::Devices::Sensors::CompassReadingChangedEventArgs> const& handler) const;
        using ReadingChanged_revoker = impl::event_revoker<Windows::Devices::Sensors::ICompass, &impl::abi_t<Windows::Devices::Sensors::ICompass>::remove_ReadingChanged>;
        ReadingChanged_revoker ReadingChanged(auto_revoke_t, Windows::Foundation::TypedEventHandler<Windows::Devices::Sensors::Compass, Windows::Devices::Sensors::CompassReadingChangedEventArgs> const& handler) const;
        auto ReadingChanged(winrt::event_token const& token) const noexcept;
    };
    template <> struct consume<Windows::Devices::Sensors::ICompass>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_ICompass<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_ICompass2
    {
        auto ReadingTransform(Windows::Graphics::Display::DisplayOrientations const& value) const;
        [[nodiscard]] auto ReadingTransform() const;
    };
    template <> struct consume<Windows::Devices::Sensors::ICompass2>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_ICompass2<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_ICompass3
    {
        auto ReportLatency(uint32_t value) const;
        [[nodiscard]] auto ReportLatency() const;
        [[nodiscard]] auto MaxBatchSize() const;
    };
    template <> struct consume<Windows::Devices::Sensors::ICompass3>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_ICompass3<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_ICompass4
    {
        [[nodiscard]] auto ReportThreshold() const;
    };
    template <> struct consume<Windows::Devices::Sensors::ICompass4>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_ICompass4<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_ICompassDataThreshold
    {
        [[nodiscard]] auto Degrees() const;
        auto Degrees(double value) const;
    };
    template <> struct consume<Windows::Devices::Sensors::ICompassDataThreshold>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_ICompassDataThreshold<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_ICompassDeviceId
    {
        [[nodiscard]] auto DeviceId() const;
    };
    template <> struct consume<Windows::Devices::Sensors::ICompassDeviceId>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_ICompassDeviceId<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_ICompassReading
    {
        [[nodiscard]] auto Timestamp() const;
        [[nodiscard]] auto HeadingMagneticNorth() const;
        [[nodiscard]] auto HeadingTrueNorth() const;
    };
    template <> struct consume<Windows::Devices::Sensors::ICompassReading>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_ICompassReading<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_ICompassReading2
    {
        [[nodiscard]] auto PerformanceCount() const;
        [[nodiscard]] auto Properties() const;
    };
    template <> struct consume<Windows::Devices::Sensors::ICompassReading2>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_ICompassReading2<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_ICompassReadingChangedEventArgs
    {
        [[nodiscard]] auto Reading() const;
    };
    template <> struct consume<Windows::Devices::Sensors::ICompassReadingChangedEventArgs>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_ICompassReadingChangedEventArgs<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_ICompassReadingHeadingAccuracy
    {
        [[nodiscard]] auto HeadingAccuracy() const;
    };
    template <> struct consume<Windows::Devices::Sensors::ICompassReadingHeadingAccuracy>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_ICompassReadingHeadingAccuracy<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_ICompassStatics
    {
        auto GetDefault() const;
    };
    template <> struct consume<Windows::Devices::Sensors::ICompassStatics>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_ICompassStatics<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_ICompassStatics2
    {
        auto GetDeviceSelector() const;
        auto FromIdAsync(param::hstring const& deviceId) const;
    };
    template <> struct consume<Windows::Devices::Sensors::ICompassStatics2>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_ICompassStatics2<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IGyrometer
    {
        auto GetCurrentReading() const;
        [[nodiscard]] auto MinimumReportInterval() const;
        auto ReportInterval(uint32_t value) const;
        [[nodiscard]] auto ReportInterval() const;
        auto ReadingChanged(Windows::Foundation::TypedEventHandler<Windows::Devices::Sensors::Gyrometer, Windows::Devices::Sensors::GyrometerReadingChangedEventArgs> const& handler) const;
        using ReadingChanged_revoker = impl::event_revoker<Windows::Devices::Sensors::IGyrometer, &impl::abi_t<Windows::Devices::Sensors::IGyrometer>::remove_ReadingChanged>;
        ReadingChanged_revoker ReadingChanged(auto_revoke_t, Windows::Foundation::TypedEventHandler<Windows::Devices::Sensors::Gyrometer, Windows::Devices::Sensors::GyrometerReadingChangedEventArgs> const& handler) const;
        auto ReadingChanged(winrt::event_token const& token) const noexcept;
    };
    template <> struct consume<Windows::Devices::Sensors::IGyrometer>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IGyrometer<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IGyrometer2
    {
        auto ReadingTransform(Windows::Graphics::Display::DisplayOrientations const& value) const;
        [[nodiscard]] auto ReadingTransform() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IGyrometer2>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IGyrometer2<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IGyrometer3
    {
        auto ReportLatency(uint32_t value) const;
        [[nodiscard]] auto ReportLatency() const;
        [[nodiscard]] auto MaxBatchSize() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IGyrometer3>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IGyrometer3<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IGyrometer4
    {
        [[nodiscard]] auto ReportThreshold() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IGyrometer4>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IGyrometer4<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IGyrometerDataThreshold
    {
        [[nodiscard]] auto XAxisInDegreesPerSecond() const;
        auto XAxisInDegreesPerSecond(double value) const;
        [[nodiscard]] auto YAxisInDegreesPerSecond() const;
        auto YAxisInDegreesPerSecond(double value) const;
        [[nodiscard]] auto ZAxisInDegreesPerSecond() const;
        auto ZAxisInDegreesPerSecond(double value) const;
    };
    template <> struct consume<Windows::Devices::Sensors::IGyrometerDataThreshold>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IGyrometerDataThreshold<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IGyrometerDeviceId
    {
        [[nodiscard]] auto DeviceId() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IGyrometerDeviceId>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IGyrometerDeviceId<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IGyrometerReading
    {
        [[nodiscard]] auto Timestamp() const;
        [[nodiscard]] auto AngularVelocityX() const;
        [[nodiscard]] auto AngularVelocityY() const;
        [[nodiscard]] auto AngularVelocityZ() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IGyrometerReading>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IGyrometerReading<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IGyrometerReading2
    {
        [[nodiscard]] auto PerformanceCount() const;
        [[nodiscard]] auto Properties() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IGyrometerReading2>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IGyrometerReading2<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IGyrometerReadingChangedEventArgs
    {
        [[nodiscard]] auto Reading() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IGyrometerReadingChangedEventArgs>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IGyrometerReadingChangedEventArgs<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IGyrometerStatics
    {
        auto GetDefault() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IGyrometerStatics>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IGyrometerStatics<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IGyrometerStatics2
    {
        auto GetDeviceSelector() const;
        auto FromIdAsync(param::hstring const& deviceId) const;
    };
    template <> struct consume<Windows::Devices::Sensors::IGyrometerStatics2>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IGyrometerStatics2<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IHingeAngleReading
    {
        [[nodiscard]] auto Timestamp() const;
        [[nodiscard]] auto AngleInDegrees() const;
        [[nodiscard]] auto Properties() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IHingeAngleReading>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IHingeAngleReading<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IHingeAngleSensor
    {
        auto GetCurrentReadingAsync() const;
        [[nodiscard]] auto DeviceId() const;
        [[nodiscard]] auto MinReportThresholdInDegrees() const;
        [[nodiscard]] auto ReportThresholdInDegrees() const;
        auto ReportThresholdInDegrees(double value) const;
        auto ReadingChanged(Windows::Foundation::TypedEventHandler<Windows::Devices::Sensors::HingeAngleSensor, Windows::Devices::Sensors::HingeAngleSensorReadingChangedEventArgs> const& handler) const;
        using ReadingChanged_revoker = impl::event_revoker<Windows::Devices::Sensors::IHingeAngleSensor, &impl::abi_t<Windows::Devices::Sensors::IHingeAngleSensor>::remove_ReadingChanged>;
        ReadingChanged_revoker ReadingChanged(auto_revoke_t, Windows::Foundation::TypedEventHandler<Windows::Devices::Sensors::HingeAngleSensor, Windows::Devices::Sensors::HingeAngleSensorReadingChangedEventArgs> const& handler) const;
        auto ReadingChanged(winrt::event_token const& token) const noexcept;
    };
    template <> struct consume<Windows::Devices::Sensors::IHingeAngleSensor>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IHingeAngleSensor<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IHingeAngleSensorReadingChangedEventArgs
    {
        [[nodiscard]] auto Reading() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IHingeAngleSensorReadingChangedEventArgs>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IHingeAngleSensorReadingChangedEventArgs<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IHingeAngleSensorStatics
    {
        auto GetDeviceSelector() const;
        auto GetDefaultAsync() const;
        auto GetRelatedToAdjacentPanelsAsync(param::hstring const& firstPanelId, param::hstring const& secondPanelId) const;
        auto FromIdAsync(param::hstring const& deviceId) const;
    };
    template <> struct consume<Windows::Devices::Sensors::IHingeAngleSensorStatics>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IHingeAngleSensorStatics<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IInclinometer
    {
        auto GetCurrentReading() const;
        [[nodiscard]] auto MinimumReportInterval() const;
        auto ReportInterval(uint32_t value) const;
        [[nodiscard]] auto ReportInterval() const;
        auto ReadingChanged(Windows::Foundation::TypedEventHandler<Windows::Devices::Sensors::Inclinometer, Windows::Devices::Sensors::InclinometerReadingChangedEventArgs> const& handler) const;
        using ReadingChanged_revoker = impl::event_revoker<Windows::Devices::Sensors::IInclinometer, &impl::abi_t<Windows::Devices::Sensors::IInclinometer>::remove_ReadingChanged>;
        ReadingChanged_revoker ReadingChanged(auto_revoke_t, Windows::Foundation::TypedEventHandler<Windows::Devices::Sensors::Inclinometer, Windows::Devices::Sensors::InclinometerReadingChangedEventArgs> const& handler) const;
        auto ReadingChanged(winrt::event_token const& token) const noexcept;
    };
    template <> struct consume<Windows::Devices::Sensors::IInclinometer>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IInclinometer<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IInclinometer2
    {
        auto ReadingTransform(Windows::Graphics::Display::DisplayOrientations const& value) const;
        [[nodiscard]] auto ReadingTransform() const;
        [[nodiscard]] auto ReadingType() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IInclinometer2>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IInclinometer2<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IInclinometer3
    {
        auto ReportLatency(uint32_t value) const;
        [[nodiscard]] auto ReportLatency() const;
        [[nodiscard]] auto MaxBatchSize() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IInclinometer3>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IInclinometer3<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IInclinometer4
    {
        [[nodiscard]] auto ReportThreshold() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IInclinometer4>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IInclinometer4<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IInclinometerDataThreshold
    {
        [[nodiscard]] auto PitchInDegrees() const;
        auto PitchInDegrees(float value) const;
        [[nodiscard]] auto RollInDegrees() const;
        auto RollInDegrees(float value) const;
        [[nodiscard]] auto YawInDegrees() const;
        auto YawInDegrees(float value) const;
    };
    template <> struct consume<Windows::Devices::Sensors::IInclinometerDataThreshold>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IInclinometerDataThreshold<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IInclinometerDeviceId
    {
        [[nodiscard]] auto DeviceId() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IInclinometerDeviceId>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IInclinometerDeviceId<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IInclinometerReading
    {
        [[nodiscard]] auto Timestamp() const;
        [[nodiscard]] auto PitchDegrees() const;
        [[nodiscard]] auto RollDegrees() const;
        [[nodiscard]] auto YawDegrees() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IInclinometerReading>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IInclinometerReading<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IInclinometerReading2
    {
        [[nodiscard]] auto PerformanceCount() const;
        [[nodiscard]] auto Properties() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IInclinometerReading2>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IInclinometerReading2<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IInclinometerReadingChangedEventArgs
    {
        [[nodiscard]] auto Reading() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IInclinometerReadingChangedEventArgs>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IInclinometerReadingChangedEventArgs<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IInclinometerReadingYawAccuracy
    {
        [[nodiscard]] auto YawAccuracy() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IInclinometerReadingYawAccuracy>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IInclinometerReadingYawAccuracy<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IInclinometerStatics
    {
        auto GetDefault() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IInclinometerStatics>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IInclinometerStatics<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IInclinometerStatics2
    {
        auto GetDefaultForRelativeReadings() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IInclinometerStatics2>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IInclinometerStatics2<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IInclinometerStatics3
    {
        auto GetDefault(Windows::Devices::Sensors::SensorReadingType const& sensorReadingtype) const;
    };
    template <> struct consume<Windows::Devices::Sensors::IInclinometerStatics3>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IInclinometerStatics3<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IInclinometerStatics4
    {
        auto GetDeviceSelector(Windows::Devices::Sensors::SensorReadingType const& readingType) const;
        auto FromIdAsync(param::hstring const& deviceId) const;
    };
    template <> struct consume<Windows::Devices::Sensors::IInclinometerStatics4>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IInclinometerStatics4<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_ILightSensor
    {
        auto GetCurrentReading() const;
        [[nodiscard]] auto MinimumReportInterval() const;
        auto ReportInterval(uint32_t value) const;
        [[nodiscard]] auto ReportInterval() const;
        auto ReadingChanged(Windows::Foundation::TypedEventHandler<Windows::Devices::Sensors::LightSensor, Windows::Devices::Sensors::LightSensorReadingChangedEventArgs> const& handler) const;
        using ReadingChanged_revoker = impl::event_revoker<Windows::Devices::Sensors::ILightSensor, &impl::abi_t<Windows::Devices::Sensors::ILightSensor>::remove_ReadingChanged>;
        ReadingChanged_revoker ReadingChanged(auto_revoke_t, Windows::Foundation::TypedEventHandler<Windows::Devices::Sensors::LightSensor, Windows::Devices::Sensors::LightSensorReadingChangedEventArgs> const& handler) const;
        auto ReadingChanged(winrt::event_token const& token) const noexcept;
    };
    template <> struct consume<Windows::Devices::Sensors::ILightSensor>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_ILightSensor<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_ILightSensor2
    {
        auto ReportLatency(uint32_t value) const;
        [[nodiscard]] auto ReportLatency() const;
        [[nodiscard]] auto MaxBatchSize() const;
    };
    template <> struct consume<Windows::Devices::Sensors::ILightSensor2>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_ILightSensor2<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_ILightSensor3
    {
        [[nodiscard]] auto ReportThreshold() const;
    };
    template <> struct consume<Windows::Devices::Sensors::ILightSensor3>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_ILightSensor3<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_ILightSensorDataThreshold
    {
        [[nodiscard]] auto LuxPercentage() const;
        auto LuxPercentage(float value) const;
        [[nodiscard]] auto AbsoluteLux() const;
        auto AbsoluteLux(float value) const;
    };
    template <> struct consume<Windows::Devices::Sensors::ILightSensorDataThreshold>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_ILightSensorDataThreshold<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_ILightSensorDeviceId
    {
        [[nodiscard]] auto DeviceId() const;
    };
    template <> struct consume<Windows::Devices::Sensors::ILightSensorDeviceId>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_ILightSensorDeviceId<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_ILightSensorReading
    {
        [[nodiscard]] auto Timestamp() const;
        [[nodiscard]] auto IlluminanceInLux() const;
    };
    template <> struct consume<Windows::Devices::Sensors::ILightSensorReading>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_ILightSensorReading<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_ILightSensorReading2
    {
        [[nodiscard]] auto PerformanceCount() const;
        [[nodiscard]] auto Properties() const;
    };
    template <> struct consume<Windows::Devices::Sensors::ILightSensorReading2>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_ILightSensorReading2<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_ILightSensorReadingChangedEventArgs
    {
        [[nodiscard]] auto Reading() const;
    };
    template <> struct consume<Windows::Devices::Sensors::ILightSensorReadingChangedEventArgs>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_ILightSensorReadingChangedEventArgs<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_ILightSensorStatics
    {
        auto GetDefault() const;
    };
    template <> struct consume<Windows::Devices::Sensors::ILightSensorStatics>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_ILightSensorStatics<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_ILightSensorStatics2
    {
        auto GetDeviceSelector() const;
        auto FromIdAsync(param::hstring const& deviceId) const;
    };
    template <> struct consume<Windows::Devices::Sensors::ILightSensorStatics2>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_ILightSensorStatics2<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IMagnetometer
    {
        auto GetCurrentReading() const;
        [[nodiscard]] auto MinimumReportInterval() const;
        auto ReportInterval(uint32_t value) const;
        [[nodiscard]] auto ReportInterval() const;
        auto ReadingChanged(Windows::Foundation::TypedEventHandler<Windows::Devices::Sensors::Magnetometer, Windows::Devices::Sensors::MagnetometerReadingChangedEventArgs> const& handler) const;
        using ReadingChanged_revoker = impl::event_revoker<Windows::Devices::Sensors::IMagnetometer, &impl::abi_t<Windows::Devices::Sensors::IMagnetometer>::remove_ReadingChanged>;
        ReadingChanged_revoker ReadingChanged(auto_revoke_t, Windows::Foundation::TypedEventHandler<Windows::Devices::Sensors::Magnetometer, Windows::Devices::Sensors::MagnetometerReadingChangedEventArgs> const& handler) const;
        auto ReadingChanged(winrt::event_token const& token) const noexcept;
    };
    template <> struct consume<Windows::Devices::Sensors::IMagnetometer>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IMagnetometer<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IMagnetometer2
    {
        auto ReadingTransform(Windows::Graphics::Display::DisplayOrientations const& value) const;
        [[nodiscard]] auto ReadingTransform() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IMagnetometer2>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IMagnetometer2<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IMagnetometer3
    {
        auto ReportLatency(uint32_t value) const;
        [[nodiscard]] auto ReportLatency() const;
        [[nodiscard]] auto MaxBatchSize() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IMagnetometer3>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IMagnetometer3<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IMagnetometer4
    {
        [[nodiscard]] auto ReportThreshold() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IMagnetometer4>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IMagnetometer4<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IMagnetometerDataThreshold
    {
        [[nodiscard]] auto XAxisMicroteslas() const;
        auto XAxisMicroteslas(float value) const;
        [[nodiscard]] auto YAxisMicroteslas() const;
        auto YAxisMicroteslas(float value) const;
        [[nodiscard]] auto ZAxisMicroteslas() const;
        auto ZAxisMicroteslas(float value) const;
    };
    template <> struct consume<Windows::Devices::Sensors::IMagnetometerDataThreshold>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IMagnetometerDataThreshold<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IMagnetometerDeviceId
    {
        [[nodiscard]] auto DeviceId() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IMagnetometerDeviceId>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IMagnetometerDeviceId<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IMagnetometerReading
    {
        [[nodiscard]] auto Timestamp() const;
        [[nodiscard]] auto MagneticFieldX() const;
        [[nodiscard]] auto MagneticFieldY() const;
        [[nodiscard]] auto MagneticFieldZ() const;
        [[nodiscard]] auto DirectionalAccuracy() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IMagnetometerReading>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IMagnetometerReading<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IMagnetometerReading2
    {
        [[nodiscard]] auto PerformanceCount() const;
        [[nodiscard]] auto Properties() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IMagnetometerReading2>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IMagnetometerReading2<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IMagnetometerReadingChangedEventArgs
    {
        [[nodiscard]] auto Reading() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IMagnetometerReadingChangedEventArgs>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IMagnetometerReadingChangedEventArgs<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IMagnetometerStatics
    {
        auto GetDefault() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IMagnetometerStatics>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IMagnetometerStatics<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IMagnetometerStatics2
    {
        auto GetDeviceSelector() const;
        auto FromIdAsync(param::hstring const& deviceId) const;
    };
    template <> struct consume<Windows::Devices::Sensors::IMagnetometerStatics2>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IMagnetometerStatics2<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IOrientationSensor
    {
        auto GetCurrentReading() const;
        [[nodiscard]] auto MinimumReportInterval() const;
        auto ReportInterval(uint32_t value) const;
        [[nodiscard]] auto ReportInterval() const;
        auto ReadingChanged(Windows::Foundation::TypedEventHandler<Windows::Devices::Sensors::OrientationSensor, Windows::Devices::Sensors::OrientationSensorReadingChangedEventArgs> const& handler) const;
        using ReadingChanged_revoker = impl::event_revoker<Windows::Devices::Sensors::IOrientationSensor, &impl::abi_t<Windows::Devices::Sensors::IOrientationSensor>::remove_ReadingChanged>;
        ReadingChanged_revoker ReadingChanged(auto_revoke_t, Windows::Foundation::TypedEventHandler<Windows::Devices::Sensors::OrientationSensor, Windows::Devices::Sensors::OrientationSensorReadingChangedEventArgs> const& handler) const;
        auto ReadingChanged(winrt::event_token const& token) const noexcept;
    };
    template <> struct consume<Windows::Devices::Sensors::IOrientationSensor>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IOrientationSensor<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IOrientationSensor2
    {
        auto ReadingTransform(Windows::Graphics::Display::DisplayOrientations const& value) const;
        [[nodiscard]] auto ReadingTransform() const;
        [[nodiscard]] auto ReadingType() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IOrientationSensor2>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IOrientationSensor2<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IOrientationSensor3
    {
        auto ReportLatency(uint32_t value) const;
        [[nodiscard]] auto ReportLatency() const;
        [[nodiscard]] auto MaxBatchSize() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IOrientationSensor3>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IOrientationSensor3<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IOrientationSensorDeviceId
    {
        [[nodiscard]] auto DeviceId() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IOrientationSensorDeviceId>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IOrientationSensorDeviceId<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IOrientationSensorReading
    {
        [[nodiscard]] auto Timestamp() const;
        [[nodiscard]] auto RotationMatrix() const;
        [[nodiscard]] auto Quaternion() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IOrientationSensorReading>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IOrientationSensorReading<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IOrientationSensorReading2
    {
        [[nodiscard]] auto PerformanceCount() const;
        [[nodiscard]] auto Properties() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IOrientationSensorReading2>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IOrientationSensorReading2<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IOrientationSensorReadingChangedEventArgs
    {
        [[nodiscard]] auto Reading() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IOrientationSensorReadingChangedEventArgs>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IOrientationSensorReadingChangedEventArgs<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IOrientationSensorReadingYawAccuracy
    {
        [[nodiscard]] auto YawAccuracy() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IOrientationSensorReadingYawAccuracy>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IOrientationSensorReadingYawAccuracy<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IOrientationSensorStatics
    {
        auto GetDefault() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IOrientationSensorStatics>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IOrientationSensorStatics<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IOrientationSensorStatics2
    {
        auto GetDefaultForRelativeReadings() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IOrientationSensorStatics2>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IOrientationSensorStatics2<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IOrientationSensorStatics3
    {
        auto GetDefault(Windows::Devices::Sensors::SensorReadingType const& sensorReadingtype) const;
        auto GetDefault(Windows::Devices::Sensors::SensorReadingType const& sensorReadingType, Windows::Devices::Sensors::SensorOptimizationGoal const& optimizationGoal) const;
    };
    template <> struct consume<Windows::Devices::Sensors::IOrientationSensorStatics3>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IOrientationSensorStatics3<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IOrientationSensorStatics4
    {
        auto GetDeviceSelector(Windows::Devices::Sensors::SensorReadingType const& readingType) const;
        auto GetDeviceSelector(Windows::Devices::Sensors::SensorReadingType const& readingType, Windows::Devices::Sensors::SensorOptimizationGoal const& optimizationGoal) const;
        auto FromIdAsync(param::hstring const& deviceId) const;
    };
    template <> struct consume<Windows::Devices::Sensors::IOrientationSensorStatics4>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IOrientationSensorStatics4<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IPedometer
    {
        [[nodiscard]] auto DeviceId() const;
        [[nodiscard]] auto PowerInMilliwatts() const;
        [[nodiscard]] auto MinimumReportInterval() const;
        auto ReportInterval(uint32_t value) const;
        [[nodiscard]] auto ReportInterval() const;
        auto ReadingChanged(Windows::Foundation::TypedEventHandler<Windows::Devices::Sensors::Pedometer, Windows::Devices::Sensors::PedometerReadingChangedEventArgs> const& handler) const;
        using ReadingChanged_revoker = impl::event_revoker<Windows::Devices::Sensors::IPedometer, &impl::abi_t<Windows::Devices::Sensors::IPedometer>::remove_ReadingChanged>;
        ReadingChanged_revoker ReadingChanged(auto_revoke_t, Windows::Foundation::TypedEventHandler<Windows::Devices::Sensors::Pedometer, Windows::Devices::Sensors::PedometerReadingChangedEventArgs> const& handler) const;
        auto ReadingChanged(winrt::event_token const& token) const noexcept;
    };
    template <> struct consume<Windows::Devices::Sensors::IPedometer>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IPedometer<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IPedometer2
    {
        auto GetCurrentReadings() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IPedometer2>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IPedometer2<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IPedometerDataThresholdFactory
    {
        auto Create(Windows::Devices::Sensors::Pedometer const& sensor, int32_t stepGoal) const;
    };
    template <> struct consume<Windows::Devices::Sensors::IPedometerDataThresholdFactory>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IPedometerDataThresholdFactory<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IPedometerReading
    {
        [[nodiscard]] auto StepKind() const;
        [[nodiscard]] auto CumulativeSteps() const;
        [[nodiscard]] auto Timestamp() const;
        [[nodiscard]] auto CumulativeStepsDuration() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IPedometerReading>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IPedometerReading<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IPedometerReadingChangedEventArgs
    {
        [[nodiscard]] auto Reading() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IPedometerReadingChangedEventArgs>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IPedometerReadingChangedEventArgs<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IPedometerStatics
    {
        auto FromIdAsync(param::hstring const& deviceId) const;
        auto GetDefaultAsync() const;
        auto GetDeviceSelector() const;
        auto GetSystemHistoryAsync(Windows::Foundation::DateTime const& fromTime) const;
        auto GetSystemHistoryAsync(Windows::Foundation::DateTime const& fromTime, Windows::Foundation::TimeSpan const& duration) const;
    };
    template <> struct consume<Windows::Devices::Sensors::IPedometerStatics>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IPedometerStatics<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IPedometerStatics2
    {
        auto GetReadingsFromTriggerDetails(Windows::Devices::Sensors::SensorDataThresholdTriggerDetails const& triggerDetails) const;
    };
    template <> struct consume<Windows::Devices::Sensors::IPedometerStatics2>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IPedometerStatics2<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IProximitySensor
    {
        [[nodiscard]] auto DeviceId() const;
        [[nodiscard]] auto MaxDistanceInMillimeters() const;
        [[nodiscard]] auto MinDistanceInMillimeters() const;
        auto GetCurrentReading() const;
        auto ReadingChanged(Windows::Foundation::TypedEventHandler<Windows::Devices::Sensors::ProximitySensor, Windows::Devices::Sensors::ProximitySensorReadingChangedEventArgs> const& handler) const;
        using ReadingChanged_revoker = impl::event_revoker<Windows::Devices::Sensors::IProximitySensor, &impl::abi_t<Windows::Devices::Sensors::IProximitySensor>::remove_ReadingChanged>;
        ReadingChanged_revoker ReadingChanged(auto_revoke_t, Windows::Foundation::TypedEventHandler<Windows::Devices::Sensors::ProximitySensor, Windows::Devices::Sensors::ProximitySensorReadingChangedEventArgs> const& handler) const;
        auto ReadingChanged(winrt::event_token const& token) const noexcept;
        auto CreateDisplayOnOffController() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IProximitySensor>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IProximitySensor<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IProximitySensorDataThresholdFactory
    {
        auto Create(Windows::Devices::Sensors::ProximitySensor const& sensor) const;
    };
    template <> struct consume<Windows::Devices::Sensors::IProximitySensorDataThresholdFactory>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IProximitySensorDataThresholdFactory<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IProximitySensorReading
    {
        [[nodiscard]] auto Timestamp() const;
        [[nodiscard]] auto IsDetected() const;
        [[nodiscard]] auto DistanceInMillimeters() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IProximitySensorReading>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IProximitySensorReading<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IProximitySensorReadingChangedEventArgs
    {
        [[nodiscard]] auto Reading() const;
    };
    template <> struct consume<Windows::Devices::Sensors::IProximitySensorReadingChangedEventArgs>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IProximitySensorReadingChangedEventArgs<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IProximitySensorStatics
    {
        auto GetDeviceSelector() const;
        auto FromId(param::hstring const& sensorId) const;
    };
    template <> struct consume<Windows::Devices::Sensors::IProximitySensorStatics>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IProximitySensorStatics<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_IProximitySensorStatics2
    {
        auto GetReadingsFromTriggerDetails(Windows::Devices::Sensors::SensorDataThresholdTriggerDetails const& triggerDetails) const;
    };
    template <> struct consume<Windows::Devices::Sensors::IProximitySensorStatics2>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_IProximitySensorStatics2<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_ISensorDataThreshold
    {
    };
    template <> struct consume<Windows::Devices::Sensors::ISensorDataThreshold>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_ISensorDataThreshold<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_ISensorDataThresholdTriggerDetails
    {
        [[nodiscard]] auto DeviceId() const;
        [[nodiscard]] auto SensorType() const;
    };
    template <> struct consume<Windows::Devices::Sensors::ISensorDataThresholdTriggerDetails>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_ISensorDataThresholdTriggerDetails<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_ISensorQuaternion
    {
        [[nodiscard]] auto W() const;
        [[nodiscard]] auto X() const;
        [[nodiscard]] auto Y() const;
        [[nodiscard]] auto Z() const;
    };
    template <> struct consume<Windows::Devices::Sensors::ISensorQuaternion>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_ISensorQuaternion<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_ISensorRotationMatrix
    {
        [[nodiscard]] auto M11() const;
        [[nodiscard]] auto M12() const;
        [[nodiscard]] auto M13() const;
        [[nodiscard]] auto M21() const;
        [[nodiscard]] auto M22() const;
        [[nodiscard]] auto M23() const;
        [[nodiscard]] auto M31() const;
        [[nodiscard]] auto M32() const;
        [[nodiscard]] auto M33() const;
    };
    template <> struct consume<Windows::Devices::Sensors::ISensorRotationMatrix>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_ISensorRotationMatrix<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_ISimpleOrientationSensor
    {
        auto GetCurrentOrientation() const;
        auto OrientationChanged(Windows::Foundation::TypedEventHandler<Windows::Devices::Sensors::SimpleOrientationSensor, Windows::Devices::Sensors::SimpleOrientationSensorOrientationChangedEventArgs> const& handler) const;
        using OrientationChanged_revoker = impl::event_revoker<Windows::Devices::Sensors::ISimpleOrientationSensor, &impl::abi_t<Windows::Devices::Sensors::ISimpleOrientationSensor>::remove_OrientationChanged>;
        OrientationChanged_revoker OrientationChanged(auto_revoke_t, Windows::Foundation::TypedEventHandler<Windows::Devices::Sensors::SimpleOrientationSensor, Windows::Devices::Sensors::SimpleOrientationSensorOrientationChangedEventArgs> const& handler) const;
        auto OrientationChanged(winrt::event_token const& token) const noexcept;
    };
    template <> struct consume<Windows::Devices::Sensors::ISimpleOrientationSensor>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_ISimpleOrientationSensor<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_ISimpleOrientationSensor2
    {
        auto ReadingTransform(Windows::Graphics::Display::DisplayOrientations const& value) const;
        [[nodiscard]] auto ReadingTransform() const;
    };
    template <> struct consume<Windows::Devices::Sensors::ISimpleOrientationSensor2>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_ISimpleOrientationSensor2<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_ISimpleOrientationSensorDeviceId
    {
        [[nodiscard]] auto DeviceId() const;
    };
    template <> struct consume<Windows::Devices::Sensors::ISimpleOrientationSensorDeviceId>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_ISimpleOrientationSensorDeviceId<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_ISimpleOrientationSensorOrientationChangedEventArgs
    {
        [[nodiscard]] auto Timestamp() const;
        [[nodiscard]] auto Orientation() const;
    };
    template <> struct consume<Windows::Devices::Sensors::ISimpleOrientationSensorOrientationChangedEventArgs>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_ISimpleOrientationSensorOrientationChangedEventArgs<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_ISimpleOrientationSensorStatics
    {
        auto GetDefault() const;
    };
    template <> struct consume<Windows::Devices::Sensors::ISimpleOrientationSensorStatics>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_ISimpleOrientationSensorStatics<D>;
    };
    template <typename D>
    struct consume_Windows_Devices_Sensors_ISimpleOrientationSensorStatics2
    {
        auto GetDeviceSelector() const;
        auto FromIdAsync(param::hstring const& deviceId) const;
    };
    template <> struct consume<Windows::Devices::Sensors::ISimpleOrientationSensorStatics2>
    {
        template <typename D> using type = consume_Windows_Devices_Sensors_ISimpleOrientationSensorStatics2<D>;
    };
}
#endif
