//! NOTE: this file is autogenerated, DO NOT MODIFY
//--------------------------------------------------------------------------------
// Section: Constants (278)
//--------------------------------------------------------------------------------
pub const GUID_DEVINTERFACE_SENSOR = Guid.initString("ba1bb692-9b7a-4833-9a1e-525ed134e7e2");
pub const SENSOR_EVENT_STATE_CHANGED = Guid.initString("bfd96016-6bd7-4560-ad34-f2f6607e8f81");
pub const SENSOR_EVENT_DATA_UPDATED = Guid.initString("2ed0f2a4-0087-41d3-87db-6773370b3c88");
pub const SENSOR_EVENT_PROPERTY_CHANGED = Guid.initString("2358f099-84c9-4d3d-90df-c2421e2b2045");
pub const SENSOR_EVENT_ACCELEROMETER_SHAKE = Guid.initString("825f5a94-0f48-4396-9ca0-6ecb5c99d915");
pub const SENSOR_EVENT_PARAMETER_COMMON_GUID = Guid.initString("64346e30-8728-4b34-bdf6-4f52442c5c28");
pub const SENSOR_EVENT_PARAMETER_EVENT_ID = PROPERTYKEY{ .fmtid = Guid.initString("64346e30-8728-4b34-bdf6-4f52442c5c28"), .pid = 2 };
pub const SENSOR_EVENT_PARAMETER_STATE = PROPERTYKEY{ .fmtid = Guid.initString("64346e30-8728-4b34-bdf6-4f52442c5c28"), .pid = 3 };
pub const SENSOR_ERROR_PARAMETER_COMMON_GUID = Guid.initString("77112bcd-fce1-4f43-b8b8-a88256adb4b3");
pub const SENSOR_PROPERTY_COMMON_GUID = Guid.initString("7f8383ec-d3ec-495c-a8cf-b8bbe85c2920");
pub const SENSOR_PROPERTY_TYPE = PROPERTYKEY{ .fmtid = Guid.initString("7f8383ec-d3ec-495c-a8cf-b8bbe85c2920"), .pid = 2 };
pub const SENSOR_PROPERTY_STATE = PROPERTYKEY{ .fmtid = Guid.initString("7f8383ec-d3ec-495c-a8cf-b8bbe85c2920"), .pid = 3 };
pub const SENSOR_PROPERTY_PERSISTENT_UNIQUE_ID = PROPERTYKEY{ .fmtid = Guid.initString("7f8383ec-d3ec-495c-a8cf-b8bbe85c2920"), .pid = 5 };
pub const SENSOR_PROPERTY_MANUFACTURER = PROPERTYKEY{ .fmtid = Guid.initString("7f8383ec-d3ec-495c-a8cf-b8bbe85c2920"), .pid = 6 };
pub const SENSOR_PROPERTY_MODEL = PROPERTYKEY{ .fmtid = Guid.initString("7f8383ec-d3ec-495c-a8cf-b8bbe85c2920"), .pid = 7 };
pub const SENSOR_PROPERTY_SERIAL_NUMBER = PROPERTYKEY{ .fmtid = Guid.initString("7f8383ec-d3ec-495c-a8cf-b8bbe85c2920"), .pid = 8 };
pub const SENSOR_PROPERTY_FRIENDLY_NAME = PROPERTYKEY{ .fmtid = Guid.initString("7f8383ec-d3ec-495c-a8cf-b8bbe85c2920"), .pid = 9 };
pub const SENSOR_PROPERTY_DESCRIPTION = PROPERTYKEY{ .fmtid = Guid.initString("7f8383ec-d3ec-495c-a8cf-b8bbe85c2920"), .pid = 10 };
pub const SENSOR_PROPERTY_CONNECTION_TYPE = PROPERTYKEY{ .fmtid = Guid.initString("7f8383ec-d3ec-495c-a8cf-b8bbe85c2920"), .pid = 11 };
pub const SENSOR_PROPERTY_MIN_REPORT_INTERVAL = PROPERTYKEY{ .fmtid = Guid.initString("7f8383ec-d3ec-495c-a8cf-b8bbe85c2920"), .pid = 12 };
pub const SENSOR_PROPERTY_CURRENT_REPORT_INTERVAL = PROPERTYKEY{ .fmtid = Guid.initString("7f8383ec-d3ec-495c-a8cf-b8bbe85c2920"), .pid = 13 };
pub const SENSOR_PROPERTY_CHANGE_SENSITIVITY = PROPERTYKEY{ .fmtid = Guid.initString("7f8383ec-d3ec-495c-a8cf-b8bbe85c2920"), .pid = 14 };
pub const SENSOR_PROPERTY_DEVICE_PATH = PROPERTYKEY{ .fmtid = Guid.initString("7f8383ec-d3ec-495c-a8cf-b8bbe85c2920"), .pid = 15 };
pub const SENSOR_PROPERTY_LIGHT_RESPONSE_CURVE = PROPERTYKEY{ .fmtid = Guid.initString("7f8383ec-d3ec-495c-a8cf-b8bbe85c2920"), .pid = 16 };
pub const SENSOR_PROPERTY_ACCURACY = PROPERTYKEY{ .fmtid = Guid.initString("7f8383ec-d3ec-495c-a8cf-b8bbe85c2920"), .pid = 17 };
pub const SENSOR_PROPERTY_RESOLUTION = PROPERTYKEY{ .fmtid = Guid.initString("7f8383ec-d3ec-495c-a8cf-b8bbe85c2920"), .pid = 18 };
pub const SENSOR_PROPERTY_LOCATION_DESIRED_ACCURACY = PROPERTYKEY{ .fmtid = Guid.initString("7f8383ec-d3ec-495c-a8cf-b8bbe85c2920"), .pid = 19 };
pub const SENSOR_PROPERTY_RANGE_MINIMUM = PROPERTYKEY{ .fmtid = Guid.initString("7f8383ec-d3ec-495c-a8cf-b8bbe85c2920"), .pid = 20 };
pub const SENSOR_PROPERTY_RANGE_MAXIMUM = PROPERTYKEY{ .fmtid = Guid.initString("7f8383ec-d3ec-495c-a8cf-b8bbe85c2920"), .pid = 21 };
pub const SENSOR_PROPERTY_HID_USAGE = PROPERTYKEY{ .fmtid = Guid.initString("7f8383ec-d3ec-495c-a8cf-b8bbe85c2920"), .pid = 22 };
pub const SENSOR_PROPERTY_RADIO_STATE = PROPERTYKEY{ .fmtid = Guid.initString("7f8383ec-d3ec-495c-a8cf-b8bbe85c2920"), .pid = 23 };
pub const SENSOR_PROPERTY_RADIO_STATE_PREVIOUS = PROPERTYKEY{ .fmtid = Guid.initString("7f8383ec-d3ec-495c-a8cf-b8bbe85c2920"), .pid = 24 };
pub const SENSOR_CATEGORY_ALL = Guid.initString("c317c286-c468-4288-9975-d4c4587c442c");
pub const SENSOR_CATEGORY_LOCATION = Guid.initString("bfa794e4-f964-4fdb-90f6-51056bfe4b44");
pub const SENSOR_CATEGORY_ENVIRONMENTAL = Guid.initString("323439aa-7f66-492b-ba0c-73e9aa0a65d5");
pub const SENSOR_CATEGORY_MOTION = Guid.initString("cd09daf1-3b2e-4c3d-b598-b5e5ff93fd46");
pub const SENSOR_CATEGORY_ORIENTATION = Guid.initString("9e6c04b6-96fe-4954-b726-68682a473f69");
pub const SENSOR_CATEGORY_MECHANICAL = Guid.initString("8d131d68-8ef7-4656-80b5-cccbd93791c5");
pub const SENSOR_CATEGORY_ELECTRICAL = Guid.initString("fb73fcd8-fc4a-483c-ac58-27b691c6beff");
pub const SENSOR_CATEGORY_BIOMETRIC = Guid.initString("ca19690f-a2c7-477d-a99e-99ec6e2b5648");
pub const SENSOR_CATEGORY_LIGHT = Guid.initString("17a665c0-9063-4216-b202-5c7a255e18ce");
pub const SENSOR_CATEGORY_SCANNER = Guid.initString("b000e77e-f5b5-420f-815d-0270a726f270");
pub const SENSOR_CATEGORY_OTHER = Guid.initString("2c90e7a9-f4c9-4fa2-af37-56d471fe5a3d");
pub const SENSOR_CATEGORY_UNSUPPORTED = Guid.initString("2beae7fa-19b0-48c5-a1f6-b5480dc206b0");
pub const SENSOR_TYPE_LOCATION_GPS = Guid.initString("ed4ca589-327a-4ff9-a560-91da4b48275e");
pub const SENSOR_TYPE_LOCATION_STATIC = Guid.initString("095f8184-0fa9-4445-8e6e-b70f320b6b4c");
pub const SENSOR_TYPE_LOCATION_LOOKUP = Guid.initString("3b2eae4a-72ce-436d-96d2-3c5b8570e987");
pub const SENSOR_TYPE_LOCATION_TRIANGULATION = Guid.initString("691c341a-5406-4fe1-942f-2246cbeb39e0");
pub const SENSOR_TYPE_LOCATION_OTHER = Guid.initString("9b2d0566-0368-4f71-b88d-533f132031de");
pub const SENSOR_TYPE_LOCATION_BROADCAST = Guid.initString("d26988cf-5162-4039-bb17-4c58b698e44a");
pub const SENSOR_TYPE_LOCATION_DEAD_RECKONING = Guid.initString("1a37d538-f28b-42da-9fce-a9d0a2a6d829");
pub const SENSOR_TYPE_ENVIRONMENTAL_TEMPERATURE = Guid.initString("04fd0ec4-d5da-45fa-95a9-5db38ee19306");
pub const SENSOR_TYPE_ENVIRONMENTAL_ATMOSPHERIC_PRESSURE = Guid.initString("0e903829-ff8a-4a93-97df-3dcbde402288");
pub const SENSOR_TYPE_ENVIRONMENTAL_HUMIDITY = Guid.initString("5c72bf67-bd7e-4257-990b-98a3ba3b400a");
pub const SENSOR_TYPE_ENVIRONMENTAL_WIND_SPEED = Guid.initString("dd50607b-a45f-42cd-8efd-ec61761c4226");
pub const SENSOR_TYPE_ENVIRONMENTAL_WIND_DIRECTION = Guid.initString("9ef57a35-9306-434d-af09-37fa5a9c00bd");
pub const SENSOR_TYPE_ACCELEROMETER_1D = Guid.initString("c04d2387-7340-4cc2-991e-3b18cb8ef2f4");
pub const SENSOR_TYPE_ACCELEROMETER_2D = Guid.initString("b2c517a8-f6b5-4ba6-a423-5df560b4cc07");
pub const SENSOR_TYPE_ACCELEROMETER_3D = Guid.initString("c2fb0f5f-e2d2-4c78-bcd0-352a9582819d");
pub const SENSOR_TYPE_MOTION_DETECTOR = Guid.initString("5c7c1a12-30a5-43b9-a4b2-cf09ec5b7be8");
pub const SENSOR_TYPE_GYROMETER_1D = Guid.initString("fa088734-f552-4584-8324-edfaf649652c");
pub const SENSOR_TYPE_GYROMETER_2D = Guid.initString("31ef4f83-919b-48bf-8de0-5d7a9d240556");
pub const SENSOR_TYPE_GYROMETER_3D = Guid.initString("09485f5a-759e-42c2-bd4b-a349b75c8643");
pub const SENSOR_TYPE_SPEEDOMETER = Guid.initString("6bd73c1f-0bb4-4310-81b2-dfc18a52bf94");
pub const SENSOR_TYPE_COMPASS_1D = Guid.initString("a415f6c5-cb50-49d0-8e62-a8270bd7a26c");
pub const SENSOR_TYPE_COMPASS_2D = Guid.initString("15655cc0-997a-4d30-84db-57caba3648bb");
pub const SENSOR_TYPE_COMPASS_3D = Guid.initString("76b5ce0d-17dd-414d-93a1-e127f40bdf6e");
pub const SENSOR_TYPE_INCLINOMETER_1D = Guid.initString("b96f98c5-7a75-4ba7-94e9-ac868c966dd8");
pub const SENSOR_TYPE_INCLINOMETER_2D = Guid.initString("ab140f6d-83eb-4264-b70b-b16a5b256a01");
pub const SENSOR_TYPE_INCLINOMETER_3D = Guid.initString("b84919fb-ea85-4976-8444-6f6f5c6d31db");
pub const SENSOR_TYPE_DISTANCE_1D = Guid.initString("5f14ab2f-1407-4306-a93f-b1dbabe4f9c0");
pub const SENSOR_TYPE_DISTANCE_2D = Guid.initString("5cf9a46c-a9a2-4e55-b6a1-a04aafa95a92");
pub const SENSOR_TYPE_DISTANCE_3D = Guid.initString("a20cae31-0e25-4772-9fe5-96608a1354b2");
pub const SENSOR_TYPE_AGGREGATED_QUADRANT_ORIENTATION = Guid.initString("9f81f1af-c4ab-4307-9904-c828bfb90829");
pub const SENSOR_TYPE_AGGREGATED_DEVICE_ORIENTATION = Guid.initString("cdb5d8f7-3cfd-41c8-8542-cce622cf5d6e");
pub const SENSOR_TYPE_AGGREGATED_SIMPLE_DEVICE_ORIENTATION = Guid.initString("86a19291-0482-402c-bf4c-addac52b1c39");
pub const SENSOR_TYPE_VOLTAGE = Guid.initString("c5484637-4fb7-4953-98b8-a56d8aa1fb1e");
pub const SENSOR_TYPE_CURRENT = Guid.initString("5adc9fce-15a0-4bbe-a1ad-2d38a9ae831c");
pub const SENSOR_TYPE_CAPACITANCE = Guid.initString("ca2ffb1c-2317-49c0-a0b4-b63ce63461a0");
pub const SENSOR_TYPE_RESISTANCE = Guid.initString("9993d2c8-c157-4a52-a7b5-195c76037231");
pub const SENSOR_TYPE_INDUCTANCE = Guid.initString("dc1d933f-c435-4c7d-a2fe-607192a524d3");
pub const SENSOR_TYPE_ELECTRICAL_POWER = Guid.initString("212f10f5-14ab-4376-9a43-a7794098c2fe");
pub const SENSOR_TYPE_POTENTIOMETER = Guid.initString("2b3681a9-cadc-45aa-a6ff-54957c8bb440");
pub const SENSOR_TYPE_FREQUENCY = Guid.initString("8cd2cbb6-73e6-4640-a709-72ae8fb60d7f");
pub const SENSOR_TYPE_BOOLEAN_SWITCH = Guid.initString("9c7e371f-1041-460b-8d5c-71e4752e350c");
pub const SENSOR_TYPE_MULTIVALUE_SWITCH = Guid.initString("b3ee4d76-37a4-4402-b25e-99c60a775fa1");
pub const SENSOR_TYPE_FORCE = Guid.initString("c2ab2b02-1a1c-4778-a81b-954a1788cc75");
pub const SENSOR_TYPE_SCALE = Guid.initString("c06dd92c-7feb-438e-9bf6-82207fff5bb8");
pub const SENSOR_TYPE_PRESSURE = Guid.initString("26d31f34-6352-41cf-b793-ea0713d53d77");
pub const SENSOR_TYPE_STRAIN = Guid.initString("c6d1ec0e-6803-4361-ad3d-85bcc58c6d29");
pub const SENSOR_TYPE_BOOLEAN_SWITCH_ARRAY = Guid.initString("545c8ba5-b143-4545-868f-ca7fd986b4f6");
pub const SENSOR_TYPE_HUMAN_PRESENCE = Guid.initString("c138c12b-ad52-451c-9375-87f518ff10c6");
pub const SENSOR_TYPE_HUMAN_PROXIMITY = Guid.initString("5220dae9-3179-4430-9f90-06266d2a34de");
pub const SENSOR_TYPE_TOUCH = Guid.initString("17db3018-06c4-4f7d-81af-9274b7599c27");
pub const SENSOR_TYPE_AMBIENT_LIGHT = Guid.initString("97f115c8-599a-4153-8894-d2d12899918a");
pub const SENSOR_TYPE_RFID_SCANNER = Guid.initString("44328ef5-02dd-4e8d-ad5d-9249832b2eca");
pub const SENSOR_TYPE_BARCODE_SCANNER = Guid.initString("990b3d8f-85bb-45ff-914d-998c04f372df");
pub const SENSOR_TYPE_CUSTOM = Guid.initString("e83af229-8640-4d18-a213-e22675ebb2c3");
pub const SENSOR_TYPE_UNKNOWN = Guid.initString("10ba83e3-ef4f-41ed-9885-a87d6435a8e1");
pub const SENSOR_DATA_TYPE_COMMON_GUID = Guid.initString("db5e0cf2-cf1f-4c18-b46c-d86011d62150");
pub const SENSOR_DATA_TYPE_TIMESTAMP = PROPERTYKEY{ .fmtid = Guid.initString("db5e0cf2-cf1f-4c18-b46c-d86011d62150"), .pid = 2 };
pub const SENSOR_DATA_TYPE_LOCATION_GUID = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4");
pub const SENSOR_DATA_TYPE_LATITUDE_DEGREES = PROPERTYKEY{ .fmtid = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4"), .pid = 2 };
pub const SENSOR_DATA_TYPE_LONGITUDE_DEGREES = PROPERTYKEY{ .fmtid = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4"), .pid = 3 };
pub const SENSOR_DATA_TYPE_ALTITUDE_SEALEVEL_METERS = PROPERTYKEY{ .fmtid = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4"), .pid = 4 };
pub const SENSOR_DATA_TYPE_ALTITUDE_ELLIPSOID_METERS = PROPERTYKEY{ .fmtid = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4"), .pid = 5 };
pub const SENSOR_DATA_TYPE_SPEED_KNOTS = PROPERTYKEY{ .fmtid = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4"), .pid = 6 };
pub const SENSOR_DATA_TYPE_TRUE_HEADING_DEGREES = PROPERTYKEY{ .fmtid = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4"), .pid = 7 };
pub const SENSOR_DATA_TYPE_MAGNETIC_HEADING_DEGREES = PROPERTYKEY{ .fmtid = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4"), .pid = 8 };
pub const SENSOR_DATA_TYPE_MAGNETIC_VARIATION = PROPERTYKEY{ .fmtid = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4"), .pid = 9 };
pub const SENSOR_DATA_TYPE_FIX_QUALITY = PROPERTYKEY{ .fmtid = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4"), .pid = 10 };
pub const SENSOR_DATA_TYPE_FIX_TYPE = PROPERTYKEY{ .fmtid = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4"), .pid = 11 };
pub const SENSOR_DATA_TYPE_POSITION_DILUTION_OF_PRECISION = PROPERTYKEY{ .fmtid = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4"), .pid = 12 };
pub const SENSOR_DATA_TYPE_HORIZONAL_DILUTION_OF_PRECISION = PROPERTYKEY{ .fmtid = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4"), .pid = 13 };
pub const SENSOR_DATA_TYPE_VERTICAL_DILUTION_OF_PRECISION = PROPERTYKEY{ .fmtid = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4"), .pid = 14 };
pub const SENSOR_DATA_TYPE_SATELLITES_USED_COUNT = PROPERTYKEY{ .fmtid = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4"), .pid = 15 };
pub const SENSOR_DATA_TYPE_SATELLITES_USED_PRNS = PROPERTYKEY{ .fmtid = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4"), .pid = 16 };
pub const SENSOR_DATA_TYPE_SATELLITES_IN_VIEW = PROPERTYKEY{ .fmtid = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4"), .pid = 17 };
pub const SENSOR_DATA_TYPE_SATELLITES_IN_VIEW_PRNS = PROPERTYKEY{ .fmtid = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4"), .pid = 18 };
pub const SENSOR_DATA_TYPE_SATELLITES_IN_VIEW_ELEVATION = PROPERTYKEY{ .fmtid = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4"), .pid = 19 };
pub const SENSOR_DATA_TYPE_SATELLITES_IN_VIEW_AZIMUTH = PROPERTYKEY{ .fmtid = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4"), .pid = 20 };
pub const SENSOR_DATA_TYPE_SATELLITES_IN_VIEW_STN_RATIO = PROPERTYKEY{ .fmtid = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4"), .pid = 21 };
pub const SENSOR_DATA_TYPE_ERROR_RADIUS_METERS = PROPERTYKEY{ .fmtid = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4"), .pid = 22 };
pub const SENSOR_DATA_TYPE_ADDRESS1 = PROPERTYKEY{ .fmtid = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4"), .pid = 23 };
pub const SENSOR_DATA_TYPE_ADDRESS2 = PROPERTYKEY{ .fmtid = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4"), .pid = 24 };
pub const SENSOR_DATA_TYPE_CITY = PROPERTYKEY{ .fmtid = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4"), .pid = 25 };
pub const SENSOR_DATA_TYPE_STATE_PROVINCE = PROPERTYKEY{ .fmtid = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4"), .pid = 26 };
pub const SENSOR_DATA_TYPE_POSTALCODE = PROPERTYKEY{ .fmtid = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4"), .pid = 27 };
pub const SENSOR_DATA_TYPE_COUNTRY_REGION = PROPERTYKEY{ .fmtid = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4"), .pid = 28 };
pub const SENSOR_DATA_TYPE_ALTITUDE_ELLIPSOID_ERROR_METERS = PROPERTYKEY{ .fmtid = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4"), .pid = 29 };
pub const SENSOR_DATA_TYPE_ALTITUDE_SEALEVEL_ERROR_METERS = PROPERTYKEY{ .fmtid = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4"), .pid = 30 };
pub const SENSOR_DATA_TYPE_GPS_SELECTION_MODE = PROPERTYKEY{ .fmtid = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4"), .pid = 31 };
pub const SENSOR_DATA_TYPE_GPS_OPERATION_MODE = PROPERTYKEY{ .fmtid = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4"), .pid = 32 };
pub const SENSOR_DATA_TYPE_GPS_STATUS = PROPERTYKEY{ .fmtid = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4"), .pid = 33 };
pub const SENSOR_DATA_TYPE_GEOIDAL_SEPARATION = PROPERTYKEY{ .fmtid = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4"), .pid = 34 };
pub const SENSOR_DATA_TYPE_DGPS_DATA_AGE = PROPERTYKEY{ .fmtid = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4"), .pid = 35 };
pub const SENSOR_DATA_TYPE_ALTITUDE_ANTENNA_SEALEVEL_METERS = PROPERTYKEY{ .fmtid = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4"), .pid = 36 };
pub const SENSOR_DATA_TYPE_DIFFERENTIAL_REFERENCE_STATION_ID = PROPERTYKEY{ .fmtid = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4"), .pid = 37 };
pub const SENSOR_DATA_TYPE_NMEA_SENTENCE = PROPERTYKEY{ .fmtid = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4"), .pid = 38 };
pub const SENSOR_DATA_TYPE_SATELLITES_IN_VIEW_ID = PROPERTYKEY{ .fmtid = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4"), .pid = 39 };
pub const SENSOR_DATA_TYPE_LOCATION_SOURCE = PROPERTYKEY{ .fmtid = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4"), .pid = 40 };
pub const SENSOR_DATA_TYPE_SATELLITES_USED_PRNS_AND_CONSTELLATIONS = PROPERTYKEY{ .fmtid = Guid.initString("055c74d8-ca6f-47d6-95c6-1ed3637a0ff4"), .pid = 41 };
pub const SENSOR_DATA_TYPE_ENVIRONMENTAL_GUID = Guid.initString("8b0aa2f1-2d57-42ee-8cc0-4d27622b46c4");
pub const SENSOR_DATA_TYPE_TEMPERATURE_CELSIUS = PROPERTYKEY{ .fmtid = Guid.initString("8b0aa2f1-2d57-42ee-8cc0-4d27622b46c4"), .pid = 2 };
pub const SENSOR_DATA_TYPE_RELATIVE_HUMIDITY_PERCENT = PROPERTYKEY{ .fmtid = Guid.initString("8b0aa2f1-2d57-42ee-8cc0-4d27622b46c4"), .pid = 3 };
pub const SENSOR_DATA_TYPE_ATMOSPHERIC_PRESSURE_BAR = PROPERTYKEY{ .fmtid = Guid.initString("8b0aa2f1-2d57-42ee-8cc0-4d27622b46c4"), .pid = 4 };
pub const SENSOR_DATA_TYPE_WIND_DIRECTION_DEGREES_ANTICLOCKWISE = PROPERTYKEY{ .fmtid = Guid.initString("8b0aa2f1-2d57-42ee-8cc0-4d27622b46c4"), .pid = 5 };
pub const SENSOR_DATA_TYPE_WIND_SPEED_METERS_PER_SECOND = PROPERTYKEY{ .fmtid = Guid.initString("8b0aa2f1-2d57-42ee-8cc0-4d27622b46c4"), .pid = 6 };
pub const SENSOR_DATA_TYPE_MOTION_GUID = Guid.initString("3f8a69a2-07c5-4e48-a965-cd797aab56d5");
pub const SENSOR_DATA_TYPE_ACCELERATION_X_G = PROPERTYKEY{ .fmtid = Guid.initString("3f8a69a2-07c5-4e48-a965-cd797aab56d5"), .pid = 2 };
pub const SENSOR_DATA_TYPE_ACCELERATION_Y_G = PROPERTYKEY{ .fmtid = Guid.initString("3f8a69a2-07c5-4e48-a965-cd797aab56d5"), .pid = 3 };
pub const SENSOR_DATA_TYPE_ACCELERATION_Z_G = PROPERTYKEY{ .fmtid = Guid.initString("3f8a69a2-07c5-4e48-a965-cd797aab56d5"), .pid = 4 };
pub const SENSOR_DATA_TYPE_ANGULAR_ACCELERATION_X_DEGREES_PER_SECOND_SQUARED = PROPERTYKEY{ .fmtid = Guid.initString("3f8a69a2-07c5-4e48-a965-cd797aab56d5"), .pid = 5 };
pub const SENSOR_DATA_TYPE_ANGULAR_ACCELERATION_Y_DEGREES_PER_SECOND_SQUARED = PROPERTYKEY{ .fmtid = Guid.initString("3f8a69a2-07c5-4e48-a965-cd797aab56d5"), .pid = 6 };
pub const SENSOR_DATA_TYPE_ANGULAR_ACCELERATION_Z_DEGREES_PER_SECOND_SQUARED = PROPERTYKEY{ .fmtid = Guid.initString("3f8a69a2-07c5-4e48-a965-cd797aab56d5"), .pid = 7 };
pub const SENSOR_DATA_TYPE_SPEED_METERS_PER_SECOND = PROPERTYKEY{ .fmtid = Guid.initString("3f8a69a2-07c5-4e48-a965-cd797aab56d5"), .pid = 8 };
pub const SENSOR_DATA_TYPE_MOTION_STATE = PROPERTYKEY{ .fmtid = Guid.initString("3f8a69a2-07c5-4e48-a965-cd797aab56d5"), .pid = 9 };
pub const SENSOR_DATA_TYPE_ANGULAR_VELOCITY_X_DEGREES_PER_SECOND = PROPERTYKEY{ .fmtid = Guid.initString("3f8a69a2-07c5-4e48-a965-cd797aab56d5"), .pid = 10 };
pub const SENSOR_DATA_TYPE_ANGULAR_VELOCITY_Y_DEGREES_PER_SECOND = PROPERTYKEY{ .fmtid = Guid.initString("3f8a69a2-07c5-4e48-a965-cd797aab56d5"), .pid = 11 };
pub const SENSOR_DATA_TYPE_ANGULAR_VELOCITY_Z_DEGREES_PER_SECOND = PROPERTYKEY{ .fmtid = Guid.initString("3f8a69a2-07c5-4e48-a965-cd797aab56d5"), .pid = 12 };
pub const SENSOR_DATA_TYPE_ORIENTATION_GUID = Guid.initString("1637d8a2-4248-4275-865d-558de84aedfd");
pub const SENSOR_DATA_TYPE_TILT_X_DEGREES = PROPERTYKEY{ .fmtid = Guid.initString("1637d8a2-4248-4275-865d-558de84aedfd"), .pid = 2 };
pub const SENSOR_DATA_TYPE_TILT_Y_DEGREES = PROPERTYKEY{ .fmtid = Guid.initString("1637d8a2-4248-4275-865d-558de84aedfd"), .pid = 3 };
pub const SENSOR_DATA_TYPE_TILT_Z_DEGREES = PROPERTYKEY{ .fmtid = Guid.initString("1637d8a2-4248-4275-865d-558de84aedfd"), .pid = 4 };
pub const SENSOR_DATA_TYPE_MAGNETIC_HEADING_X_DEGREES = PROPERTYKEY{ .fmtid = Guid.initString("1637d8a2-4248-4275-865d-558de84aedfd"), .pid = 5 };
pub const SENSOR_DATA_TYPE_MAGNETIC_HEADING_Y_DEGREES = PROPERTYKEY{ .fmtid = Guid.initString("1637d8a2-4248-4275-865d-558de84aedfd"), .pid = 6 };
pub const SENSOR_DATA_TYPE_MAGNETIC_HEADING_Z_DEGREES = PROPERTYKEY{ .fmtid = Guid.initString("1637d8a2-4248-4275-865d-558de84aedfd"), .pid = 7 };
pub const SENSOR_DATA_TYPE_DISTANCE_X_METERS = PROPERTYKEY{ .fmtid = Guid.initString("1637d8a2-4248-4275-865d-558de84aedfd"), .pid = 8 };
pub const SENSOR_DATA_TYPE_DISTANCE_Y_METERS = PROPERTYKEY{ .fmtid = Guid.initString("1637d8a2-4248-4275-865d-558de84aedfd"), .pid = 9 };
pub const SENSOR_DATA_TYPE_DISTANCE_Z_METERS = PROPERTYKEY{ .fmtid = Guid.initString("1637d8a2-4248-4275-865d-558de84aedfd"), .pid = 10 };
pub const SENSOR_DATA_TYPE_MAGNETIC_HEADING_COMPENSATED_MAGNETIC_NORTH_DEGREES = PROPERTYKEY{ .fmtid = Guid.initString("1637d8a2-4248-4275-865d-558de84aedfd"), .pid = 11 };
pub const SENSOR_DATA_TYPE_MAGNETIC_HEADING_COMPENSATED_TRUE_NORTH_DEGREES = PROPERTYKEY{ .fmtid = Guid.initString("1637d8a2-4248-4275-865d-558de84aedfd"), .pid = 12 };
pub const SENSOR_DATA_TYPE_MAGNETIC_HEADING_MAGNETIC_NORTH_DEGREES = PROPERTYKEY{ .fmtid = Guid.initString("1637d8a2-4248-4275-865d-558de84aedfd"), .pid = 13 };
pub const SENSOR_DATA_TYPE_MAGNETIC_HEADING_TRUE_NORTH_DEGREES = PROPERTYKEY{ .fmtid = Guid.initString("1637d8a2-4248-4275-865d-558de84aedfd"), .pid = 14 };
pub const SENSOR_DATA_TYPE_QUADRANT_ANGLE_DEGREES = PROPERTYKEY{ .fmtid = Guid.initString("1637d8a2-4248-4275-865d-558de84aedfd"), .pid = 15 };
pub const SENSOR_DATA_TYPE_ROTATION_MATRIX = PROPERTYKEY{ .fmtid = Guid.initString("1637d8a2-4248-4275-865d-558de84aedfd"), .pid = 16 };
pub const SENSOR_DATA_TYPE_QUATERNION = PROPERTYKEY{ .fmtid = Guid.initString("1637d8a2-4248-4275-865d-558de84aedfd"), .pid = 17 };
pub const SENSOR_DATA_TYPE_SIMPLE_DEVICE_ORIENTATION = PROPERTYKEY{ .fmtid = Guid.initString("1637d8a2-4248-4275-865d-558de84aedfd"), .pid = 18 };
pub const SENSOR_DATA_TYPE_MAGNETIC_FIELD_STRENGTH_X_MILLIGAUSS = PROPERTYKEY{ .fmtid = Guid.initString("1637d8a2-4248-4275-865d-558de84aedfd"), .pid = 19 };
pub const SENSOR_DATA_TYPE_MAGNETIC_FIELD_STRENGTH_Y_MILLIGAUSS = PROPERTYKEY{ .fmtid = Guid.initString("1637d8a2-4248-4275-865d-558de84aedfd"), .pid = 20 };
pub const SENSOR_DATA_TYPE_MAGNETIC_FIELD_STRENGTH_Z_MILLIGAUSS = PROPERTYKEY{ .fmtid = Guid.initString("1637d8a2-4248-4275-865d-558de84aedfd"), .pid = 21 };
pub const SENSOR_DATA_TYPE_MAGNETOMETER_ACCURACY = PROPERTYKEY{ .fmtid = Guid.initString("1637d8a2-4248-4275-865d-558de84aedfd"), .pid = 22 };
pub const SENSOR_DATA_TYPE_GUID_MECHANICAL_GUID = Guid.initString("38564a7c-f2f2-49bb-9b2b-ba60f66a58df");
pub const SENSOR_DATA_TYPE_BOOLEAN_SWITCH_STATE = PROPERTYKEY{ .fmtid = Guid.initString("38564a7c-f2f2-49bb-9b2b-ba60f66a58df"), .pid = 2 };
pub const SENSOR_DATA_TYPE_MULTIVALUE_SWITCH_STATE = PROPERTYKEY{ .fmtid = Guid.initString("38564a7c-f2f2-49bb-9b2b-ba60f66a58df"), .pid = 3 };
pub const SENSOR_DATA_TYPE_FORCE_NEWTONS = PROPERTYKEY{ .fmtid = Guid.initString("38564a7c-f2f2-49bb-9b2b-ba60f66a58df"), .pid = 4 };
pub const SENSOR_DATA_TYPE_ABSOLUTE_PRESSURE_PASCAL = PROPERTYKEY{ .fmtid = Guid.initString("38564a7c-f2f2-49bb-9b2b-ba60f66a58df"), .pid = 5 };
pub const SENSOR_DATA_TYPE_GAUGE_PRESSURE_PASCAL = PROPERTYKEY{ .fmtid = Guid.initString("38564a7c-f2f2-49bb-9b2b-ba60f66a58df"), .pid = 6 };
pub const SENSOR_DATA_TYPE_STRAIN = PROPERTYKEY{ .fmtid = Guid.initString("38564a7c-f2f2-49bb-9b2b-ba60f66a58df"), .pid = 7 };
pub const SENSOR_DATA_TYPE_WEIGHT_KILOGRAMS = PROPERTYKEY{ .fmtid = Guid.initString("38564a7c-f2f2-49bb-9b2b-ba60f66a58df"), .pid = 8 };
pub const SENSOR_DATA_TYPE_BOOLEAN_SWITCH_ARRAY_STATES = PROPERTYKEY{ .fmtid = Guid.initString("38564a7c-f2f2-49bb-9b2b-ba60f66a58df"), .pid = 10 };
pub const SENSOR_DATA_TYPE_BIOMETRIC_GUID = Guid.initString("2299288a-6d9e-4b0b-b7ec-3528f89e40af");
pub const SENSOR_DATA_TYPE_HUMAN_PRESENCE = PROPERTYKEY{ .fmtid = Guid.initString("2299288a-6d9e-4b0b-b7ec-3528f89e40af"), .pid = 2 };
pub const SENSOR_DATA_TYPE_HUMAN_PROXIMITY_METERS = PROPERTYKEY{ .fmtid = Guid.initString("2299288a-6d9e-4b0b-b7ec-3528f89e40af"), .pid = 3 };
pub const SENSOR_DATA_TYPE_TOUCH_STATE = PROPERTYKEY{ .fmtid = Guid.initString("2299288a-6d9e-4b0b-b7ec-3528f89e40af"), .pid = 4 };
pub const SENSOR_DATA_TYPE_LIGHT_GUID = Guid.initString("e4c77ce2-dcb7-46e9-8439-4fec548833a6");
pub const SENSOR_DATA_TYPE_LIGHT_LEVEL_LUX = PROPERTYKEY{ .fmtid = Guid.initString("e4c77ce2-dcb7-46e9-8439-4fec548833a6"), .pid = 2 };
pub const SENSOR_DATA_TYPE_LIGHT_TEMPERATURE_KELVIN = PROPERTYKEY{ .fmtid = Guid.initString("e4c77ce2-dcb7-46e9-8439-4fec548833a6"), .pid = 3 };
pub const SENSOR_DATA_TYPE_LIGHT_CHROMACITY = PROPERTYKEY{ .fmtid = Guid.initString("e4c77ce2-dcb7-46e9-8439-4fec548833a6"), .pid = 4 };
pub const SENSOR_DATA_TYPE_SCANNER_GUID = Guid.initString("d7a59a3c-3421-44ab-8d3a-9de8ab6c4cae");
pub const SENSOR_DATA_TYPE_RFID_TAG_40_BIT = PROPERTYKEY{ .fmtid = Guid.initString("d7a59a3c-3421-44ab-8d3a-9de8ab6c4cae"), .pid = 2 };
pub const SENSOR_DATA_TYPE_ELECTRICAL_GUID = Guid.initString("bbb246d1-e242-4780-a2d3-cded84f35842");
pub const SENSOR_DATA_TYPE_VOLTAGE_VOLTS = PROPERTYKEY{ .fmtid = Guid.initString("bbb246d1-e242-4780-a2d3-cded84f35842"), .pid = 2 };
pub const SENSOR_DATA_TYPE_CURRENT_AMPS = PROPERTYKEY{ .fmtid = Guid.initString("bbb246d1-e242-4780-a2d3-cded84f35842"), .pid = 3 };
pub const SENSOR_DATA_TYPE_CAPACITANCE_FARAD = PROPERTYKEY{ .fmtid = Guid.initString("bbb246d1-e242-4780-a2d3-cded84f35842"), .pid = 4 };
pub const SENSOR_DATA_TYPE_RESISTANCE_OHMS = PROPERTYKEY{ .fmtid = Guid.initString("bbb246d1-e242-4780-a2d3-cded84f35842"), .pid = 5 };
pub const SENSOR_DATA_TYPE_INDUCTANCE_HENRY = PROPERTYKEY{ .fmtid = Guid.initString("bbb246d1-e242-4780-a2d3-cded84f35842"), .pid = 6 };
pub const SENSOR_DATA_TYPE_ELECTRICAL_POWER_WATTS = PROPERTYKEY{ .fmtid = Guid.initString("bbb246d1-e242-4780-a2d3-cded84f35842"), .pid = 7 };
pub const SENSOR_DATA_TYPE_ELECTRICAL_PERCENT_OF_RANGE = PROPERTYKEY{ .fmtid = Guid.initString("bbb246d1-e242-4780-a2d3-cded84f35842"), .pid = 8 };
pub const SENSOR_DATA_TYPE_ELECTRICAL_FREQUENCY_HERTZ = PROPERTYKEY{ .fmtid = Guid.initString("bbb246d1-e242-4780-a2d3-cded84f35842"), .pid = 9 };
pub const SENSOR_DATA_TYPE_CUSTOM_GUID = Guid.initString("b14c764f-07cf-41e8-9d82-ebe3d0776a6f");
pub const SENSOR_DATA_TYPE_CUSTOM_USAGE = PROPERTYKEY{ .fmtid = Guid.initString("b14c764f-07cf-41e8-9d82-ebe3d0776a6f"), .pid = 5 };
pub const SENSOR_DATA_TYPE_CUSTOM_BOOLEAN_ARRAY = PROPERTYKEY{ .fmtid = Guid.initString("b14c764f-07cf-41e8-9d82-ebe3d0776a6f"), .pid = 6 };
pub const SENSOR_DATA_TYPE_CUSTOM_VALUE1 = PROPERTYKEY{ .fmtid = Guid.initString("b14c764f-07cf-41e8-9d82-ebe3d0776a6f"), .pid = 7 };
pub const SENSOR_DATA_TYPE_CUSTOM_VALUE2 = PROPERTYKEY{ .fmtid = Guid.initString("b14c764f-07cf-41e8-9d82-ebe3d0776a6f"), .pid = 8 };
pub const SENSOR_DATA_TYPE_CUSTOM_VALUE3 = PROPERTYKEY{ .fmtid = Guid.initString("b14c764f-07cf-41e8-9d82-ebe3d0776a6f"), .pid = 9 };
pub const SENSOR_DATA_TYPE_CUSTOM_VALUE4 = PROPERTYKEY{ .fmtid = Guid.initString("b14c764f-07cf-41e8-9d82-ebe3d0776a6f"), .pid = 10 };
pub const SENSOR_DATA_TYPE_CUSTOM_VALUE5 = PROPERTYKEY{ .fmtid = Guid.initString("b14c764f-07cf-41e8-9d82-ebe3d0776a6f"), .pid = 11 };
pub const SENSOR_DATA_TYPE_CUSTOM_VALUE6 = PROPERTYKEY{ .fmtid = Guid.initString("b14c764f-07cf-41e8-9d82-ebe3d0776a6f"), .pid = 12 };
pub const SENSOR_DATA_TYPE_CUSTOM_VALUE7 = PROPERTYKEY{ .fmtid = Guid.initString("b14c764f-07cf-41e8-9d82-ebe3d0776a6f"), .pid = 13 };
pub const SENSOR_DATA_TYPE_CUSTOM_VALUE8 = PROPERTYKEY{ .fmtid = Guid.initString("b14c764f-07cf-41e8-9d82-ebe3d0776a6f"), .pid = 14 };
pub const SENSOR_DATA_TYPE_CUSTOM_VALUE9 = PROPERTYKEY{ .fmtid = Guid.initString("b14c764f-07cf-41e8-9d82-ebe3d0776a6f"), .pid = 15 };
pub const SENSOR_DATA_TYPE_CUSTOM_VALUE10 = PROPERTYKEY{ .fmtid = Guid.initString("b14c764f-07cf-41e8-9d82-ebe3d0776a6f"), .pid = 16 };
pub const SENSOR_DATA_TYPE_CUSTOM_VALUE11 = PROPERTYKEY{ .fmtid = Guid.initString("b14c764f-07cf-41e8-9d82-ebe3d0776a6f"), .pid = 17 };
pub const SENSOR_DATA_TYPE_CUSTOM_VALUE12 = PROPERTYKEY{ .fmtid = Guid.initString("b14c764f-07cf-41e8-9d82-ebe3d0776a6f"), .pid = 18 };
pub const SENSOR_DATA_TYPE_CUSTOM_VALUE13 = PROPERTYKEY{ .fmtid = Guid.initString("b14c764f-07cf-41e8-9d82-ebe3d0776a6f"), .pid = 19 };
pub const SENSOR_DATA_TYPE_CUSTOM_VALUE14 = PROPERTYKEY{ .fmtid = Guid.initString("b14c764f-07cf-41e8-9d82-ebe3d0776a6f"), .pid = 20 };
pub const SENSOR_DATA_TYPE_CUSTOM_VALUE15 = PROPERTYKEY{ .fmtid = Guid.initString("b14c764f-07cf-41e8-9d82-ebe3d0776a6f"), .pid = 21 };
pub const SENSOR_DATA_TYPE_CUSTOM_VALUE16 = PROPERTYKEY{ .fmtid = Guid.initString("b14c764f-07cf-41e8-9d82-ebe3d0776a6f"), .pid = 22 };
pub const SENSOR_DATA_TYPE_CUSTOM_VALUE17 = PROPERTYKEY{ .fmtid = Guid.initString("b14c764f-07cf-41e8-9d82-ebe3d0776a6f"), .pid = 23 };
pub const SENSOR_DATA_TYPE_CUSTOM_VALUE18 = PROPERTYKEY{ .fmtid = Guid.initString("b14c764f-07cf-41e8-9d82-ebe3d0776a6f"), .pid = 24 };
pub const SENSOR_DATA_TYPE_CUSTOM_VALUE19 = PROPERTYKEY{ .fmtid = Guid.initString("b14c764f-07cf-41e8-9d82-ebe3d0776a6f"), .pid = 25 };
pub const SENSOR_DATA_TYPE_CUSTOM_VALUE20 = PROPERTYKEY{ .fmtid = Guid.initString("b14c764f-07cf-41e8-9d82-ebe3d0776a6f"), .pid = 26 };
pub const SENSOR_DATA_TYPE_CUSTOM_VALUE21 = PROPERTYKEY{ .fmtid = Guid.initString("b14c764f-07cf-41e8-9d82-ebe3d0776a6f"), .pid = 27 };
pub const SENSOR_DATA_TYPE_CUSTOM_VALUE22 = PROPERTYKEY{ .fmtid = Guid.initString("b14c764f-07cf-41e8-9d82-ebe3d0776a6f"), .pid = 28 };
pub const SENSOR_DATA_TYPE_CUSTOM_VALUE23 = PROPERTYKEY{ .fmtid = Guid.initString("b14c764f-07cf-41e8-9d82-ebe3d0776a6f"), .pid = 29 };
pub const SENSOR_DATA_TYPE_CUSTOM_VALUE24 = PROPERTYKEY{ .fmtid = Guid.initString("b14c764f-07cf-41e8-9d82-ebe3d0776a6f"), .pid = 30 };
pub const SENSOR_DATA_TYPE_CUSTOM_VALUE25 = PROPERTYKEY{ .fmtid = Guid.initString("b14c764f-07cf-41e8-9d82-ebe3d0776a6f"), .pid = 31 };
pub const SENSOR_DATA_TYPE_CUSTOM_VALUE26 = PROPERTYKEY{ .fmtid = Guid.initString("b14c764f-07cf-41e8-9d82-ebe3d0776a6f"), .pid = 32 };
pub const SENSOR_DATA_TYPE_CUSTOM_VALUE27 = PROPERTYKEY{ .fmtid = Guid.initString("b14c764f-07cf-41e8-9d82-ebe3d0776a6f"), .pid = 33 };
pub const SENSOR_DATA_TYPE_CUSTOM_VALUE28 = PROPERTYKEY{ .fmtid = Guid.initString("b14c764f-07cf-41e8-9d82-ebe3d0776a6f"), .pid = 34 };
pub const SENSOR_PROPERTY_TEST_GUID = Guid.initString("e1e962f4-6e65-45f7-9c36-d487b7b1bd34");
pub const SENSOR_PROPERTY_CLEAR_ASSISTANCE_DATA = PROPERTYKEY{ .fmtid = Guid.initString("e1e962f4-6e65-45f7-9c36-d487b7b1bd34"), .pid = 2 };
pub const SENSOR_PROPERTY_TURN_ON_OFF_NMEA = PROPERTYKEY{ .fmtid = Guid.initString("e1e962f4-6e65-45f7-9c36-d487b7b1bd34"), .pid = 3 };
pub const GNSS_CLEAR_ALL_ASSISTANCE_DATA = @as(u32, 1);
pub const GUID_SensorCategory_All = Guid.initString("c317c286-c468-4288-9975-d4c4587c442c");
pub const GUID_SensorCategory_Biometric = Guid.initString("ca19690f-a2c7-477d-a99e-99ec6e2b5648");
pub const GUID_SensorCategory_Electrical = Guid.initString("fb73fcd8-fc4a-483c-ac58-27b691c6beff");
pub const GUID_SensorCategory_Environmental = Guid.initString("323439aa-7f66-492b-ba0c-73e9aa0a65d5");
pub const GUID_SensorCategory_Light = Guid.initString("17a665c0-9063-4216-b202-5c7a255e18ce");
pub const GUID_SensorCategory_Location = Guid.initString("bfa794e4-f964-4fdb-90f6-51056bfe4b44");
pub const GUID_SensorCategory_Mechanical = Guid.initString("8d131d68-8ef7-4656-80b5-cccbd93791c5");
pub const GUID_SensorCategory_Motion = Guid.initString("cd09daf1-3b2e-4c3d-b598-b5e5ff93fd46");
pub const GUID_SensorCategory_Orientation = Guid.initString("9e6c04b6-96fe-4954-b726-68682a473f69");
pub const GUID_SensorCategory_Other = Guid.initString("2c90e7a9-f4c9-4fa2-af37-56d471fe5a3d");
pub const GUID_SensorCategory_PersonalActivity = Guid.initString("f1609081-1e12-412b-a14d-cbb0e95bd2e5");
pub const GUID_SensorCategory_Scanner = Guid.initString("b000e77e-f5b5-420f-815d-0270a726f270");
pub const GUID_SensorCategory_Unsupported = Guid.initString("2beae7fa-19b0-48c5-a1f6-b5480dc206b0");
pub const GUID_SensorType_Accelerometer3D = Guid.initString("c2fb0f5f-e2d2-4c78-bcd0-352a9582819d");
pub const GUID_SensorType_ActivityDetection = Guid.initString("9d9e0118-1807-4f2e-96e4-2ce57142e196");
pub const GUID_SensorType_AmbientLight = Guid.initString("97f115c8-599a-4153-8894-d2d12899918a");
pub const GUID_SensorType_Barometer = Guid.initString("0e903829-ff8a-4a93-97df-3dcbde402288");
pub const GUID_SensorType_Custom = Guid.initString("e83af229-8640-4d18-a213-e22675ebb2c3");
pub const GUID_SensorType_FloorElevation = Guid.initString("ade4987f-7ac4-4dfa-9722-0a027181c747");
pub const GUID_SensorType_GeomagneticOrientation = Guid.initString("e77195f8-2d1f-4823-971b-1c4467556c9d");
pub const GUID_SensorType_GravityVector = Guid.initString("03b52c73-bb76-463f-9524-38de76eb700b");
pub const GUID_SensorType_Gyrometer3D = Guid.initString("09485f5a-759e-42c2-bd4b-a349b75c8643");
pub const GUID_SensorType_Humidity = Guid.initString("5c72bf67-bd7e-4257-990b-98a3ba3b400a");
pub const GUID_SensorType_LinearAccelerometer = Guid.initString("038b0283-97b4-41c8-bc24-5ff1aa48fec7");
pub const GUID_SensorType_Magnetometer3D = Guid.initString("55e5effb-15c7-40df-8698-a84b7c863c53");
pub const GUID_SensorType_Orientation = Guid.initString("cdb5d8f7-3cfd-41c8-8542-cce622cf5d6e");
pub const GUID_SensorType_Pedometer = Guid.initString("b19f89af-e3eb-444b-8dea-202575a71599");
pub const GUID_SensorType_Proximity = Guid.initString("5220dae9-3179-4430-9f90-06266d2a34de");
pub const GUID_SensorType_RelativeOrientation = Guid.initString("40993b51-4706-44dc-98d5-c920c037ffab");
pub const GUID_SensorType_SimpleDeviceOrientation = Guid.initString("86a19291-0482-402c-bf4c-addac52b1c39");
pub const GUID_SensorType_Temperature = Guid.initString("04fd0ec4-d5da-45fa-95a9-5db38ee19306");
pub const GUID_SensorType_HingeAngle = Guid.initString("82358065-f4c4-4da1-b272-13c23332a207");
pub const SENSOR_PROPERTY_LIST_HEADER_SIZE = @as(u32, 8);

//--------------------------------------------------------------------------------
// Section: Types (36)
//--------------------------------------------------------------------------------
const CLSID_SensorManager_Value = Guid.initString("77a1c827-fcd2-4689-8915-9d613cc5fa3e");
pub const CLSID_SensorManager = &CLSID_SensorManager_Value;

const CLSID_SensorCollection_Value = Guid.initString("79c43adb-a429-469f-aa39-2f2b74b75937");
pub const CLSID_SensorCollection = &CLSID_SensorCollection_Value;

const CLSID_Sensor_Value = Guid.initString("e97ced00-523a-4133-bf6f-d3a2dae7f6ba");
pub const CLSID_Sensor = &CLSID_Sensor_Value;

const CLSID_SensorDataReport_Value = Guid.initString("4ea9d6ef-694b-4218-8816-ccda8da74bba");
pub const CLSID_SensorDataReport = &CLSID_SensorDataReport_Value;

pub const SensorState = enum(i32) {
    MIN = 0,
    // READY = 0, this enum value conflicts with MIN
    NOT_AVAILABLE = 1,
    NO_DATA = 2,
    INITIALIZING = 3,
    ACCESS_DENIED = 4,
    ERROR = 5,
    // MAX = 5, this enum value conflicts with ERROR
};
pub const SENSOR_STATE_MIN = SensorState.MIN;
pub const SENSOR_STATE_READY = SensorState.MIN;
pub const SENSOR_STATE_NOT_AVAILABLE = SensorState.NOT_AVAILABLE;
pub const SENSOR_STATE_NO_DATA = SensorState.NO_DATA;
pub const SENSOR_STATE_INITIALIZING = SensorState.INITIALIZING;
pub const SENSOR_STATE_ACCESS_DENIED = SensorState.ACCESS_DENIED;
pub const SENSOR_STATE_ERROR = SensorState.ERROR;
pub const SENSOR_STATE_MAX = SensorState.ERROR;

pub const SensorConnectionType = enum(i32) {
    INTEGRATED = 0,
    ATTACHED = 1,
    EXTERNAL = 2,
};
pub const SENSOR_CONNECTION_TYPE_PC_INTEGRATED = SensorConnectionType.INTEGRATED;
pub const SENSOR_CONNECTION_TYPE_PC_ATTACHED = SensorConnectionType.ATTACHED;
pub const SENSOR_CONNECTION_TYPE_PC_EXTERNAL = SensorConnectionType.EXTERNAL;

pub const LOCATION_DESIRED_ACCURACY = enum(i32) {
    DEFAULT = 0,
    HIGH = 1,
};
pub const LOCATION_DESIRED_ACCURACY_DEFAULT = LOCATION_DESIRED_ACCURACY.DEFAULT;
pub const LOCATION_DESIRED_ACCURACY_HIGH = LOCATION_DESIRED_ACCURACY.HIGH;

pub const LOCATION_POSITION_SOURCE = enum(i32) {
    CELLULAR = 0,
    SATELLITE = 1,
    WIFI = 2,
    IPADDRESS = 3,
    UNKNOWN = 4,
};
pub const LOCATION_POSITION_SOURCE_CELLULAR = LOCATION_POSITION_SOURCE.CELLULAR;
pub const LOCATION_POSITION_SOURCE_SATELLITE = LOCATION_POSITION_SOURCE.SATELLITE;
pub const LOCATION_POSITION_SOURCE_WIFI = LOCATION_POSITION_SOURCE.WIFI;
pub const LOCATION_POSITION_SOURCE_IPADDRESS = LOCATION_POSITION_SOURCE.IPADDRESS;
pub const LOCATION_POSITION_SOURCE_UNKNOWN = LOCATION_POSITION_SOURCE.UNKNOWN;

pub const SimpleDeviceOrientation = enum(i32) {
    NOT_ROTATED = 0,
    ROTATED_90 = 1,
    ROTATED_180 = 2,
    ROTATED_270 = 3,
    ROTATED_FACE_UP = 4,
    ROTATED_FACE_DOWN = 5,
};
pub const SIMPLE_DEVICE_ORIENTATION_NOT_ROTATED = SimpleDeviceOrientation.NOT_ROTATED;
pub const SIMPLE_DEVICE_ORIENTATION_ROTATED_90 = SimpleDeviceOrientation.ROTATED_90;
pub const SIMPLE_DEVICE_ORIENTATION_ROTATED_180 = SimpleDeviceOrientation.ROTATED_180;
pub const SIMPLE_DEVICE_ORIENTATION_ROTATED_270 = SimpleDeviceOrientation.ROTATED_270;
pub const SIMPLE_DEVICE_ORIENTATION_ROTATED_FACE_UP = SimpleDeviceOrientation.ROTATED_FACE_UP;
pub const SIMPLE_DEVICE_ORIENTATION_ROTATED_FACE_DOWN = SimpleDeviceOrientation.ROTATED_FACE_DOWN;

pub const MagnetometerAccuracy = enum(i32) {
    UNKNOWN = 0,
    UNRELIABLE = 1,
    APPROXIMATE = 2,
    HIGH = 3,
};
pub const MAGNETOMETER_ACCURACY_UNKNOWN = MagnetometerAccuracy.UNKNOWN;
pub const MAGNETOMETER_ACCURACY_UNRELIABLE = MagnetometerAccuracy.UNRELIABLE;
pub const MAGNETOMETER_ACCURACY_APPROXIMATE = MagnetometerAccuracy.APPROXIMATE;
pub const MAGNETOMETER_ACCURACY_HIGH = MagnetometerAccuracy.HIGH;

// TODO: this type is limited to platform 'windows6.1'
const IID_ISensorManager_Value = Guid.initString("bd77db67-45a8-42dc-8d00-6dcf15f8377a");
pub const IID_ISensorManager = &IID_ISensorManager_Value;
pub const ISensorManager = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetSensorsByCategory: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISensorManager,
                sensorCategory: ?*Guid,
                ppSensorsFound: ?*?*ISensorCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISensorManager,
                sensorCategory: ?*Guid,
                ppSensorsFound: ?*?*ISensorCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetSensorsByType: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISensorManager,
                sensorType: ?*Guid,
                ppSensorsFound: ?*?*ISensorCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISensorManager,
                sensorType: ?*Guid,
                ppSensorsFound: ?*?*ISensorCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetSensorByID: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISensorManager,
                sensorID: ?*Guid,
                ppSensor: ?*?*ISensor,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISensorManager,
                sensorID: ?*Guid,
                ppSensor: ?*?*ISensor,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetEventSink: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISensorManager,
                pEvents: ?*ISensorManagerEvents,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISensorManager,
                pEvents: ?*ISensorManagerEvents,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        RequestPermissions: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISensorManager,
                hParent: ?HWND,
                pSensors: ?*ISensorCollection,
                fModal: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISensorManager,
                hParent: ?HWND,
                pSensors: ?*ISensorCollection,
                fModal: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISensorManager_GetSensorsByCategory(self: *const T, sensorCategory: ?*Guid, ppSensorsFound: ?*?*ISensorCollection) HRESULT {
                return @as(*const ISensorManager.VTable, @ptrCast(self.vtable)).GetSensorsByCategory(@as(*const ISensorManager, @ptrCast(self)), sensorCategory, ppSensorsFound);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISensorManager_GetSensorsByType(self: *const T, sensorType: ?*Guid, ppSensorsFound: ?*?*ISensorCollection) HRESULT {
                return @as(*const ISensorManager.VTable, @ptrCast(self.vtable)).GetSensorsByType(@as(*const ISensorManager, @ptrCast(self)), sensorType, ppSensorsFound);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISensorManager_GetSensorByID(self: *const T, sensorID: ?*Guid, ppSensor: ?*?*ISensor) HRESULT {
                return @as(*const ISensorManager.VTable, @ptrCast(self.vtable)).GetSensorByID(@as(*const ISensorManager, @ptrCast(self)), sensorID, ppSensor);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISensorManager_SetEventSink(self: *const T, pEvents: ?*ISensorManagerEvents) HRESULT {
                return @as(*const ISensorManager.VTable, @ptrCast(self.vtable)).SetEventSink(@as(*const ISensorManager, @ptrCast(self)), pEvents);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISensorManager_RequestPermissions(self: *const T, hParent: ?HWND, pSensors: ?*ISensorCollection, fModal: BOOL) HRESULT {
                return @as(*const ISensorManager.VTable, @ptrCast(self.vtable)).RequestPermissions(@as(*const ISensorManager, @ptrCast(self)), hParent, pSensors, fModal);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows8.0'
const IID_ILocationPermissions_Value = Guid.initString("d5fb0a7f-e74e-44f5-8e02-4806863a274f");
pub const IID_ILocationPermissions = &IID_ILocationPermissions_Value;
pub const ILocationPermissions = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetGlobalLocationPermission: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ILocationPermissions,
                pfEnabled: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ILocationPermissions,
                pfEnabled: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        CheckLocationCapability: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ILocationPermissions,
                dwClientThreadId: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ILocationPermissions,
                dwClientThreadId: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ILocationPermissions_GetGlobalLocationPermission(self: *const T, pfEnabled: ?*BOOL) HRESULT {
                return @as(*const ILocationPermissions.VTable, @ptrCast(self.vtable)).GetGlobalLocationPermission(@as(*const ILocationPermissions, @ptrCast(self)), pfEnabled);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ILocationPermissions_CheckLocationCapability(self: *const T, dwClientThreadId: u32) HRESULT {
                return @as(*const ILocationPermissions.VTable, @ptrCast(self.vtable)).CheckLocationCapability(@as(*const ILocationPermissions, @ptrCast(self)), dwClientThreadId);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.1'
const IID_ISensorCollection_Value = Guid.initString("23571e11-e545-4dd8-a337-b89bf44b10df");
pub const IID_ISensorCollection = &IID_ISensorCollection_Value;
pub const ISensorCollection = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetAt: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISensorCollection,
                ulIndex: u32,
                ppSensor: ?*?*ISensor,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISensorCollection,
                ulIndex: u32,
                ppSensor: ?*?*ISensor,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetCount: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISensorCollection,
                pCount: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISensorCollection,
                pCount: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Add: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISensorCollection,
                pSensor: ?*ISensor,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISensorCollection,
                pSensor: ?*ISensor,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Remove: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISensorCollection,
                pSensor: ?*ISensor,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISensorCollection,
                pSensor: ?*ISensor,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        RemoveByID: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISensorCollection,
                sensorID: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISensorCollection,
                sensorID: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Clear: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISensorCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISensorCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISensorCollection_GetAt(self: *const T, ulIndex: u32, ppSensor: ?*?*ISensor) HRESULT {
                return @as(*const ISensorCollection.VTable, @ptrCast(self.vtable)).GetAt(@as(*const ISensorCollection, @ptrCast(self)), ulIndex, ppSensor);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISensorCollection_GetCount(self: *const T, pCount: ?*u32) HRESULT {
                return @as(*const ISensorCollection.VTable, @ptrCast(self.vtable)).GetCount(@as(*const ISensorCollection, @ptrCast(self)), pCount);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISensorCollection_Add(self: *const T, pSensor: ?*ISensor) HRESULT {
                return @as(*const ISensorCollection.VTable, @ptrCast(self.vtable)).Add(@as(*const ISensorCollection, @ptrCast(self)), pSensor);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISensorCollection_Remove(self: *const T, pSensor: ?*ISensor) HRESULT {
                return @as(*const ISensorCollection.VTable, @ptrCast(self.vtable)).Remove(@as(*const ISensorCollection, @ptrCast(self)), pSensor);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISensorCollection_RemoveByID(self: *const T, sensorID: ?*Guid) HRESULT {
                return @as(*const ISensorCollection.VTable, @ptrCast(self.vtable)).RemoveByID(@as(*const ISensorCollection, @ptrCast(self)), sensorID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISensorCollection_Clear(self: *const T) HRESULT {
                return @as(*const ISensorCollection.VTable, @ptrCast(self.vtable)).Clear(@as(*const ISensorCollection, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.1'
const IID_ISensor_Value = Guid.initString("5fa08f80-2657-458e-af75-46f73fa6ac5c");
pub const IID_ISensor = &IID_ISensor_Value;
pub const ISensor = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetID: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISensor,
                pID: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISensor,
                pID: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetCategory: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISensor,
                pSensorCategory: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISensor,
                pSensorCategory: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetType: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISensor,
                pSensorType: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISensor,
                pSensorType: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetFriendlyName: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISensor,
                pFriendlyName: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISensor,
                pFriendlyName: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetProperty: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISensor,
                key: ?*const PROPERTYKEY,
                pProperty: ?*PROPVARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISensor,
                key: ?*const PROPERTYKEY,
                pProperty: ?*PROPVARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetProperties: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISensor,
                pKeys: ?*IPortableDeviceKeyCollection,
                ppProperties: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISensor,
                pKeys: ?*IPortableDeviceKeyCollection,
                ppProperties: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetSupportedDataFields: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISensor,
                ppDataFields: ?*?*IPortableDeviceKeyCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISensor,
                ppDataFields: ?*?*IPortableDeviceKeyCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetProperties: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISensor,
                pProperties: ?*IPortableDeviceValues,
                ppResults: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISensor,
                pProperties: ?*IPortableDeviceValues,
                ppResults: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SupportsDataField: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISensor,
                key: ?*const PROPERTYKEY,
                pIsSupported: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISensor,
                key: ?*const PROPERTYKEY,
                pIsSupported: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetState: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISensor,
                pState: ?*SensorState,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISensor,
                pState: ?*SensorState,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetData: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISensor,
                ppDataReport: ?*?*ISensorDataReport,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISensor,
                ppDataReport: ?*?*ISensorDataReport,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SupportsEvent: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISensor,
                eventGuid: ?*const Guid,
                pIsSupported: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISensor,
                eventGuid: ?*const Guid,
                pIsSupported: ?*i16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetEventInterest: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISensor,
                ppValues: ?[*]?*Guid,
                pCount: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISensor,
                ppValues: ?[*]?*Guid,
                pCount: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetEventInterest: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISensor,
                pValues: ?[*]Guid,
                count: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISensor,
                pValues: ?[*]Guid,
                count: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetEventSink: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISensor,
                pEvents: ?*ISensorEvents,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISensor,
                pEvents: ?*ISensorEvents,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISensor_GetID(self: *const T, pID: ?*Guid) HRESULT {
                return @as(*const ISensor.VTable, @ptrCast(self.vtable)).GetID(@as(*const ISensor, @ptrCast(self)), pID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISensor_GetCategory(self: *const T, pSensorCategory: ?*Guid) HRESULT {
                return @as(*const ISensor.VTable, @ptrCast(self.vtable)).GetCategory(@as(*const ISensor, @ptrCast(self)), pSensorCategory);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISensor_GetType(self: *const T, pSensorType: ?*Guid) HRESULT {
                return @as(*const ISensor.VTable, @ptrCast(self.vtable)).GetType(@as(*const ISensor, @ptrCast(self)), pSensorType);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISensor_GetFriendlyName(self: *const T, pFriendlyName: ?*?BSTR) HRESULT {
                return @as(*const ISensor.VTable, @ptrCast(self.vtable)).GetFriendlyName(@as(*const ISensor, @ptrCast(self)), pFriendlyName);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISensor_GetProperty(self: *const T, key: ?*const PROPERTYKEY, pProperty: ?*PROPVARIANT) HRESULT {
                return @as(*const ISensor.VTable, @ptrCast(self.vtable)).GetProperty(@as(*const ISensor, @ptrCast(self)), key, pProperty);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISensor_GetProperties(self: *const T, pKeys: ?*IPortableDeviceKeyCollection, ppProperties: ?*?*IPortableDeviceValues) HRESULT {
                return @as(*const ISensor.VTable, @ptrCast(self.vtable)).GetProperties(@as(*const ISensor, @ptrCast(self)), pKeys, ppProperties);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISensor_GetSupportedDataFields(self: *const T, ppDataFields: ?*?*IPortableDeviceKeyCollection) HRESULT {
                return @as(*const ISensor.VTable, @ptrCast(self.vtable)).GetSupportedDataFields(@as(*const ISensor, @ptrCast(self)), ppDataFields);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISensor_SetProperties(self: *const T, pProperties: ?*IPortableDeviceValues, ppResults: ?*?*IPortableDeviceValues) HRESULT {
                return @as(*const ISensor.VTable, @ptrCast(self.vtable)).SetProperties(@as(*const ISensor, @ptrCast(self)), pProperties, ppResults);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISensor_SupportsDataField(self: *const T, key: ?*const PROPERTYKEY, pIsSupported: ?*i16) HRESULT {
                return @as(*const ISensor.VTable, @ptrCast(self.vtable)).SupportsDataField(@as(*const ISensor, @ptrCast(self)), key, pIsSupported);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISensor_GetState(self: *const T, pState: ?*SensorState) HRESULT {
                return @as(*const ISensor.VTable, @ptrCast(self.vtable)).GetState(@as(*const ISensor, @ptrCast(self)), pState);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISensor_GetData(self: *const T, ppDataReport: ?*?*ISensorDataReport) HRESULT {
                return @as(*const ISensor.VTable, @ptrCast(self.vtable)).GetData(@as(*const ISensor, @ptrCast(self)), ppDataReport);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISensor_SupportsEvent(self: *const T, eventGuid: ?*const Guid, pIsSupported: ?*i16) HRESULT {
                return @as(*const ISensor.VTable, @ptrCast(self.vtable)).SupportsEvent(@as(*const ISensor, @ptrCast(self)), eventGuid, pIsSupported);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISensor_GetEventInterest(self: *const T, ppValues: ?[*]?*Guid, pCount: ?*u32) HRESULT {
                return @as(*const ISensor.VTable, @ptrCast(self.vtable)).GetEventInterest(@as(*const ISensor, @ptrCast(self)), ppValues, pCount);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISensor_SetEventInterest(self: *const T, pValues: ?[*]Guid, count: u32) HRESULT {
                return @as(*const ISensor.VTable, @ptrCast(self.vtable)).SetEventInterest(@as(*const ISensor, @ptrCast(self)), pValues, count);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISensor_SetEventSink(self: *const T, pEvents: ?*ISensorEvents) HRESULT {
                return @as(*const ISensor.VTable, @ptrCast(self.vtable)).SetEventSink(@as(*const ISensor, @ptrCast(self)), pEvents);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.1'
const IID_ISensorDataReport_Value = Guid.initString("0ab9df9b-c4b5-4796-8898-0470706a2e1d");
pub const IID_ISensorDataReport = &IID_ISensorDataReport_Value;
pub const ISensorDataReport = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetTimestamp: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISensorDataReport,
                pTimeStamp: ?*SYSTEMTIME,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISensorDataReport,
                pTimeStamp: ?*SYSTEMTIME,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetSensorValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISensorDataReport,
                pKey: ?*const PROPERTYKEY,
                pValue: ?*PROPVARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISensorDataReport,
                pKey: ?*const PROPERTYKEY,
                pValue: ?*PROPVARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetSensorValues: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISensorDataReport,
                pKeys: ?*IPortableDeviceKeyCollection,
                ppValues: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISensorDataReport,
                pKeys: ?*IPortableDeviceKeyCollection,
                ppValues: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISensorDataReport_GetTimestamp(self: *const T, pTimeStamp: ?*SYSTEMTIME) HRESULT {
                return @as(*const ISensorDataReport.VTable, @ptrCast(self.vtable)).GetTimestamp(@as(*const ISensorDataReport, @ptrCast(self)), pTimeStamp);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISensorDataReport_GetSensorValue(self: *const T, pKey: ?*const PROPERTYKEY, pValue: ?*PROPVARIANT) HRESULT {
                return @as(*const ISensorDataReport.VTable, @ptrCast(self.vtable)).GetSensorValue(@as(*const ISensorDataReport, @ptrCast(self)), pKey, pValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISensorDataReport_GetSensorValues(self: *const T, pKeys: ?*IPortableDeviceKeyCollection, ppValues: ?*?*IPortableDeviceValues) HRESULT {
                return @as(*const ISensorDataReport.VTable, @ptrCast(self.vtable)).GetSensorValues(@as(*const ISensorDataReport, @ptrCast(self)), pKeys, ppValues);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.1'
const IID_ISensorManagerEvents_Value = Guid.initString("9b3b0b86-266a-4aad-b21f-fde5501001b7");
pub const IID_ISensorManagerEvents = &IID_ISensorManagerEvents_Value;
pub const ISensorManagerEvents = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        OnSensorEnter: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISensorManagerEvents,
                pSensor: ?*ISensor,
                state: SensorState,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISensorManagerEvents,
                pSensor: ?*ISensor,
                state: SensorState,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISensorManagerEvents_OnSensorEnter(self: *const T, pSensor: ?*ISensor, state: SensorState) HRESULT {
                return @as(*const ISensorManagerEvents.VTable, @ptrCast(self.vtable)).OnSensorEnter(@as(*const ISensorManagerEvents, @ptrCast(self)), pSensor, state);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.1'
const IID_ISensorEvents_Value = Guid.initString("5d8dcc91-4641-47e7-b7c3-b74f48a6c391");
pub const IID_ISensorEvents = &IID_ISensorEvents_Value;
pub const ISensorEvents = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        OnStateChanged: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISensorEvents,
                pSensor: ?*ISensor,
                state: SensorState,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISensorEvents,
                pSensor: ?*ISensor,
                state: SensorState,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnDataUpdated: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISensorEvents,
                pSensor: ?*ISensor,
                pNewData: ?*ISensorDataReport,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISensorEvents,
                pSensor: ?*ISensor,
                pNewData: ?*ISensorDataReport,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnEvent: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISensorEvents,
                pSensor: ?*ISensor,
                eventID: ?*const Guid,
                pEventData: ?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISensorEvents,
                pSensor: ?*ISensor,
                eventID: ?*const Guid,
                pEventData: ?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnLeave: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const ISensorEvents,
                ID: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const ISensorEvents,
                ID: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISensorEvents_OnStateChanged(self: *const T, pSensor: ?*ISensor, state: SensorState) HRESULT {
                return @as(*const ISensorEvents.VTable, @ptrCast(self.vtable)).OnStateChanged(@as(*const ISensorEvents, @ptrCast(self)), pSensor, state);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISensorEvents_OnDataUpdated(self: *const T, pSensor: ?*ISensor, pNewData: ?*ISensorDataReport) HRESULT {
                return @as(*const ISensorEvents.VTable, @ptrCast(self.vtable)).OnDataUpdated(@as(*const ISensorEvents, @ptrCast(self)), pSensor, pNewData);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISensorEvents_OnEvent(self: *const T, pSensor: ?*ISensor, eventID: ?*const Guid, pEventData: ?*IPortableDeviceValues) HRESULT {
                return @as(*const ISensorEvents.VTable, @ptrCast(self.vtable)).OnEvent(@as(*const ISensorEvents, @ptrCast(self)), pSensor, eventID, pEventData);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn ISensorEvents_OnLeave(self: *const T, ID: ?*Guid) HRESULT {
                return @as(*const ISensorEvents.VTable, @ptrCast(self.vtable)).OnLeave(@as(*const ISensorEvents, @ptrCast(self)), ID);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

pub const ACTIVITY_STATE_COUNT = enum(i32) {
    t = 8,
};
pub const ActivityStateCount = ACTIVITY_STATE_COUNT.t;

pub const ACTIVITY_STATE = enum(i32) {
    Unknown = 1,
    Stationary = 2,
    Fidgeting = 4,
    Walking = 8,
    Running = 16,
    InVehicle = 32,
    Biking = 64,
    Idle = 128,
    Max = 256,
    Force_Dword = -1,
};
pub const ActivityState_Unknown = ACTIVITY_STATE.Unknown;
pub const ActivityState_Stationary = ACTIVITY_STATE.Stationary;
pub const ActivityState_Fidgeting = ACTIVITY_STATE.Fidgeting;
pub const ActivityState_Walking = ACTIVITY_STATE.Walking;
pub const ActivityState_Running = ACTIVITY_STATE.Running;
pub const ActivityState_InVehicle = ACTIVITY_STATE.InVehicle;
pub const ActivityState_Biking = ACTIVITY_STATE.Biking;
pub const ActivityState_Idle = ACTIVITY_STATE.Idle;
pub const ActivityState_Max = ACTIVITY_STATE.Max;
pub const ActivityState_Force_Dword = ACTIVITY_STATE.Force_Dword;

pub const ELEVATION_CHANGE_MODE = enum(i32) {
    Unknown = 0,
    Elevator = 1,
    Stepping = 2,
    Max = 3,
    Force_Dword = -1,
};
pub const ElevationChangeMode_Unknown = ELEVATION_CHANGE_MODE.Unknown;
pub const ElevationChangeMode_Elevator = ELEVATION_CHANGE_MODE.Elevator;
pub const ElevationChangeMode_Stepping = ELEVATION_CHANGE_MODE.Stepping;
pub const ElevationChangeMode_Max = ELEVATION_CHANGE_MODE.Max;
pub const ElevationChangeMode_Force_Dword = ELEVATION_CHANGE_MODE.Force_Dword;

pub const MAGNETOMETER_ACCURACY = enum(i32) {
    Unknown = 0,
    Unreliable = 1,
    Approximate = 2,
    High = 3,
};
pub const MagnetometerAccuracy_Unknown = MAGNETOMETER_ACCURACY.Unknown;
pub const MagnetometerAccuracy_Unreliable = MAGNETOMETER_ACCURACY.Unreliable;
pub const MagnetometerAccuracy_Approximate = MAGNETOMETER_ACCURACY.Approximate;
pub const MagnetometerAccuracy_High = MAGNETOMETER_ACCURACY.High;

pub const PEDOMETER_STEP_TYPE_COUNT = enum(i32) {
    t = 3,
};
pub const PedometerStepTypeCount = PEDOMETER_STEP_TYPE_COUNT.t;

pub const PEDOMETER_STEP_TYPE = enum(i32) {
    Unknown = 1,
    Walking = 2,
    Running = 4,
    Max = 8,
    Force_Dword = -1,
};
pub const PedometerStepType_Unknown = PEDOMETER_STEP_TYPE.Unknown;
pub const PedometerStepType_Walking = PEDOMETER_STEP_TYPE.Walking;
pub const PedometerStepType_Running = PEDOMETER_STEP_TYPE.Running;
pub const PedometerStepType_Max = PEDOMETER_STEP_TYPE.Max;
pub const PedometerStepType_Force_Dword = PEDOMETER_STEP_TYPE.Force_Dword;

pub const PROXIMITY_TYPE = enum(i32) {
    ObjectProximity = 0,
    HumanProximity = 1,
    Force_Dword = -1,
};
pub const ProximityType_ObjectProximity = PROXIMITY_TYPE.ObjectProximity;
pub const ProximityType_HumanProximity = PROXIMITY_TYPE.HumanProximity;
pub const ProximityType_Force_Dword = PROXIMITY_TYPE.Force_Dword;

pub const HUMAN_PRESENCE_DETECTION_TYPE_COUNT = enum(i32) {
    t = 4,
};
pub const HumanPresenceDetectionTypeCount = HUMAN_PRESENCE_DETECTION_TYPE_COUNT.t;

pub const HUMAN_PRESENCE_DETECTION_TYPE = enum(i32) {
    VendorDefinedNonBiometric = 1,
    VendorDefinedBiometric = 2,
    FacialBiometric = 4,
    AudioBiometric = 8,
    Force_Dword = -1,
};
pub const HumanPresenceDetectionType_VendorDefinedNonBiometric = HUMAN_PRESENCE_DETECTION_TYPE.VendorDefinedNonBiometric;
pub const HumanPresenceDetectionType_VendorDefinedBiometric = HUMAN_PRESENCE_DETECTION_TYPE.VendorDefinedBiometric;
pub const HumanPresenceDetectionType_FacialBiometric = HUMAN_PRESENCE_DETECTION_TYPE.FacialBiometric;
pub const HumanPresenceDetectionType_AudioBiometric = HUMAN_PRESENCE_DETECTION_TYPE.AudioBiometric;
pub const HumanPresenceDetectionType_Force_Dword = HUMAN_PRESENCE_DETECTION_TYPE.Force_Dword;

pub const SIMPLE_DEVICE_ORIENTATION = enum(i32) {
    NotRotated = 0,
    Rotated90DegreesCounterclockwise = 1,
    Rotated180DegreesCounterclockwise = 2,
    Rotated270DegreesCounterclockwise = 3,
    Faceup = 4,
    Facedown = 5,
};
pub const SimpleDeviceOrientation_NotRotated = SIMPLE_DEVICE_ORIENTATION.NotRotated;
pub const SimpleDeviceOrientation_Rotated90DegreesCounterclockwise = SIMPLE_DEVICE_ORIENTATION.Rotated90DegreesCounterclockwise;
pub const SimpleDeviceOrientation_Rotated180DegreesCounterclockwise = SIMPLE_DEVICE_ORIENTATION.Rotated180DegreesCounterclockwise;
pub const SimpleDeviceOrientation_Rotated270DegreesCounterclockwise = SIMPLE_DEVICE_ORIENTATION.Rotated270DegreesCounterclockwise;
pub const SimpleDeviceOrientation_Faceup = SIMPLE_DEVICE_ORIENTATION.Faceup;
pub const SimpleDeviceOrientation_Facedown = SIMPLE_DEVICE_ORIENTATION.Facedown;

pub const SENSOR_STATE = enum(i32) {
    Initializing = 0,
    Idle = 1,
    Active = 2,
    Error = 3,
};
pub const SensorState_Initializing = SENSOR_STATE.Initializing;
pub const SensorState_Idle = SENSOR_STATE.Idle;
pub const SensorState_Active = SENSOR_STATE.Active;
pub const SensorState_Error = SENSOR_STATE.Error;

pub const SENSOR_CONNECTION_TYPES = enum(i32) {
    Integrated = 0,
    Attached = 1,
    External = 2,
};
pub const SensorConnectionType_Integrated = SENSOR_CONNECTION_TYPES.Integrated;
pub const SensorConnectionType_Attached = SENSOR_CONNECTION_TYPES.Attached;
pub const SensorConnectionType_External = SENSOR_CONNECTION_TYPES.External;

pub const SENSOR_VALUE_PAIR = extern struct {
    Key: PROPERTYKEY,
    Value: PROPVARIANT,
};

pub const SENSOR_COLLECTION_LIST = extern struct {
    AllocatedSizeInBytes: u32,
    Count: u32,
    List: [1]SENSOR_VALUE_PAIR,
};

pub const SENSOR_PROPERTY_LIST = extern struct {
    AllocatedSizeInBytes: u32,
    Count: u32,
    List: [1]PROPERTYKEY,
};

pub const VEC3D = extern struct {
    X: f32,
    Y: f32,
    Z: f32,
};

pub const MATRIX3X3 = extern struct {
    Anonymous: extern union {
        Anonymous1: extern struct {
            A11: f32,
            A12: f32,
            A13: f32,
            A21: f32,
            A22: f32,
            A23: f32,
            A31: f32,
            A32: f32,
            A33: f32,
        },
        Anonymous2: extern struct {
            V1: VEC3D,
            V2: VEC3D,
            V3: VEC3D,
        },
        M: [9]f32,
    },
};

pub const QUATERNION = extern struct {
    X: f32,
    Y: f32,
    Z: f32,
    W: f32,
};

pub const AXIS = enum(i32) {
    X = 0,
    Y = 1,
    Z = 2,
    MAX = 3,
};
pub const AXIS_X = AXIS.X;
pub const AXIS_Y = AXIS.Y;
pub const AXIS_Z = AXIS.Z;
pub const AXIS_MAX = AXIS.MAX;

//--------------------------------------------------------------------------------
// Section: Functions (40)
//--------------------------------------------------------------------------------
pub extern "sensorsutilsv2" fn GetPerformanceTime(
    TimeMs: ?*u32,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;

pub extern "sensorsutilsv2" fn InitPropVariantFromFloat(
    fltVal: f32,
    ppropvar: ?*PROPVARIANT,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

pub extern "sensorsutilsv2" fn PropKeyFindKeyGetPropVariant(
    pList: ?*const SENSOR_COLLECTION_LIST,
    pKey: ?*const PROPERTYKEY,
    TypeCheck: BOOLEAN,
    pValue: ?*PROPVARIANT,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;

pub extern "sensorsutilsv2" fn PropKeyFindKeySetPropVariant(
    pList: ?*SENSOR_COLLECTION_LIST,
    pKey: ?*const PROPERTYKEY,
    TypeCheck: BOOLEAN,
    pValue: ?*PROPVARIANT,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;

pub extern "sensorsutilsv2" fn PropKeyFindKeyGetFileTime(
    pList: ?*const SENSOR_COLLECTION_LIST,
    pKey: ?*const PROPERTYKEY,
    pRetValue: ?*FILETIME,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;

pub extern "sensorsutilsv2" fn PropKeyFindKeyGetGuid(
    pList: ?*const SENSOR_COLLECTION_LIST,
    pKey: ?*const PROPERTYKEY,
    pRetValue: ?*Guid,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;

pub extern "sensorsutilsv2" fn PropKeyFindKeyGetBool(
    pList: ?*const SENSOR_COLLECTION_LIST,
    pKey: ?*const PROPERTYKEY,
    pRetValue: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;

pub extern "sensorsutilsv2" fn PropKeyFindKeyGetUlong(
    pList: ?*const SENSOR_COLLECTION_LIST,
    pKey: ?*const PROPERTYKEY,
    pRetValue: ?*u32,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;

pub extern "sensorsutilsv2" fn PropKeyFindKeyGetUshort(
    pList: ?*const SENSOR_COLLECTION_LIST,
    pKey: ?*const PROPERTYKEY,
    pRetValue: ?*u16,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;

pub extern "sensorsutilsv2" fn PropKeyFindKeyGetFloat(
    pList: ?*const SENSOR_COLLECTION_LIST,
    pKey: ?*const PROPERTYKEY,
    pRetValue: ?*f32,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;

pub extern "sensorsutilsv2" fn PropKeyFindKeyGetDouble(
    pList: ?*const SENSOR_COLLECTION_LIST,
    pKey: ?*const PROPERTYKEY,
    pRetValue: ?*f64,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;

pub extern "sensorsutilsv2" fn PropKeyFindKeyGetInt32(
    pList: ?*const SENSOR_COLLECTION_LIST,
    pKey: ?*const PROPERTYKEY,
    pRetValue: ?*i32,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;

pub extern "sensorsutilsv2" fn PropKeyFindKeyGetInt64(
    pList: ?*const SENSOR_COLLECTION_LIST,
    pKey: ?*const PROPERTYKEY,
    pRetValue: ?*i64,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;

pub extern "sensorsutilsv2" fn PropKeyFindKeyGetNthUlong(
    pList: ?*const SENSOR_COLLECTION_LIST,
    pKey: ?*const PROPERTYKEY,
    Occurrence: u32,
    pRetValue: ?*u32,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;

pub extern "sensorsutilsv2" fn PropKeyFindKeyGetNthUshort(
    pList: ?*const SENSOR_COLLECTION_LIST,
    pKey: ?*const PROPERTYKEY,
    Occurrence: u32,
    pRetValue: ?*u16,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;

pub extern "sensorsutilsv2" fn PropKeyFindKeyGetNthInt64(
    pList: ?*const SENSOR_COLLECTION_LIST,
    pKey: ?*const PROPERTYKEY,
    Occurrence: u32,
    pRetValue: ?*i64,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;

pub extern "sensorsutilsv2" fn IsKeyPresentInPropertyList(
    pList: ?*SENSOR_PROPERTY_LIST,
    pKey: ?*const PROPERTYKEY,
) callconv(@import("std").os.windows.WINAPI) BOOLEAN;

pub extern "sensorsutilsv2" fn IsKeyPresentInCollectionList(
    pList: ?*SENSOR_COLLECTION_LIST,
    pKey: ?*const PROPERTYKEY,
) callconv(@import("std").os.windows.WINAPI) BOOLEAN;

pub extern "sensorsutilsv2" fn IsCollectionListSame(
    ListA: ?*const SENSOR_COLLECTION_LIST,
    ListB: ?*const SENSOR_COLLECTION_LIST,
) callconv(@import("std").os.windows.WINAPI) BOOLEAN;

pub extern "sensorsutilsv2" fn PropVariantGetInformation(
    PropVariantValue: ?*const PROPVARIANT,
    PropVariantOffset: ?*u32,
    PropVariantSize: ?*u32,
    PropVariantPointer: ?*?*anyopaque,
    RemappedType: ?*u32,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;

pub extern "sensorsutilsv2" fn PropertiesListCopy(
    Target: ?*SENSOR_PROPERTY_LIST,
    Source: ?*const SENSOR_PROPERTY_LIST,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;

pub extern "sensorsutilsv2" fn PropertiesListGetFillableCount(
    BufferSizeBytes: u32,
) callconv(@import("std").os.windows.WINAPI) u32;

pub extern "sensorsutilsv2" fn CollectionsListGetMarshalledSize(
    Collection: ?*const SENSOR_COLLECTION_LIST,
) callconv(@import("std").os.windows.WINAPI) u32;

pub extern "sensorsutilsv2" fn CollectionsListCopyAndMarshall(
    Target: ?*SENSOR_COLLECTION_LIST,
    Source: ?*const SENSOR_COLLECTION_LIST,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;

pub extern "sensorsutilsv2" fn CollectionsListMarshall(
    Target: ?*SENSOR_COLLECTION_LIST,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;

pub extern "sensorsutilsv2" fn CollectionsListGetMarshalledSizeWithoutSerialization(
    Collection: ?*const SENSOR_COLLECTION_LIST,
) callconv(@import("std").os.windows.WINAPI) u32;

pub extern "sensorsutilsv2" fn CollectionsListUpdateMarshalledPointer(
    Collection: ?*SENSOR_COLLECTION_LIST,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;

pub extern "sensorsutilsv2" fn SerializationBufferAllocate(
    SizeInBytes: u32,
    pBuffer: ?*?*u8,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;

pub extern "sensorsutilsv2" fn SerializationBufferFree(
    Buffer: ?*u8,
) callconv(@import("std").os.windows.WINAPI) void;

pub extern "sensorsutilsv2" fn CollectionsListGetSerializedSize(
    Collection: ?*const SENSOR_COLLECTION_LIST,
) callconv(@import("std").os.windows.WINAPI) u32;

pub extern "sensorsutilsv2" fn CollectionsListSerializeToBuffer(
    SourceCollection: ?*const SENSOR_COLLECTION_LIST,
    TargetBufferSizeInBytes: u32,
    // TODO: what to do with BytesParamIndex 1?
    TargetBuffer: ?*u8,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;

pub extern "sensorsutilsv2" fn CollectionsListAllocateBufferAndSerialize(
    SourceCollection: ?*const SENSOR_COLLECTION_LIST,
    pTargetBufferSizeInBytes: ?*u32,
    pTargetBuffer: ?*?*u8,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;

pub extern "sensorsutilsv2" fn CollectionsListDeserializeFromBuffer(
    SourceBufferSizeInBytes: u32,
    // TODO: what to do with BytesParamIndex 0?
    SourceBuffer: ?*const u8,
    TargetCollection: ?*SENSOR_COLLECTION_LIST,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;

pub extern "sensorsutilsv2" fn SensorCollectionGetAt(
    Index: u32,
    pSensorsList: ?*SENSOR_COLLECTION_LIST,
    pKey: ?*PROPERTYKEY,
    pValue: ?*PROPVARIANT,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;

pub extern "sensorsutilsv2" fn CollectionsListGetFillableCount(
    BufferSizeBytes: u32,
) callconv(@import("std").os.windows.WINAPI) u32;

pub extern "sensorsutilsv2" fn EvaluateActivityThresholds(
    newSample: ?*SENSOR_COLLECTION_LIST,
    oldSample: ?*SENSOR_COLLECTION_LIST,
    thresholds: ?*SENSOR_COLLECTION_LIST,
) callconv(@import("std").os.windows.WINAPI) BOOLEAN;

pub extern "sensorsutilsv2" fn CollectionsListSortSubscribedActivitiesByConfidence(
    thresholds: ?*SENSOR_COLLECTION_LIST,
    pCollection: ?*SENSOR_COLLECTION_LIST,
) callconv(@import("std").os.windows.WINAPI) NTSTATUS;

pub extern "sensorsutilsv2" fn InitPropVariantFromCLSIDArray(
    members: [*]Guid,
    size: u32,
    ppropvar: ?*PROPVARIANT,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

pub extern "sensorsutilsv2" fn IsSensorSubscribed(
    subscriptionList: ?*SENSOR_COLLECTION_LIST,
    currentType: Guid,
) callconv(@import("std").os.windows.WINAPI) BOOLEAN;

pub extern "sensorsutilsv2" fn IsGUIDPresentInList(
    guidArray: [*]const Guid,
    arrayLength: u32,
    guidElem: ?*const Guid,
) callconv(@import("std").os.windows.WINAPI) BOOLEAN;

//--------------------------------------------------------------------------------
// Section: Unicode Aliases (0)
//--------------------------------------------------------------------------------
const thismodule = @This();
pub usingnamespace switch (@import("../zig.zig").unicode_mode) {
    .ansi => struct {},
    .wide => struct {},
    .unspecified => if (@import("builtin").is_test) struct {} else struct {},
};
//--------------------------------------------------------------------------------
// Section: Imports (14)
//--------------------------------------------------------------------------------
const Guid = @import("../zig.zig").Guid;
const BOOL = @import("../foundation.zig").BOOL;
const BOOLEAN = @import("../foundation.zig").BOOLEAN;
const BSTR = @import("../foundation.zig").BSTR;
const FILETIME = @import("../foundation.zig").FILETIME;
const HRESULT = @import("../foundation.zig").HRESULT;
const HWND = @import("../foundation.zig").HWND;
const IPortableDeviceKeyCollection = @import("../devices/portable_devices.zig").IPortableDeviceKeyCollection;
const IPortableDeviceValues = @import("../devices/portable_devices.zig").IPortableDeviceValues;
const IUnknown = @import("../system/com.zig").IUnknown;
const NTSTATUS = @import("../foundation.zig").NTSTATUS;
const PROPERTYKEY = @import("../ui/shell/properties_system.zig").PROPERTYKEY;
const PROPVARIANT = @import("../system/com/structured_storage.zig").PROPVARIANT;
const SYSTEMTIME = @import("../foundation.zig").SYSTEMTIME;

test {
    @setEvalBranchQuota(comptime @import("std").meta.declarations(@This()).len * 3);

    // reference all the pub declarations
    if (!@import("builtin").is_test) return;
    inline for (comptime @import("std").meta.declarations(@This())) |decl| {
        if (decl.is_pub) {
            _ = @field(@This(), decl.name);
        }
    }
}
