//! NOTE: this file is autogenerated, DO NOT MODIFY
//--------------------------------------------------------------------------------
// Section: Constants (868)
//--------------------------------------------------------------------------------
pub const DEVPKEY_MTPBTH_IsConnected = PROPERTYKEY{ .fmtid = Guid.initString("ea1237fa-589d-4472-84e4-0abe36fd62ef"), .pid = 2 };
pub const GUID_DEVINTERFACE_WPD = Guid.initString("6ac27878-a6fa-4155-ba85-f98f491d4f33");
pub const GUID_DEVINTERFACE_WPD_PRIVATE = Guid.initString("ba0c718f-4ded-49b7-bdd3-fabe28661211");
pub const GUID_DEVINTERFACE_WPD_SERVICE = Guid.initString("9ef44f80-3d64-4246-a6aa-206f328d1edc");
pub const WPD_CONTROL_FUNCTION_GENERIC_MESSAGE = @as(u32, 66);
pub const IOCTL_WPD_MESSAGE_READWRITE_ACCESS = @as(u32, 4243720);
pub const IOCTL_WPD_MESSAGE_READ_ACCESS = @as(u32, 4210952);
pub const FACILITY_WPD = @as(u32, 42);
pub const E_WPD_DEVICE_ALREADY_OPENED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2144731135));
pub const E_WPD_DEVICE_NOT_OPEN = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2144731134));
pub const E_WPD_OBJECT_ALREADY_ATTACHED_TO_DEVICE = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2144731133));
pub const E_WPD_OBJECT_NOT_ATTACHED_TO_DEVICE = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2144731132));
pub const E_WPD_OBJECT_NOT_COMMITED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2144731131));
pub const E_WPD_DEVICE_IS_HUNG = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2144731130));
pub const E_WPD_SMS_INVALID_RECIPIENT = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2144731036));
pub const E_WPD_SMS_INVALID_MESSAGE_BODY = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2144731035));
pub const E_WPD_SMS_SERVICE_UNAVAILABLE = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2144731034));
pub const E_WPD_SERVICE_ALREADY_OPENED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2144730936));
pub const E_WPD_SERVICE_NOT_OPEN = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2144730935));
pub const E_WPD_OBJECT_ALREADY_ATTACHED_TO_SERVICE = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2144730934));
pub const E_WPD_OBJECT_NOT_ATTACHED_TO_SERVICE = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2144730933));
pub const E_WPD_SERVICE_BAD_PARAMETER_ORDER = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2144730932));
pub const WPD_EVENT_NOTIFICATION = Guid.initString("2ba2e40a-6b4c-4295-bb43-26322b99aeb2");
pub const WPD_EVENT_OBJECT_ADDED = Guid.initString("a726da95-e207-4b02-8d44-bef2e86cbffc");
pub const WPD_EVENT_OBJECT_REMOVED = Guid.initString("be82ab88-a52c-4823-96e5-d0272671fc38");
pub const WPD_EVENT_OBJECT_UPDATED = Guid.initString("1445a759-2e01-485d-9f27-ff07dae697ab");
pub const WPD_EVENT_DEVICE_RESET = Guid.initString("7755cf53-c1ed-44f3-b5a2-451e2c376b27");
pub const WPD_EVENT_DEVICE_CAPABILITIES_UPDATED = Guid.initString("36885aa1-cd54-4daa-b3d0-afb3e03f5999");
pub const WPD_EVENT_STORAGE_FORMAT = Guid.initString("3782616b-22bc-4474-a251-3070f8d38857");
pub const WPD_EVENT_OBJECT_TRANSFER_REQUESTED = Guid.initString("8d16a0a1-f2c6-41da-8f19-5e53721adbf2");
pub const WPD_EVENT_DEVICE_REMOVED = Guid.initString("e4cbca1b-6918-48b9-85ee-02be7c850af9");
pub const WPD_EVENT_SERVICE_METHOD_COMPLETE = Guid.initString("8a33f5f8-0acc-4d9b-9cc4-112d353b86ca");
pub const WPD_CONTENT_TYPE_FUNCTIONAL_OBJECT = Guid.initString("99ed0160-17ff-4c44-9d98-1d7a6f941921");
pub const WPD_CONTENT_TYPE_FOLDER = Guid.initString("27e2e392-a111-48e0-ab0c-e17705a05f85");
pub const WPD_CONTENT_TYPE_IMAGE = Guid.initString("ef2107d5-a52a-4243-a26b-62d4176d7603");
pub const WPD_CONTENT_TYPE_DOCUMENT = Guid.initString("680adf52-950a-4041-9b41-65e393648155");
pub const WPD_CONTENT_TYPE_CONTACT = Guid.initString("eaba8313-4525-4707-9f0e-87c6808e9435");
pub const WPD_CONTENT_TYPE_CONTACT_GROUP = Guid.initString("346b8932-4c36-40d8-9415-1828291f9de9");
pub const WPD_CONTENT_TYPE_AUDIO = Guid.initString("4ad2c85e-5e2d-45e5-8864-4f229e3c6cf0");
pub const WPD_CONTENT_TYPE_VIDEO = Guid.initString("9261b03c-3d78-4519-85e3-02c5e1f50bb9");
pub const WPD_CONTENT_TYPE_TELEVISION = Guid.initString("60a169cf-f2ae-4e21-9375-9677f11c1c6e");
pub const WPD_CONTENT_TYPE_PLAYLIST = Guid.initString("1a33f7e4-af13-48f5-994e-77369dfe04a3");
pub const WPD_CONTENT_TYPE_MIXED_CONTENT_ALBUM = Guid.initString("00f0c3ac-a593-49ac-9219-24abca5a2563");
pub const WPD_CONTENT_TYPE_AUDIO_ALBUM = Guid.initString("aa18737e-5009-48fa-ae21-85f24383b4e6");
pub const WPD_CONTENT_TYPE_IMAGE_ALBUM = Guid.initString("75793148-15f5-4a30-a813-54ed8a37e226");
pub const WPD_CONTENT_TYPE_VIDEO_ALBUM = Guid.initString("012b0db7-d4c1-45d6-b081-94b87779614f");
pub const WPD_CONTENT_TYPE_MEMO = Guid.initString("9cd20ecf-3b50-414f-a641-e473ffe45751");
pub const WPD_CONTENT_TYPE_EMAIL = Guid.initString("8038044a-7e51-4f8f-883d-1d0623d14533");
pub const WPD_CONTENT_TYPE_APPOINTMENT = Guid.initString("0fed060e-8793-4b1e-90c9-48ac389ac631");
pub const WPD_CONTENT_TYPE_TASK = Guid.initString("63252f2c-887f-4cb6-b1ac-d29855dcef6c");
pub const WPD_CONTENT_TYPE_PROGRAM = Guid.initString("d269f96a-247c-4bff-98fb-97f3c49220e6");
pub const WPD_CONTENT_TYPE_GENERIC_FILE = Guid.initString("0085e0a6-8d34-45d7-bc5c-447e59c73d48");
pub const WPD_CONTENT_TYPE_CALENDAR = Guid.initString("a1fd5967-6023-49a0-9df1-f8060be751b0");
pub const WPD_CONTENT_TYPE_GENERIC_MESSAGE = Guid.initString("e80eaaf8-b2db-4133-b67e-1bef4b4a6e5f");
pub const WPD_CONTENT_TYPE_NETWORK_ASSOCIATION = Guid.initString("031da7ee-18c8-4205-847e-89a11261d0f3");
pub const WPD_CONTENT_TYPE_CERTIFICATE = Guid.initString("dc3876e8-a948-4060-9050-cbd77e8a3d87");
pub const WPD_CONTENT_TYPE_WIRELESS_PROFILE = Guid.initString("0bac070a-9f5f-4da4-a8f6-3de44d68fd6c");
pub const WPD_CONTENT_TYPE_MEDIA_CAST = Guid.initString("5e88b3cc-3e65-4e62-bfff-229495253ab0");
pub const WPD_CONTENT_TYPE_SECTION = Guid.initString("821089f5-1d91-4dc9-be3c-bbb1b35b18ce");
pub const WPD_CONTENT_TYPE_UNSPECIFIED = Guid.initString("28d8d31e-249c-454e-aabc-34883168e634");
pub const WPD_CONTENT_TYPE_ALL = Guid.initString("80e170d2-1055-4a3e-b952-82cc4f8a8689");
pub const WPD_FUNCTIONAL_CATEGORY_DEVICE = Guid.initString("08ea466b-e3a4-4336-a1f3-a44d2b5c438c");
pub const WPD_FUNCTIONAL_CATEGORY_STORAGE = Guid.initString("23f05bbc-15de-4c2a-a55b-a9af5ce412ef");
pub const WPD_FUNCTIONAL_CATEGORY_STILL_IMAGE_CAPTURE = Guid.initString("613ca327-ab93-4900-b4fa-895bb5874b79");
pub const WPD_FUNCTIONAL_CATEGORY_AUDIO_CAPTURE = Guid.initString("3f2a1919-c7c2-4a00-855d-f57cf06debbb");
pub const WPD_FUNCTIONAL_CATEGORY_VIDEO_CAPTURE = Guid.initString("e23e5f6b-7243-43aa-8df1-0eb3d968a918");
pub const WPD_FUNCTIONAL_CATEGORY_SMS = Guid.initString("0044a0b1-c1e9-4afd-b358-a62c6117c9cf");
pub const WPD_FUNCTIONAL_CATEGORY_RENDERING_INFORMATION = Guid.initString("08600ba4-a7ba-4a01-ab0e-0065d0a356d3");
pub const WPD_FUNCTIONAL_CATEGORY_NETWORK_CONFIGURATION = Guid.initString("48f4db72-7c6a-4ab0-9e1a-470e3cdbf26a");
pub const WPD_FUNCTIONAL_CATEGORY_ALL = Guid.initString("2d8a6512-a74c-448e-ba8a-f4ac07c49399");
pub const WPD_OBJECT_FORMAT_ICON = Guid.initString("077232ed-102c-4638-9c22-83f142bfc822");
pub const WPD_OBJECT_FORMAT_M4A = Guid.initString("30aba7ac-6ffd-4c23-a359-3e9b52f3f1c8");
pub const WPD_OBJECT_FORMAT_NETWORK_ASSOCIATION = Guid.initString("b1020000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_X509V3CERTIFICATE = Guid.initString("b1030000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_MICROSOFT_WFC = Guid.initString("b1040000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_3GPA = Guid.initString("e5172730-f971-41ef-a10b-2271a0019d7a");
pub const WPD_OBJECT_FORMAT_3G2A = Guid.initString("1a11202d-8759-4e34-ba5e-b1211087eee4");
pub const WPD_OBJECT_FORMAT_ALL = Guid.initString("c1f62eb2-4bb3-479c-9cfa-05b5f3a57b22");
pub const WPD_CATEGORY_NULL = Guid.initString("00000000-0000-0000-0000-000000000000");
pub const WPD_PROPERTY_NULL = PROPERTYKEY{ .fmtid = Guid.initString("00000000-0000-0000-0000-000000000000"), .pid = 0 };
pub const WPD_OBJECT_PROPERTIES_V1 = Guid.initString("ef6b490d-5cd8-437a-affc-da8b60ee4a3c");
pub const WPD_OBJECT_CONTENT_TYPE = PROPERTYKEY{ .fmtid = Guid.initString("ef6b490d-5cd8-437a-affc-da8b60ee4a3c"), .pid = 7 };
pub const WPD_OBJECT_REFERENCES = PROPERTYKEY{ .fmtid = Guid.initString("ef6b490d-5cd8-437a-affc-da8b60ee4a3c"), .pid = 14 };
pub const WPD_OBJECT_CONTAINER_FUNCTIONAL_OBJECT_ID = PROPERTYKEY{ .fmtid = Guid.initString("ef6b490d-5cd8-437a-affc-da8b60ee4a3c"), .pid = 23 };
pub const WPD_OBJECT_GENERATE_THUMBNAIL_FROM_RESOURCE = PROPERTYKEY{ .fmtid = Guid.initString("ef6b490d-5cd8-437a-affc-da8b60ee4a3c"), .pid = 24 };
pub const WPD_OBJECT_HINT_LOCATION_DISPLAY_NAME = PROPERTYKEY{ .fmtid = Guid.initString("ef6b490d-5cd8-437a-affc-da8b60ee4a3c"), .pid = 25 };
pub const WPD_OBJECT_PROPERTIES_V2 = Guid.initString("0373cd3d-4a46-40d7-b4d8-73e8da74e775");
pub const WPD_OBJECT_SUPPORTED_UNITS = PROPERTYKEY{ .fmtid = Guid.initString("0373cd3d-4a46-40d7-b4d8-73e8da74e775"), .pid = 2 };
pub const WPD_FUNCTIONAL_OBJECT_PROPERTIES_V1 = Guid.initString("8f052d93-abca-4fc5-a5ac-b01df4dbe598");
pub const WPD_FUNCTIONAL_OBJECT_CATEGORY = PROPERTYKEY{ .fmtid = Guid.initString("8f052d93-abca-4fc5-a5ac-b01df4dbe598"), .pid = 2 };
pub const WPD_STORAGE_OBJECT_PROPERTIES_V1 = Guid.initString("01a3057a-74d6-4e80-bea7-dc4c212ce50a");
pub const WPD_STORAGE_TYPE = PROPERTYKEY{ .fmtid = Guid.initString("01a3057a-74d6-4e80-bea7-dc4c212ce50a"), .pid = 2 };
pub const WPD_STORAGE_FILE_SYSTEM_TYPE = PROPERTYKEY{ .fmtid = Guid.initString("01a3057a-74d6-4e80-bea7-dc4c212ce50a"), .pid = 3 };
pub const WPD_STORAGE_CAPACITY = PROPERTYKEY{ .fmtid = Guid.initString("01a3057a-74d6-4e80-bea7-dc4c212ce50a"), .pid = 4 };
pub const WPD_STORAGE_FREE_SPACE_IN_BYTES = PROPERTYKEY{ .fmtid = Guid.initString("01a3057a-74d6-4e80-bea7-dc4c212ce50a"), .pid = 5 };
pub const WPD_STORAGE_FREE_SPACE_IN_OBJECTS = PROPERTYKEY{ .fmtid = Guid.initString("01a3057a-74d6-4e80-bea7-dc4c212ce50a"), .pid = 6 };
pub const WPD_STORAGE_DESCRIPTION = PROPERTYKEY{ .fmtid = Guid.initString("01a3057a-74d6-4e80-bea7-dc4c212ce50a"), .pid = 7 };
pub const WPD_STORAGE_SERIAL_NUMBER = PROPERTYKEY{ .fmtid = Guid.initString("01a3057a-74d6-4e80-bea7-dc4c212ce50a"), .pid = 8 };
pub const WPD_STORAGE_MAX_OBJECT_SIZE = PROPERTYKEY{ .fmtid = Guid.initString("01a3057a-74d6-4e80-bea7-dc4c212ce50a"), .pid = 9 };
pub const WPD_STORAGE_CAPACITY_IN_OBJECTS = PROPERTYKEY{ .fmtid = Guid.initString("01a3057a-74d6-4e80-bea7-dc4c212ce50a"), .pid = 10 };
pub const WPD_STORAGE_ACCESS_CAPABILITY = PROPERTYKEY{ .fmtid = Guid.initString("01a3057a-74d6-4e80-bea7-dc4c212ce50a"), .pid = 11 };
pub const WPD_NETWORK_ASSOCIATION_PROPERTIES_V1 = Guid.initString("e4c93c1f-b203-43f1-a100-5a07d11b0274");
pub const WPD_NETWORK_ASSOCIATION_HOST_NETWORK_IDENTIFIERS = PROPERTYKEY{ .fmtid = Guid.initString("e4c93c1f-b203-43f1-a100-5a07d11b0274"), .pid = 2 };
pub const WPD_NETWORK_ASSOCIATION_X509V3SEQUENCE = PROPERTYKEY{ .fmtid = Guid.initString("e4c93c1f-b203-43f1-a100-5a07d11b0274"), .pid = 3 };
pub const WPD_STILL_IMAGE_CAPTURE_OBJECT_PROPERTIES_V1 = Guid.initString("58c571ec-1bcb-42a7-8ac5-bb291573a260");
pub const WPD_STILL_IMAGE_CAPTURE_RESOLUTION = PROPERTYKEY{ .fmtid = Guid.initString("58c571ec-1bcb-42a7-8ac5-bb291573a260"), .pid = 2 };
pub const WPD_STILL_IMAGE_CAPTURE_FORMAT = PROPERTYKEY{ .fmtid = Guid.initString("58c571ec-1bcb-42a7-8ac5-bb291573a260"), .pid = 3 };
pub const WPD_STILL_IMAGE_COMPRESSION_SETTING = PROPERTYKEY{ .fmtid = Guid.initString("58c571ec-1bcb-42a7-8ac5-bb291573a260"), .pid = 4 };
pub const WPD_STILL_IMAGE_WHITE_BALANCE = PROPERTYKEY{ .fmtid = Guid.initString("58c571ec-1bcb-42a7-8ac5-bb291573a260"), .pid = 5 };
pub const WPD_STILL_IMAGE_RGB_GAIN = PROPERTYKEY{ .fmtid = Guid.initString("58c571ec-1bcb-42a7-8ac5-bb291573a260"), .pid = 6 };
pub const WPD_STILL_IMAGE_FNUMBER = PROPERTYKEY{ .fmtid = Guid.initString("58c571ec-1bcb-42a7-8ac5-bb291573a260"), .pid = 7 };
pub const WPD_STILL_IMAGE_FOCAL_LENGTH = PROPERTYKEY{ .fmtid = Guid.initString("58c571ec-1bcb-42a7-8ac5-bb291573a260"), .pid = 8 };
pub const WPD_STILL_IMAGE_FOCUS_DISTANCE = PROPERTYKEY{ .fmtid = Guid.initString("58c571ec-1bcb-42a7-8ac5-bb291573a260"), .pid = 9 };
pub const WPD_STILL_IMAGE_FOCUS_MODE = PROPERTYKEY{ .fmtid = Guid.initString("58c571ec-1bcb-42a7-8ac5-bb291573a260"), .pid = 10 };
pub const WPD_STILL_IMAGE_EXPOSURE_METERING_MODE = PROPERTYKEY{ .fmtid = Guid.initString("58c571ec-1bcb-42a7-8ac5-bb291573a260"), .pid = 11 };
pub const WPD_STILL_IMAGE_FLASH_MODE = PROPERTYKEY{ .fmtid = Guid.initString("58c571ec-1bcb-42a7-8ac5-bb291573a260"), .pid = 12 };
pub const WPD_STILL_IMAGE_EXPOSURE_TIME = PROPERTYKEY{ .fmtid = Guid.initString("58c571ec-1bcb-42a7-8ac5-bb291573a260"), .pid = 13 };
pub const WPD_STILL_IMAGE_EXPOSURE_PROGRAM_MODE = PROPERTYKEY{ .fmtid = Guid.initString("58c571ec-1bcb-42a7-8ac5-bb291573a260"), .pid = 14 };
pub const WPD_STILL_IMAGE_EXPOSURE_INDEX = PROPERTYKEY{ .fmtid = Guid.initString("58c571ec-1bcb-42a7-8ac5-bb291573a260"), .pid = 15 };
pub const WPD_STILL_IMAGE_EXPOSURE_BIAS_COMPENSATION = PROPERTYKEY{ .fmtid = Guid.initString("58c571ec-1bcb-42a7-8ac5-bb291573a260"), .pid = 16 };
pub const WPD_STILL_IMAGE_CAPTURE_DELAY = PROPERTYKEY{ .fmtid = Guid.initString("58c571ec-1bcb-42a7-8ac5-bb291573a260"), .pid = 17 };
pub const WPD_STILL_IMAGE_CAPTURE_MODE = PROPERTYKEY{ .fmtid = Guid.initString("58c571ec-1bcb-42a7-8ac5-bb291573a260"), .pid = 18 };
pub const WPD_STILL_IMAGE_CONTRAST = PROPERTYKEY{ .fmtid = Guid.initString("58c571ec-1bcb-42a7-8ac5-bb291573a260"), .pid = 19 };
pub const WPD_STILL_IMAGE_SHARPNESS = PROPERTYKEY{ .fmtid = Guid.initString("58c571ec-1bcb-42a7-8ac5-bb291573a260"), .pid = 20 };
pub const WPD_STILL_IMAGE_DIGITAL_ZOOM = PROPERTYKEY{ .fmtid = Guid.initString("58c571ec-1bcb-42a7-8ac5-bb291573a260"), .pid = 21 };
pub const WPD_STILL_IMAGE_EFFECT_MODE = PROPERTYKEY{ .fmtid = Guid.initString("58c571ec-1bcb-42a7-8ac5-bb291573a260"), .pid = 22 };
pub const WPD_STILL_IMAGE_BURST_NUMBER = PROPERTYKEY{ .fmtid = Guid.initString("58c571ec-1bcb-42a7-8ac5-bb291573a260"), .pid = 23 };
pub const WPD_STILL_IMAGE_BURST_INTERVAL = PROPERTYKEY{ .fmtid = Guid.initString("58c571ec-1bcb-42a7-8ac5-bb291573a260"), .pid = 24 };
pub const WPD_STILL_IMAGE_TIMELAPSE_NUMBER = PROPERTYKEY{ .fmtid = Guid.initString("58c571ec-1bcb-42a7-8ac5-bb291573a260"), .pid = 25 };
pub const WPD_STILL_IMAGE_TIMELAPSE_INTERVAL = PROPERTYKEY{ .fmtid = Guid.initString("58c571ec-1bcb-42a7-8ac5-bb291573a260"), .pid = 26 };
pub const WPD_STILL_IMAGE_FOCUS_METERING_MODE = PROPERTYKEY{ .fmtid = Guid.initString("58c571ec-1bcb-42a7-8ac5-bb291573a260"), .pid = 27 };
pub const WPD_STILL_IMAGE_UPLOAD_URL = PROPERTYKEY{ .fmtid = Guid.initString("58c571ec-1bcb-42a7-8ac5-bb291573a260"), .pid = 28 };
pub const WPD_STILL_IMAGE_ARTIST = PROPERTYKEY{ .fmtid = Guid.initString("58c571ec-1bcb-42a7-8ac5-bb291573a260"), .pid = 29 };
pub const WPD_STILL_IMAGE_CAMERA_MODEL = PROPERTYKEY{ .fmtid = Guid.initString("58c571ec-1bcb-42a7-8ac5-bb291573a260"), .pid = 30 };
pub const WPD_STILL_IMAGE_CAMERA_MANUFACTURER = PROPERTYKEY{ .fmtid = Guid.initString("58c571ec-1bcb-42a7-8ac5-bb291573a260"), .pid = 31 };
pub const WPD_RENDERING_INFORMATION_OBJECT_PROPERTIES_V1 = Guid.initString("c53d039f-ee23-4a31-8590-7639879870b4");
pub const WPD_RENDERING_INFORMATION_PROFILES = PROPERTYKEY{ .fmtid = Guid.initString("c53d039f-ee23-4a31-8590-7639879870b4"), .pid = 2 };
pub const WPD_RENDERING_INFORMATION_PROFILE_ENTRY_TYPE = PROPERTYKEY{ .fmtid = Guid.initString("c53d039f-ee23-4a31-8590-7639879870b4"), .pid = 3 };
pub const WPD_RENDERING_INFORMATION_PROFILE_ENTRY_CREATABLE_RESOURCES = PROPERTYKEY{ .fmtid = Guid.initString("c53d039f-ee23-4a31-8590-7639879870b4"), .pid = 4 };
pub const WPD_CLIENT_INFORMATION_PROPERTIES_V1 = Guid.initString("204d9f0c-2292-4080-9f42-40664e70f859");
pub const WPD_CLIENT_NAME = PROPERTYKEY{ .fmtid = Guid.initString("204d9f0c-2292-4080-9f42-40664e70f859"), .pid = 2 };
pub const WPD_CLIENT_MAJOR_VERSION = PROPERTYKEY{ .fmtid = Guid.initString("204d9f0c-2292-4080-9f42-40664e70f859"), .pid = 3 };
pub const WPD_CLIENT_MINOR_VERSION = PROPERTYKEY{ .fmtid = Guid.initString("204d9f0c-2292-4080-9f42-40664e70f859"), .pid = 4 };
pub const WPD_CLIENT_REVISION = PROPERTYKEY{ .fmtid = Guid.initString("204d9f0c-2292-4080-9f42-40664e70f859"), .pid = 5 };
pub const WPD_CLIENT_WMDRM_APPLICATION_PRIVATE_KEY = PROPERTYKEY{ .fmtid = Guid.initString("204d9f0c-2292-4080-9f42-40664e70f859"), .pid = 6 };
pub const WPD_CLIENT_WMDRM_APPLICATION_CERTIFICATE = PROPERTYKEY{ .fmtid = Guid.initString("204d9f0c-2292-4080-9f42-40664e70f859"), .pid = 7 };
pub const WPD_CLIENT_SECURITY_QUALITY_OF_SERVICE = PROPERTYKEY{ .fmtid = Guid.initString("204d9f0c-2292-4080-9f42-40664e70f859"), .pid = 8 };
pub const WPD_CLIENT_DESIRED_ACCESS = PROPERTYKEY{ .fmtid = Guid.initString("204d9f0c-2292-4080-9f42-40664e70f859"), .pid = 9 };
pub const WPD_CLIENT_SHARE_MODE = PROPERTYKEY{ .fmtid = Guid.initString("204d9f0c-2292-4080-9f42-40664e70f859"), .pid = 10 };
pub const WPD_CLIENT_EVENT_COOKIE = PROPERTYKEY{ .fmtid = Guid.initString("204d9f0c-2292-4080-9f42-40664e70f859"), .pid = 11 };
pub const WPD_CLIENT_MINIMUM_RESULTS_BUFFER_SIZE = PROPERTYKEY{ .fmtid = Guid.initString("204d9f0c-2292-4080-9f42-40664e70f859"), .pid = 12 };
pub const WPD_CLIENT_MANUAL_CLOSE_ON_DISCONNECT = PROPERTYKEY{ .fmtid = Guid.initString("204d9f0c-2292-4080-9f42-40664e70f859"), .pid = 13 };
pub const WPD_PROPERTY_ATTRIBUTES_V1 = Guid.initString("ab7943d8-6332-445f-a00d-8d5ef1e96f37");
pub const WPD_PROPERTY_ATTRIBUTE_FORM = PROPERTYKEY{ .fmtid = Guid.initString("ab7943d8-6332-445f-a00d-8d5ef1e96f37"), .pid = 2 };
pub const WPD_PROPERTY_ATTRIBUTE_CAN_READ = PROPERTYKEY{ .fmtid = Guid.initString("ab7943d8-6332-445f-a00d-8d5ef1e96f37"), .pid = 3 };
pub const WPD_PROPERTY_ATTRIBUTE_CAN_WRITE = PROPERTYKEY{ .fmtid = Guid.initString("ab7943d8-6332-445f-a00d-8d5ef1e96f37"), .pid = 4 };
pub const WPD_PROPERTY_ATTRIBUTE_CAN_DELETE = PROPERTYKEY{ .fmtid = Guid.initString("ab7943d8-6332-445f-a00d-8d5ef1e96f37"), .pid = 5 };
pub const WPD_PROPERTY_ATTRIBUTE_DEFAULT_VALUE = PROPERTYKEY{ .fmtid = Guid.initString("ab7943d8-6332-445f-a00d-8d5ef1e96f37"), .pid = 6 };
pub const WPD_PROPERTY_ATTRIBUTE_FAST_PROPERTY = PROPERTYKEY{ .fmtid = Guid.initString("ab7943d8-6332-445f-a00d-8d5ef1e96f37"), .pid = 7 };
pub const WPD_PROPERTY_ATTRIBUTE_RANGE_MIN = PROPERTYKEY{ .fmtid = Guid.initString("ab7943d8-6332-445f-a00d-8d5ef1e96f37"), .pid = 8 };
pub const WPD_PROPERTY_ATTRIBUTE_RANGE_MAX = PROPERTYKEY{ .fmtid = Guid.initString("ab7943d8-6332-445f-a00d-8d5ef1e96f37"), .pid = 9 };
pub const WPD_PROPERTY_ATTRIBUTE_RANGE_STEP = PROPERTYKEY{ .fmtid = Guid.initString("ab7943d8-6332-445f-a00d-8d5ef1e96f37"), .pid = 10 };
pub const WPD_PROPERTY_ATTRIBUTE_ENUMERATION_ELEMENTS = PROPERTYKEY{ .fmtid = Guid.initString("ab7943d8-6332-445f-a00d-8d5ef1e96f37"), .pid = 11 };
pub const WPD_PROPERTY_ATTRIBUTE_REGULAR_EXPRESSION = PROPERTYKEY{ .fmtid = Guid.initString("ab7943d8-6332-445f-a00d-8d5ef1e96f37"), .pid = 12 };
pub const WPD_PROPERTY_ATTRIBUTE_MAX_SIZE = PROPERTYKEY{ .fmtid = Guid.initString("ab7943d8-6332-445f-a00d-8d5ef1e96f37"), .pid = 13 };
pub const WPD_PROPERTY_ATTRIBUTES_V2 = Guid.initString("5d9da160-74ae-43cc-85a9-fe555a80798e");
pub const WPD_PROPERTY_ATTRIBUTE_NAME = PROPERTYKEY{ .fmtid = Guid.initString("5d9da160-74ae-43cc-85a9-fe555a80798e"), .pid = 2 };
pub const WPD_PROPERTY_ATTRIBUTE_VARTYPE = PROPERTYKEY{ .fmtid = Guid.initString("5d9da160-74ae-43cc-85a9-fe555a80798e"), .pid = 3 };
pub const WPD_CLASS_EXTENSION_OPTIONS_V1 = Guid.initString("6309ffef-a87c-4ca7-8434-797576e40a96");
pub const WPD_CLASS_EXTENSION_OPTIONS_SUPPORTED_CONTENT_TYPES = PROPERTYKEY{ .fmtid = Guid.initString("6309ffef-a87c-4ca7-8434-797576e40a96"), .pid = 2 };
pub const WPD_CLASS_EXTENSION_OPTIONS_DONT_REGISTER_WPD_DEVICE_INTERFACE = PROPERTYKEY{ .fmtid = Guid.initString("6309ffef-a87c-4ca7-8434-797576e40a96"), .pid = 3 };
pub const WPD_CLASS_EXTENSION_OPTIONS_REGISTER_WPD_PRIVATE_DEVICE_INTERFACE = PROPERTYKEY{ .fmtid = Guid.initString("6309ffef-a87c-4ca7-8434-797576e40a96"), .pid = 4 };
pub const WPD_CLASS_EXTENSION_OPTIONS_V2 = Guid.initString("3e3595da-4d71-49fe-a0b4-d4406c3ae93f");
pub const WPD_CLASS_EXTENSION_OPTIONS_MULTITRANSPORT_MODE = PROPERTYKEY{ .fmtid = Guid.initString("3e3595da-4d71-49fe-a0b4-d4406c3ae93f"), .pid = 2 };
pub const WPD_CLASS_EXTENSION_OPTIONS_DEVICE_IDENTIFICATION_VALUES = PROPERTYKEY{ .fmtid = Guid.initString("3e3595da-4d71-49fe-a0b4-d4406c3ae93f"), .pid = 3 };
pub const WPD_CLASS_EXTENSION_OPTIONS_TRANSPORT_BANDWIDTH = PROPERTYKEY{ .fmtid = Guid.initString("3e3595da-4d71-49fe-a0b4-d4406c3ae93f"), .pid = 4 };
pub const WPD_CLASS_EXTENSION_OPTIONS_V3 = Guid.initString("65c160f8-1367-4ce2-939d-8310839f0d30");
pub const WPD_CLASS_EXTENSION_OPTIONS_SILENCE_AUTOPLAY = PROPERTYKEY{ .fmtid = Guid.initString("65c160f8-1367-4ce2-939d-8310839f0d30"), .pid = 2 };
pub const WPD_RESOURCE_ATTRIBUTES_V1 = Guid.initString("1eb6f604-9278-429f-93cc-5bb8c06656b6");
pub const WPD_RESOURCE_ATTRIBUTE_TOTAL_SIZE = PROPERTYKEY{ .fmtid = Guid.initString("1eb6f604-9278-429f-93cc-5bb8c06656b6"), .pid = 2 };
pub const WPD_RESOURCE_ATTRIBUTE_CAN_READ = PROPERTYKEY{ .fmtid = Guid.initString("1eb6f604-9278-429f-93cc-5bb8c06656b6"), .pid = 3 };
pub const WPD_RESOURCE_ATTRIBUTE_CAN_WRITE = PROPERTYKEY{ .fmtid = Guid.initString("1eb6f604-9278-429f-93cc-5bb8c06656b6"), .pid = 4 };
pub const WPD_RESOURCE_ATTRIBUTE_CAN_DELETE = PROPERTYKEY{ .fmtid = Guid.initString("1eb6f604-9278-429f-93cc-5bb8c06656b6"), .pid = 5 };
pub const WPD_RESOURCE_ATTRIBUTE_OPTIMAL_READ_BUFFER_SIZE = PROPERTYKEY{ .fmtid = Guid.initString("1eb6f604-9278-429f-93cc-5bb8c06656b6"), .pid = 6 };
pub const WPD_RESOURCE_ATTRIBUTE_OPTIMAL_WRITE_BUFFER_SIZE = PROPERTYKEY{ .fmtid = Guid.initString("1eb6f604-9278-429f-93cc-5bb8c06656b6"), .pid = 7 };
pub const WPD_RESOURCE_ATTRIBUTE_FORMAT = PROPERTYKEY{ .fmtid = Guid.initString("1eb6f604-9278-429f-93cc-5bb8c06656b6"), .pid = 8 };
pub const WPD_RESOURCE_ATTRIBUTE_RESOURCE_KEY = PROPERTYKEY{ .fmtid = Guid.initString("1eb6f604-9278-429f-93cc-5bb8c06656b6"), .pid = 9 };
pub const WPD_DEVICE_PROPERTIES_V1 = Guid.initString("26d4979a-e643-4626-9e2b-736dc0c92fdc");
pub const WPD_DEVICE_SYNC_PARTNER = PROPERTYKEY{ .fmtid = Guid.initString("26d4979a-e643-4626-9e2b-736dc0c92fdc"), .pid = 2 };
pub const WPD_DEVICE_FIRMWARE_VERSION = PROPERTYKEY{ .fmtid = Guid.initString("26d4979a-e643-4626-9e2b-736dc0c92fdc"), .pid = 3 };
pub const WPD_DEVICE_POWER_LEVEL = PROPERTYKEY{ .fmtid = Guid.initString("26d4979a-e643-4626-9e2b-736dc0c92fdc"), .pid = 4 };
pub const WPD_DEVICE_POWER_SOURCE = PROPERTYKEY{ .fmtid = Guid.initString("26d4979a-e643-4626-9e2b-736dc0c92fdc"), .pid = 5 };
pub const WPD_DEVICE_PROTOCOL = PROPERTYKEY{ .fmtid = Guid.initString("26d4979a-e643-4626-9e2b-736dc0c92fdc"), .pid = 6 };
pub const WPD_DEVICE_MANUFACTURER = PROPERTYKEY{ .fmtid = Guid.initString("26d4979a-e643-4626-9e2b-736dc0c92fdc"), .pid = 7 };
pub const WPD_DEVICE_MODEL = PROPERTYKEY{ .fmtid = Guid.initString("26d4979a-e643-4626-9e2b-736dc0c92fdc"), .pid = 8 };
pub const WPD_DEVICE_SERIAL_NUMBER = PROPERTYKEY{ .fmtid = Guid.initString("26d4979a-e643-4626-9e2b-736dc0c92fdc"), .pid = 9 };
pub const WPD_DEVICE_SUPPORTS_NON_CONSUMABLE = PROPERTYKEY{ .fmtid = Guid.initString("26d4979a-e643-4626-9e2b-736dc0c92fdc"), .pid = 10 };
pub const WPD_DEVICE_DATETIME = PROPERTYKEY{ .fmtid = Guid.initString("26d4979a-e643-4626-9e2b-736dc0c92fdc"), .pid = 11 };
pub const WPD_DEVICE_FRIENDLY_NAME = PROPERTYKEY{ .fmtid = Guid.initString("26d4979a-e643-4626-9e2b-736dc0c92fdc"), .pid = 12 };
pub const WPD_DEVICE_SUPPORTED_DRM_SCHEMES = PROPERTYKEY{ .fmtid = Guid.initString("26d4979a-e643-4626-9e2b-736dc0c92fdc"), .pid = 13 };
pub const WPD_DEVICE_SUPPORTED_FORMATS_ARE_ORDERED = PROPERTYKEY{ .fmtid = Guid.initString("26d4979a-e643-4626-9e2b-736dc0c92fdc"), .pid = 14 };
pub const WPD_DEVICE_TYPE = PROPERTYKEY{ .fmtid = Guid.initString("26d4979a-e643-4626-9e2b-736dc0c92fdc"), .pid = 15 };
pub const WPD_DEVICE_NETWORK_IDENTIFIER = PROPERTYKEY{ .fmtid = Guid.initString("26d4979a-e643-4626-9e2b-736dc0c92fdc"), .pid = 16 };
pub const WPD_DEVICE_PROPERTIES_V2 = Guid.initString("463dd662-7fc4-4291-911c-7f4c9cca9799");
pub const WPD_DEVICE_FUNCTIONAL_UNIQUE_ID = PROPERTYKEY{ .fmtid = Guid.initString("463dd662-7fc4-4291-911c-7f4c9cca9799"), .pid = 2 };
pub const WPD_DEVICE_MODEL_UNIQUE_ID = PROPERTYKEY{ .fmtid = Guid.initString("463dd662-7fc4-4291-911c-7f4c9cca9799"), .pid = 3 };
pub const WPD_DEVICE_TRANSPORT = PROPERTYKEY{ .fmtid = Guid.initString("463dd662-7fc4-4291-911c-7f4c9cca9799"), .pid = 4 };
pub const WPD_DEVICE_USE_DEVICE_STAGE = PROPERTYKEY{ .fmtid = Guid.initString("463dd662-7fc4-4291-911c-7f4c9cca9799"), .pid = 5 };
pub const WPD_DEVICE_PROPERTIES_V3 = Guid.initString("6c2b878c-c2ec-490d-b425-d7a75e23e5ed");
pub const WPD_DEVICE_EDP_IDENTITY = PROPERTYKEY{ .fmtid = Guid.initString("6c2b878c-c2ec-490d-b425-d7a75e23e5ed"), .pid = 1 };
pub const WPD_SERVICE_PROPERTIES_V1 = Guid.initString("7510698a-cb54-481c-b8db-0d75c93f1c06");
pub const WPD_SERVICE_VERSION = PROPERTYKEY{ .fmtid = Guid.initString("7510698a-cb54-481c-b8db-0d75c93f1c06"), .pid = 2 };
pub const WPD_EVENT_PROPERTIES_V1 = Guid.initString("15ab1953-f817-4fef-a921-5676e838f6e0");
pub const WPD_EVENT_PARAMETER_PNP_DEVICE_ID = PROPERTYKEY{ .fmtid = Guid.initString("15ab1953-f817-4fef-a921-5676e838f6e0"), .pid = 2 };
pub const WPD_EVENT_PARAMETER_EVENT_ID = PROPERTYKEY{ .fmtid = Guid.initString("15ab1953-f817-4fef-a921-5676e838f6e0"), .pid = 3 };
pub const WPD_EVENT_PARAMETER_OPERATION_STATE = PROPERTYKEY{ .fmtid = Guid.initString("15ab1953-f817-4fef-a921-5676e838f6e0"), .pid = 4 };
pub const WPD_EVENT_PARAMETER_OPERATION_PROGRESS = PROPERTYKEY{ .fmtid = Guid.initString("15ab1953-f817-4fef-a921-5676e838f6e0"), .pid = 5 };
pub const WPD_EVENT_PARAMETER_OBJECT_PARENT_PERSISTENT_UNIQUE_ID = PROPERTYKEY{ .fmtid = Guid.initString("15ab1953-f817-4fef-a921-5676e838f6e0"), .pid = 6 };
pub const WPD_EVENT_PARAMETER_OBJECT_CREATION_COOKIE = PROPERTYKEY{ .fmtid = Guid.initString("15ab1953-f817-4fef-a921-5676e838f6e0"), .pid = 7 };
pub const WPD_EVENT_PARAMETER_CHILD_HIERARCHY_CHANGED = PROPERTYKEY{ .fmtid = Guid.initString("15ab1953-f817-4fef-a921-5676e838f6e0"), .pid = 8 };
pub const WPD_EVENT_PROPERTIES_V2 = Guid.initString("52807b8a-4914-4323-9b9a-74f654b2b846");
pub const WPD_EVENT_PARAMETER_SERVICE_METHOD_CONTEXT = PROPERTYKEY{ .fmtid = Guid.initString("52807b8a-4914-4323-9b9a-74f654b2b846"), .pid = 2 };
pub const WPD_EVENT_OPTIONS_V1 = Guid.initString("b3d8dad7-a361-4b83-8a48-5b02ce10713b");
pub const WPD_EVENT_OPTION_IS_BROADCAST_EVENT = PROPERTYKEY{ .fmtid = Guid.initString("b3d8dad7-a361-4b83-8a48-5b02ce10713b"), .pid = 2 };
pub const WPD_EVENT_OPTION_IS_AUTOPLAY_EVENT = PROPERTYKEY{ .fmtid = Guid.initString("b3d8dad7-a361-4b83-8a48-5b02ce10713b"), .pid = 3 };
pub const WPD_EVENT_ATTRIBUTES_V1 = Guid.initString("10c96578-2e81-4111-adde-e08ca6138f6d");
pub const WPD_EVENT_ATTRIBUTE_NAME = PROPERTYKEY{ .fmtid = Guid.initString("10c96578-2e81-4111-adde-e08ca6138f6d"), .pid = 2 };
pub const WPD_EVENT_ATTRIBUTE_PARAMETERS = PROPERTYKEY{ .fmtid = Guid.initString("10c96578-2e81-4111-adde-e08ca6138f6d"), .pid = 3 };
pub const WPD_EVENT_ATTRIBUTE_OPTIONS = PROPERTYKEY{ .fmtid = Guid.initString("10c96578-2e81-4111-adde-e08ca6138f6d"), .pid = 4 };
pub const WPD_API_OPTIONS_V1 = Guid.initString("10e54a3e-052d-4777-a13c-de7614be2bc4");
pub const WPD_API_OPTION_USE_CLEAR_DATA_STREAM = PROPERTYKEY{ .fmtid = Guid.initString("10e54a3e-052d-4777-a13c-de7614be2bc4"), .pid = 2 };
pub const WPD_API_OPTION_IOCTL_ACCESS = PROPERTYKEY{ .fmtid = Guid.initString("10e54a3e-052d-4777-a13c-de7614be2bc4"), .pid = 3 };
pub const WPD_FORMAT_ATTRIBUTES_V1 = Guid.initString("a0a02000-bcaf-4be8-b3f5-233f231cf58f");
pub const WPD_FORMAT_ATTRIBUTE_NAME = PROPERTYKEY{ .fmtid = Guid.initString("a0a02000-bcaf-4be8-b3f5-233f231cf58f"), .pid = 2 };
pub const WPD_FORMAT_ATTRIBUTE_MIMETYPE = PROPERTYKEY{ .fmtid = Guid.initString("a0a02000-bcaf-4be8-b3f5-233f231cf58f"), .pid = 3 };
pub const WPD_METHOD_ATTRIBUTES_V1 = Guid.initString("f17a5071-f039-44af-8efe-432cf32e432a");
pub const WPD_METHOD_ATTRIBUTE_NAME = PROPERTYKEY{ .fmtid = Guid.initString("f17a5071-f039-44af-8efe-432cf32e432a"), .pid = 2 };
pub const WPD_METHOD_ATTRIBUTE_ASSOCIATED_FORMAT = PROPERTYKEY{ .fmtid = Guid.initString("f17a5071-f039-44af-8efe-432cf32e432a"), .pid = 3 };
pub const WPD_METHOD_ATTRIBUTE_ACCESS = PROPERTYKEY{ .fmtid = Guid.initString("f17a5071-f039-44af-8efe-432cf32e432a"), .pid = 4 };
pub const WPD_METHOD_ATTRIBUTE_PARAMETERS = PROPERTYKEY{ .fmtid = Guid.initString("f17a5071-f039-44af-8efe-432cf32e432a"), .pid = 5 };
pub const WPD_PARAMETER_ATTRIBUTES_V1 = Guid.initString("e6864dd7-f325-45ea-a1d5-97cf73b6ca58");
pub const WPD_PARAMETER_ATTRIBUTE_ORDER = PROPERTYKEY{ .fmtid = Guid.initString("e6864dd7-f325-45ea-a1d5-97cf73b6ca58"), .pid = 2 };
pub const WPD_PARAMETER_ATTRIBUTE_USAGE = PROPERTYKEY{ .fmtid = Guid.initString("e6864dd7-f325-45ea-a1d5-97cf73b6ca58"), .pid = 3 };
pub const WPD_PARAMETER_ATTRIBUTE_FORM = PROPERTYKEY{ .fmtid = Guid.initString("e6864dd7-f325-45ea-a1d5-97cf73b6ca58"), .pid = 4 };
pub const WPD_PARAMETER_ATTRIBUTE_DEFAULT_VALUE = PROPERTYKEY{ .fmtid = Guid.initString("e6864dd7-f325-45ea-a1d5-97cf73b6ca58"), .pid = 5 };
pub const WPD_PARAMETER_ATTRIBUTE_RANGE_MIN = PROPERTYKEY{ .fmtid = Guid.initString("e6864dd7-f325-45ea-a1d5-97cf73b6ca58"), .pid = 6 };
pub const WPD_PARAMETER_ATTRIBUTE_RANGE_MAX = PROPERTYKEY{ .fmtid = Guid.initString("e6864dd7-f325-45ea-a1d5-97cf73b6ca58"), .pid = 7 };
pub const WPD_PARAMETER_ATTRIBUTE_RANGE_STEP = PROPERTYKEY{ .fmtid = Guid.initString("e6864dd7-f325-45ea-a1d5-97cf73b6ca58"), .pid = 8 };
pub const WPD_PARAMETER_ATTRIBUTE_ENUMERATION_ELEMENTS = PROPERTYKEY{ .fmtid = Guid.initString("e6864dd7-f325-45ea-a1d5-97cf73b6ca58"), .pid = 9 };
pub const WPD_PARAMETER_ATTRIBUTE_REGULAR_EXPRESSION = PROPERTYKEY{ .fmtid = Guid.initString("e6864dd7-f325-45ea-a1d5-97cf73b6ca58"), .pid = 10 };
pub const WPD_PARAMETER_ATTRIBUTE_MAX_SIZE = PROPERTYKEY{ .fmtid = Guid.initString("e6864dd7-f325-45ea-a1d5-97cf73b6ca58"), .pid = 11 };
pub const WPD_PARAMETER_ATTRIBUTE_VARTYPE = PROPERTYKEY{ .fmtid = Guid.initString("e6864dd7-f325-45ea-a1d5-97cf73b6ca58"), .pid = 12 };
pub const WPD_PARAMETER_ATTRIBUTE_NAME = PROPERTYKEY{ .fmtid = Guid.initString("e6864dd7-f325-45ea-a1d5-97cf73b6ca58"), .pid = 13 };
pub const WPD_CATEGORY_COMMON = Guid.initString("f0422a9c-5dc8-4440-b5bd-5df28835658a");
pub const WPD_COMMAND_COMMON_RESET_DEVICE = PROPERTYKEY{ .fmtid = Guid.initString("f0422a9c-5dc8-4440-b5bd-5df28835658a"), .pid = 2 };
pub const WPD_COMMAND_COMMON_GET_OBJECT_IDS_FROM_PERSISTENT_UNIQUE_IDS = PROPERTYKEY{ .fmtid = Guid.initString("f0422a9c-5dc8-4440-b5bd-5df28835658a"), .pid = 3 };
pub const WPD_COMMAND_COMMON_SAVE_CLIENT_INFORMATION = PROPERTYKEY{ .fmtid = Guid.initString("f0422a9c-5dc8-4440-b5bd-5df28835658a"), .pid = 4 };
pub const WPD_PROPERTY_COMMON_COMMAND_CATEGORY = PROPERTYKEY{ .fmtid = Guid.initString("f0422a9c-5dc8-4440-b5bd-5df28835658a"), .pid = 1001 };
pub const WPD_PROPERTY_COMMON_COMMAND_ID = PROPERTYKEY{ .fmtid = Guid.initString("f0422a9c-5dc8-4440-b5bd-5df28835658a"), .pid = 1002 };
pub const WPD_PROPERTY_COMMON_HRESULT = PROPERTYKEY{ .fmtid = Guid.initString("f0422a9c-5dc8-4440-b5bd-5df28835658a"), .pid = 1003 };
pub const WPD_PROPERTY_COMMON_DRIVER_ERROR_CODE = PROPERTYKEY{ .fmtid = Guid.initString("f0422a9c-5dc8-4440-b5bd-5df28835658a"), .pid = 1004 };
pub const WPD_PROPERTY_COMMON_COMMAND_TARGET = PROPERTYKEY{ .fmtid = Guid.initString("f0422a9c-5dc8-4440-b5bd-5df28835658a"), .pid = 1006 };
pub const WPD_PROPERTY_COMMON_PERSISTENT_UNIQUE_IDS = PROPERTYKEY{ .fmtid = Guid.initString("f0422a9c-5dc8-4440-b5bd-5df28835658a"), .pid = 1007 };
pub const WPD_PROPERTY_COMMON_OBJECT_IDS = PROPERTYKEY{ .fmtid = Guid.initString("f0422a9c-5dc8-4440-b5bd-5df28835658a"), .pid = 1008 };
pub const WPD_PROPERTY_COMMON_CLIENT_INFORMATION = PROPERTYKEY{ .fmtid = Guid.initString("f0422a9c-5dc8-4440-b5bd-5df28835658a"), .pid = 1009 };
pub const WPD_PROPERTY_COMMON_CLIENT_INFORMATION_CONTEXT = PROPERTYKEY{ .fmtid = Guid.initString("f0422a9c-5dc8-4440-b5bd-5df28835658a"), .pid = 1010 };
pub const WPD_PROPERTY_COMMON_ACTIVITY_ID = PROPERTYKEY{ .fmtid = Guid.initString("f0422a9c-5dc8-4440-b5bd-5df28835658a"), .pid = 1011 };
pub const WPD_OPTION_VALID_OBJECT_IDS = PROPERTYKEY{ .fmtid = Guid.initString("f0422a9c-5dc8-4440-b5bd-5df28835658a"), .pid = 5001 };
pub const WPD_CATEGORY_OBJECT_ENUMERATION = Guid.initString("b7474e91-e7f8-4ad9-b400-ad1a4b58eeec");
pub const WPD_COMMAND_OBJECT_ENUMERATION_START_FIND = PROPERTYKEY{ .fmtid = Guid.initString("b7474e91-e7f8-4ad9-b400-ad1a4b58eeec"), .pid = 2 };
pub const WPD_COMMAND_OBJECT_ENUMERATION_FIND_NEXT = PROPERTYKEY{ .fmtid = Guid.initString("b7474e91-e7f8-4ad9-b400-ad1a4b58eeec"), .pid = 3 };
pub const WPD_COMMAND_OBJECT_ENUMERATION_END_FIND = PROPERTYKEY{ .fmtid = Guid.initString("b7474e91-e7f8-4ad9-b400-ad1a4b58eeec"), .pid = 4 };
pub const WPD_PROPERTY_OBJECT_ENUMERATION_PARENT_ID = PROPERTYKEY{ .fmtid = Guid.initString("b7474e91-e7f8-4ad9-b400-ad1a4b58eeec"), .pid = 1001 };
pub const WPD_PROPERTY_OBJECT_ENUMERATION_FILTER = PROPERTYKEY{ .fmtid = Guid.initString("b7474e91-e7f8-4ad9-b400-ad1a4b58eeec"), .pid = 1002 };
pub const WPD_PROPERTY_OBJECT_ENUMERATION_OBJECT_IDS = PROPERTYKEY{ .fmtid = Guid.initString("b7474e91-e7f8-4ad9-b400-ad1a4b58eeec"), .pid = 1003 };
pub const WPD_PROPERTY_OBJECT_ENUMERATION_CONTEXT = PROPERTYKEY{ .fmtid = Guid.initString("b7474e91-e7f8-4ad9-b400-ad1a4b58eeec"), .pid = 1004 };
pub const WPD_PROPERTY_OBJECT_ENUMERATION_NUM_OBJECTS_REQUESTED = PROPERTYKEY{ .fmtid = Guid.initString("b7474e91-e7f8-4ad9-b400-ad1a4b58eeec"), .pid = 1005 };
pub const WPD_CATEGORY_OBJECT_PROPERTIES = Guid.initString("9e5582e4-0814-44e6-981a-b2998d583804");
pub const WPD_COMMAND_OBJECT_PROPERTIES_GET_SUPPORTED = PROPERTYKEY{ .fmtid = Guid.initString("9e5582e4-0814-44e6-981a-b2998d583804"), .pid = 2 };
pub const WPD_COMMAND_OBJECT_PROPERTIES_GET_ATTRIBUTES = PROPERTYKEY{ .fmtid = Guid.initString("9e5582e4-0814-44e6-981a-b2998d583804"), .pid = 3 };
pub const WPD_COMMAND_OBJECT_PROPERTIES_GET = PROPERTYKEY{ .fmtid = Guid.initString("9e5582e4-0814-44e6-981a-b2998d583804"), .pid = 4 };
pub const WPD_COMMAND_OBJECT_PROPERTIES_SET = PROPERTYKEY{ .fmtid = Guid.initString("9e5582e4-0814-44e6-981a-b2998d583804"), .pid = 5 };
pub const WPD_COMMAND_OBJECT_PROPERTIES_GET_ALL = PROPERTYKEY{ .fmtid = Guid.initString("9e5582e4-0814-44e6-981a-b2998d583804"), .pid = 6 };
pub const WPD_COMMAND_OBJECT_PROPERTIES_DELETE = PROPERTYKEY{ .fmtid = Guid.initString("9e5582e4-0814-44e6-981a-b2998d583804"), .pid = 7 };
pub const WPD_PROPERTY_OBJECT_PROPERTIES_OBJECT_ID = PROPERTYKEY{ .fmtid = Guid.initString("9e5582e4-0814-44e6-981a-b2998d583804"), .pid = 1001 };
pub const WPD_PROPERTY_OBJECT_PROPERTIES_PROPERTY_KEYS = PROPERTYKEY{ .fmtid = Guid.initString("9e5582e4-0814-44e6-981a-b2998d583804"), .pid = 1002 };
pub const WPD_PROPERTY_OBJECT_PROPERTIES_PROPERTY_ATTRIBUTES = PROPERTYKEY{ .fmtid = Guid.initString("9e5582e4-0814-44e6-981a-b2998d583804"), .pid = 1003 };
pub const WPD_PROPERTY_OBJECT_PROPERTIES_PROPERTY_VALUES = PROPERTYKEY{ .fmtid = Guid.initString("9e5582e4-0814-44e6-981a-b2998d583804"), .pid = 1004 };
pub const WPD_PROPERTY_OBJECT_PROPERTIES_PROPERTY_WRITE_RESULTS = PROPERTYKEY{ .fmtid = Guid.initString("9e5582e4-0814-44e6-981a-b2998d583804"), .pid = 1005 };
pub const WPD_PROPERTY_OBJECT_PROPERTIES_PROPERTY_DELETE_RESULTS = PROPERTYKEY{ .fmtid = Guid.initString("9e5582e4-0814-44e6-981a-b2998d583804"), .pid = 1006 };
pub const WPD_CATEGORY_OBJECT_PROPERTIES_BULK = Guid.initString("11c824dd-04cd-4e4e-8c7b-f6efb794d84e");
pub const WPD_COMMAND_OBJECT_PROPERTIES_BULK_GET_VALUES_BY_OBJECT_LIST_START = PROPERTYKEY{ .fmtid = Guid.initString("11c824dd-04cd-4e4e-8c7b-f6efb794d84e"), .pid = 2 };
pub const WPD_COMMAND_OBJECT_PROPERTIES_BULK_GET_VALUES_BY_OBJECT_LIST_NEXT = PROPERTYKEY{ .fmtid = Guid.initString("11c824dd-04cd-4e4e-8c7b-f6efb794d84e"), .pid = 3 };
pub const WPD_COMMAND_OBJECT_PROPERTIES_BULK_GET_VALUES_BY_OBJECT_LIST_END = PROPERTYKEY{ .fmtid = Guid.initString("11c824dd-04cd-4e4e-8c7b-f6efb794d84e"), .pid = 4 };
pub const WPD_COMMAND_OBJECT_PROPERTIES_BULK_GET_VALUES_BY_OBJECT_FORMAT_START = PROPERTYKEY{ .fmtid = Guid.initString("11c824dd-04cd-4e4e-8c7b-f6efb794d84e"), .pid = 5 };
pub const WPD_COMMAND_OBJECT_PROPERTIES_BULK_GET_VALUES_BY_OBJECT_FORMAT_NEXT = PROPERTYKEY{ .fmtid = Guid.initString("11c824dd-04cd-4e4e-8c7b-f6efb794d84e"), .pid = 6 };
pub const WPD_COMMAND_OBJECT_PROPERTIES_BULK_GET_VALUES_BY_OBJECT_FORMAT_END = PROPERTYKEY{ .fmtid = Guid.initString("11c824dd-04cd-4e4e-8c7b-f6efb794d84e"), .pid = 7 };
pub const WPD_COMMAND_OBJECT_PROPERTIES_BULK_SET_VALUES_BY_OBJECT_LIST_START = PROPERTYKEY{ .fmtid = Guid.initString("11c824dd-04cd-4e4e-8c7b-f6efb794d84e"), .pid = 8 };
pub const WPD_COMMAND_OBJECT_PROPERTIES_BULK_SET_VALUES_BY_OBJECT_LIST_NEXT = PROPERTYKEY{ .fmtid = Guid.initString("11c824dd-04cd-4e4e-8c7b-f6efb794d84e"), .pid = 9 };
pub const WPD_COMMAND_OBJECT_PROPERTIES_BULK_SET_VALUES_BY_OBJECT_LIST_END = PROPERTYKEY{ .fmtid = Guid.initString("11c824dd-04cd-4e4e-8c7b-f6efb794d84e"), .pid = 10 };
pub const WPD_PROPERTY_OBJECT_PROPERTIES_BULK_OBJECT_IDS = PROPERTYKEY{ .fmtid = Guid.initString("11c824dd-04cd-4e4e-8c7b-f6efb794d84e"), .pid = 1001 };
pub const WPD_PROPERTY_OBJECT_PROPERTIES_BULK_CONTEXT = PROPERTYKEY{ .fmtid = Guid.initString("11c824dd-04cd-4e4e-8c7b-f6efb794d84e"), .pid = 1002 };
pub const WPD_PROPERTY_OBJECT_PROPERTIES_BULK_VALUES = PROPERTYKEY{ .fmtid = Guid.initString("11c824dd-04cd-4e4e-8c7b-f6efb794d84e"), .pid = 1003 };
pub const WPD_PROPERTY_OBJECT_PROPERTIES_BULK_PROPERTY_KEYS = PROPERTYKEY{ .fmtid = Guid.initString("11c824dd-04cd-4e4e-8c7b-f6efb794d84e"), .pid = 1004 };
pub const WPD_PROPERTY_OBJECT_PROPERTIES_BULK_DEPTH = PROPERTYKEY{ .fmtid = Guid.initString("11c824dd-04cd-4e4e-8c7b-f6efb794d84e"), .pid = 1005 };
pub const WPD_PROPERTY_OBJECT_PROPERTIES_BULK_PARENT_OBJECT_ID = PROPERTYKEY{ .fmtid = Guid.initString("11c824dd-04cd-4e4e-8c7b-f6efb794d84e"), .pid = 1006 };
pub const WPD_PROPERTY_OBJECT_PROPERTIES_BULK_OBJECT_FORMAT = PROPERTYKEY{ .fmtid = Guid.initString("11c824dd-04cd-4e4e-8c7b-f6efb794d84e"), .pid = 1007 };
pub const WPD_PROPERTY_OBJECT_PROPERTIES_BULK_WRITE_RESULTS = PROPERTYKEY{ .fmtid = Guid.initString("11c824dd-04cd-4e4e-8c7b-f6efb794d84e"), .pid = 1008 };
pub const WPD_CATEGORY_OBJECT_RESOURCES = Guid.initString("b3a2b22d-a595-4108-be0a-fc3c965f3d4a");
pub const WPD_COMMAND_OBJECT_RESOURCES_GET_SUPPORTED = PROPERTYKEY{ .fmtid = Guid.initString("b3a2b22d-a595-4108-be0a-fc3c965f3d4a"), .pid = 2 };
pub const WPD_COMMAND_OBJECT_RESOURCES_GET_ATTRIBUTES = PROPERTYKEY{ .fmtid = Guid.initString("b3a2b22d-a595-4108-be0a-fc3c965f3d4a"), .pid = 3 };
pub const WPD_COMMAND_OBJECT_RESOURCES_OPEN = PROPERTYKEY{ .fmtid = Guid.initString("b3a2b22d-a595-4108-be0a-fc3c965f3d4a"), .pid = 4 };
pub const WPD_COMMAND_OBJECT_RESOURCES_READ = PROPERTYKEY{ .fmtid = Guid.initString("b3a2b22d-a595-4108-be0a-fc3c965f3d4a"), .pid = 5 };
pub const WPD_COMMAND_OBJECT_RESOURCES_WRITE = PROPERTYKEY{ .fmtid = Guid.initString("b3a2b22d-a595-4108-be0a-fc3c965f3d4a"), .pid = 6 };
pub const WPD_COMMAND_OBJECT_RESOURCES_CLOSE = PROPERTYKEY{ .fmtid = Guid.initString("b3a2b22d-a595-4108-be0a-fc3c965f3d4a"), .pid = 7 };
pub const WPD_COMMAND_OBJECT_RESOURCES_DELETE = PROPERTYKEY{ .fmtid = Guid.initString("b3a2b22d-a595-4108-be0a-fc3c965f3d4a"), .pid = 8 };
pub const WPD_COMMAND_OBJECT_RESOURCES_CREATE_RESOURCE = PROPERTYKEY{ .fmtid = Guid.initString("b3a2b22d-a595-4108-be0a-fc3c965f3d4a"), .pid = 9 };
pub const WPD_COMMAND_OBJECT_RESOURCES_REVERT = PROPERTYKEY{ .fmtid = Guid.initString("b3a2b22d-a595-4108-be0a-fc3c965f3d4a"), .pid = 10 };
pub const WPD_COMMAND_OBJECT_RESOURCES_SEEK = PROPERTYKEY{ .fmtid = Guid.initString("b3a2b22d-a595-4108-be0a-fc3c965f3d4a"), .pid = 11 };
pub const WPD_COMMAND_OBJECT_RESOURCES_COMMIT = PROPERTYKEY{ .fmtid = Guid.initString("b3a2b22d-a595-4108-be0a-fc3c965f3d4a"), .pid = 12 };
pub const WPD_COMMAND_OBJECT_RESOURCES_SEEK_IN_UNITS = PROPERTYKEY{ .fmtid = Guid.initString("b3a2b22d-a595-4108-be0a-fc3c965f3d4a"), .pid = 13 };
pub const WPD_PROPERTY_OBJECT_RESOURCES_OBJECT_ID = PROPERTYKEY{ .fmtid = Guid.initString("b3a2b22d-a595-4108-be0a-fc3c965f3d4a"), .pid = 1001 };
pub const WPD_PROPERTY_OBJECT_RESOURCES_ACCESS_MODE = PROPERTYKEY{ .fmtid = Guid.initString("b3a2b22d-a595-4108-be0a-fc3c965f3d4a"), .pid = 1002 };
pub const WPD_PROPERTY_OBJECT_RESOURCES_RESOURCE_KEYS = PROPERTYKEY{ .fmtid = Guid.initString("b3a2b22d-a595-4108-be0a-fc3c965f3d4a"), .pid = 1003 };
pub const WPD_PROPERTY_OBJECT_RESOURCES_RESOURCE_ATTRIBUTES = PROPERTYKEY{ .fmtid = Guid.initString("b3a2b22d-a595-4108-be0a-fc3c965f3d4a"), .pid = 1004 };
pub const WPD_PROPERTY_OBJECT_RESOURCES_CONTEXT = PROPERTYKEY{ .fmtid = Guid.initString("b3a2b22d-a595-4108-be0a-fc3c965f3d4a"), .pid = 1005 };
pub const WPD_PROPERTY_OBJECT_RESOURCES_NUM_BYTES_TO_READ = PROPERTYKEY{ .fmtid = Guid.initString("b3a2b22d-a595-4108-be0a-fc3c965f3d4a"), .pid = 1006 };
pub const WPD_PROPERTY_OBJECT_RESOURCES_NUM_BYTES_READ = PROPERTYKEY{ .fmtid = Guid.initString("b3a2b22d-a595-4108-be0a-fc3c965f3d4a"), .pid = 1007 };
pub const WPD_PROPERTY_OBJECT_RESOURCES_NUM_BYTES_TO_WRITE = PROPERTYKEY{ .fmtid = Guid.initString("b3a2b22d-a595-4108-be0a-fc3c965f3d4a"), .pid = 1008 };
pub const WPD_PROPERTY_OBJECT_RESOURCES_NUM_BYTES_WRITTEN = PROPERTYKEY{ .fmtid = Guid.initString("b3a2b22d-a595-4108-be0a-fc3c965f3d4a"), .pid = 1009 };
pub const WPD_PROPERTY_OBJECT_RESOURCES_DATA = PROPERTYKEY{ .fmtid = Guid.initString("b3a2b22d-a595-4108-be0a-fc3c965f3d4a"), .pid = 1010 };
pub const WPD_PROPERTY_OBJECT_RESOURCES_OPTIMAL_TRANSFER_BUFFER_SIZE = PROPERTYKEY{ .fmtid = Guid.initString("b3a2b22d-a595-4108-be0a-fc3c965f3d4a"), .pid = 1011 };
pub const WPD_PROPERTY_OBJECT_RESOURCES_SEEK_OFFSET = PROPERTYKEY{ .fmtid = Guid.initString("b3a2b22d-a595-4108-be0a-fc3c965f3d4a"), .pid = 1012 };
pub const WPD_PROPERTY_OBJECT_RESOURCES_SEEK_ORIGIN_FLAG = PROPERTYKEY{ .fmtid = Guid.initString("b3a2b22d-a595-4108-be0a-fc3c965f3d4a"), .pid = 1013 };
pub const WPD_PROPERTY_OBJECT_RESOURCES_POSITION_FROM_START = PROPERTYKEY{ .fmtid = Guid.initString("b3a2b22d-a595-4108-be0a-fc3c965f3d4a"), .pid = 1014 };
pub const WPD_PROPERTY_OBJECT_RESOURCES_SUPPORTS_UNITS = PROPERTYKEY{ .fmtid = Guid.initString("b3a2b22d-a595-4108-be0a-fc3c965f3d4a"), .pid = 1015 };
pub const WPD_PROPERTY_OBJECT_RESOURCES_STREAM_UNITS = PROPERTYKEY{ .fmtid = Guid.initString("b3a2b22d-a595-4108-be0a-fc3c965f3d4a"), .pid = 1016 };
pub const WPD_OPTION_OBJECT_RESOURCES_SEEK_ON_READ_SUPPORTED = PROPERTYKEY{ .fmtid = Guid.initString("b3a2b22d-a595-4108-be0a-fc3c965f3d4a"), .pid = 5001 };
pub const WPD_OPTION_OBJECT_RESOURCES_SEEK_ON_WRITE_SUPPORTED = PROPERTYKEY{ .fmtid = Guid.initString("b3a2b22d-a595-4108-be0a-fc3c965f3d4a"), .pid = 5002 };
pub const WPD_OPTION_OBJECT_RESOURCES_NO_INPUT_BUFFER_ON_READ = PROPERTYKEY{ .fmtid = Guid.initString("b3a2b22d-a595-4108-be0a-fc3c965f3d4a"), .pid = 5003 };
pub const WPD_CATEGORY_OBJECT_MANAGEMENT = Guid.initString("ef1e43dd-a9ed-4341-8bcc-186192aea089");
pub const WPD_COMMAND_OBJECT_MANAGEMENT_CREATE_OBJECT_WITH_PROPERTIES_ONLY = PROPERTYKEY{ .fmtid = Guid.initString("ef1e43dd-a9ed-4341-8bcc-186192aea089"), .pid = 2 };
pub const WPD_COMMAND_OBJECT_MANAGEMENT_CREATE_OBJECT_WITH_PROPERTIES_AND_DATA = PROPERTYKEY{ .fmtid = Guid.initString("ef1e43dd-a9ed-4341-8bcc-186192aea089"), .pid = 3 };
pub const WPD_COMMAND_OBJECT_MANAGEMENT_WRITE_OBJECT_DATA = PROPERTYKEY{ .fmtid = Guid.initString("ef1e43dd-a9ed-4341-8bcc-186192aea089"), .pid = 4 };
pub const WPD_COMMAND_OBJECT_MANAGEMENT_COMMIT_OBJECT = PROPERTYKEY{ .fmtid = Guid.initString("ef1e43dd-a9ed-4341-8bcc-186192aea089"), .pid = 5 };
pub const WPD_COMMAND_OBJECT_MANAGEMENT_REVERT_OBJECT = PROPERTYKEY{ .fmtid = Guid.initString("ef1e43dd-a9ed-4341-8bcc-186192aea089"), .pid = 6 };
pub const WPD_COMMAND_OBJECT_MANAGEMENT_DELETE_OBJECTS = PROPERTYKEY{ .fmtid = Guid.initString("ef1e43dd-a9ed-4341-8bcc-186192aea089"), .pid = 7 };
pub const WPD_COMMAND_OBJECT_MANAGEMENT_MOVE_OBJECTS = PROPERTYKEY{ .fmtid = Guid.initString("ef1e43dd-a9ed-4341-8bcc-186192aea089"), .pid = 8 };
pub const WPD_COMMAND_OBJECT_MANAGEMENT_COPY_OBJECTS = PROPERTYKEY{ .fmtid = Guid.initString("ef1e43dd-a9ed-4341-8bcc-186192aea089"), .pid = 9 };
pub const WPD_COMMAND_OBJECT_MANAGEMENT_UPDATE_OBJECT_WITH_PROPERTIES_AND_DATA = PROPERTYKEY{ .fmtid = Guid.initString("ef1e43dd-a9ed-4341-8bcc-186192aea089"), .pid = 10 };
pub const WPD_PROPERTY_OBJECT_MANAGEMENT_CREATION_PROPERTIES = PROPERTYKEY{ .fmtid = Guid.initString("ef1e43dd-a9ed-4341-8bcc-186192aea089"), .pid = 1001 };
pub const WPD_PROPERTY_OBJECT_MANAGEMENT_CONTEXT = PROPERTYKEY{ .fmtid = Guid.initString("ef1e43dd-a9ed-4341-8bcc-186192aea089"), .pid = 1002 };
pub const WPD_PROPERTY_OBJECT_MANAGEMENT_NUM_BYTES_TO_WRITE = PROPERTYKEY{ .fmtid = Guid.initString("ef1e43dd-a9ed-4341-8bcc-186192aea089"), .pid = 1003 };
pub const WPD_PROPERTY_OBJECT_MANAGEMENT_NUM_BYTES_WRITTEN = PROPERTYKEY{ .fmtid = Guid.initString("ef1e43dd-a9ed-4341-8bcc-186192aea089"), .pid = 1004 };
pub const WPD_PROPERTY_OBJECT_MANAGEMENT_DATA = PROPERTYKEY{ .fmtid = Guid.initString("ef1e43dd-a9ed-4341-8bcc-186192aea089"), .pid = 1005 };
pub const WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_ID = PROPERTYKEY{ .fmtid = Guid.initString("ef1e43dd-a9ed-4341-8bcc-186192aea089"), .pid = 1006 };
pub const WPD_PROPERTY_OBJECT_MANAGEMENT_DELETE_OPTIONS = PROPERTYKEY{ .fmtid = Guid.initString("ef1e43dd-a9ed-4341-8bcc-186192aea089"), .pid = 1007 };
pub const WPD_PROPERTY_OBJECT_MANAGEMENT_OPTIMAL_TRANSFER_BUFFER_SIZE = PROPERTYKEY{ .fmtid = Guid.initString("ef1e43dd-a9ed-4341-8bcc-186192aea089"), .pid = 1008 };
pub const WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_IDS = PROPERTYKEY{ .fmtid = Guid.initString("ef1e43dd-a9ed-4341-8bcc-186192aea089"), .pid = 1009 };
pub const WPD_PROPERTY_OBJECT_MANAGEMENT_DELETE_RESULTS = PROPERTYKEY{ .fmtid = Guid.initString("ef1e43dd-a9ed-4341-8bcc-186192aea089"), .pid = 1010 };
pub const WPD_PROPERTY_OBJECT_MANAGEMENT_DESTINATION_FOLDER_OBJECT_ID = PROPERTYKEY{ .fmtid = Guid.initString("ef1e43dd-a9ed-4341-8bcc-186192aea089"), .pid = 1011 };
pub const WPD_PROPERTY_OBJECT_MANAGEMENT_MOVE_RESULTS = PROPERTYKEY{ .fmtid = Guid.initString("ef1e43dd-a9ed-4341-8bcc-186192aea089"), .pid = 1012 };
pub const WPD_PROPERTY_OBJECT_MANAGEMENT_COPY_RESULTS = PROPERTYKEY{ .fmtid = Guid.initString("ef1e43dd-a9ed-4341-8bcc-186192aea089"), .pid = 1013 };
pub const WPD_PROPERTY_OBJECT_MANAGEMENT_UPDATE_PROPERTIES = PROPERTYKEY{ .fmtid = Guid.initString("ef1e43dd-a9ed-4341-8bcc-186192aea089"), .pid = 1014 };
pub const WPD_PROPERTY_OBJECT_MANAGEMENT_PROPERTY_KEYS = PROPERTYKEY{ .fmtid = Guid.initString("ef1e43dd-a9ed-4341-8bcc-186192aea089"), .pid = 1015 };
pub const WPD_PROPERTY_OBJECT_MANAGEMENT_OBJECT_FORMAT = PROPERTYKEY{ .fmtid = Guid.initString("ef1e43dd-a9ed-4341-8bcc-186192aea089"), .pid = 1016 };
pub const WPD_OPTION_OBJECT_MANAGEMENT_RECURSIVE_DELETE_SUPPORTED = PROPERTYKEY{ .fmtid = Guid.initString("ef1e43dd-a9ed-4341-8bcc-186192aea089"), .pid = 5001 };
pub const WPD_CATEGORY_CAPABILITIES = Guid.initString("0cabec78-6b74-41c6-9216-2639d1fce356");
pub const WPD_COMMAND_CAPABILITIES_GET_SUPPORTED_COMMANDS = PROPERTYKEY{ .fmtid = Guid.initString("0cabec78-6b74-41c6-9216-2639d1fce356"), .pid = 2 };
pub const WPD_COMMAND_CAPABILITIES_GET_COMMAND_OPTIONS = PROPERTYKEY{ .fmtid = Guid.initString("0cabec78-6b74-41c6-9216-2639d1fce356"), .pid = 3 };
pub const WPD_COMMAND_CAPABILITIES_GET_SUPPORTED_FUNCTIONAL_CATEGORIES = PROPERTYKEY{ .fmtid = Guid.initString("0cabec78-6b74-41c6-9216-2639d1fce356"), .pid = 4 };
pub const WPD_COMMAND_CAPABILITIES_GET_FUNCTIONAL_OBJECTS = PROPERTYKEY{ .fmtid = Guid.initString("0cabec78-6b74-41c6-9216-2639d1fce356"), .pid = 5 };
pub const WPD_COMMAND_CAPABILITIES_GET_SUPPORTED_CONTENT_TYPES = PROPERTYKEY{ .fmtid = Guid.initString("0cabec78-6b74-41c6-9216-2639d1fce356"), .pid = 6 };
pub const WPD_COMMAND_CAPABILITIES_GET_SUPPORTED_FORMATS = PROPERTYKEY{ .fmtid = Guid.initString("0cabec78-6b74-41c6-9216-2639d1fce356"), .pid = 7 };
pub const WPD_COMMAND_CAPABILITIES_GET_SUPPORTED_FORMAT_PROPERTIES = PROPERTYKEY{ .fmtid = Guid.initString("0cabec78-6b74-41c6-9216-2639d1fce356"), .pid = 8 };
pub const WPD_COMMAND_CAPABILITIES_GET_FIXED_PROPERTY_ATTRIBUTES = PROPERTYKEY{ .fmtid = Guid.initString("0cabec78-6b74-41c6-9216-2639d1fce356"), .pid = 9 };
pub const WPD_COMMAND_CAPABILITIES_GET_SUPPORTED_EVENTS = PROPERTYKEY{ .fmtid = Guid.initString("0cabec78-6b74-41c6-9216-2639d1fce356"), .pid = 10 };
pub const WPD_COMMAND_CAPABILITIES_GET_EVENT_OPTIONS = PROPERTYKEY{ .fmtid = Guid.initString("0cabec78-6b74-41c6-9216-2639d1fce356"), .pid = 11 };
pub const WPD_PROPERTY_CAPABILITIES_SUPPORTED_COMMANDS = PROPERTYKEY{ .fmtid = Guid.initString("0cabec78-6b74-41c6-9216-2639d1fce356"), .pid = 1001 };
pub const WPD_PROPERTY_CAPABILITIES_COMMAND = PROPERTYKEY{ .fmtid = Guid.initString("0cabec78-6b74-41c6-9216-2639d1fce356"), .pid = 1002 };
pub const WPD_PROPERTY_CAPABILITIES_COMMAND_OPTIONS = PROPERTYKEY{ .fmtid = Guid.initString("0cabec78-6b74-41c6-9216-2639d1fce356"), .pid = 1003 };
pub const WPD_PROPERTY_CAPABILITIES_FUNCTIONAL_CATEGORIES = PROPERTYKEY{ .fmtid = Guid.initString("0cabec78-6b74-41c6-9216-2639d1fce356"), .pid = 1004 };
pub const WPD_PROPERTY_CAPABILITIES_FUNCTIONAL_CATEGORY = PROPERTYKEY{ .fmtid = Guid.initString("0cabec78-6b74-41c6-9216-2639d1fce356"), .pid = 1005 };
pub const WPD_PROPERTY_CAPABILITIES_FUNCTIONAL_OBJECTS = PROPERTYKEY{ .fmtid = Guid.initString("0cabec78-6b74-41c6-9216-2639d1fce356"), .pid = 1006 };
pub const WPD_PROPERTY_CAPABILITIES_CONTENT_TYPES = PROPERTYKEY{ .fmtid = Guid.initString("0cabec78-6b74-41c6-9216-2639d1fce356"), .pid = 1007 };
pub const WPD_PROPERTY_CAPABILITIES_CONTENT_TYPE = PROPERTYKEY{ .fmtid = Guid.initString("0cabec78-6b74-41c6-9216-2639d1fce356"), .pid = 1008 };
pub const WPD_PROPERTY_CAPABILITIES_FORMATS = PROPERTYKEY{ .fmtid = Guid.initString("0cabec78-6b74-41c6-9216-2639d1fce356"), .pid = 1009 };
pub const WPD_PROPERTY_CAPABILITIES_FORMAT = PROPERTYKEY{ .fmtid = Guid.initString("0cabec78-6b74-41c6-9216-2639d1fce356"), .pid = 1010 };
pub const WPD_PROPERTY_CAPABILITIES_PROPERTY_KEYS = PROPERTYKEY{ .fmtid = Guid.initString("0cabec78-6b74-41c6-9216-2639d1fce356"), .pid = 1011 };
pub const WPD_PROPERTY_CAPABILITIES_PROPERTY_ATTRIBUTES = PROPERTYKEY{ .fmtid = Guid.initString("0cabec78-6b74-41c6-9216-2639d1fce356"), .pid = 1012 };
pub const WPD_PROPERTY_CAPABILITIES_SUPPORTED_EVENTS = PROPERTYKEY{ .fmtid = Guid.initString("0cabec78-6b74-41c6-9216-2639d1fce356"), .pid = 1013 };
pub const WPD_PROPERTY_CAPABILITIES_EVENT = PROPERTYKEY{ .fmtid = Guid.initString("0cabec78-6b74-41c6-9216-2639d1fce356"), .pid = 1014 };
pub const WPD_PROPERTY_CAPABILITIES_EVENT_OPTIONS = PROPERTYKEY{ .fmtid = Guid.initString("0cabec78-6b74-41c6-9216-2639d1fce356"), .pid = 1015 };
pub const WPD_CATEGORY_STORAGE = Guid.initString("d8f907a6-34cc-45fa-97fb-d007fa47ec94");
pub const WPD_COMMAND_STORAGE_FORMAT = PROPERTYKEY{ .fmtid = Guid.initString("d8f907a6-34cc-45fa-97fb-d007fa47ec94"), .pid = 2 };
pub const WPD_COMMAND_STORAGE_EJECT = PROPERTYKEY{ .fmtid = Guid.initString("d8f907a6-34cc-45fa-97fb-d007fa47ec94"), .pid = 4 };
pub const WPD_PROPERTY_STORAGE_OBJECT_ID = PROPERTYKEY{ .fmtid = Guid.initString("d8f907a6-34cc-45fa-97fb-d007fa47ec94"), .pid = 1001 };
pub const WPD_PROPERTY_STORAGE_DESTINATION_OBJECT_ID = PROPERTYKEY{ .fmtid = Guid.initString("d8f907a6-34cc-45fa-97fb-d007fa47ec94"), .pid = 1002 };
pub const WPD_CATEGORY_SMS = Guid.initString("afc25d66-fe0d-4114-9097-970c93e920d1");
pub const WPD_COMMAND_SMS_SEND = PROPERTYKEY{ .fmtid = Guid.initString("afc25d66-fe0d-4114-9097-970c93e920d1"), .pid = 2 };
pub const WPD_PROPERTY_SMS_RECIPIENT = PROPERTYKEY{ .fmtid = Guid.initString("afc25d66-fe0d-4114-9097-970c93e920d1"), .pid = 1001 };
pub const WPD_PROPERTY_SMS_MESSAGE_TYPE = PROPERTYKEY{ .fmtid = Guid.initString("afc25d66-fe0d-4114-9097-970c93e920d1"), .pid = 1002 };
pub const WPD_PROPERTY_SMS_TEXT_MESSAGE = PROPERTYKEY{ .fmtid = Guid.initString("afc25d66-fe0d-4114-9097-970c93e920d1"), .pid = 1003 };
pub const WPD_PROPERTY_SMS_BINARY_MESSAGE = PROPERTYKEY{ .fmtid = Guid.initString("afc25d66-fe0d-4114-9097-970c93e920d1"), .pid = 1004 };
pub const WPD_OPTION_SMS_BINARY_MESSAGE_SUPPORTED = PROPERTYKEY{ .fmtid = Guid.initString("afc25d66-fe0d-4114-9097-970c93e920d1"), .pid = 5001 };
pub const WPD_CATEGORY_STILL_IMAGE_CAPTURE = Guid.initString("4fcd6982-22a2-4b05-a48b-62d38bf27b32");
pub const WPD_COMMAND_STILL_IMAGE_CAPTURE_INITIATE = PROPERTYKEY{ .fmtid = Guid.initString("4fcd6982-22a2-4b05-a48b-62d38bf27b32"), .pid = 2 };
pub const WPD_CATEGORY_MEDIA_CAPTURE = Guid.initString("59b433ba-fe44-4d8d-808c-6bcb9b0f15e8");
pub const WPD_COMMAND_MEDIA_CAPTURE_START = PROPERTYKEY{ .fmtid = Guid.initString("59b433ba-fe44-4d8d-808c-6bcb9b0f15e8"), .pid = 2 };
pub const WPD_COMMAND_MEDIA_CAPTURE_STOP = PROPERTYKEY{ .fmtid = Guid.initString("59b433ba-fe44-4d8d-808c-6bcb9b0f15e8"), .pid = 3 };
pub const WPD_COMMAND_MEDIA_CAPTURE_PAUSE = PROPERTYKEY{ .fmtid = Guid.initString("59b433ba-fe44-4d8d-808c-6bcb9b0f15e8"), .pid = 4 };
pub const WPD_CATEGORY_DEVICE_HINTS = Guid.initString("0d5fb92b-cb46-4c4f-8343-0bc3d3f17c84");
pub const WPD_COMMAND_DEVICE_HINTS_GET_CONTENT_LOCATION = PROPERTYKEY{ .fmtid = Guid.initString("0d5fb92b-cb46-4c4f-8343-0bc3d3f17c84"), .pid = 2 };
pub const WPD_PROPERTY_DEVICE_HINTS_CONTENT_TYPE = PROPERTYKEY{ .fmtid = Guid.initString("0d5fb92b-cb46-4c4f-8343-0bc3d3f17c84"), .pid = 1001 };
pub const WPD_PROPERTY_DEVICE_HINTS_CONTENT_LOCATIONS = PROPERTYKEY{ .fmtid = Guid.initString("0d5fb92b-cb46-4c4f-8343-0bc3d3f17c84"), .pid = 1002 };
pub const WPD_CLASS_EXTENSION_V1 = Guid.initString("33fb0d11-64a3-4fac-b4c7-3dfeaa99b051");
pub const WPD_COMMAND_CLASS_EXTENSION_WRITE_DEVICE_INFORMATION = PROPERTYKEY{ .fmtid = Guid.initString("33fb0d11-64a3-4fac-b4c7-3dfeaa99b051"), .pid = 2 };
pub const WPD_PROPERTY_CLASS_EXTENSION_DEVICE_INFORMATION_VALUES = PROPERTYKEY{ .fmtid = Guid.initString("33fb0d11-64a3-4fac-b4c7-3dfeaa99b051"), .pid = 1001 };
pub const WPD_PROPERTY_CLASS_EXTENSION_DEVICE_INFORMATION_WRITE_RESULTS = PROPERTYKEY{ .fmtid = Guid.initString("33fb0d11-64a3-4fac-b4c7-3dfeaa99b051"), .pid = 1002 };
pub const WPD_CLASS_EXTENSION_V2 = Guid.initString("7f0779b5-fa2b-4766-9cb2-f73ba30b6758");
pub const WPD_COMMAND_CLASS_EXTENSION_REGISTER_SERVICE_INTERFACES = PROPERTYKEY{ .fmtid = Guid.initString("7f0779b5-fa2b-4766-9cb2-f73ba30b6758"), .pid = 2 };
pub const WPD_COMMAND_CLASS_EXTENSION_UNREGISTER_SERVICE_INTERFACES = PROPERTYKEY{ .fmtid = Guid.initString("7f0779b5-fa2b-4766-9cb2-f73ba30b6758"), .pid = 3 };
pub const WPD_PROPERTY_CLASS_EXTENSION_SERVICE_OBJECT_ID = PROPERTYKEY{ .fmtid = Guid.initString("7f0779b5-fa2b-4766-9cb2-f73ba30b6758"), .pid = 1001 };
pub const WPD_PROPERTY_CLASS_EXTENSION_SERVICE_INTERFACES = PROPERTYKEY{ .fmtid = Guid.initString("7f0779b5-fa2b-4766-9cb2-f73ba30b6758"), .pid = 1002 };
pub const WPD_PROPERTY_CLASS_EXTENSION_SERVICE_REGISTRATION_RESULTS = PROPERTYKEY{ .fmtid = Guid.initString("7f0779b5-fa2b-4766-9cb2-f73ba30b6758"), .pid = 1003 };
pub const WPD_CATEGORY_NETWORK_CONFIGURATION = Guid.initString("78f9c6fc-79b8-473c-9060-6bd23dd072c4");
pub const WPD_COMMAND_GENERATE_KEYPAIR = PROPERTYKEY{ .fmtid = Guid.initString("78f9c6fc-79b8-473c-9060-6bd23dd072c4"), .pid = 2 };
pub const WPD_COMMAND_COMMIT_KEYPAIR = PROPERTYKEY{ .fmtid = Guid.initString("78f9c6fc-79b8-473c-9060-6bd23dd072c4"), .pid = 3 };
pub const WPD_COMMAND_PROCESS_WIRELESS_PROFILE = PROPERTYKEY{ .fmtid = Guid.initString("78f9c6fc-79b8-473c-9060-6bd23dd072c4"), .pid = 4 };
pub const WPD_PROPERTY_PUBLIC_KEY = PROPERTYKEY{ .fmtid = Guid.initString("78f9c6fc-79b8-473c-9060-6bd23dd072c4"), .pid = 1001 };
pub const WPD_CATEGORY_SERVICE_COMMON = Guid.initString("322f071d-36ef-477f-b4b5-6f52d734baee");
pub const WPD_COMMAND_SERVICE_COMMON_GET_SERVICE_OBJECT_ID = PROPERTYKEY{ .fmtid = Guid.initString("322f071d-36ef-477f-b4b5-6f52d734baee"), .pid = 2 };
pub const WPD_PROPERTY_SERVICE_OBJECT_ID = PROPERTYKEY{ .fmtid = Guid.initString("322f071d-36ef-477f-b4b5-6f52d734baee"), .pid = 1001 };
pub const WPD_CATEGORY_SERVICE_CAPABILITIES = Guid.initString("24457e74-2e9f-44f9-8c57-1d1bcb170b89");
pub const WPD_COMMAND_SERVICE_CAPABILITIES_GET_SUPPORTED_METHODS = PROPERTYKEY{ .fmtid = Guid.initString("24457e74-2e9f-44f9-8c57-1d1bcb170b89"), .pid = 2 };
pub const WPD_COMMAND_SERVICE_CAPABILITIES_GET_SUPPORTED_METHODS_BY_FORMAT = PROPERTYKEY{ .fmtid = Guid.initString("24457e74-2e9f-44f9-8c57-1d1bcb170b89"), .pid = 3 };
pub const WPD_COMMAND_SERVICE_CAPABILITIES_GET_METHOD_ATTRIBUTES = PROPERTYKEY{ .fmtid = Guid.initString("24457e74-2e9f-44f9-8c57-1d1bcb170b89"), .pid = 4 };
pub const WPD_COMMAND_SERVICE_CAPABILITIES_GET_METHOD_PARAMETER_ATTRIBUTES = PROPERTYKEY{ .fmtid = Guid.initString("24457e74-2e9f-44f9-8c57-1d1bcb170b89"), .pid = 5 };
pub const WPD_COMMAND_SERVICE_CAPABILITIES_GET_SUPPORTED_FORMATS = PROPERTYKEY{ .fmtid = Guid.initString("24457e74-2e9f-44f9-8c57-1d1bcb170b89"), .pid = 6 };
pub const WPD_COMMAND_SERVICE_CAPABILITIES_GET_FORMAT_ATTRIBUTES = PROPERTYKEY{ .fmtid = Guid.initString("24457e74-2e9f-44f9-8c57-1d1bcb170b89"), .pid = 7 };
pub const WPD_COMMAND_SERVICE_CAPABILITIES_GET_SUPPORTED_FORMAT_PROPERTIES = PROPERTYKEY{ .fmtid = Guid.initString("24457e74-2e9f-44f9-8c57-1d1bcb170b89"), .pid = 8 };
pub const WPD_COMMAND_SERVICE_CAPABILITIES_GET_FORMAT_PROPERTY_ATTRIBUTES = PROPERTYKEY{ .fmtid = Guid.initString("24457e74-2e9f-44f9-8c57-1d1bcb170b89"), .pid = 9 };
pub const WPD_COMMAND_SERVICE_CAPABILITIES_GET_SUPPORTED_EVENTS = PROPERTYKEY{ .fmtid = Guid.initString("24457e74-2e9f-44f9-8c57-1d1bcb170b89"), .pid = 10 };
pub const WPD_COMMAND_SERVICE_CAPABILITIES_GET_EVENT_ATTRIBUTES = PROPERTYKEY{ .fmtid = Guid.initString("24457e74-2e9f-44f9-8c57-1d1bcb170b89"), .pid = 11 };
pub const WPD_COMMAND_SERVICE_CAPABILITIES_GET_EVENT_PARAMETER_ATTRIBUTES = PROPERTYKEY{ .fmtid = Guid.initString("24457e74-2e9f-44f9-8c57-1d1bcb170b89"), .pid = 12 };
pub const WPD_COMMAND_SERVICE_CAPABILITIES_GET_INHERITED_SERVICES = PROPERTYKEY{ .fmtid = Guid.initString("24457e74-2e9f-44f9-8c57-1d1bcb170b89"), .pid = 13 };
pub const WPD_COMMAND_SERVICE_CAPABILITIES_GET_FORMAT_RENDERING_PROFILES = PROPERTYKEY{ .fmtid = Guid.initString("24457e74-2e9f-44f9-8c57-1d1bcb170b89"), .pid = 14 };
pub const WPD_COMMAND_SERVICE_CAPABILITIES_GET_SUPPORTED_COMMANDS = PROPERTYKEY{ .fmtid = Guid.initString("24457e74-2e9f-44f9-8c57-1d1bcb170b89"), .pid = 15 };
pub const WPD_COMMAND_SERVICE_CAPABILITIES_GET_COMMAND_OPTIONS = PROPERTYKEY{ .fmtid = Guid.initString("24457e74-2e9f-44f9-8c57-1d1bcb170b89"), .pid = 16 };
pub const WPD_PROPERTY_SERVICE_CAPABILITIES_SUPPORTED_METHODS = PROPERTYKEY{ .fmtid = Guid.initString("24457e74-2e9f-44f9-8c57-1d1bcb170b89"), .pid = 1001 };
pub const WPD_PROPERTY_SERVICE_CAPABILITIES_FORMAT = PROPERTYKEY{ .fmtid = Guid.initString("24457e74-2e9f-44f9-8c57-1d1bcb170b89"), .pid = 1002 };
pub const WPD_PROPERTY_SERVICE_CAPABILITIES_METHOD = PROPERTYKEY{ .fmtid = Guid.initString("24457e74-2e9f-44f9-8c57-1d1bcb170b89"), .pid = 1003 };
pub const WPD_PROPERTY_SERVICE_CAPABILITIES_METHOD_ATTRIBUTES = PROPERTYKEY{ .fmtid = Guid.initString("24457e74-2e9f-44f9-8c57-1d1bcb170b89"), .pid = 1004 };
pub const WPD_PROPERTY_SERVICE_CAPABILITIES_PARAMETER = PROPERTYKEY{ .fmtid = Guid.initString("24457e74-2e9f-44f9-8c57-1d1bcb170b89"), .pid = 1005 };
pub const WPD_PROPERTY_SERVICE_CAPABILITIES_PARAMETER_ATTRIBUTES = PROPERTYKEY{ .fmtid = Guid.initString("24457e74-2e9f-44f9-8c57-1d1bcb170b89"), .pid = 1006 };
pub const WPD_PROPERTY_SERVICE_CAPABILITIES_FORMATS = PROPERTYKEY{ .fmtid = Guid.initString("24457e74-2e9f-44f9-8c57-1d1bcb170b89"), .pid = 1007 };
pub const WPD_PROPERTY_SERVICE_CAPABILITIES_FORMAT_ATTRIBUTES = PROPERTYKEY{ .fmtid = Guid.initString("24457e74-2e9f-44f9-8c57-1d1bcb170b89"), .pid = 1008 };
pub const WPD_PROPERTY_SERVICE_CAPABILITIES_PROPERTY_KEYS = PROPERTYKEY{ .fmtid = Guid.initString("24457e74-2e9f-44f9-8c57-1d1bcb170b89"), .pid = 1009 };
pub const WPD_PROPERTY_SERVICE_CAPABILITIES_PROPERTY_ATTRIBUTES = PROPERTYKEY{ .fmtid = Guid.initString("24457e74-2e9f-44f9-8c57-1d1bcb170b89"), .pid = 1010 };
pub const WPD_PROPERTY_SERVICE_CAPABILITIES_SUPPORTED_EVENTS = PROPERTYKEY{ .fmtid = Guid.initString("24457e74-2e9f-44f9-8c57-1d1bcb170b89"), .pid = 1011 };
pub const WPD_PROPERTY_SERVICE_CAPABILITIES_EVENT = PROPERTYKEY{ .fmtid = Guid.initString("24457e74-2e9f-44f9-8c57-1d1bcb170b89"), .pid = 1012 };
pub const WPD_PROPERTY_SERVICE_CAPABILITIES_EVENT_ATTRIBUTES = PROPERTYKEY{ .fmtid = Guid.initString("24457e74-2e9f-44f9-8c57-1d1bcb170b89"), .pid = 1013 };
pub const WPD_PROPERTY_SERVICE_CAPABILITIES_INHERITANCE_TYPE = PROPERTYKEY{ .fmtid = Guid.initString("24457e74-2e9f-44f9-8c57-1d1bcb170b89"), .pid = 1014 };
pub const WPD_PROPERTY_SERVICE_CAPABILITIES_INHERITED_SERVICES = PROPERTYKEY{ .fmtid = Guid.initString("24457e74-2e9f-44f9-8c57-1d1bcb170b89"), .pid = 1015 };
pub const WPD_PROPERTY_SERVICE_CAPABILITIES_RENDERING_PROFILES = PROPERTYKEY{ .fmtid = Guid.initString("24457e74-2e9f-44f9-8c57-1d1bcb170b89"), .pid = 1016 };
pub const WPD_PROPERTY_SERVICE_CAPABILITIES_SUPPORTED_COMMANDS = PROPERTYKEY{ .fmtid = Guid.initString("24457e74-2e9f-44f9-8c57-1d1bcb170b89"), .pid = 1017 };
pub const WPD_PROPERTY_SERVICE_CAPABILITIES_COMMAND = PROPERTYKEY{ .fmtid = Guid.initString("24457e74-2e9f-44f9-8c57-1d1bcb170b89"), .pid = 1018 };
pub const WPD_PROPERTY_SERVICE_CAPABILITIES_COMMAND_OPTIONS = PROPERTYKEY{ .fmtid = Guid.initString("24457e74-2e9f-44f9-8c57-1d1bcb170b89"), .pid = 1019 };
pub const WPD_CATEGORY_SERVICE_METHODS = Guid.initString("2d521ca8-c1b0-4268-a342-cf19321569bc");
pub const WPD_COMMAND_SERVICE_METHODS_START_INVOKE = PROPERTYKEY{ .fmtid = Guid.initString("2d521ca8-c1b0-4268-a342-cf19321569bc"), .pid = 2 };
pub const WPD_COMMAND_SERVICE_METHODS_CANCEL_INVOKE = PROPERTYKEY{ .fmtid = Guid.initString("2d521ca8-c1b0-4268-a342-cf19321569bc"), .pid = 3 };
pub const WPD_COMMAND_SERVICE_METHODS_END_INVOKE = PROPERTYKEY{ .fmtid = Guid.initString("2d521ca8-c1b0-4268-a342-cf19321569bc"), .pid = 4 };
pub const WPD_PROPERTY_SERVICE_METHOD = PROPERTYKEY{ .fmtid = Guid.initString("2d521ca8-c1b0-4268-a342-cf19321569bc"), .pid = 1001 };
pub const WPD_PROPERTY_SERVICE_METHOD_PARAMETER_VALUES = PROPERTYKEY{ .fmtid = Guid.initString("2d521ca8-c1b0-4268-a342-cf19321569bc"), .pid = 1002 };
pub const WPD_PROPERTY_SERVICE_METHOD_RESULT_VALUES = PROPERTYKEY{ .fmtid = Guid.initString("2d521ca8-c1b0-4268-a342-cf19321569bc"), .pid = 1003 };
pub const WPD_PROPERTY_SERVICE_METHOD_CONTEXT = PROPERTYKEY{ .fmtid = Guid.initString("2d521ca8-c1b0-4268-a342-cf19321569bc"), .pid = 1004 };
pub const WPD_PROPERTY_SERVICE_METHOD_HRESULT = PROPERTYKEY{ .fmtid = Guid.initString("2d521ca8-c1b0-4268-a342-cf19321569bc"), .pid = 1005 };
pub const WPD_RESOURCE_DEFAULT = PROPERTYKEY{ .fmtid = Guid.initString("e81e79be-34f0-41bf-b53f-f1a06ae87842"), .pid = 0 };
pub const WPD_RESOURCE_CONTACT_PHOTO = PROPERTYKEY{ .fmtid = Guid.initString("2c4d6803-80ea-4580-af9a-5be1a23eddcb"), .pid = 0 };
pub const WPD_RESOURCE_THUMBNAIL = PROPERTYKEY{ .fmtid = Guid.initString("c7c407ba-98fa-46b5-9960-23fec124cfde"), .pid = 0 };
pub const WPD_RESOURCE_ICON = PROPERTYKEY{ .fmtid = Guid.initString("f195fed8-aa28-4ee3-b153-e182dd5edc39"), .pid = 0 };
pub const WPD_RESOURCE_AUDIO_CLIP = PROPERTYKEY{ .fmtid = Guid.initString("3bc13982-85b1-48e0-95a6-8d3ad06be117"), .pid = 0 };
pub const WPD_RESOURCE_ALBUM_ART = PROPERTYKEY{ .fmtid = Guid.initString("f02aa354-2300-4e2d-a1b9-3b6730f7fa21"), .pid = 0 };
pub const WPD_RESOURCE_GENERIC = PROPERTYKEY{ .fmtid = Guid.initString("b9b9f515-ba70-4647-94dc-fa4925e95a07"), .pid = 0 };
pub const WPD_RESOURCE_VIDEO_CLIP = PROPERTYKEY{ .fmtid = Guid.initString("b566ee42-6368-4290-8662-70182fb79f20"), .pid = 0 };
pub const WPD_RESOURCE_BRANDING_ART = PROPERTYKEY{ .fmtid = Guid.initString("b633b1ae-6caf-4a87-9589-22ded6dd5899"), .pid = 0 };
pub const WPD_OBJECT_FORMAT_PROPERTIES_ONLY = Guid.initString("30010000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_UNSPECIFIED = Guid.initString("30000000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_SCRIPT = Guid.initString("30020000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_EXECUTABLE = Guid.initString("30030000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_TEXT = Guid.initString("30040000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_HTML = Guid.initString("30050000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_DPOF = Guid.initString("30060000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_AIFF = Guid.initString("30070000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_WAVE = Guid.initString("30080000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_MP3 = Guid.initString("30090000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_AVI = Guid.initString("300a0000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_MPEG = Guid.initString("300b0000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_ASF = Guid.initString("300c0000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_EXIF = Guid.initString("38010000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_TIFFEP = Guid.initString("38020000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_FLASHPIX = Guid.initString("38030000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_BMP = Guid.initString("38040000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_CIFF = Guid.initString("38050000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_GIF = Guid.initString("38070000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_JFIF = Guid.initString("38080000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_PCD = Guid.initString("38090000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_PICT = Guid.initString("380a0000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_PNG = Guid.initString("380b0000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_TIFF = Guid.initString("380d0000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_TIFFIT = Guid.initString("380e0000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_JP2 = Guid.initString("380f0000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_JPX = Guid.initString("38100000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_WBMP = Guid.initString("b8030000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_JPEGXR = Guid.initString("b8040000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_WINDOWSIMAGEFORMAT = Guid.initString("b8810000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_WMA = Guid.initString("b9010000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_WMV = Guid.initString("b9810000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_WPLPLAYLIST = Guid.initString("ba100000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_M3UPLAYLIST = Guid.initString("ba110000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_MPLPLAYLIST = Guid.initString("ba120000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_ASXPLAYLIST = Guid.initString("ba130000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_PLSPLAYLIST = Guid.initString("ba140000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_ABSTRACT_CONTACT_GROUP = Guid.initString("ba060000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_ABSTRACT_MEDIA_CAST = Guid.initString("ba0b0000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_VCALENDAR1 = Guid.initString("be020000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_ICALENDAR = Guid.initString("be030000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_ABSTRACT_CONTACT = Guid.initString("bb810000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_VCARD2 = Guid.initString("bb820000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_VCARD3 = Guid.initString("bb830000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_XML = Guid.initString("ba820000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_AAC = Guid.initString("b9030000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_AUDIBLE = Guid.initString("b9040000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_FLAC = Guid.initString("b9060000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_QCELP = Guid.initString("b9070000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_AMR = Guid.initString("b9080000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_OGG = Guid.initString("b9020000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_MP4 = Guid.initString("b9820000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_MP2 = Guid.initString("b9830000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_MICROSOFT_WORD = Guid.initString("ba830000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_MHT_COMPILED_HTML = Guid.initString("ba840000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_MICROSOFT_EXCEL = Guid.initString("ba850000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_MICROSOFT_POWERPOINT = Guid.initString("ba860000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_3GP = Guid.initString("b9840000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_3G2 = Guid.initString("b9850000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_AVCHD = Guid.initString("b9860000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_ATSCTS = Guid.initString("b9870000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_DVBTS = Guid.initString("b9880000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_FORMAT_MKV = Guid.initString("b9900000-ae6c-4804-98ba-c57b46965fe7");
pub const WPD_OBJECT_ID = PROPERTYKEY{ .fmtid = Guid.initString("ef6b490d-5cd8-437a-affc-da8b60ee4a3c"), .pid = 2 };
pub const WPD_OBJECT_PARENT_ID = PROPERTYKEY{ .fmtid = Guid.initString("ef6b490d-5cd8-437a-affc-da8b60ee4a3c"), .pid = 3 };
pub const WPD_OBJECT_NAME = PROPERTYKEY{ .fmtid = Guid.initString("ef6b490d-5cd8-437a-affc-da8b60ee4a3c"), .pid = 4 };
pub const WPD_OBJECT_PERSISTENT_UNIQUE_ID = PROPERTYKEY{ .fmtid = Guid.initString("ef6b490d-5cd8-437a-affc-da8b60ee4a3c"), .pid = 5 };
pub const WPD_OBJECT_FORMAT = PROPERTYKEY{ .fmtid = Guid.initString("ef6b490d-5cd8-437a-affc-da8b60ee4a3c"), .pid = 6 };
pub const WPD_OBJECT_ISHIDDEN = PROPERTYKEY{ .fmtid = Guid.initString("ef6b490d-5cd8-437a-affc-da8b60ee4a3c"), .pid = 9 };
pub const WPD_OBJECT_ISSYSTEM = PROPERTYKEY{ .fmtid = Guid.initString("ef6b490d-5cd8-437a-affc-da8b60ee4a3c"), .pid = 10 };
pub const WPD_OBJECT_SIZE = PROPERTYKEY{ .fmtid = Guid.initString("ef6b490d-5cd8-437a-affc-da8b60ee4a3c"), .pid = 11 };
pub const WPD_OBJECT_ORIGINAL_FILE_NAME = PROPERTYKEY{ .fmtid = Guid.initString("ef6b490d-5cd8-437a-affc-da8b60ee4a3c"), .pid = 12 };
pub const WPD_OBJECT_NON_CONSUMABLE = PROPERTYKEY{ .fmtid = Guid.initString("ef6b490d-5cd8-437a-affc-da8b60ee4a3c"), .pid = 13 };
pub const WPD_OBJECT_KEYWORDS = PROPERTYKEY{ .fmtid = Guid.initString("ef6b490d-5cd8-437a-affc-da8b60ee4a3c"), .pid = 15 };
pub const WPD_OBJECT_SYNC_ID = PROPERTYKEY{ .fmtid = Guid.initString("ef6b490d-5cd8-437a-affc-da8b60ee4a3c"), .pid = 16 };
pub const WPD_OBJECT_IS_DRM_PROTECTED = PROPERTYKEY{ .fmtid = Guid.initString("ef6b490d-5cd8-437a-affc-da8b60ee4a3c"), .pid = 17 };
pub const WPD_OBJECT_DATE_CREATED = PROPERTYKEY{ .fmtid = Guid.initString("ef6b490d-5cd8-437a-affc-da8b60ee4a3c"), .pid = 18 };
pub const WPD_OBJECT_DATE_MODIFIED = PROPERTYKEY{ .fmtid = Guid.initString("ef6b490d-5cd8-437a-affc-da8b60ee4a3c"), .pid = 19 };
pub const WPD_OBJECT_DATE_AUTHORED = PROPERTYKEY{ .fmtid = Guid.initString("ef6b490d-5cd8-437a-affc-da8b60ee4a3c"), .pid = 20 };
pub const WPD_OBJECT_BACK_REFERENCES = PROPERTYKEY{ .fmtid = Guid.initString("ef6b490d-5cd8-437a-affc-da8b60ee4a3c"), .pid = 21 };
pub const WPD_OBJECT_CAN_DELETE = PROPERTYKEY{ .fmtid = Guid.initString("ef6b490d-5cd8-437a-affc-da8b60ee4a3c"), .pid = 26 };
pub const WPD_OBJECT_LANGUAGE_LOCALE = PROPERTYKEY{ .fmtid = Guid.initString("ef6b490d-5cd8-437a-affc-da8b60ee4a3c"), .pid = 27 };
pub const WPD_FOLDER_OBJECT_PROPERTIES_V1 = Guid.initString("7e9a7abf-e568-4b34-aa2f-13bb12ab177d");
pub const WPD_FOLDER_CONTENT_TYPES_ALLOWED = PROPERTYKEY{ .fmtid = Guid.initString("7e9a7abf-e568-4b34-aa2f-13bb12ab177d"), .pid = 2 };
pub const WPD_IMAGE_OBJECT_PROPERTIES_V1 = Guid.initString("63d64908-9fa1-479f-85ba-9952216447db");
pub const WPD_IMAGE_BITDEPTH = PROPERTYKEY{ .fmtid = Guid.initString("63d64908-9fa1-479f-85ba-9952216447db"), .pid = 3 };
pub const WPD_IMAGE_CROPPED_STATUS = PROPERTYKEY{ .fmtid = Guid.initString("63d64908-9fa1-479f-85ba-9952216447db"), .pid = 4 };
pub const WPD_IMAGE_COLOR_CORRECTED_STATUS = PROPERTYKEY{ .fmtid = Guid.initString("63d64908-9fa1-479f-85ba-9952216447db"), .pid = 5 };
pub const WPD_IMAGE_FNUMBER = PROPERTYKEY{ .fmtid = Guid.initString("63d64908-9fa1-479f-85ba-9952216447db"), .pid = 6 };
pub const WPD_IMAGE_EXPOSURE_TIME = PROPERTYKEY{ .fmtid = Guid.initString("63d64908-9fa1-479f-85ba-9952216447db"), .pid = 7 };
pub const WPD_IMAGE_EXPOSURE_INDEX = PROPERTYKEY{ .fmtid = Guid.initString("63d64908-9fa1-479f-85ba-9952216447db"), .pid = 8 };
pub const WPD_IMAGE_HORIZONTAL_RESOLUTION = PROPERTYKEY{ .fmtid = Guid.initString("63d64908-9fa1-479f-85ba-9952216447db"), .pid = 9 };
pub const WPD_IMAGE_VERTICAL_RESOLUTION = PROPERTYKEY{ .fmtid = Guid.initString("63d64908-9fa1-479f-85ba-9952216447db"), .pid = 10 };
pub const WPD_DOCUMENT_OBJECT_PROPERTIES_V1 = Guid.initString("0b110203-eb95-4f02-93e0-97c631493ad5");
pub const WPD_MEDIA_PROPERTIES_V1 = Guid.initString("2ed8ba05-0ad3-42dc-b0d0-bc95ac396ac8");
pub const WPD_MEDIA_TOTAL_BITRATE = PROPERTYKEY{ .fmtid = Guid.initString("2ed8ba05-0ad3-42dc-b0d0-bc95ac396ac8"), .pid = 2 };
pub const WPD_MEDIA_BITRATE_TYPE = PROPERTYKEY{ .fmtid = Guid.initString("2ed8ba05-0ad3-42dc-b0d0-bc95ac396ac8"), .pid = 3 };
pub const WPD_MEDIA_COPYRIGHT = PROPERTYKEY{ .fmtid = Guid.initString("2ed8ba05-0ad3-42dc-b0d0-bc95ac396ac8"), .pid = 4 };
pub const WPD_MEDIA_SUBSCRIPTION_CONTENT_ID = PROPERTYKEY{ .fmtid = Guid.initString("2ed8ba05-0ad3-42dc-b0d0-bc95ac396ac8"), .pid = 5 };
pub const WPD_MEDIA_USE_COUNT = PROPERTYKEY{ .fmtid = Guid.initString("2ed8ba05-0ad3-42dc-b0d0-bc95ac396ac8"), .pid = 6 };
pub const WPD_MEDIA_SKIP_COUNT = PROPERTYKEY{ .fmtid = Guid.initString("2ed8ba05-0ad3-42dc-b0d0-bc95ac396ac8"), .pid = 7 };
pub const WPD_MEDIA_LAST_ACCESSED_TIME = PROPERTYKEY{ .fmtid = Guid.initString("2ed8ba05-0ad3-42dc-b0d0-bc95ac396ac8"), .pid = 8 };
pub const WPD_MEDIA_PARENTAL_RATING = PROPERTYKEY{ .fmtid = Guid.initString("2ed8ba05-0ad3-42dc-b0d0-bc95ac396ac8"), .pid = 9 };
pub const WPD_MEDIA_META_GENRE = PROPERTYKEY{ .fmtid = Guid.initString("2ed8ba05-0ad3-42dc-b0d0-bc95ac396ac8"), .pid = 10 };
pub const WPD_MEDIA_COMPOSER = PROPERTYKEY{ .fmtid = Guid.initString("2ed8ba05-0ad3-42dc-b0d0-bc95ac396ac8"), .pid = 11 };
pub const WPD_MEDIA_EFFECTIVE_RATING = PROPERTYKEY{ .fmtid = Guid.initString("2ed8ba05-0ad3-42dc-b0d0-bc95ac396ac8"), .pid = 12 };
pub const WPD_MEDIA_SUB_TITLE = PROPERTYKEY{ .fmtid = Guid.initString("2ed8ba05-0ad3-42dc-b0d0-bc95ac396ac8"), .pid = 13 };
pub const WPD_MEDIA_RELEASE_DATE = PROPERTYKEY{ .fmtid = Guid.initString("2ed8ba05-0ad3-42dc-b0d0-bc95ac396ac8"), .pid = 14 };
pub const WPD_MEDIA_SAMPLE_RATE = PROPERTYKEY{ .fmtid = Guid.initString("2ed8ba05-0ad3-42dc-b0d0-bc95ac396ac8"), .pid = 15 };
pub const WPD_MEDIA_STAR_RATING = PROPERTYKEY{ .fmtid = Guid.initString("2ed8ba05-0ad3-42dc-b0d0-bc95ac396ac8"), .pid = 16 };
pub const WPD_MEDIA_USER_EFFECTIVE_RATING = PROPERTYKEY{ .fmtid = Guid.initString("2ed8ba05-0ad3-42dc-b0d0-bc95ac396ac8"), .pid = 17 };
pub const WPD_MEDIA_TITLE = PROPERTYKEY{ .fmtid = Guid.initString("2ed8ba05-0ad3-42dc-b0d0-bc95ac396ac8"), .pid = 18 };
pub const WPD_MEDIA_DURATION = PROPERTYKEY{ .fmtid = Guid.initString("2ed8ba05-0ad3-42dc-b0d0-bc95ac396ac8"), .pid = 19 };
pub const WPD_MEDIA_BUY_NOW = PROPERTYKEY{ .fmtid = Guid.initString("2ed8ba05-0ad3-42dc-b0d0-bc95ac396ac8"), .pid = 20 };
pub const WPD_MEDIA_ENCODING_PROFILE = PROPERTYKEY{ .fmtid = Guid.initString("2ed8ba05-0ad3-42dc-b0d0-bc95ac396ac8"), .pid = 21 };
pub const WPD_MEDIA_WIDTH = PROPERTYKEY{ .fmtid = Guid.initString("2ed8ba05-0ad3-42dc-b0d0-bc95ac396ac8"), .pid = 22 };
pub const WPD_MEDIA_HEIGHT = PROPERTYKEY{ .fmtid = Guid.initString("2ed8ba05-0ad3-42dc-b0d0-bc95ac396ac8"), .pid = 23 };
pub const WPD_MEDIA_ARTIST = PROPERTYKEY{ .fmtid = Guid.initString("2ed8ba05-0ad3-42dc-b0d0-bc95ac396ac8"), .pid = 24 };
pub const WPD_MEDIA_ALBUM_ARTIST = PROPERTYKEY{ .fmtid = Guid.initString("2ed8ba05-0ad3-42dc-b0d0-bc95ac396ac8"), .pid = 25 };
pub const WPD_MEDIA_OWNER = PROPERTYKEY{ .fmtid = Guid.initString("2ed8ba05-0ad3-42dc-b0d0-bc95ac396ac8"), .pid = 26 };
pub const WPD_MEDIA_MANAGING_EDITOR = PROPERTYKEY{ .fmtid = Guid.initString("2ed8ba05-0ad3-42dc-b0d0-bc95ac396ac8"), .pid = 27 };
pub const WPD_MEDIA_WEBMASTER = PROPERTYKEY{ .fmtid = Guid.initString("2ed8ba05-0ad3-42dc-b0d0-bc95ac396ac8"), .pid = 28 };
pub const WPD_MEDIA_SOURCE_URL = PROPERTYKEY{ .fmtid = Guid.initString("2ed8ba05-0ad3-42dc-b0d0-bc95ac396ac8"), .pid = 29 };
pub const WPD_MEDIA_DESTINATION_URL = PROPERTYKEY{ .fmtid = Guid.initString("2ed8ba05-0ad3-42dc-b0d0-bc95ac396ac8"), .pid = 30 };
pub const WPD_MEDIA_DESCRIPTION = PROPERTYKEY{ .fmtid = Guid.initString("2ed8ba05-0ad3-42dc-b0d0-bc95ac396ac8"), .pid = 31 };
pub const WPD_MEDIA_GENRE = PROPERTYKEY{ .fmtid = Guid.initString("2ed8ba05-0ad3-42dc-b0d0-bc95ac396ac8"), .pid = 32 };
pub const WPD_MEDIA_TIME_BOOKMARK = PROPERTYKEY{ .fmtid = Guid.initString("2ed8ba05-0ad3-42dc-b0d0-bc95ac396ac8"), .pid = 33 };
pub const WPD_MEDIA_OBJECT_BOOKMARK = PROPERTYKEY{ .fmtid = Guid.initString("2ed8ba05-0ad3-42dc-b0d0-bc95ac396ac8"), .pid = 34 };
pub const WPD_MEDIA_LAST_BUILD_DATE = PROPERTYKEY{ .fmtid = Guid.initString("2ed8ba05-0ad3-42dc-b0d0-bc95ac396ac8"), .pid = 35 };
pub const WPD_MEDIA_BYTE_BOOKMARK = PROPERTYKEY{ .fmtid = Guid.initString("2ed8ba05-0ad3-42dc-b0d0-bc95ac396ac8"), .pid = 36 };
pub const WPD_MEDIA_TIME_TO_LIVE = PROPERTYKEY{ .fmtid = Guid.initString("2ed8ba05-0ad3-42dc-b0d0-bc95ac396ac8"), .pid = 37 };
pub const WPD_MEDIA_GUID = PROPERTYKEY{ .fmtid = Guid.initString("2ed8ba05-0ad3-42dc-b0d0-bc95ac396ac8"), .pid = 38 };
pub const WPD_MEDIA_SUB_DESCRIPTION = PROPERTYKEY{ .fmtid = Guid.initString("2ed8ba05-0ad3-42dc-b0d0-bc95ac396ac8"), .pid = 39 };
pub const WPD_MEDIA_AUDIO_ENCODING_PROFILE = PROPERTYKEY{ .fmtid = Guid.initString("2ed8ba05-0ad3-42dc-b0d0-bc95ac396ac8"), .pid = 49 };
pub const WPD_CONTACT_OBJECT_PROPERTIES_V1 = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b");
pub const WPD_CONTACT_DISPLAY_NAME = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 2 };
pub const WPD_CONTACT_FIRST_NAME = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 3 };
pub const WPD_CONTACT_MIDDLE_NAMES = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 4 };
pub const WPD_CONTACT_LAST_NAME = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 5 };
pub const WPD_CONTACT_PREFIX = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 6 };
pub const WPD_CONTACT_SUFFIX = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 7 };
pub const WPD_CONTACT_PHONETIC_FIRST_NAME = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 8 };
pub const WPD_CONTACT_PHONETIC_LAST_NAME = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 9 };
pub const WPD_CONTACT_PERSONAL_FULL_POSTAL_ADDRESS = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 10 };
pub const WPD_CONTACT_PERSONAL_POSTAL_ADDRESS_LINE1 = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 11 };
pub const WPD_CONTACT_PERSONAL_POSTAL_ADDRESS_LINE2 = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 12 };
pub const WPD_CONTACT_PERSONAL_POSTAL_ADDRESS_CITY = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 13 };
pub const WPD_CONTACT_PERSONAL_POSTAL_ADDRESS_REGION = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 14 };
pub const WPD_CONTACT_PERSONAL_POSTAL_ADDRESS_POSTAL_CODE = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 15 };
pub const WPD_CONTACT_PERSONAL_POSTAL_ADDRESS_COUNTRY = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 16 };
pub const WPD_CONTACT_BUSINESS_FULL_POSTAL_ADDRESS = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 17 };
pub const WPD_CONTACT_BUSINESS_POSTAL_ADDRESS_LINE1 = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 18 };
pub const WPD_CONTACT_BUSINESS_POSTAL_ADDRESS_LINE2 = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 19 };
pub const WPD_CONTACT_BUSINESS_POSTAL_ADDRESS_CITY = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 20 };
pub const WPD_CONTACT_BUSINESS_POSTAL_ADDRESS_REGION = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 21 };
pub const WPD_CONTACT_BUSINESS_POSTAL_ADDRESS_POSTAL_CODE = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 22 };
pub const WPD_CONTACT_BUSINESS_POSTAL_ADDRESS_COUNTRY = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 23 };
pub const WPD_CONTACT_OTHER_FULL_POSTAL_ADDRESS = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 24 };
pub const WPD_CONTACT_OTHER_POSTAL_ADDRESS_LINE1 = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 25 };
pub const WPD_CONTACT_OTHER_POSTAL_ADDRESS_LINE2 = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 26 };
pub const WPD_CONTACT_OTHER_POSTAL_ADDRESS_CITY = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 27 };
pub const WPD_CONTACT_OTHER_POSTAL_ADDRESS_REGION = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 28 };
pub const WPD_CONTACT_OTHER_POSTAL_ADDRESS_POSTAL_CODE = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 29 };
pub const WPD_CONTACT_OTHER_POSTAL_ADDRESS_POSTAL_COUNTRY = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 30 };
pub const WPD_CONTACT_PRIMARY_EMAIL_ADDRESS = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 31 };
pub const WPD_CONTACT_PERSONAL_EMAIL = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 32 };
pub const WPD_CONTACT_PERSONAL_EMAIL2 = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 33 };
pub const WPD_CONTACT_BUSINESS_EMAIL = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 34 };
pub const WPD_CONTACT_BUSINESS_EMAIL2 = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 35 };
pub const WPD_CONTACT_OTHER_EMAILS = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 36 };
pub const WPD_CONTACT_PRIMARY_PHONE = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 37 };
pub const WPD_CONTACT_PERSONAL_PHONE = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 38 };
pub const WPD_CONTACT_PERSONAL_PHONE2 = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 39 };
pub const WPD_CONTACT_BUSINESS_PHONE = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 40 };
pub const WPD_CONTACT_BUSINESS_PHONE2 = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 41 };
pub const WPD_CONTACT_MOBILE_PHONE = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 42 };
pub const WPD_CONTACT_MOBILE_PHONE2 = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 43 };
pub const WPD_CONTACT_PERSONAL_FAX = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 44 };
pub const WPD_CONTACT_BUSINESS_FAX = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 45 };
pub const WPD_CONTACT_PAGER = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 46 };
pub const WPD_CONTACT_OTHER_PHONES = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 47 };
pub const WPD_CONTACT_PRIMARY_WEB_ADDRESS = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 48 };
pub const WPD_CONTACT_PERSONAL_WEB_ADDRESS = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 49 };
pub const WPD_CONTACT_BUSINESS_WEB_ADDRESS = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 50 };
pub const WPD_CONTACT_INSTANT_MESSENGER = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 51 };
pub const WPD_CONTACT_INSTANT_MESSENGER2 = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 52 };
pub const WPD_CONTACT_INSTANT_MESSENGER3 = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 53 };
pub const WPD_CONTACT_COMPANY_NAME = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 54 };
pub const WPD_CONTACT_PHONETIC_COMPANY_NAME = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 55 };
pub const WPD_CONTACT_ROLE = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 56 };
pub const WPD_CONTACT_BIRTHDATE = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 57 };
pub const WPD_CONTACT_PRIMARY_FAX = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 58 };
pub const WPD_CONTACT_SPOUSE = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 59 };
pub const WPD_CONTACT_CHILDREN = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 60 };
pub const WPD_CONTACT_ASSISTANT = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 61 };
pub const WPD_CONTACT_ANNIVERSARY_DATE = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 62 };
pub const WPD_CONTACT_RINGTONE = PROPERTYKEY{ .fmtid = Guid.initString("fbd4fdab-987d-4777-b3f9-726185a9312b"), .pid = 63 };
pub const WPD_MUSIC_OBJECT_PROPERTIES_V1 = Guid.initString("b324f56a-dc5d-46e5-b6df-d2ea414888c6");
pub const WPD_MUSIC_ALBUM = PROPERTYKEY{ .fmtid = Guid.initString("b324f56a-dc5d-46e5-b6df-d2ea414888c6"), .pid = 3 };
pub const WPD_MUSIC_TRACK = PROPERTYKEY{ .fmtid = Guid.initString("b324f56a-dc5d-46e5-b6df-d2ea414888c6"), .pid = 4 };
pub const WPD_MUSIC_LYRICS = PROPERTYKEY{ .fmtid = Guid.initString("b324f56a-dc5d-46e5-b6df-d2ea414888c6"), .pid = 6 };
pub const WPD_MUSIC_MOOD = PROPERTYKEY{ .fmtid = Guid.initString("b324f56a-dc5d-46e5-b6df-d2ea414888c6"), .pid = 8 };
pub const WPD_AUDIO_BITRATE = PROPERTYKEY{ .fmtid = Guid.initString("b324f56a-dc5d-46e5-b6df-d2ea414888c6"), .pid = 9 };
pub const WPD_AUDIO_CHANNEL_COUNT = PROPERTYKEY{ .fmtid = Guid.initString("b324f56a-dc5d-46e5-b6df-d2ea414888c6"), .pid = 10 };
pub const WPD_AUDIO_FORMAT_CODE = PROPERTYKEY{ .fmtid = Guid.initString("b324f56a-dc5d-46e5-b6df-d2ea414888c6"), .pid = 11 };
pub const WPD_AUDIO_BIT_DEPTH = PROPERTYKEY{ .fmtid = Guid.initString("b324f56a-dc5d-46e5-b6df-d2ea414888c6"), .pid = 12 };
pub const WPD_AUDIO_BLOCK_ALIGNMENT = PROPERTYKEY{ .fmtid = Guid.initString("b324f56a-dc5d-46e5-b6df-d2ea414888c6"), .pid = 13 };
pub const WPD_VIDEO_OBJECT_PROPERTIES_V1 = Guid.initString("346f2163-f998-4146-8b01-d19b4c00de9a");
pub const WPD_VIDEO_AUTHOR = PROPERTYKEY{ .fmtid = Guid.initString("346f2163-f998-4146-8b01-d19b4c00de9a"), .pid = 2 };
pub const WPD_VIDEO_RECORDEDTV_STATION_NAME = PROPERTYKEY{ .fmtid = Guid.initString("346f2163-f998-4146-8b01-d19b4c00de9a"), .pid = 4 };
pub const WPD_VIDEO_RECORDEDTV_CHANNEL_NUMBER = PROPERTYKEY{ .fmtid = Guid.initString("346f2163-f998-4146-8b01-d19b4c00de9a"), .pid = 5 };
pub const WPD_VIDEO_RECORDEDTV_REPEAT = PROPERTYKEY{ .fmtid = Guid.initString("346f2163-f998-4146-8b01-d19b4c00de9a"), .pid = 7 };
pub const WPD_VIDEO_BUFFER_SIZE = PROPERTYKEY{ .fmtid = Guid.initString("346f2163-f998-4146-8b01-d19b4c00de9a"), .pid = 8 };
pub const WPD_VIDEO_CREDITS = PROPERTYKEY{ .fmtid = Guid.initString("346f2163-f998-4146-8b01-d19b4c00de9a"), .pid = 9 };
pub const WPD_VIDEO_KEY_FRAME_DISTANCE = PROPERTYKEY{ .fmtid = Guid.initString("346f2163-f998-4146-8b01-d19b4c00de9a"), .pid = 10 };
pub const WPD_VIDEO_QUALITY_SETTING = PROPERTYKEY{ .fmtid = Guid.initString("346f2163-f998-4146-8b01-d19b4c00de9a"), .pid = 11 };
pub const WPD_VIDEO_SCAN_TYPE = PROPERTYKEY{ .fmtid = Guid.initString("346f2163-f998-4146-8b01-d19b4c00de9a"), .pid = 12 };
pub const WPD_VIDEO_BITRATE = PROPERTYKEY{ .fmtid = Guid.initString("346f2163-f998-4146-8b01-d19b4c00de9a"), .pid = 13 };
pub const WPD_VIDEO_FOURCC_CODE = PROPERTYKEY{ .fmtid = Guid.initString("346f2163-f998-4146-8b01-d19b4c00de9a"), .pid = 14 };
pub const WPD_VIDEO_FRAMERATE = PROPERTYKEY{ .fmtid = Guid.initString("346f2163-f998-4146-8b01-d19b4c00de9a"), .pid = 15 };
pub const WPD_COMMON_INFORMATION_OBJECT_PROPERTIES_V1 = Guid.initString("b28ae94b-05a4-4e8e-be01-72cc7e099d8f");
pub const WPD_COMMON_INFORMATION_SUBJECT = PROPERTYKEY{ .fmtid = Guid.initString("b28ae94b-05a4-4e8e-be01-72cc7e099d8f"), .pid = 2 };
pub const WPD_COMMON_INFORMATION_BODY_TEXT = PROPERTYKEY{ .fmtid = Guid.initString("b28ae94b-05a4-4e8e-be01-72cc7e099d8f"), .pid = 3 };
pub const WPD_COMMON_INFORMATION_PRIORITY = PROPERTYKEY{ .fmtid = Guid.initString("b28ae94b-05a4-4e8e-be01-72cc7e099d8f"), .pid = 4 };
pub const WPD_COMMON_INFORMATION_START_DATETIME = PROPERTYKEY{ .fmtid = Guid.initString("b28ae94b-05a4-4e8e-be01-72cc7e099d8f"), .pid = 5 };
pub const WPD_COMMON_INFORMATION_END_DATETIME = PROPERTYKEY{ .fmtid = Guid.initString("b28ae94b-05a4-4e8e-be01-72cc7e099d8f"), .pid = 6 };
pub const WPD_COMMON_INFORMATION_NOTES = PROPERTYKEY{ .fmtid = Guid.initString("b28ae94b-05a4-4e8e-be01-72cc7e099d8f"), .pid = 7 };
pub const WPD_MEMO_OBJECT_PROPERTIES_V1 = Guid.initString("5ffbfc7b-7483-41ad-afb9-da3f4e592b8d");
pub const WPD_EMAIL_OBJECT_PROPERTIES_V1 = Guid.initString("41f8f65a-5484-4782-b13d-4740dd7c37c5");
pub const WPD_EMAIL_TO_LINE = PROPERTYKEY{ .fmtid = Guid.initString("41f8f65a-5484-4782-b13d-4740dd7c37c5"), .pid = 2 };
pub const WPD_EMAIL_CC_LINE = PROPERTYKEY{ .fmtid = Guid.initString("41f8f65a-5484-4782-b13d-4740dd7c37c5"), .pid = 3 };
pub const WPD_EMAIL_BCC_LINE = PROPERTYKEY{ .fmtid = Guid.initString("41f8f65a-5484-4782-b13d-4740dd7c37c5"), .pid = 4 };
pub const WPD_EMAIL_HAS_BEEN_READ = PROPERTYKEY{ .fmtid = Guid.initString("41f8f65a-5484-4782-b13d-4740dd7c37c5"), .pid = 7 };
pub const WPD_EMAIL_RECEIVED_TIME = PROPERTYKEY{ .fmtid = Guid.initString("41f8f65a-5484-4782-b13d-4740dd7c37c5"), .pid = 8 };
pub const WPD_EMAIL_HAS_ATTACHMENTS = PROPERTYKEY{ .fmtid = Guid.initString("41f8f65a-5484-4782-b13d-4740dd7c37c5"), .pid = 9 };
pub const WPD_EMAIL_SENDER_ADDRESS = PROPERTYKEY{ .fmtid = Guid.initString("41f8f65a-5484-4782-b13d-4740dd7c37c5"), .pid = 10 };
pub const WPD_APPOINTMENT_OBJECT_PROPERTIES_V1 = Guid.initString("f99efd03-431d-40d8-a1c9-4e220d9c88d3");
pub const WPD_APPOINTMENT_LOCATION = PROPERTYKEY{ .fmtid = Guid.initString("f99efd03-431d-40d8-a1c9-4e220d9c88d3"), .pid = 3 };
pub const WPD_APPOINTMENT_TYPE = PROPERTYKEY{ .fmtid = Guid.initString("f99efd03-431d-40d8-a1c9-4e220d9c88d3"), .pid = 7 };
pub const WPD_APPOINTMENT_REQUIRED_ATTENDEES = PROPERTYKEY{ .fmtid = Guid.initString("f99efd03-431d-40d8-a1c9-4e220d9c88d3"), .pid = 8 };
pub const WPD_APPOINTMENT_OPTIONAL_ATTENDEES = PROPERTYKEY{ .fmtid = Guid.initString("f99efd03-431d-40d8-a1c9-4e220d9c88d3"), .pid = 9 };
pub const WPD_APPOINTMENT_ACCEPTED_ATTENDEES = PROPERTYKEY{ .fmtid = Guid.initString("f99efd03-431d-40d8-a1c9-4e220d9c88d3"), .pid = 10 };
pub const WPD_APPOINTMENT_RESOURCES = PROPERTYKEY{ .fmtid = Guid.initString("f99efd03-431d-40d8-a1c9-4e220d9c88d3"), .pid = 11 };
pub const WPD_APPOINTMENT_TENTATIVE_ATTENDEES = PROPERTYKEY{ .fmtid = Guid.initString("f99efd03-431d-40d8-a1c9-4e220d9c88d3"), .pid = 12 };
pub const WPD_APPOINTMENT_DECLINED_ATTENDEES = PROPERTYKEY{ .fmtid = Guid.initString("f99efd03-431d-40d8-a1c9-4e220d9c88d3"), .pid = 13 };
pub const WPD_TASK_OBJECT_PROPERTIES_V1 = Guid.initString("e354e95e-d8a0-4637-a03a-0cb26838dbc7");
pub const WPD_TASK_STATUS = PROPERTYKEY{ .fmtid = Guid.initString("e354e95e-d8a0-4637-a03a-0cb26838dbc7"), .pid = 6 };
pub const WPD_TASK_PERCENT_COMPLETE = PROPERTYKEY{ .fmtid = Guid.initString("e354e95e-d8a0-4637-a03a-0cb26838dbc7"), .pid = 8 };
pub const WPD_TASK_REMINDER_DATE = PROPERTYKEY{ .fmtid = Guid.initString("e354e95e-d8a0-4637-a03a-0cb26838dbc7"), .pid = 10 };
pub const WPD_TASK_OWNER = PROPERTYKEY{ .fmtid = Guid.initString("e354e95e-d8a0-4637-a03a-0cb26838dbc7"), .pid = 11 };
pub const WPD_SMS_OBJECT_PROPERTIES_V1 = Guid.initString("7e1074cc-50ff-4dd1-a742-53be6f093a0d");
pub const WPD_SMS_PROVIDER = PROPERTYKEY{ .fmtid = Guid.initString("7e1074cc-50ff-4dd1-a742-53be6f093a0d"), .pid = 2 };
pub const WPD_SMS_TIMEOUT = PROPERTYKEY{ .fmtid = Guid.initString("7e1074cc-50ff-4dd1-a742-53be6f093a0d"), .pid = 3 };
pub const WPD_SMS_MAX_PAYLOAD = PROPERTYKEY{ .fmtid = Guid.initString("7e1074cc-50ff-4dd1-a742-53be6f093a0d"), .pid = 4 };
pub const WPD_SMS_ENCODING = PROPERTYKEY{ .fmtid = Guid.initString("7e1074cc-50ff-4dd1-a742-53be6f093a0d"), .pid = 5 };
pub const WPD_SECTION_OBJECT_PROPERTIES_V1 = Guid.initString("516afd2b-c64e-44f0-98dc-bee1c88f7d66");
pub const WPD_SECTION_DATA_OFFSET = PROPERTYKEY{ .fmtid = Guid.initString("516afd2b-c64e-44f0-98dc-bee1c88f7d66"), .pid = 2 };
pub const WPD_SECTION_DATA_LENGTH = PROPERTYKEY{ .fmtid = Guid.initString("516afd2b-c64e-44f0-98dc-bee1c88f7d66"), .pid = 3 };
pub const WPD_SECTION_DATA_UNITS = PROPERTYKEY{ .fmtid = Guid.initString("516afd2b-c64e-44f0-98dc-bee1c88f7d66"), .pid = 4 };
pub const WPD_SECTION_DATA_REFERENCED_OBJECT_RESOURCE = PROPERTYKEY{ .fmtid = Guid.initString("516afd2b-c64e-44f0-98dc-bee1c88f7d66"), .pid = 5 };
pub const DEVSVC_SERVICEINFO_VERSION = @as(u32, 100);
pub const DEVSVCTYPE_DEFAULT = @as(u32, 0);
pub const DEVSVCTYPE_ABSTRACT = @as(u32, 1);
pub const TYPE_CalendarSvc = @as(u32, 0);
pub const ENUM_CalendarObj_BusyStatusFree = @as(u32, 0);
pub const ENUM_CalendarObj_BusyStatusBusy = @as(u32, 1);
pub const ENUM_CalendarObj_BusyStatusOutOfOffice = @as(u32, 2);
pub const ENUM_CalendarObj_BusyStatusTentative = @as(u32, 3);
pub const TYPE_HintsSvc = @as(u32, 0);
pub const TYPE_MessageSvc = @as(u32, 0);
pub const ENUM_MessageObj_PriorityHighest = @as(u32, 2);
pub const ENUM_MessageObj_PriorityNormal = @as(u32, 1);
pub const ENUM_MessageObj_PriorityLowest = @as(u32, 0);
pub const ENUM_MessageObj_ReadFalse = @as(u32, 0);
pub const ENUM_MessageObj_ReadTrue = @as(u32, 255);
pub const ENUM_MessageObj_PatternTypeDaily = @as(u32, 1);
pub const ENUM_MessageObj_PatternTypeWeekly = @as(u32, 2);
pub const ENUM_MessageObj_PatternTypeMonthly = @as(u32, 3);
pub const ENUM_MessageObj_PatternTypeYearly = @as(u32, 4);
pub const FLAG_MessageObj_DayOfWeekNone = @as(u32, 0);
pub const FLAG_MessageObj_DayOfWeekSunday = @as(u32, 1);
pub const FLAG_MessageObj_DayOfWeekMonday = @as(u32, 2);
pub const FLAG_MessageObj_DayOfWeekTuesday = @as(u32, 4);
pub const FLAG_MessageObj_DayOfWeekWednesday = @as(u32, 8);
pub const FLAG_MessageObj_DayOfWeekThursday = @as(u32, 16);
pub const FLAG_MessageObj_DayOfWeekFriday = @as(u32, 32);
pub const FLAG_MessageObj_DayOfWeekSaturday = @as(u32, 64);
pub const RANGEMIN_MessageObj_PatternDayOfMonth = @as(u32, 1);
pub const RANGEMAX_MessageObj_PatternDayOfMonth = @as(u32, 31);
pub const RANGESTEP_MessageObj_PatternDayOfMonth = @as(u32, 1);
pub const RANGEMIN_MessageObj_PatternMonthOfYear = @as(u32, 1);
pub const RANGEMAX_MessageObj_PatternMonthOfYear = @as(u32, 12);
pub const RANGESTEP_MessageObj_PatternMonthOfYear = @as(u32, 1);
pub const ENUM_MessageObj_PatternInstanceNone = @as(u32, 0);
pub const ENUM_MessageObj_PatternInstanceFirst = @as(u32, 1);
pub const ENUM_MessageObj_PatternInstanceSecond = @as(u32, 2);
pub const ENUM_MessageObj_PatternInstanceThird = @as(u32, 3);
pub const ENUM_MessageObj_PatternInstanceFourth = @as(u32, 4);
pub const ENUM_MessageObj_PatternInstanceLast = @as(u32, 5);
pub const TYPE_DeviceMetadataSvc = @as(u32, 0);
pub const ENUM_DeviceMetadataObj_DefaultCABFalse = @as(u32, 0);
pub const ENUM_DeviceMetadataObj_DefaultCABTrue = @as(u32, 1);
pub const TYPE_NotesSvc = @as(u32, 0);
pub const TYPE_StatusSvc = @as(u32, 0);
pub const RANGEMIN_StatusSvc_SignalStrength = @as(u32, 0);
pub const RANGEMAX_StatusSvc_SignalStrength = @as(u32, 4);
pub const RANGESTEP_StatusSvc_SignalStrength = @as(u32, 1);
pub const RANGEMAX_StatusSvc_TextMessages = @as(u32, 255);
pub const RANGEMAX_StatusSvc_NewPictures = @as(u32, 65535);
pub const RANGEMAX_StatusSvc_MissedCalls = @as(u32, 255);
pub const RANGEMAX_StatusSvc_VoiceMail = @as(u32, 255);
pub const ENUM_StatusSvc_RoamingInactive = @as(u32, 0);
pub const ENUM_StatusSvc_RoamingActive = @as(u32, 1);
pub const ENUM_StatusSvc_RoamingUnknown = @as(u32, 2);
pub const RANGEMIN_StatusSvc_BatteryLife = @as(u32, 0);
pub const RANGEMAX_StatusSvc_BatteryLife = @as(u32, 100);
pub const RANGESTEP_StatusSvc_BatteryLife = @as(u32, 1);
pub const ENUM_StatusSvc_ChargingInactive = @as(u32, 0);
pub const ENUM_StatusSvc_ChargingActive = @as(u32, 1);
pub const ENUM_StatusSvc_ChargingUnknown = @as(u32, 2);
pub const SYNCSVC_FILTER_NONE = @as(u32, 0);
pub const SYNCSVC_FILTER_CONTACTS_WITH_PHONE = @as(u32, 1);
pub const SYNCSVC_FILTER_TASK_ACTIVE = @as(u32, 2);
pub const SYNCSVC_FILTER_CALENDAR_WINDOW_WITH_RECURRENCE = @as(u32, 3);
pub const ENUM_SyncSvc_SyncObjectReferencesDisabled = @as(u32, 0);
pub const ENUM_SyncSvc_SyncObjectReferencesEnabled = @as(u32, 255);
pub const TYPE_TasksSvc = @as(u32, 0);
pub const ENUM_TaskObj_CompleteFalse = @as(u32, 0);
pub const ENUM_TaskObj_CompleteTrue = @as(u32, 255);
pub const WPD_CATEGORY_MTP_EXT_VENDOR_OPERATIONS = Guid.initString("4d545058-1a2e-4106-a357-771e0819fc56");
pub const WPD_COMMAND_MTP_EXT_GET_SUPPORTED_VENDOR_OPCODES = PROPERTYKEY{ .fmtid = Guid.initString("4d545058-1a2e-4106-a357-771e0819fc56"), .pid = 11 };
pub const WPD_COMMAND_MTP_EXT_EXECUTE_COMMAND_WITHOUT_DATA_PHASE = PROPERTYKEY{ .fmtid = Guid.initString("4d545058-1a2e-4106-a357-771e0819fc56"), .pid = 12 };
pub const WPD_COMMAND_MTP_EXT_EXECUTE_COMMAND_WITH_DATA_TO_READ = PROPERTYKEY{ .fmtid = Guid.initString("4d545058-1a2e-4106-a357-771e0819fc56"), .pid = 13 };
pub const WPD_COMMAND_MTP_EXT_EXECUTE_COMMAND_WITH_DATA_TO_WRITE = PROPERTYKEY{ .fmtid = Guid.initString("4d545058-1a2e-4106-a357-771e0819fc56"), .pid = 14 };
pub const WPD_COMMAND_MTP_EXT_READ_DATA = PROPERTYKEY{ .fmtid = Guid.initString("4d545058-1a2e-4106-a357-771e0819fc56"), .pid = 15 };
pub const WPD_COMMAND_MTP_EXT_WRITE_DATA = PROPERTYKEY{ .fmtid = Guid.initString("4d545058-1a2e-4106-a357-771e0819fc56"), .pid = 16 };
pub const WPD_COMMAND_MTP_EXT_END_DATA_TRANSFER = PROPERTYKEY{ .fmtid = Guid.initString("4d545058-1a2e-4106-a357-771e0819fc56"), .pid = 17 };
pub const WPD_COMMAND_MTP_EXT_GET_VENDOR_EXTENSION_DESCRIPTION = PROPERTYKEY{ .fmtid = Guid.initString("4d545058-1a2e-4106-a357-771e0819fc56"), .pid = 18 };
pub const WPD_PROPERTY_MTP_EXT_OPERATION_CODE = PROPERTYKEY{ .fmtid = Guid.initString("4d545058-1a2e-4106-a357-771e0819fc56"), .pid = 1001 };
pub const WPD_PROPERTY_MTP_EXT_OPERATION_PARAMS = PROPERTYKEY{ .fmtid = Guid.initString("4d545058-1a2e-4106-a357-771e0819fc56"), .pid = 1002 };
pub const WPD_PROPERTY_MTP_EXT_RESPONSE_CODE = PROPERTYKEY{ .fmtid = Guid.initString("4d545058-1a2e-4106-a357-771e0819fc56"), .pid = 1003 };
pub const WPD_PROPERTY_MTP_EXT_RESPONSE_PARAMS = PROPERTYKEY{ .fmtid = Guid.initString("4d545058-1a2e-4106-a357-771e0819fc56"), .pid = 1004 };
pub const WPD_PROPERTY_MTP_EXT_VENDOR_OPERATION_CODES = PROPERTYKEY{ .fmtid = Guid.initString("4d545058-1a2e-4106-a357-771e0819fc56"), .pid = 1005 };
pub const WPD_PROPERTY_MTP_EXT_TRANSFER_CONTEXT = PROPERTYKEY{ .fmtid = Guid.initString("4d545058-1a2e-4106-a357-771e0819fc56"), .pid = 1006 };
pub const WPD_PROPERTY_MTP_EXT_TRANSFER_TOTAL_DATA_SIZE = PROPERTYKEY{ .fmtid = Guid.initString("4d545058-1a2e-4106-a357-771e0819fc56"), .pid = 1007 };
pub const WPD_PROPERTY_MTP_EXT_TRANSFER_NUM_BYTES_TO_READ = PROPERTYKEY{ .fmtid = Guid.initString("4d545058-1a2e-4106-a357-771e0819fc56"), .pid = 1008 };
pub const WPD_PROPERTY_MTP_EXT_TRANSFER_NUM_BYTES_READ = PROPERTYKEY{ .fmtid = Guid.initString("4d545058-1a2e-4106-a357-771e0819fc56"), .pid = 1009 };
pub const WPD_PROPERTY_MTP_EXT_TRANSFER_NUM_BYTES_TO_WRITE = PROPERTYKEY{ .fmtid = Guid.initString("4d545058-1a2e-4106-a357-771e0819fc56"), .pid = 1010 };
pub const WPD_PROPERTY_MTP_EXT_TRANSFER_NUM_BYTES_WRITTEN = PROPERTYKEY{ .fmtid = Guid.initString("4d545058-1a2e-4106-a357-771e0819fc56"), .pid = 1011 };
pub const WPD_PROPERTY_MTP_EXT_TRANSFER_DATA = PROPERTYKEY{ .fmtid = Guid.initString("4d545058-1a2e-4106-a357-771e0819fc56"), .pid = 1012 };
pub const WPD_PROPERTY_MTP_EXT_OPTIMAL_TRANSFER_BUFFER_SIZE = PROPERTYKEY{ .fmtid = Guid.initString("4d545058-1a2e-4106-a357-771e0819fc56"), .pid = 1013 };
pub const WPD_PROPERTY_MTP_EXT_VENDOR_EXTENSION_DESCRIPTION = PROPERTYKEY{ .fmtid = Guid.initString("4d545058-1a2e-4106-a357-771e0819fc56"), .pid = 1014 };
pub const WPD_PROPERTIES_MTP_VENDOR_EXTENDED_OBJECT_PROPS = Guid.initString("4d545058-4fce-4578-95c8-8698a9bc0f49");
pub const WPD_PROPERTIES_MTP_VENDOR_EXTENDED_DEVICE_PROPS = Guid.initString("4d545058-8900-40b3-8f1d-dc246e1e8370");
pub const WPD_EVENT_MTP_VENDOR_EXTENDED_EVENTS = Guid.initString("00000000-5738-4ff2-8445-be3126691059");
pub const WPD_PROPERTY_MTP_EXT_EVENT_PARAMS = PROPERTYKEY{ .fmtid = Guid.initString("4d545058-ef88-4e4d-95c3-4f327f728a96"), .pid = 1011 };
pub const CLSID_WPD_NAMESPACE_EXTENSION = Guid.initString("35786d3c-b075-49b9-88dd-029876e11c01");
pub const WPDNSE_OBJECT_PROPERTIES_V1 = Guid.initString("34d71409-4b47-4d80-aaac-3a28a4a3b3e6");
pub const WPDNSE_OBJECT_HAS_CONTACT_PHOTO = PROPERTYKEY{ .fmtid = Guid.initString("34d71409-4b47-4d80-aaac-3a28a4a3b3e6"), .pid = 2 };
pub const WPDNSE_OBJECT_HAS_THUMBNAIL = PROPERTYKEY{ .fmtid = Guid.initString("34d71409-4b47-4d80-aaac-3a28a4a3b3e6"), .pid = 3 };
pub const WPDNSE_OBJECT_HAS_ICON = PROPERTYKEY{ .fmtid = Guid.initString("34d71409-4b47-4d80-aaac-3a28a4a3b3e6"), .pid = 4 };
pub const WPDNSE_OBJECT_HAS_AUDIO_CLIP = PROPERTYKEY{ .fmtid = Guid.initString("34d71409-4b47-4d80-aaac-3a28a4a3b3e6"), .pid = 5 };
pub const WPDNSE_OBJECT_HAS_ALBUM_ART = PROPERTYKEY{ .fmtid = Guid.initString("34d71409-4b47-4d80-aaac-3a28a4a3b3e6"), .pid = 6 };
pub const WPDNSE_OBJECT_OPTIMAL_READ_BLOCK_SIZE = PROPERTYKEY{ .fmtid = Guid.initString("34d71409-4b47-4d80-aaac-3a28a4a3b3e6"), .pid = 7 };
pub const WPDNSE_PROPSHEET_DEVICE_GENERAL = @as(u32, 1);
pub const WPDNSE_PROPSHEET_STORAGE_GENERAL = @as(u32, 2);
pub const WPDNSE_PROPSHEET_CONTENT_GENERAL = @as(u32, 4);
pub const WPDNSE_PROPSHEET_CONTENT_REFERENCES = @as(u32, 8);
pub const WPDNSE_PROPSHEET_CONTENT_RESOURCES = @as(u32, 16);
pub const WPDNSE_PROPSHEET_CONTENT_DETAILS = @as(u32, 32);
pub const TYPE_ContactsSvc = @as(u32, 0);
pub const TYPE_RingtonesSvc = @as(u32, 0);
pub const TYPE_AnchorSyncSvc = @as(u32, 1);
pub const ENUM_AnchorResults_AnchorStateNormal = @as(u32, 0);
pub const ENUM_AnchorResults_AnchorStateInvalid = @as(u32, 1);
pub const ENUM_AnchorResults_AnchorStateOld = @as(u32, 2);
pub const ENUM_AnchorResults_ItemStateInvalid = @as(u32, 0);
pub const ENUM_AnchorResults_ItemStateDeleted = @as(u32, 1);
pub const ENUM_AnchorResults_ItemStateCreated = @as(u32, 2);
pub const ENUM_AnchorResults_ItemStateUpdated = @as(u32, 3);
pub const ENUM_AnchorResults_ItemStateChanged = @as(u32, 4);
pub const TYPE_FullEnumSyncSvc = @as(u32, 1);

//--------------------------------------------------------------------------------
// Section: Types (80)
//--------------------------------------------------------------------------------
pub const DELETE_OBJECT_OPTIONS = enum(i32) {
    NO_RECURSION = 0,
    WITH_RECURSION = 1,
};
pub const PORTABLE_DEVICE_DELETE_NO_RECURSION = DELETE_OBJECT_OPTIONS.NO_RECURSION;
pub const PORTABLE_DEVICE_DELETE_WITH_RECURSION = DELETE_OBJECT_OPTIONS.WITH_RECURSION;

pub const WPD_DEVICE_TYPES = enum(i32) {
    GENERIC = 0,
    CAMERA = 1,
    MEDIA_PLAYER = 2,
    PHONE = 3,
    VIDEO = 4,
    PERSONAL_INFORMATION_MANAGER = 5,
    AUDIO_RECORDER = 6,
};
pub const WPD_DEVICE_TYPE_GENERIC = WPD_DEVICE_TYPES.GENERIC;
pub const WPD_DEVICE_TYPE_CAMERA = WPD_DEVICE_TYPES.CAMERA;
pub const WPD_DEVICE_TYPE_MEDIA_PLAYER = WPD_DEVICE_TYPES.MEDIA_PLAYER;
pub const WPD_DEVICE_TYPE_PHONE = WPD_DEVICE_TYPES.PHONE;
pub const WPD_DEVICE_TYPE_VIDEO = WPD_DEVICE_TYPES.VIDEO;
pub const WPD_DEVICE_TYPE_PERSONAL_INFORMATION_MANAGER = WPD_DEVICE_TYPES.PERSONAL_INFORMATION_MANAGER;
pub const WPD_DEVICE_TYPE_AUDIO_RECORDER = WPD_DEVICE_TYPES.AUDIO_RECORDER;

pub const WpdAttributeForm = enum(i32) {
    UNSPECIFIED = 0,
    RANGE = 1,
    ENUMERATION = 2,
    REGULAR_EXPRESSION = 3,
    OBJECT_IDENTIFIER = 4,
};
pub const WPD_PROPERTY_ATTRIBUTE_FORM_UNSPECIFIED = WpdAttributeForm.UNSPECIFIED;
pub const WPD_PROPERTY_ATTRIBUTE_FORM_RANGE = WpdAttributeForm.RANGE;
pub const WPD_PROPERTY_ATTRIBUTE_FORM_ENUMERATION = WpdAttributeForm.ENUMERATION;
pub const WPD_PROPERTY_ATTRIBUTE_FORM_REGULAR_EXPRESSION = WpdAttributeForm.REGULAR_EXPRESSION;
pub const WPD_PROPERTY_ATTRIBUTE_FORM_OBJECT_IDENTIFIER = WpdAttributeForm.OBJECT_IDENTIFIER;

pub const WpdParameterAttributeForm = enum(i32) {
    UNSPECIFIED = 0,
    RANGE = 1,
    ENUMERATION = 2,
    REGULAR_EXPRESSION = 3,
    OBJECT_IDENTIFIER = 4,
};
pub const WPD_PARAMETER_ATTRIBUTE_FORM_UNSPECIFIED = WpdParameterAttributeForm.UNSPECIFIED;
pub const WPD_PARAMETER_ATTRIBUTE_FORM_RANGE = WpdParameterAttributeForm.RANGE;
pub const WPD_PARAMETER_ATTRIBUTE_FORM_ENUMERATION = WpdParameterAttributeForm.ENUMERATION;
pub const WPD_PARAMETER_ATTRIBUTE_FORM_REGULAR_EXPRESSION = WpdParameterAttributeForm.REGULAR_EXPRESSION;
pub const WPD_PARAMETER_ATTRIBUTE_FORM_OBJECT_IDENTIFIER = WpdParameterAttributeForm.OBJECT_IDENTIFIER;

pub const WPD_DEVICE_TRANSPORTS = enum(i32) {
    UNSPECIFIED = 0,
    USB = 1,
    IP = 2,
    BLUETOOTH = 3,
};
pub const WPD_DEVICE_TRANSPORT_UNSPECIFIED = WPD_DEVICE_TRANSPORTS.UNSPECIFIED;
pub const WPD_DEVICE_TRANSPORT_USB = WPD_DEVICE_TRANSPORTS.USB;
pub const WPD_DEVICE_TRANSPORT_IP = WPD_DEVICE_TRANSPORTS.IP;
pub const WPD_DEVICE_TRANSPORT_BLUETOOTH = WPD_DEVICE_TRANSPORTS.BLUETOOTH;

pub const WPD_STORAGE_TYPE_VALUES = enum(i32) {
    UNDEFINED = 0,
    FIXED_ROM = 1,
    REMOVABLE_ROM = 2,
    FIXED_RAM = 3,
    REMOVABLE_RAM = 4,
};
pub const WPD_STORAGE_TYPE_UNDEFINED = WPD_STORAGE_TYPE_VALUES.UNDEFINED;
pub const WPD_STORAGE_TYPE_FIXED_ROM = WPD_STORAGE_TYPE_VALUES.FIXED_ROM;
pub const WPD_STORAGE_TYPE_REMOVABLE_ROM = WPD_STORAGE_TYPE_VALUES.REMOVABLE_ROM;
pub const WPD_STORAGE_TYPE_FIXED_RAM = WPD_STORAGE_TYPE_VALUES.FIXED_RAM;
pub const WPD_STORAGE_TYPE_REMOVABLE_RAM = WPD_STORAGE_TYPE_VALUES.REMOVABLE_RAM;

pub const WPD_STORAGE_ACCESS_CAPABILITY_VALUES = enum(i32) {
    WRITE = 0,
    _ONLY_WITHOUT_OBJECT_DELETION = 1,
    _ONLY_WITH_OBJECT_DELETION = 2,
};
pub const WPD_STORAGE_ACCESS_CAPABILITY_READWRITE = WPD_STORAGE_ACCESS_CAPABILITY_VALUES.WRITE;
pub const WPD_STORAGE_ACCESS_CAPABILITY_READ_ONLY_WITHOUT_OBJECT_DELETION = WPD_STORAGE_ACCESS_CAPABILITY_VALUES._ONLY_WITHOUT_OBJECT_DELETION;
pub const WPD_STORAGE_ACCESS_CAPABILITY_READ_ONLY_WITH_OBJECT_DELETION = WPD_STORAGE_ACCESS_CAPABILITY_VALUES._ONLY_WITH_OBJECT_DELETION;

pub const WPD_SMS_ENCODING_TYPES = enum(i32) {
    @"7_BIT" = 0,
    @"8_BIT" = 1,
    UTF_16 = 2,
};
pub const SMS_ENCODING_7_BIT = WPD_SMS_ENCODING_TYPES.@"7_BIT";
pub const SMS_ENCODING_8_BIT = WPD_SMS_ENCODING_TYPES.@"8_BIT";
pub const SMS_ENCODING_UTF_16 = WPD_SMS_ENCODING_TYPES.UTF_16;

pub const SMS_MESSAGE_TYPES = enum(i32) {
    TEXT_MESSAGE = 0,
    BINARY_MESSAGE = 1,
};
pub const SMS_TEXT_MESSAGE = SMS_MESSAGE_TYPES.TEXT_MESSAGE;
pub const SMS_BINARY_MESSAGE = SMS_MESSAGE_TYPES.BINARY_MESSAGE;

pub const WPD_POWER_SOURCES = enum(i32) {
    BATTERY = 0,
    EXTERNAL = 1,
};
pub const WPD_POWER_SOURCE_BATTERY = WPD_POWER_SOURCES.BATTERY;
pub const WPD_POWER_SOURCE_EXTERNAL = WPD_POWER_SOURCES.EXTERNAL;

pub const WPD_WHITE_BALANCE_SETTINGS = enum(i32) {
    UNDEFINED = 0,
    MANUAL = 1,
    AUTOMATIC = 2,
    ONE_PUSH_AUTOMATIC = 3,
    DAYLIGHT = 4,
    FLORESCENT = 5,
    TUNGSTEN = 6,
    FLASH = 7,
};
pub const WPD_WHITE_BALANCE_UNDEFINED = WPD_WHITE_BALANCE_SETTINGS.UNDEFINED;
pub const WPD_WHITE_BALANCE_MANUAL = WPD_WHITE_BALANCE_SETTINGS.MANUAL;
pub const WPD_WHITE_BALANCE_AUTOMATIC = WPD_WHITE_BALANCE_SETTINGS.AUTOMATIC;
pub const WPD_WHITE_BALANCE_ONE_PUSH_AUTOMATIC = WPD_WHITE_BALANCE_SETTINGS.ONE_PUSH_AUTOMATIC;
pub const WPD_WHITE_BALANCE_DAYLIGHT = WPD_WHITE_BALANCE_SETTINGS.DAYLIGHT;
pub const WPD_WHITE_BALANCE_FLORESCENT = WPD_WHITE_BALANCE_SETTINGS.FLORESCENT;
pub const WPD_WHITE_BALANCE_TUNGSTEN = WPD_WHITE_BALANCE_SETTINGS.TUNGSTEN;
pub const WPD_WHITE_BALANCE_FLASH = WPD_WHITE_BALANCE_SETTINGS.FLASH;

pub const WPD_FOCUS_MODES = enum(i32) {
    UNDEFINED = 0,
    MANUAL = 1,
    AUTOMATIC = 2,
    AUTOMATIC_MACRO = 3,
};
pub const WPD_FOCUS_UNDEFINED = WPD_FOCUS_MODES.UNDEFINED;
pub const WPD_FOCUS_MANUAL = WPD_FOCUS_MODES.MANUAL;
pub const WPD_FOCUS_AUTOMATIC = WPD_FOCUS_MODES.AUTOMATIC;
pub const WPD_FOCUS_AUTOMATIC_MACRO = WPD_FOCUS_MODES.AUTOMATIC_MACRO;

pub const WPD_EXPOSURE_METERING_MODES = enum(i32) {
    UNDEFINED = 0,
    AVERAGE = 1,
    CENTER_WEIGHTED_AVERAGE = 2,
    MULTI_SPOT = 3,
    CENTER_SPOT = 4,
};
pub const WPD_EXPOSURE_METERING_MODE_UNDEFINED = WPD_EXPOSURE_METERING_MODES.UNDEFINED;
pub const WPD_EXPOSURE_METERING_MODE_AVERAGE = WPD_EXPOSURE_METERING_MODES.AVERAGE;
pub const WPD_EXPOSURE_METERING_MODE_CENTER_WEIGHTED_AVERAGE = WPD_EXPOSURE_METERING_MODES.CENTER_WEIGHTED_AVERAGE;
pub const WPD_EXPOSURE_METERING_MODE_MULTI_SPOT = WPD_EXPOSURE_METERING_MODES.MULTI_SPOT;
pub const WPD_EXPOSURE_METERING_MODE_CENTER_SPOT = WPD_EXPOSURE_METERING_MODES.CENTER_SPOT;

pub const WPD_FLASH_MODES = enum(i32) {
    UNDEFINED = 0,
    AUTO = 1,
    OFF = 2,
    FILL = 3,
    RED_EYE_AUTO = 4,
    RED_EYE_FILL = 5,
    EXTERNAL_SYNC = 6,
};
pub const WPD_FLASH_MODE_UNDEFINED = WPD_FLASH_MODES.UNDEFINED;
pub const WPD_FLASH_MODE_AUTO = WPD_FLASH_MODES.AUTO;
pub const WPD_FLASH_MODE_OFF = WPD_FLASH_MODES.OFF;
pub const WPD_FLASH_MODE_FILL = WPD_FLASH_MODES.FILL;
pub const WPD_FLASH_MODE_RED_EYE_AUTO = WPD_FLASH_MODES.RED_EYE_AUTO;
pub const WPD_FLASH_MODE_RED_EYE_FILL = WPD_FLASH_MODES.RED_EYE_FILL;
pub const WPD_FLASH_MODE_EXTERNAL_SYNC = WPD_FLASH_MODES.EXTERNAL_SYNC;

pub const WPD_EXPOSURE_PROGRAM_MODES = enum(i32) {
    UNDEFINED = 0,
    MANUAL = 1,
    AUTO = 2,
    APERTURE_PRIORITY = 3,
    SHUTTER_PRIORITY = 4,
    CREATIVE = 5,
    ACTION = 6,
    PORTRAIT = 7,
};
pub const WPD_EXPOSURE_PROGRAM_MODE_UNDEFINED = WPD_EXPOSURE_PROGRAM_MODES.UNDEFINED;
pub const WPD_EXPOSURE_PROGRAM_MODE_MANUAL = WPD_EXPOSURE_PROGRAM_MODES.MANUAL;
pub const WPD_EXPOSURE_PROGRAM_MODE_AUTO = WPD_EXPOSURE_PROGRAM_MODES.AUTO;
pub const WPD_EXPOSURE_PROGRAM_MODE_APERTURE_PRIORITY = WPD_EXPOSURE_PROGRAM_MODES.APERTURE_PRIORITY;
pub const WPD_EXPOSURE_PROGRAM_MODE_SHUTTER_PRIORITY = WPD_EXPOSURE_PROGRAM_MODES.SHUTTER_PRIORITY;
pub const WPD_EXPOSURE_PROGRAM_MODE_CREATIVE = WPD_EXPOSURE_PROGRAM_MODES.CREATIVE;
pub const WPD_EXPOSURE_PROGRAM_MODE_ACTION = WPD_EXPOSURE_PROGRAM_MODES.ACTION;
pub const WPD_EXPOSURE_PROGRAM_MODE_PORTRAIT = WPD_EXPOSURE_PROGRAM_MODES.PORTRAIT;

pub const WPD_CAPTURE_MODES = enum(i32) {
    UNDEFINED = 0,
    NORMAL = 1,
    BURST = 2,
    TIMELAPSE = 3,
};
pub const WPD_CAPTURE_MODE_UNDEFINED = WPD_CAPTURE_MODES.UNDEFINED;
pub const WPD_CAPTURE_MODE_NORMAL = WPD_CAPTURE_MODES.NORMAL;
pub const WPD_CAPTURE_MODE_BURST = WPD_CAPTURE_MODES.BURST;
pub const WPD_CAPTURE_MODE_TIMELAPSE = WPD_CAPTURE_MODES.TIMELAPSE;

pub const WPD_EFFECT_MODES = enum(i32) {
    UNDEFINED = 0,
    COLOR = 1,
    BLACK_AND_WHITE = 2,
    SEPIA = 3,
};
pub const WPD_EFFECT_MODE_UNDEFINED = WPD_EFFECT_MODES.UNDEFINED;
pub const WPD_EFFECT_MODE_COLOR = WPD_EFFECT_MODES.COLOR;
pub const WPD_EFFECT_MODE_BLACK_AND_WHITE = WPD_EFFECT_MODES.BLACK_AND_WHITE;
pub const WPD_EFFECT_MODE_SEPIA = WPD_EFFECT_MODES.SEPIA;

pub const WPD_FOCUS_METERING_MODES = enum(i32) {
    UNDEFINED = 0,
    CENTER_SPOT = 1,
    MULTI_SPOT = 2,
};
pub const WPD_FOCUS_METERING_MODE_UNDEFINED = WPD_FOCUS_METERING_MODES.UNDEFINED;
pub const WPD_FOCUS_METERING_MODE_CENTER_SPOT = WPD_FOCUS_METERING_MODES.CENTER_SPOT;
pub const WPD_FOCUS_METERING_MODE_MULTI_SPOT = WPD_FOCUS_METERING_MODES.MULTI_SPOT;

pub const WPD_BITRATE_TYPES = enum(i32) {
    UNUSED = 0,
    DISCRETE = 1,
    VARIABLE = 2,
    FREE = 3,
};
pub const WPD_BITRATE_TYPE_UNUSED = WPD_BITRATE_TYPES.UNUSED;
pub const WPD_BITRATE_TYPE_DISCRETE = WPD_BITRATE_TYPES.DISCRETE;
pub const WPD_BITRATE_TYPE_VARIABLE = WPD_BITRATE_TYPES.VARIABLE;
pub const WPD_BITRATE_TYPE_FREE = WPD_BITRATE_TYPES.FREE;

pub const WPD_META_GENRES = enum(i32) {
    UNUSED = 0,
    GENERIC_MUSIC_AUDIO_FILE = 1,
    GENERIC_NON_MUSIC_AUDIO_FILE = 17,
    SPOKEN_WORD_AUDIO_BOOK_FILES = 18,
    SPOKEN_WORD_FILES_NON_AUDIO_BOOK = 19,
    SPOKEN_WORD_NEWS = 20,
    SPOKEN_WORD_TALK_SHOWS = 21,
    GENERIC_VIDEO_FILE = 33,
    NEWS_VIDEO_FILE = 34,
    MUSIC_VIDEO_FILE = 35,
    HOME_VIDEO_FILE = 36,
    FEATURE_FILM_VIDEO_FILE = 37,
    TELEVISION_VIDEO_FILE = 38,
    TRAINING_EDUCATIONAL_VIDEO_FILE = 39,
    PHOTO_MONTAGE_VIDEO_FILE = 40,
    GENERIC_NON_AUDIO_NON_VIDEO = 48,
    AUDIO_PODCAST = 64,
    VIDEO_PODCAST = 65,
    MIXED_PODCAST = 66,
};
pub const WPD_META_GENRE_UNUSED = WPD_META_GENRES.UNUSED;
pub const WPD_META_GENRE_GENERIC_MUSIC_AUDIO_FILE = WPD_META_GENRES.GENERIC_MUSIC_AUDIO_FILE;
pub const WPD_META_GENRE_GENERIC_NON_MUSIC_AUDIO_FILE = WPD_META_GENRES.GENERIC_NON_MUSIC_AUDIO_FILE;
pub const WPD_META_GENRE_SPOKEN_WORD_AUDIO_BOOK_FILES = WPD_META_GENRES.SPOKEN_WORD_AUDIO_BOOK_FILES;
pub const WPD_META_GENRE_SPOKEN_WORD_FILES_NON_AUDIO_BOOK = WPD_META_GENRES.SPOKEN_WORD_FILES_NON_AUDIO_BOOK;
pub const WPD_META_GENRE_SPOKEN_WORD_NEWS = WPD_META_GENRES.SPOKEN_WORD_NEWS;
pub const WPD_META_GENRE_SPOKEN_WORD_TALK_SHOWS = WPD_META_GENRES.SPOKEN_WORD_TALK_SHOWS;
pub const WPD_META_GENRE_GENERIC_VIDEO_FILE = WPD_META_GENRES.GENERIC_VIDEO_FILE;
pub const WPD_META_GENRE_NEWS_VIDEO_FILE = WPD_META_GENRES.NEWS_VIDEO_FILE;
pub const WPD_META_GENRE_MUSIC_VIDEO_FILE = WPD_META_GENRES.MUSIC_VIDEO_FILE;
pub const WPD_META_GENRE_HOME_VIDEO_FILE = WPD_META_GENRES.HOME_VIDEO_FILE;
pub const WPD_META_GENRE_FEATURE_FILM_VIDEO_FILE = WPD_META_GENRES.FEATURE_FILM_VIDEO_FILE;
pub const WPD_META_GENRE_TELEVISION_VIDEO_FILE = WPD_META_GENRES.TELEVISION_VIDEO_FILE;
pub const WPD_META_GENRE_TRAINING_EDUCATIONAL_VIDEO_FILE = WPD_META_GENRES.TRAINING_EDUCATIONAL_VIDEO_FILE;
pub const WPD_META_GENRE_PHOTO_MONTAGE_VIDEO_FILE = WPD_META_GENRES.PHOTO_MONTAGE_VIDEO_FILE;
pub const WPD_META_GENRE_GENERIC_NON_AUDIO_NON_VIDEO = WPD_META_GENRES.GENERIC_NON_AUDIO_NON_VIDEO;
pub const WPD_META_GENRE_AUDIO_PODCAST = WPD_META_GENRES.AUDIO_PODCAST;
pub const WPD_META_GENRE_VIDEO_PODCAST = WPD_META_GENRES.VIDEO_PODCAST;
pub const WPD_META_GENRE_MIXED_PODCAST = WPD_META_GENRES.MIXED_PODCAST;

pub const WPD_CROPPED_STATUS_VALUES = enum(i32) {
    NOT_CROPPED = 0,
    CROPPED = 1,
    SHOULD_NOT_BE_CROPPED = 2,
};
pub const WPD_CROPPED_STATUS_NOT_CROPPED = WPD_CROPPED_STATUS_VALUES.NOT_CROPPED;
pub const WPD_CROPPED_STATUS_CROPPED = WPD_CROPPED_STATUS_VALUES.CROPPED;
pub const WPD_CROPPED_STATUS_SHOULD_NOT_BE_CROPPED = WPD_CROPPED_STATUS_VALUES.SHOULD_NOT_BE_CROPPED;

pub const WPD_COLOR_CORRECTED_STATUS_VALUES = enum(i32) {
    NOT_CORRECTED = 0,
    CORRECTED = 1,
    SHOULD_NOT_BE_CORRECTED = 2,
};
pub const WPD_COLOR_CORRECTED_STATUS_NOT_CORRECTED = WPD_COLOR_CORRECTED_STATUS_VALUES.NOT_CORRECTED;
pub const WPD_COLOR_CORRECTED_STATUS_CORRECTED = WPD_COLOR_CORRECTED_STATUS_VALUES.CORRECTED;
pub const WPD_COLOR_CORRECTED_STATUS_SHOULD_NOT_BE_CORRECTED = WPD_COLOR_CORRECTED_STATUS_VALUES.SHOULD_NOT_BE_CORRECTED;

pub const WPD_VIDEO_SCAN_TYPES = enum(i32) {
    UNUSED = 0,
    PROGRESSIVE = 1,
    FIELD_INTERLEAVED_UPPER_FIRST = 2,
    FIELD_INTERLEAVED_LOWER_FIRST = 3,
    FIELD_SINGLE_UPPER_FIRST = 4,
    FIELD_SINGLE_LOWER_FIRST = 5,
    MIXED_INTERLACE = 6,
    MIXED_INTERLACE_AND_PROGRESSIVE = 7,
};
pub const WPD_VIDEO_SCAN_TYPE_UNUSED = WPD_VIDEO_SCAN_TYPES.UNUSED;
pub const WPD_VIDEO_SCAN_TYPE_PROGRESSIVE = WPD_VIDEO_SCAN_TYPES.PROGRESSIVE;
pub const WPD_VIDEO_SCAN_TYPE_FIELD_INTERLEAVED_UPPER_FIRST = WPD_VIDEO_SCAN_TYPES.FIELD_INTERLEAVED_UPPER_FIRST;
pub const WPD_VIDEO_SCAN_TYPE_FIELD_INTERLEAVED_LOWER_FIRST = WPD_VIDEO_SCAN_TYPES.FIELD_INTERLEAVED_LOWER_FIRST;
pub const WPD_VIDEO_SCAN_TYPE_FIELD_SINGLE_UPPER_FIRST = WPD_VIDEO_SCAN_TYPES.FIELD_SINGLE_UPPER_FIRST;
pub const WPD_VIDEO_SCAN_TYPE_FIELD_SINGLE_LOWER_FIRST = WPD_VIDEO_SCAN_TYPES.FIELD_SINGLE_LOWER_FIRST;
pub const WPD_VIDEO_SCAN_TYPE_MIXED_INTERLACE = WPD_VIDEO_SCAN_TYPES.MIXED_INTERLACE;
pub const WPD_VIDEO_SCAN_TYPE_MIXED_INTERLACE_AND_PROGRESSIVE = WPD_VIDEO_SCAN_TYPES.MIXED_INTERLACE_AND_PROGRESSIVE;

pub const WPD_OPERATION_STATES = enum(i32) {
    UNSPECIFIED = 0,
    STARTED = 1,
    RUNNING = 2,
    PAUSED = 3,
    CANCELLED = 4,
    FINISHED = 5,
    ABORTED = 6,
};
pub const WPD_OPERATION_STATE_UNSPECIFIED = WPD_OPERATION_STATES.UNSPECIFIED;
pub const WPD_OPERATION_STATE_STARTED = WPD_OPERATION_STATES.STARTED;
pub const WPD_OPERATION_STATE_RUNNING = WPD_OPERATION_STATES.RUNNING;
pub const WPD_OPERATION_STATE_PAUSED = WPD_OPERATION_STATES.PAUSED;
pub const WPD_OPERATION_STATE_CANCELLED = WPD_OPERATION_STATES.CANCELLED;
pub const WPD_OPERATION_STATE_FINISHED = WPD_OPERATION_STATES.FINISHED;
pub const WPD_OPERATION_STATE_ABORTED = WPD_OPERATION_STATES.ABORTED;

pub const WPD_SECTION_DATA_UNITS_VALUES = enum(i32) {
    BYTES = 0,
    MILLISECONDS = 1,
};
pub const WPD_SECTION_DATA_UNITS_BYTES = WPD_SECTION_DATA_UNITS_VALUES.BYTES;
pub const WPD_SECTION_DATA_UNITS_MILLISECONDS = WPD_SECTION_DATA_UNITS_VALUES.MILLISECONDS;

pub const WPD_RENDERING_INFORMATION_PROFILE_ENTRY_TYPES = enum(i32) {
    OBJECT = 0,
    RESOURCE = 1,
};
pub const WPD_RENDERING_INFORMATION_PROFILE_ENTRY_TYPE_OBJECT = WPD_RENDERING_INFORMATION_PROFILE_ENTRY_TYPES.OBJECT;
pub const WPD_RENDERING_INFORMATION_PROFILE_ENTRY_TYPE_RESOURCE = WPD_RENDERING_INFORMATION_PROFILE_ENTRY_TYPES.RESOURCE;

pub const WPD_COMMAND_ACCESS_TYPES = enum(i32) {
    READ = 1,
    READWRITE = 3,
    FROM_PROPERTY_WITH_STGM_ACCESS = 4,
    FROM_PROPERTY_WITH_FILE_ACCESS = 8,
    FROM_ATTRIBUTE_WITH_METHOD_ACCESS = 16,
};
pub const WPD_COMMAND_ACCESS_READ = WPD_COMMAND_ACCESS_TYPES.READ;
pub const WPD_COMMAND_ACCESS_READWRITE = WPD_COMMAND_ACCESS_TYPES.READWRITE;
pub const WPD_COMMAND_ACCESS_FROM_PROPERTY_WITH_STGM_ACCESS = WPD_COMMAND_ACCESS_TYPES.FROM_PROPERTY_WITH_STGM_ACCESS;
pub const WPD_COMMAND_ACCESS_FROM_PROPERTY_WITH_FILE_ACCESS = WPD_COMMAND_ACCESS_TYPES.FROM_PROPERTY_WITH_FILE_ACCESS;
pub const WPD_COMMAND_ACCESS_FROM_ATTRIBUTE_WITH_METHOD_ACCESS = WPD_COMMAND_ACCESS_TYPES.FROM_ATTRIBUTE_WITH_METHOD_ACCESS;

pub const WPD_SERVICE_INHERITANCE_TYPES = enum(i32) {
    N = 0,
};
pub const WPD_SERVICE_INHERITANCE_IMPLEMENTATION = WPD_SERVICE_INHERITANCE_TYPES.N;

pub const WPD_PARAMETER_USAGE_TYPES = enum(i32) {
    RETURN = 0,
    IN = 1,
    OUT = 2,
    INOUT = 3,
};
pub const WPD_PARAMETER_USAGE_RETURN = WPD_PARAMETER_USAGE_TYPES.RETURN;
pub const WPD_PARAMETER_USAGE_IN = WPD_PARAMETER_USAGE_TYPES.IN;
pub const WPD_PARAMETER_USAGE_OUT = WPD_PARAMETER_USAGE_TYPES.OUT;
pub const WPD_PARAMETER_USAGE_INOUT = WPD_PARAMETER_USAGE_TYPES.INOUT;

pub const WPD_COMMAND_ACCESS_LOOKUP_ENTRY = extern struct {
    Command: PROPERTYKEY,
    AccessType: u32,
    AccessProperty: PROPERTYKEY,
};

const CLSID_WpdSerializer_Value = Guid.initString("0b91a74b-ad7c-4a9d-b563-29eef9167172");
pub const CLSID_WpdSerializer = &CLSID_WpdSerializer_Value;

const CLSID_PortableDeviceValues_Value = Guid.initString("0c15d503-d017-47ce-9016-7b3f978721cc");
pub const CLSID_PortableDeviceValues = &CLSID_PortableDeviceValues_Value;

const CLSID_PortableDeviceKeyCollection_Value = Guid.initString("de2d022d-2480-43be-97f0-d1fa2cf98f4f");
pub const CLSID_PortableDeviceKeyCollection = &CLSID_PortableDeviceKeyCollection_Value;

const CLSID_PortableDevicePropVariantCollection_Value = Guid.initString("08a99e2f-6d6d-4b80-af5a-baf2bcbe4cb9");
pub const CLSID_PortableDevicePropVariantCollection = &CLSID_PortableDevicePropVariantCollection_Value;

const CLSID_PortableDeviceValuesCollection_Value = Guid.initString("3882134d-14cf-4220-9cb4-435f86d83f60");
pub const CLSID_PortableDeviceValuesCollection = &CLSID_PortableDeviceValuesCollection_Value;

pub const WPD_STREAM_UNITS = enum(i32) {
    BYTES = 0,
    FRAMES = 1,
    ROWS = 2,
    MILLISECONDS = 4,
    MICROSECONDS = 8,
};
pub const WPD_STREAM_UNITS_BYTES = WPD_STREAM_UNITS.BYTES;
pub const WPD_STREAM_UNITS_FRAMES = WPD_STREAM_UNITS.FRAMES;
pub const WPD_STREAM_UNITS_ROWS = WPD_STREAM_UNITS.ROWS;
pub const WPD_STREAM_UNITS_MILLISECONDS = WPD_STREAM_UNITS.MILLISECONDS;
pub const WPD_STREAM_UNITS_MICROSECONDS = WPD_STREAM_UNITS.MICROSECONDS;

const IID_IWpdSerializer_Value = Guid.initString("b32f4002-bb27-45ff-af4f-06631c1e8dad");
pub const IID_IWpdSerializer = &IID_IWpdSerializer_Value;
pub const IWpdSerializer = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetIPortableDeviceValuesFromBuffer: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IWpdSerializer,
                pBuffer: [*:0]u8,
                dwInputBufferLength: u32,
                ppParams: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IWpdSerializer,
                pBuffer: [*:0]u8,
                dwInputBufferLength: u32,
                ppParams: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        WriteIPortableDeviceValuesToBuffer: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IWpdSerializer,
                dwOutputBufferLength: u32,
                pResults: ?*IPortableDeviceValues,
                pBuffer: [*:0]u8,
                pdwBytesWritten: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IWpdSerializer,
                dwOutputBufferLength: u32,
                pResults: ?*IPortableDeviceValues,
                pBuffer: [*:0]u8,
                pdwBytesWritten: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetBufferFromIPortableDeviceValues: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IWpdSerializer,
                pSource: ?*IPortableDeviceValues,
                ppBuffer: [*]?*u8,
                pdwBufferSize: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IWpdSerializer,
                pSource: ?*IPortableDeviceValues,
                ppBuffer: [*]?*u8,
                pdwBufferSize: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetSerializedSize: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IWpdSerializer,
                pSource: ?*IPortableDeviceValues,
                pdwSize: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IWpdSerializer,
                pSource: ?*IPortableDeviceValues,
                pdwSize: ?*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 IWpdSerializer_GetIPortableDeviceValuesFromBuffer(self: *const T, pBuffer: [*:0]u8, dwInputBufferLength: u32, ppParams: ?*?*IPortableDeviceValues) HRESULT {
                return @as(*const IWpdSerializer.VTable, @ptrCast(self.vtable)).GetIPortableDeviceValuesFromBuffer(@as(*const IWpdSerializer, @ptrCast(self)), pBuffer, dwInputBufferLength, ppParams);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IWpdSerializer_WriteIPortableDeviceValuesToBuffer(self: *const T, dwOutputBufferLength: u32, pResults: ?*IPortableDeviceValues, pBuffer: [*:0]u8, pdwBytesWritten: ?*u32) HRESULT {
                return @as(*const IWpdSerializer.VTable, @ptrCast(self.vtable)).WriteIPortableDeviceValuesToBuffer(@as(*const IWpdSerializer, @ptrCast(self)), dwOutputBufferLength, pResults, pBuffer, pdwBytesWritten);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IWpdSerializer_GetBufferFromIPortableDeviceValues(self: *const T, pSource: ?*IPortableDeviceValues, ppBuffer: [*]?*u8, pdwBufferSize: ?*u32) HRESULT {
                return @as(*const IWpdSerializer.VTable, @ptrCast(self.vtable)).GetBufferFromIPortableDeviceValues(@as(*const IWpdSerializer, @ptrCast(self)), pSource, ppBuffer, pdwBufferSize);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IWpdSerializer_GetSerializedSize(self: *const T, pSource: ?*IPortableDeviceValues, pdwSize: ?*u32) HRESULT {
                return @as(*const IWpdSerializer.VTable, @ptrCast(self.vtable)).GetSerializedSize(@as(*const IWpdSerializer, @ptrCast(self)), pSource, pdwSize);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IPortableDeviceValues_Value = Guid.initString("6848f6f2-3155-4f86-b6f5-263eeeab3143");
pub const IID_IPortableDeviceValues = &IID_IPortableDeviceValues_Value;
pub const IPortableDeviceValues = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetCount: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValues,
                pcelt: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValues,
                pcelt: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetAt: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValues,
                index: u32,
                pKey: ?*PROPERTYKEY,
                pValue: ?*PROPVARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValues,
                index: u32,
                pKey: ?*PROPERTYKEY,
                pValue: ?*PROPVARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                pValue: ?*const PROPVARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                pValue: ?*const PROPVARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                pValue: ?*PROPVARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                pValue: ?*PROPVARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetStringValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                Value: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                Value: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetStringValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                pValue: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                pValue: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetUnsignedIntegerValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                Value: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                Value: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetUnsignedIntegerValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                pValue: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                pValue: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetSignedIntegerValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                Value: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                Value: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetSignedIntegerValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                pValue: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                pValue: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetUnsignedLargeIntegerValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                Value: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                Value: u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetUnsignedLargeIntegerValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                pValue: ?*u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                pValue: ?*u64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetSignedLargeIntegerValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                Value: i64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                Value: i64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetSignedLargeIntegerValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                pValue: ?*i64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                pValue: ?*i64,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetFloatValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                Value: f32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                Value: f32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetFloatValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                pValue: ?*f32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                pValue: ?*f32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetErrorValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                Value: HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                Value: HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetErrorValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                pValue: ?*HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                pValue: ?*HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetKeyValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                Value: ?*const PROPERTYKEY,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                Value: ?*const PROPERTYKEY,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetKeyValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                pValue: ?*PROPERTYKEY,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                pValue: ?*PROPERTYKEY,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetBoolValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                Value: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                Value: BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetBoolValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                pValue: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                pValue: ?*BOOL,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetIUnknownValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                pValue: ?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                pValue: ?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetIUnknownValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                ppValue: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                ppValue: ?*?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetGuidValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                Value: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                Value: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetGuidValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                pValue: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                pValue: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetBufferValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                pValue: [*:0]u8,
                cbValue: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                pValue: [*:0]u8,
                cbValue: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetBufferValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                ppValue: [*]?*u8,
                pcbValue: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                ppValue: [*]?*u8,
                pcbValue: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetIPortableDeviceValuesValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                pValue: ?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                pValue: ?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetIPortableDeviceValuesValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                ppValue: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                ppValue: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetIPortableDevicePropVariantCollectionValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                pValue: ?*IPortableDevicePropVariantCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                pValue: ?*IPortableDevicePropVariantCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetIPortableDevicePropVariantCollectionValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                ppValue: ?*?*IPortableDevicePropVariantCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                ppValue: ?*?*IPortableDevicePropVariantCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetIPortableDeviceKeyCollectionValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                pValue: ?*IPortableDeviceKeyCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                pValue: ?*IPortableDeviceKeyCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetIPortableDeviceKeyCollectionValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                ppValue: ?*?*IPortableDeviceKeyCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                ppValue: ?*?*IPortableDeviceKeyCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetIPortableDeviceValuesCollectionValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                pValue: ?*IPortableDeviceValuesCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                pValue: ?*IPortableDeviceValuesCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetIPortableDeviceValuesCollectionValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                ppValue: ?*?*IPortableDeviceValuesCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
                ppValue: ?*?*IPortableDeviceValuesCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        RemoveValue: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValues,
                key: ?*const PROPERTYKEY,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        CopyValuesFromPropertyStore: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValues,
                pStore: ?*IPropertyStore,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValues,
                pStore: ?*IPropertyStore,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        CopyValuesToPropertyStore: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValues,
                pStore: ?*IPropertyStore,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValues,
                pStore: ?*IPropertyStore,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Clear: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const 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 IPortableDeviceValues_GetCount(self: *const T, pcelt: ?*u32) HRESULT {
                return @as(*const IPortableDeviceValues.VTable, @ptrCast(self.vtable)).GetCount(@as(*const IPortableDeviceValues, @ptrCast(self)), pcelt);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValues_GetAt(self: *const T, index: u32, pKey: ?*PROPERTYKEY, pValue: ?*PROPVARIANT) HRESULT {
                return @as(*const IPortableDeviceValues.VTable, @ptrCast(self.vtable)).GetAt(@as(*const IPortableDeviceValues, @ptrCast(self)), index, pKey, pValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValues_SetValue(self: *const T, key: ?*const PROPERTYKEY, pValue: ?*const PROPVARIANT) HRESULT {
                return @as(*const IPortableDeviceValues.VTable, @ptrCast(self.vtable)).SetValue(@as(*const IPortableDeviceValues, @ptrCast(self)), key, pValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValues_GetValue(self: *const T, key: ?*const PROPERTYKEY, pValue: ?*PROPVARIANT) HRESULT {
                return @as(*const IPortableDeviceValues.VTable, @ptrCast(self.vtable)).GetValue(@as(*const IPortableDeviceValues, @ptrCast(self)), key, pValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValues_SetStringValue(self: *const T, key: ?*const PROPERTYKEY, Value: ?[*:0]const u16) HRESULT {
                return @as(*const IPortableDeviceValues.VTable, @ptrCast(self.vtable)).SetStringValue(@as(*const IPortableDeviceValues, @ptrCast(self)), key, Value);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValues_GetStringValue(self: *const T, key: ?*const PROPERTYKEY, pValue: ?*?PWSTR) HRESULT {
                return @as(*const IPortableDeviceValues.VTable, @ptrCast(self.vtable)).GetStringValue(@as(*const IPortableDeviceValues, @ptrCast(self)), key, pValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValues_SetUnsignedIntegerValue(self: *const T, key: ?*const PROPERTYKEY, Value: u32) HRESULT {
                return @as(*const IPortableDeviceValues.VTable, @ptrCast(self.vtable)).SetUnsignedIntegerValue(@as(*const IPortableDeviceValues, @ptrCast(self)), key, Value);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValues_GetUnsignedIntegerValue(self: *const T, key: ?*const PROPERTYKEY, pValue: ?*u32) HRESULT {
                return @as(*const IPortableDeviceValues.VTable, @ptrCast(self.vtable)).GetUnsignedIntegerValue(@as(*const IPortableDeviceValues, @ptrCast(self)), key, pValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValues_SetSignedIntegerValue(self: *const T, key: ?*const PROPERTYKEY, Value: i32) HRESULT {
                return @as(*const IPortableDeviceValues.VTable, @ptrCast(self.vtable)).SetSignedIntegerValue(@as(*const IPortableDeviceValues, @ptrCast(self)), key, Value);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValues_GetSignedIntegerValue(self: *const T, key: ?*const PROPERTYKEY, pValue: ?*i32) HRESULT {
                return @as(*const IPortableDeviceValues.VTable, @ptrCast(self.vtable)).GetSignedIntegerValue(@as(*const IPortableDeviceValues, @ptrCast(self)), key, pValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValues_SetUnsignedLargeIntegerValue(self: *const T, key: ?*const PROPERTYKEY, Value: u64) HRESULT {
                return @as(*const IPortableDeviceValues.VTable, @ptrCast(self.vtable)).SetUnsignedLargeIntegerValue(@as(*const IPortableDeviceValues, @ptrCast(self)), key, Value);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValues_GetUnsignedLargeIntegerValue(self: *const T, key: ?*const PROPERTYKEY, pValue: ?*u64) HRESULT {
                return @as(*const IPortableDeviceValues.VTable, @ptrCast(self.vtable)).GetUnsignedLargeIntegerValue(@as(*const IPortableDeviceValues, @ptrCast(self)), key, pValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValues_SetSignedLargeIntegerValue(self: *const T, key: ?*const PROPERTYKEY, Value: i64) HRESULT {
                return @as(*const IPortableDeviceValues.VTable, @ptrCast(self.vtable)).SetSignedLargeIntegerValue(@as(*const IPortableDeviceValues, @ptrCast(self)), key, Value);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValues_GetSignedLargeIntegerValue(self: *const T, key: ?*const PROPERTYKEY, pValue: ?*i64) HRESULT {
                return @as(*const IPortableDeviceValues.VTable, @ptrCast(self.vtable)).GetSignedLargeIntegerValue(@as(*const IPortableDeviceValues, @ptrCast(self)), key, pValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValues_SetFloatValue(self: *const T, key: ?*const PROPERTYKEY, Value: f32) HRESULT {
                return @as(*const IPortableDeviceValues.VTable, @ptrCast(self.vtable)).SetFloatValue(@as(*const IPortableDeviceValues, @ptrCast(self)), key, Value);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValues_GetFloatValue(self: *const T, key: ?*const PROPERTYKEY, pValue: ?*f32) HRESULT {
                return @as(*const IPortableDeviceValues.VTable, @ptrCast(self.vtable)).GetFloatValue(@as(*const IPortableDeviceValues, @ptrCast(self)), key, pValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValues_SetErrorValue(self: *const T, key: ?*const PROPERTYKEY, Value: HRESULT) HRESULT {
                return @as(*const IPortableDeviceValues.VTable, @ptrCast(self.vtable)).SetErrorValue(@as(*const IPortableDeviceValues, @ptrCast(self)), key, Value);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValues_GetErrorValue(self: *const T, key: ?*const PROPERTYKEY, pValue: ?*HRESULT) HRESULT {
                return @as(*const IPortableDeviceValues.VTable, @ptrCast(self.vtable)).GetErrorValue(@as(*const IPortableDeviceValues, @ptrCast(self)), key, pValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValues_SetKeyValue(self: *const T, key: ?*const PROPERTYKEY, Value: ?*const PROPERTYKEY) HRESULT {
                return @as(*const IPortableDeviceValues.VTable, @ptrCast(self.vtable)).SetKeyValue(@as(*const IPortableDeviceValues, @ptrCast(self)), key, Value);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValues_GetKeyValue(self: *const T, key: ?*const PROPERTYKEY, pValue: ?*PROPERTYKEY) HRESULT {
                return @as(*const IPortableDeviceValues.VTable, @ptrCast(self.vtable)).GetKeyValue(@as(*const IPortableDeviceValues, @ptrCast(self)), key, pValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValues_SetBoolValue(self: *const T, key: ?*const PROPERTYKEY, Value: BOOL) HRESULT {
                return @as(*const IPortableDeviceValues.VTable, @ptrCast(self.vtable)).SetBoolValue(@as(*const IPortableDeviceValues, @ptrCast(self)), key, Value);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValues_GetBoolValue(self: *const T, key: ?*const PROPERTYKEY, pValue: ?*BOOL) HRESULT {
                return @as(*const IPortableDeviceValues.VTable, @ptrCast(self.vtable)).GetBoolValue(@as(*const IPortableDeviceValues, @ptrCast(self)), key, pValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValues_SetIUnknownValue(self: *const T, key: ?*const PROPERTYKEY, pValue: ?*IUnknown) HRESULT {
                return @as(*const IPortableDeviceValues.VTable, @ptrCast(self.vtable)).SetIUnknownValue(@as(*const IPortableDeviceValues, @ptrCast(self)), key, pValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValues_GetIUnknownValue(self: *const T, key: ?*const PROPERTYKEY, ppValue: ?*?*IUnknown) HRESULT {
                return @as(*const IPortableDeviceValues.VTable, @ptrCast(self.vtable)).GetIUnknownValue(@as(*const IPortableDeviceValues, @ptrCast(self)), key, ppValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValues_SetGuidValue(self: *const T, key: ?*const PROPERTYKEY, Value: ?*const Guid) HRESULT {
                return @as(*const IPortableDeviceValues.VTable, @ptrCast(self.vtable)).SetGuidValue(@as(*const IPortableDeviceValues, @ptrCast(self)), key, Value);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValues_GetGuidValue(self: *const T, key: ?*const PROPERTYKEY, pValue: ?*Guid) HRESULT {
                return @as(*const IPortableDeviceValues.VTable, @ptrCast(self.vtable)).GetGuidValue(@as(*const IPortableDeviceValues, @ptrCast(self)), key, pValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValues_SetBufferValue(self: *const T, key: ?*const PROPERTYKEY, pValue: [*:0]u8, cbValue: u32) HRESULT {
                return @as(*const IPortableDeviceValues.VTable, @ptrCast(self.vtable)).SetBufferValue(@as(*const IPortableDeviceValues, @ptrCast(self)), key, pValue, cbValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValues_GetBufferValue(self: *const T, key: ?*const PROPERTYKEY, ppValue: [*]?*u8, pcbValue: ?*u32) HRESULT {
                return @as(*const IPortableDeviceValues.VTable, @ptrCast(self.vtable)).GetBufferValue(@as(*const IPortableDeviceValues, @ptrCast(self)), key, ppValue, pcbValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValues_SetIPortableDeviceValuesValue(self: *const T, key: ?*const PROPERTYKEY, pValue: ?*IPortableDeviceValues) HRESULT {
                return @as(*const IPortableDeviceValues.VTable, @ptrCast(self.vtable)).SetIPortableDeviceValuesValue(@as(*const IPortableDeviceValues, @ptrCast(self)), key, pValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValues_GetIPortableDeviceValuesValue(self: *const T, key: ?*const PROPERTYKEY, ppValue: ?*?*IPortableDeviceValues) HRESULT {
                return @as(*const IPortableDeviceValues.VTable, @ptrCast(self.vtable)).GetIPortableDeviceValuesValue(@as(*const IPortableDeviceValues, @ptrCast(self)), key, ppValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValues_SetIPortableDevicePropVariantCollectionValue(self: *const T, key: ?*const PROPERTYKEY, pValue: ?*IPortableDevicePropVariantCollection) HRESULT {
                return @as(*const IPortableDeviceValues.VTable, @ptrCast(self.vtable)).SetIPortableDevicePropVariantCollectionValue(@as(*const IPortableDeviceValues, @ptrCast(self)), key, pValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValues_GetIPortableDevicePropVariantCollectionValue(self: *const T, key: ?*const PROPERTYKEY, ppValue: ?*?*IPortableDevicePropVariantCollection) HRESULT {
                return @as(*const IPortableDeviceValues.VTable, @ptrCast(self.vtable)).GetIPortableDevicePropVariantCollectionValue(@as(*const IPortableDeviceValues, @ptrCast(self)), key, ppValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValues_SetIPortableDeviceKeyCollectionValue(self: *const T, key: ?*const PROPERTYKEY, pValue: ?*IPortableDeviceKeyCollection) HRESULT {
                return @as(*const IPortableDeviceValues.VTable, @ptrCast(self.vtable)).SetIPortableDeviceKeyCollectionValue(@as(*const IPortableDeviceValues, @ptrCast(self)), key, pValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValues_GetIPortableDeviceKeyCollectionValue(self: *const T, key: ?*const PROPERTYKEY, ppValue: ?*?*IPortableDeviceKeyCollection) HRESULT {
                return @as(*const IPortableDeviceValues.VTable, @ptrCast(self.vtable)).GetIPortableDeviceKeyCollectionValue(@as(*const IPortableDeviceValues, @ptrCast(self)), key, ppValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValues_SetIPortableDeviceValuesCollectionValue(self: *const T, key: ?*const PROPERTYKEY, pValue: ?*IPortableDeviceValuesCollection) HRESULT {
                return @as(*const IPortableDeviceValues.VTable, @ptrCast(self.vtable)).SetIPortableDeviceValuesCollectionValue(@as(*const IPortableDeviceValues, @ptrCast(self)), key, pValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValues_GetIPortableDeviceValuesCollectionValue(self: *const T, key: ?*const PROPERTYKEY, ppValue: ?*?*IPortableDeviceValuesCollection) HRESULT {
                return @as(*const IPortableDeviceValues.VTable, @ptrCast(self.vtable)).GetIPortableDeviceValuesCollectionValue(@as(*const IPortableDeviceValues, @ptrCast(self)), key, ppValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValues_RemoveValue(self: *const T, key: ?*const PROPERTYKEY) HRESULT {
                return @as(*const IPortableDeviceValues.VTable, @ptrCast(self.vtable)).RemoveValue(@as(*const IPortableDeviceValues, @ptrCast(self)), key);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValues_CopyValuesFromPropertyStore(self: *const T, pStore: ?*IPropertyStore) HRESULT {
                return @as(*const IPortableDeviceValues.VTable, @ptrCast(self.vtable)).CopyValuesFromPropertyStore(@as(*const IPortableDeviceValues, @ptrCast(self)), pStore);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValues_CopyValuesToPropertyStore(self: *const T, pStore: ?*IPropertyStore) HRESULT {
                return @as(*const IPortableDeviceValues.VTable, @ptrCast(self.vtable)).CopyValuesToPropertyStore(@as(*const IPortableDeviceValues, @ptrCast(self)), pStore);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValues_Clear(self: *const T) HRESULT {
                return @as(*const IPortableDeviceValues.VTable, @ptrCast(self.vtable)).Clear(@as(*const IPortableDeviceValues, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IPortableDeviceKeyCollection_Value = Guid.initString("dada2357-e0ad-492e-98db-dd61c53ba353");
pub const IID_IPortableDeviceKeyCollection = &IID_IPortableDeviceKeyCollection_Value;
pub const IPortableDeviceKeyCollection = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetCount: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceKeyCollection,
                pcElems: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceKeyCollection,
                pcElems: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetAt: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceKeyCollection,
                dwIndex: u32,
                pKey: ?*PROPERTYKEY,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceKeyCollection,
                dwIndex: u32,
                pKey: ?*PROPERTYKEY,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Add: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceKeyCollection,
                Key: ?*const PROPERTYKEY,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceKeyCollection,
                Key: ?*const PROPERTYKEY,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Clear: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceKeyCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceKeyCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        RemoveAt: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceKeyCollection,
                dwIndex: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceKeyCollection,
                dwIndex: 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 IPortableDeviceKeyCollection_GetCount(self: *const T, pcElems: ?*u32) HRESULT {
                return @as(*const IPortableDeviceKeyCollection.VTable, @ptrCast(self.vtable)).GetCount(@as(*const IPortableDeviceKeyCollection, @ptrCast(self)), pcElems);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceKeyCollection_GetAt(self: *const T, dwIndex: u32, pKey: ?*PROPERTYKEY) HRESULT {
                return @as(*const IPortableDeviceKeyCollection.VTable, @ptrCast(self.vtable)).GetAt(@as(*const IPortableDeviceKeyCollection, @ptrCast(self)), dwIndex, pKey);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceKeyCollection_Add(self: *const T, Key: ?*const PROPERTYKEY) HRESULT {
                return @as(*const IPortableDeviceKeyCollection.VTable, @ptrCast(self.vtable)).Add(@as(*const IPortableDeviceKeyCollection, @ptrCast(self)), Key);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceKeyCollection_Clear(self: *const T) HRESULT {
                return @as(*const IPortableDeviceKeyCollection.VTable, @ptrCast(self.vtable)).Clear(@as(*const IPortableDeviceKeyCollection, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceKeyCollection_RemoveAt(self: *const T, dwIndex: u32) HRESULT {
                return @as(*const IPortableDeviceKeyCollection.VTable, @ptrCast(self.vtable)).RemoveAt(@as(*const IPortableDeviceKeyCollection, @ptrCast(self)), dwIndex);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IPortableDevicePropVariantCollection_Value = Guid.initString("89b2e422-4f1b-4316-bcef-a44afea83eb3");
pub const IID_IPortableDevicePropVariantCollection = &IID_IPortableDevicePropVariantCollection_Value;
pub const IPortableDevicePropVariantCollection = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetCount: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDevicePropVariantCollection,
                pcElems: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDevicePropVariantCollection,
                pcElems: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetAt: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDevicePropVariantCollection,
                dwIndex: u32,
                pValue: ?*PROPVARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDevicePropVariantCollection,
                dwIndex: u32,
                pValue: ?*PROPVARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Add: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDevicePropVariantCollection,
                pValue: ?*const PROPVARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDevicePropVariantCollection,
                pValue: ?*const PROPVARIANT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetType: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDevicePropVariantCollection,
                pvt: ?*u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDevicePropVariantCollection,
                pvt: ?*u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        ChangeType: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDevicePropVariantCollection,
                vt: u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDevicePropVariantCollection,
                vt: u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Clear: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDevicePropVariantCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDevicePropVariantCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        RemoveAt: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDevicePropVariantCollection,
                dwIndex: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDevicePropVariantCollection,
                dwIndex: 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 IPortableDevicePropVariantCollection_GetCount(self: *const T, pcElems: ?*u32) HRESULT {
                return @as(*const IPortableDevicePropVariantCollection.VTable, @ptrCast(self.vtable)).GetCount(@as(*const IPortableDevicePropVariantCollection, @ptrCast(self)), pcElems);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDevicePropVariantCollection_GetAt(self: *const T, dwIndex: u32, pValue: ?*PROPVARIANT) HRESULT {
                return @as(*const IPortableDevicePropVariantCollection.VTable, @ptrCast(self.vtable)).GetAt(@as(*const IPortableDevicePropVariantCollection, @ptrCast(self)), dwIndex, pValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDevicePropVariantCollection_Add(self: *const T, pValue: ?*const PROPVARIANT) HRESULT {
                return @as(*const IPortableDevicePropVariantCollection.VTable, @ptrCast(self.vtable)).Add(@as(*const IPortableDevicePropVariantCollection, @ptrCast(self)), pValue);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDevicePropVariantCollection_GetType(self: *const T, pvt: ?*u16) HRESULT {
                return @as(*const IPortableDevicePropVariantCollection.VTable, @ptrCast(self.vtable)).GetType(@as(*const IPortableDevicePropVariantCollection, @ptrCast(self)), pvt);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDevicePropVariantCollection_ChangeType(self: *const T, vt: u16) HRESULT {
                return @as(*const IPortableDevicePropVariantCollection.VTable, @ptrCast(self.vtable)).ChangeType(@as(*const IPortableDevicePropVariantCollection, @ptrCast(self)), vt);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDevicePropVariantCollection_Clear(self: *const T) HRESULT {
                return @as(*const IPortableDevicePropVariantCollection.VTable, @ptrCast(self.vtable)).Clear(@as(*const IPortableDevicePropVariantCollection, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDevicePropVariantCollection_RemoveAt(self: *const T, dwIndex: u32) HRESULT {
                return @as(*const IPortableDevicePropVariantCollection.VTable, @ptrCast(self.vtable)).RemoveAt(@as(*const IPortableDevicePropVariantCollection, @ptrCast(self)), dwIndex);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IPortableDeviceValuesCollection_Value = Guid.initString("6e3f2d79-4e07-48c4-8208-d8c2e5af4a99");
pub const IID_IPortableDeviceValuesCollection = &IID_IPortableDeviceValuesCollection_Value;
pub const IPortableDeviceValuesCollection = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetCount: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValuesCollection,
                pcElems: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValuesCollection,
                pcElems: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetAt: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValuesCollection,
                dwIndex: u32,
                ppValues: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValuesCollection,
                dwIndex: u32,
                ppValues: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Add: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValuesCollection,
                pValues: ?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValuesCollection,
                pValues: ?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Clear: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValuesCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValuesCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        RemoveAt: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceValuesCollection,
                dwIndex: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceValuesCollection,
                dwIndex: 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 IPortableDeviceValuesCollection_GetCount(self: *const T, pcElems: ?*u32) HRESULT {
                return @as(*const IPortableDeviceValuesCollection.VTable, @ptrCast(self.vtable)).GetCount(@as(*const IPortableDeviceValuesCollection, @ptrCast(self)), pcElems);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValuesCollection_GetAt(self: *const T, dwIndex: u32, ppValues: ?*?*IPortableDeviceValues) HRESULT {
                return @as(*const IPortableDeviceValuesCollection.VTable, @ptrCast(self.vtable)).GetAt(@as(*const IPortableDeviceValuesCollection, @ptrCast(self)), dwIndex, ppValues);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValuesCollection_Add(self: *const T, pValues: ?*IPortableDeviceValues) HRESULT {
                return @as(*const IPortableDeviceValuesCollection.VTable, @ptrCast(self.vtable)).Add(@as(*const IPortableDeviceValuesCollection, @ptrCast(self)), pValues);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValuesCollection_Clear(self: *const T) HRESULT {
                return @as(*const IPortableDeviceValuesCollection.VTable, @ptrCast(self.vtable)).Clear(@as(*const IPortableDeviceValuesCollection, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceValuesCollection_RemoveAt(self: *const T, dwIndex: u32) HRESULT {
                return @as(*const IPortableDeviceValuesCollection.VTable, @ptrCast(self.vtable)).RemoveAt(@as(*const IPortableDeviceValuesCollection, @ptrCast(self)), dwIndex);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const CLSID_PortableDevice_Value = Guid.initString("728a21c5-3d9e-48d7-9810-864848f0f404");
pub const CLSID_PortableDevice = &CLSID_PortableDevice_Value;

const CLSID_PortableDeviceManager_Value = Guid.initString("0af10cec-2ecd-4b92-9581-34f6ae0637f3");
pub const CLSID_PortableDeviceManager = &CLSID_PortableDeviceManager_Value;

const CLSID_PortableDeviceService_Value = Guid.initString("ef5db4c2-9312-422c-9152-411cd9c4dd84");
pub const CLSID_PortableDeviceService = &CLSID_PortableDeviceService_Value;

const CLSID_PortableDeviceDispatchFactory_Value = Guid.initString("43232233-8338-4658-ae01-0b4ae830b6b0");
pub const CLSID_PortableDeviceDispatchFactory = &CLSID_PortableDeviceDispatchFactory_Value;

const CLSID_PortableDeviceFTM_Value = Guid.initString("f7c0039a-4762-488a-b4b3-760ef9a1ba9b");
pub const CLSID_PortableDeviceFTM = &CLSID_PortableDeviceFTM_Value;

const CLSID_PortableDeviceServiceFTM_Value = Guid.initString("1649b154-c794-497a-9b03-f3f0121302f3");
pub const CLSID_PortableDeviceServiceFTM = &CLSID_PortableDeviceServiceFTM_Value;

const CLSID_PortableDeviceWebControl_Value = Guid.initString("186dd02c-2dec-41b5-a7d4-b59056fade51");
pub const CLSID_PortableDeviceWebControl = &CLSID_PortableDeviceWebControl_Value;

const IID_IPortableDeviceManager_Value = Guid.initString("a1567595-4c2f-4574-a6fa-ecef917b9a40");
pub const IID_IPortableDeviceManager = &IID_IPortableDeviceManager_Value;
pub const IPortableDeviceManager = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetDevices: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceManager,
                pPnPDeviceIDs: ?*?PWSTR,
                pcPnPDeviceIDs: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceManager,
                pPnPDeviceIDs: ?*?PWSTR,
                pcPnPDeviceIDs: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        RefreshDeviceList: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceManager,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceManager,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetDeviceFriendlyName: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceManager,
                pszPnPDeviceID: ?[*:0]const u16,
                pDeviceFriendlyName: ?PWSTR,
                pcchDeviceFriendlyName: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceManager,
                pszPnPDeviceID: ?[*:0]const u16,
                pDeviceFriendlyName: ?PWSTR,
                pcchDeviceFriendlyName: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetDeviceDescription: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceManager,
                pszPnPDeviceID: ?[*:0]const u16,
                pDeviceDescription: ?PWSTR,
                pcchDeviceDescription: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceManager,
                pszPnPDeviceID: ?[*:0]const u16,
                pDeviceDescription: ?PWSTR,
                pcchDeviceDescription: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetDeviceManufacturer: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceManager,
                pszPnPDeviceID: ?[*:0]const u16,
                pDeviceManufacturer: ?PWSTR,
                pcchDeviceManufacturer: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceManager,
                pszPnPDeviceID: ?[*:0]const u16,
                pDeviceManufacturer: ?PWSTR,
                pcchDeviceManufacturer: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetDeviceProperty: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceManager,
                pszPnPDeviceID: ?[*:0]const u16,
                pszDevicePropertyName: ?[*:0]const u16,
                pData: ?*u8,
                pcbData: ?*u32,
                pdwType: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceManager,
                pszPnPDeviceID: ?[*:0]const u16,
                pszDevicePropertyName: ?[*:0]const u16,
                pData: ?*u8,
                pcbData: ?*u32,
                pdwType: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetPrivateDevices: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceManager,
                pPnPDeviceIDs: ?*?PWSTR,
                pcPnPDeviceIDs: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceManager,
                pPnPDeviceIDs: ?*?PWSTR,
                pcPnPDeviceIDs: ?*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 IPortableDeviceManager_GetDevices(self: *const T, pPnPDeviceIDs: ?*?PWSTR, pcPnPDeviceIDs: ?*u32) HRESULT {
                return @as(*const IPortableDeviceManager.VTable, @ptrCast(self.vtable)).GetDevices(@as(*const IPortableDeviceManager, @ptrCast(self)), pPnPDeviceIDs, pcPnPDeviceIDs);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceManager_RefreshDeviceList(self: *const T) HRESULT {
                return @as(*const IPortableDeviceManager.VTable, @ptrCast(self.vtable)).RefreshDeviceList(@as(*const IPortableDeviceManager, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceManager_GetDeviceFriendlyName(self: *const T, pszPnPDeviceID: ?[*:0]const u16, pDeviceFriendlyName: ?PWSTR, pcchDeviceFriendlyName: ?*u32) HRESULT {
                return @as(*const IPortableDeviceManager.VTable, @ptrCast(self.vtable)).GetDeviceFriendlyName(@as(*const IPortableDeviceManager, @ptrCast(self)), pszPnPDeviceID, pDeviceFriendlyName, pcchDeviceFriendlyName);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceManager_GetDeviceDescription(self: *const T, pszPnPDeviceID: ?[*:0]const u16, pDeviceDescription: ?PWSTR, pcchDeviceDescription: ?*u32) HRESULT {
                return @as(*const IPortableDeviceManager.VTable, @ptrCast(self.vtable)).GetDeviceDescription(@as(*const IPortableDeviceManager, @ptrCast(self)), pszPnPDeviceID, pDeviceDescription, pcchDeviceDescription);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceManager_GetDeviceManufacturer(self: *const T, pszPnPDeviceID: ?[*:0]const u16, pDeviceManufacturer: ?PWSTR, pcchDeviceManufacturer: ?*u32) HRESULT {
                return @as(*const IPortableDeviceManager.VTable, @ptrCast(self.vtable)).GetDeviceManufacturer(@as(*const IPortableDeviceManager, @ptrCast(self)), pszPnPDeviceID, pDeviceManufacturer, pcchDeviceManufacturer);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceManager_GetDeviceProperty(self: *const T, pszPnPDeviceID: ?[*:0]const u16, pszDevicePropertyName: ?[*:0]const u16, pData: ?*u8, pcbData: ?*u32, pdwType: ?*u32) HRESULT {
                return @as(*const IPortableDeviceManager.VTable, @ptrCast(self.vtable)).GetDeviceProperty(@as(*const IPortableDeviceManager, @ptrCast(self)), pszPnPDeviceID, pszDevicePropertyName, pData, pcbData, pdwType);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceManager_GetPrivateDevices(self: *const T, pPnPDeviceIDs: ?*?PWSTR, pcPnPDeviceIDs: ?*u32) HRESULT {
                return @as(*const IPortableDeviceManager.VTable, @ptrCast(self.vtable)).GetPrivateDevices(@as(*const IPortableDeviceManager, @ptrCast(self)), pPnPDeviceIDs, pcPnPDeviceIDs);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IPortableDevice_Value = Guid.initString("625e2df8-6392-4cf0-9ad1-3cfa5f17775c");
pub const IID_IPortableDevice = &IID_IPortableDevice_Value;
pub const IPortableDevice = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Open: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDevice,
                pszPnPDeviceID: ?[*:0]const u16,
                pClientInfo: ?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDevice,
                pszPnPDeviceID: ?[*:0]const u16,
                pClientInfo: ?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SendCommand: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDevice,
                dwFlags: u32,
                pParameters: ?*IPortableDeviceValues,
                ppResults: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDevice,
                dwFlags: u32,
                pParameters: ?*IPortableDeviceValues,
                ppResults: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Content: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDevice,
                ppContent: ?*?*IPortableDeviceContent,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDevice,
                ppContent: ?*?*IPortableDeviceContent,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Capabilities: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDevice,
                ppCapabilities: ?*?*IPortableDeviceCapabilities,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDevice,
                ppCapabilities: ?*?*IPortableDeviceCapabilities,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Cancel: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDevice,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDevice,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Close: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDevice,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDevice,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Advise: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDevice,
                dwFlags: u32,
                pCallback: ?*IPortableDeviceEventCallback,
                pParameters: ?*IPortableDeviceValues,
                ppszCookie: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDevice,
                dwFlags: u32,
                pCallback: ?*IPortableDeviceEventCallback,
                pParameters: ?*IPortableDeviceValues,
                ppszCookie: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Unadvise: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDevice,
                pszCookie: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDevice,
                pszCookie: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetPnPDeviceID: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDevice,
                ppszPnPDeviceID: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDevice,
                ppszPnPDeviceID: ?*?PWSTR,
            ) 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 IPortableDevice_Open(self: *const T, pszPnPDeviceID: ?[*:0]const u16, pClientInfo: ?*IPortableDeviceValues) HRESULT {
                return @as(*const IPortableDevice.VTable, @ptrCast(self.vtable)).Open(@as(*const IPortableDevice, @ptrCast(self)), pszPnPDeviceID, pClientInfo);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDevice_SendCommand(self: *const T, dwFlags: u32, pParameters: ?*IPortableDeviceValues, ppResults: ?*?*IPortableDeviceValues) HRESULT {
                return @as(*const IPortableDevice.VTable, @ptrCast(self.vtable)).SendCommand(@as(*const IPortableDevice, @ptrCast(self)), dwFlags, pParameters, ppResults);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDevice_Content(self: *const T, ppContent: ?*?*IPortableDeviceContent) HRESULT {
                return @as(*const IPortableDevice.VTable, @ptrCast(self.vtable)).Content(@as(*const IPortableDevice, @ptrCast(self)), ppContent);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDevice_Capabilities(self: *const T, ppCapabilities: ?*?*IPortableDeviceCapabilities) HRESULT {
                return @as(*const IPortableDevice.VTable, @ptrCast(self.vtable)).Capabilities(@as(*const IPortableDevice, @ptrCast(self)), ppCapabilities);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDevice_Cancel(self: *const T) HRESULT {
                return @as(*const IPortableDevice.VTable, @ptrCast(self.vtable)).Cancel(@as(*const IPortableDevice, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDevice_Close(self: *const T) HRESULT {
                return @as(*const IPortableDevice.VTable, @ptrCast(self.vtable)).Close(@as(*const IPortableDevice, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDevice_Advise(self: *const T, dwFlags: u32, pCallback: ?*IPortableDeviceEventCallback, pParameters: ?*IPortableDeviceValues, ppszCookie: ?*?PWSTR) HRESULT {
                return @as(*const IPortableDevice.VTable, @ptrCast(self.vtable)).Advise(@as(*const IPortableDevice, @ptrCast(self)), dwFlags, pCallback, pParameters, ppszCookie);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDevice_Unadvise(self: *const T, pszCookie: ?[*:0]const u16) HRESULT {
                return @as(*const IPortableDevice.VTable, @ptrCast(self.vtable)).Unadvise(@as(*const IPortableDevice, @ptrCast(self)), pszCookie);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDevice_GetPnPDeviceID(self: *const T, ppszPnPDeviceID: ?*?PWSTR) HRESULT {
                return @as(*const IPortableDevice.VTable, @ptrCast(self.vtable)).GetPnPDeviceID(@as(*const IPortableDevice, @ptrCast(self)), ppszPnPDeviceID);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IPortableDeviceContent_Value = Guid.initString("6a96ed84-7c73-4480-9938-bf5af477d426");
pub const IID_IPortableDeviceContent = &IID_IPortableDeviceContent_Value;
pub const IPortableDeviceContent = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        EnumObjects: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceContent,
                dwFlags: u32,
                pszParentObjectID: ?[*:0]const u16,
                pFilter: ?*IPortableDeviceValues,
                ppEnum: ?*?*IEnumPortableDeviceObjectIDs,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceContent,
                dwFlags: u32,
                pszParentObjectID: ?[*:0]const u16,
                pFilter: ?*IPortableDeviceValues,
                ppEnum: ?*?*IEnumPortableDeviceObjectIDs,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Properties: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceContent,
                ppProperties: ?*?*IPortableDeviceProperties,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceContent,
                ppProperties: ?*?*IPortableDeviceProperties,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Transfer: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceContent,
                ppResources: ?*?*IPortableDeviceResources,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceContent,
                ppResources: ?*?*IPortableDeviceResources,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        CreateObjectWithPropertiesOnly: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceContent,
                pValues: ?*IPortableDeviceValues,
                ppszObjectID: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceContent,
                pValues: ?*IPortableDeviceValues,
                ppszObjectID: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        CreateObjectWithPropertiesAndData: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceContent,
                pValues: ?*IPortableDeviceValues,
                ppData: ?*?*IStream,
                pdwOptimalWriteBufferSize: ?*u32,
                ppszCookie: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceContent,
                pValues: ?*IPortableDeviceValues,
                ppData: ?*?*IStream,
                pdwOptimalWriteBufferSize: ?*u32,
                ppszCookie: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Delete: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceContent,
                dwOptions: u32,
                pObjectIDs: ?*IPortableDevicePropVariantCollection,
                ppResults: ?*?*IPortableDevicePropVariantCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceContent,
                dwOptions: u32,
                pObjectIDs: ?*IPortableDevicePropVariantCollection,
                ppResults: ?*?*IPortableDevicePropVariantCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetObjectIDsFromPersistentUniqueIDs: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceContent,
                pPersistentUniqueIDs: ?*IPortableDevicePropVariantCollection,
                ppObjectIDs: ?*?*IPortableDevicePropVariantCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceContent,
                pPersistentUniqueIDs: ?*IPortableDevicePropVariantCollection,
                ppObjectIDs: ?*?*IPortableDevicePropVariantCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Cancel: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceContent,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceContent,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Move: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceContent,
                pObjectIDs: ?*IPortableDevicePropVariantCollection,
                pszDestinationFolderObjectID: ?[*:0]const u16,
                ppResults: ?*?*IPortableDevicePropVariantCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceContent,
                pObjectIDs: ?*IPortableDevicePropVariantCollection,
                pszDestinationFolderObjectID: ?[*:0]const u16,
                ppResults: ?*?*IPortableDevicePropVariantCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Copy: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceContent,
                pObjectIDs: ?*IPortableDevicePropVariantCollection,
                pszDestinationFolderObjectID: ?[*:0]const u16,
                ppResults: ?*?*IPortableDevicePropVariantCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceContent,
                pObjectIDs: ?*IPortableDevicePropVariantCollection,
                pszDestinationFolderObjectID: ?[*:0]const u16,
                ppResults: ?*?*IPortableDevicePropVariantCollection,
            ) 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 IPortableDeviceContent_EnumObjects(self: *const T, dwFlags: u32, pszParentObjectID: ?[*:0]const u16, pFilter: ?*IPortableDeviceValues, ppEnum: ?*?*IEnumPortableDeviceObjectIDs) HRESULT {
                return @as(*const IPortableDeviceContent.VTable, @ptrCast(self.vtable)).EnumObjects(@as(*const IPortableDeviceContent, @ptrCast(self)), dwFlags, pszParentObjectID, pFilter, ppEnum);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceContent_Properties(self: *const T, ppProperties: ?*?*IPortableDeviceProperties) HRESULT {
                return @as(*const IPortableDeviceContent.VTable, @ptrCast(self.vtable)).Properties(@as(*const IPortableDeviceContent, @ptrCast(self)), ppProperties);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceContent_Transfer(self: *const T, ppResources: ?*?*IPortableDeviceResources) HRESULT {
                return @as(*const IPortableDeviceContent.VTable, @ptrCast(self.vtable)).Transfer(@as(*const IPortableDeviceContent, @ptrCast(self)), ppResources);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceContent_CreateObjectWithPropertiesOnly(self: *const T, pValues: ?*IPortableDeviceValues, ppszObjectID: ?*?PWSTR) HRESULT {
                return @as(*const IPortableDeviceContent.VTable, @ptrCast(self.vtable)).CreateObjectWithPropertiesOnly(@as(*const IPortableDeviceContent, @ptrCast(self)), pValues, ppszObjectID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceContent_CreateObjectWithPropertiesAndData(self: *const T, pValues: ?*IPortableDeviceValues, ppData: ?*?*IStream, pdwOptimalWriteBufferSize: ?*u32, ppszCookie: ?*?PWSTR) HRESULT {
                return @as(*const IPortableDeviceContent.VTable, @ptrCast(self.vtable)).CreateObjectWithPropertiesAndData(@as(*const IPortableDeviceContent, @ptrCast(self)), pValues, ppData, pdwOptimalWriteBufferSize, ppszCookie);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceContent_Delete(self: *const T, dwOptions: u32, pObjectIDs: ?*IPortableDevicePropVariantCollection, ppResults: ?*?*IPortableDevicePropVariantCollection) HRESULT {
                return @as(*const IPortableDeviceContent.VTable, @ptrCast(self.vtable)).Delete(@as(*const IPortableDeviceContent, @ptrCast(self)), dwOptions, pObjectIDs, ppResults);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceContent_GetObjectIDsFromPersistentUniqueIDs(self: *const T, pPersistentUniqueIDs: ?*IPortableDevicePropVariantCollection, ppObjectIDs: ?*?*IPortableDevicePropVariantCollection) HRESULT {
                return @as(*const IPortableDeviceContent.VTable, @ptrCast(self.vtable)).GetObjectIDsFromPersistentUniqueIDs(@as(*const IPortableDeviceContent, @ptrCast(self)), pPersistentUniqueIDs, ppObjectIDs);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceContent_Cancel(self: *const T) HRESULT {
                return @as(*const IPortableDeviceContent.VTable, @ptrCast(self.vtable)).Cancel(@as(*const IPortableDeviceContent, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceContent_Move(self: *const T, pObjectIDs: ?*IPortableDevicePropVariantCollection, pszDestinationFolderObjectID: ?[*:0]const u16, ppResults: ?*?*IPortableDevicePropVariantCollection) HRESULT {
                return @as(*const IPortableDeviceContent.VTable, @ptrCast(self.vtable)).Move(@as(*const IPortableDeviceContent, @ptrCast(self)), pObjectIDs, pszDestinationFolderObjectID, ppResults);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceContent_Copy(self: *const T, pObjectIDs: ?*IPortableDevicePropVariantCollection, pszDestinationFolderObjectID: ?[*:0]const u16, ppResults: ?*?*IPortableDevicePropVariantCollection) HRESULT {
                return @as(*const IPortableDeviceContent.VTable, @ptrCast(self.vtable)).Copy(@as(*const IPortableDeviceContent, @ptrCast(self)), pObjectIDs, pszDestinationFolderObjectID, ppResults);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.1'
const IID_IPortableDeviceContent2_Value = Guid.initString("9b4add96-f6bf-4034-8708-eca72bf10554");
pub const IID_IPortableDeviceContent2 = &IID_IPortableDeviceContent2_Value;
pub const IPortableDeviceContent2 = extern struct {
    pub const VTable = extern struct {
        base: IPortableDeviceContent.VTable,
        UpdateObjectWithPropertiesAndData: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceContent2,
                pszObjectID: ?[*:0]const u16,
                pProperties: ?*IPortableDeviceValues,
                ppData: ?*?*IStream,
                pdwOptimalWriteBufferSize: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceContent2,
                pszObjectID: ?[*:0]const u16,
                pProperties: ?*IPortableDeviceValues,
                ppData: ?*?*IStream,
                pdwOptimalWriteBufferSize: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IPortableDeviceContent.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceContent2_UpdateObjectWithPropertiesAndData(self: *const T, pszObjectID: ?[*:0]const u16, pProperties: ?*IPortableDeviceValues, ppData: ?*?*IStream, pdwOptimalWriteBufferSize: ?*u32) HRESULT {
                return @as(*const IPortableDeviceContent2.VTable, @ptrCast(self.vtable)).UpdateObjectWithPropertiesAndData(@as(*const IPortableDeviceContent2, @ptrCast(self)), pszObjectID, pProperties, ppData, pdwOptimalWriteBufferSize);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IEnumPortableDeviceObjectIDs_Value = Guid.initString("10ece955-cf41-4728-bfa0-41eedf1bbf19");
pub const IID_IEnumPortableDeviceObjectIDs = &IID_IEnumPortableDeviceObjectIDs_Value;
pub const IEnumPortableDeviceObjectIDs = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Next: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IEnumPortableDeviceObjectIDs,
                cObjects: u32,
                pObjIDs: [*]?PWSTR,
                pcFetched: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IEnumPortableDeviceObjectIDs,
                cObjects: u32,
                pObjIDs: [*]?PWSTR,
                pcFetched: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Skip: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IEnumPortableDeviceObjectIDs,
                cObjects: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IEnumPortableDeviceObjectIDs,
                cObjects: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Reset: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IEnumPortableDeviceObjectIDs,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IEnumPortableDeviceObjectIDs,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Clone: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IEnumPortableDeviceObjectIDs,
                ppEnum: ?*?*IEnumPortableDeviceObjectIDs,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IEnumPortableDeviceObjectIDs,
                ppEnum: ?*?*IEnumPortableDeviceObjectIDs,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Cancel: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IEnumPortableDeviceObjectIDs,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IEnumPortableDeviceObjectIDs,
            ) 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 IEnumPortableDeviceObjectIDs_Next(self: *const T, cObjects: u32, pObjIDs: [*]?PWSTR, pcFetched: ?*u32) HRESULT {
                return @as(*const IEnumPortableDeviceObjectIDs.VTable, @ptrCast(self.vtable)).Next(@as(*const IEnumPortableDeviceObjectIDs, @ptrCast(self)), cObjects, pObjIDs, pcFetched);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IEnumPortableDeviceObjectIDs_Skip(self: *const T, cObjects: u32) HRESULT {
                return @as(*const IEnumPortableDeviceObjectIDs.VTable, @ptrCast(self.vtable)).Skip(@as(*const IEnumPortableDeviceObjectIDs, @ptrCast(self)), cObjects);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IEnumPortableDeviceObjectIDs_Reset(self: *const T) HRESULT {
                return @as(*const IEnumPortableDeviceObjectIDs.VTable, @ptrCast(self.vtable)).Reset(@as(*const IEnumPortableDeviceObjectIDs, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IEnumPortableDeviceObjectIDs_Clone(self: *const T, ppEnum: ?*?*IEnumPortableDeviceObjectIDs) HRESULT {
                return @as(*const IEnumPortableDeviceObjectIDs.VTable, @ptrCast(self.vtable)).Clone(@as(*const IEnumPortableDeviceObjectIDs, @ptrCast(self)), ppEnum);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IEnumPortableDeviceObjectIDs_Cancel(self: *const T) HRESULT {
                return @as(*const IEnumPortableDeviceObjectIDs.VTable, @ptrCast(self.vtable)).Cancel(@as(*const IEnumPortableDeviceObjectIDs, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IPortableDeviceProperties_Value = Guid.initString("7f6d695c-03df-4439-a809-59266beee3a6");
pub const IID_IPortableDeviceProperties = &IID_IPortableDeviceProperties_Value;
pub const IPortableDeviceProperties = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetSupportedProperties: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceProperties,
                pszObjectID: ?[*:0]const u16,
                ppKeys: ?*?*IPortableDeviceKeyCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceProperties,
                pszObjectID: ?[*:0]const u16,
                ppKeys: ?*?*IPortableDeviceKeyCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetPropertyAttributes: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceProperties,
                pszObjectID: ?[*:0]const u16,
                Key: ?*const PROPERTYKEY,
                ppAttributes: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceProperties,
                pszObjectID: ?[*:0]const u16,
                Key: ?*const PROPERTYKEY,
                ppAttributes: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetValues: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceProperties,
                pszObjectID: ?[*:0]const u16,
                pKeys: ?*IPortableDeviceKeyCollection,
                ppValues: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceProperties,
                pszObjectID: ?[*:0]const u16,
                pKeys: ?*IPortableDeviceKeyCollection,
                ppValues: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetValues: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceProperties,
                pszObjectID: ?[*:0]const u16,
                pValues: ?*IPortableDeviceValues,
                ppResults: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceProperties,
                pszObjectID: ?[*:0]const u16,
                pValues: ?*IPortableDeviceValues,
                ppResults: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Delete: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceProperties,
                pszObjectID: ?[*:0]const u16,
                pKeys: ?*IPortableDeviceKeyCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceProperties,
                pszObjectID: ?[*:0]const u16,
                pKeys: ?*IPortableDeviceKeyCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Cancel: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceProperties,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceProperties,
            ) 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 IPortableDeviceProperties_GetSupportedProperties(self: *const T, pszObjectID: ?[*:0]const u16, ppKeys: ?*?*IPortableDeviceKeyCollection) HRESULT {
                return @as(*const IPortableDeviceProperties.VTable, @ptrCast(self.vtable)).GetSupportedProperties(@as(*const IPortableDeviceProperties, @ptrCast(self)), pszObjectID, ppKeys);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceProperties_GetPropertyAttributes(self: *const T, pszObjectID: ?[*:0]const u16, Key: ?*const PROPERTYKEY, ppAttributes: ?*?*IPortableDeviceValues) HRESULT {
                return @as(*const IPortableDeviceProperties.VTable, @ptrCast(self.vtable)).GetPropertyAttributes(@as(*const IPortableDeviceProperties, @ptrCast(self)), pszObjectID, Key, ppAttributes);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceProperties_GetValues(self: *const T, pszObjectID: ?[*:0]const u16, pKeys: ?*IPortableDeviceKeyCollection, ppValues: ?*?*IPortableDeviceValues) HRESULT {
                return @as(*const IPortableDeviceProperties.VTable, @ptrCast(self.vtable)).GetValues(@as(*const IPortableDeviceProperties, @ptrCast(self)), pszObjectID, pKeys, ppValues);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceProperties_SetValues(self: *const T, pszObjectID: ?[*:0]const u16, pValues: ?*IPortableDeviceValues, ppResults: ?*?*IPortableDeviceValues) HRESULT {
                return @as(*const IPortableDeviceProperties.VTable, @ptrCast(self.vtable)).SetValues(@as(*const IPortableDeviceProperties, @ptrCast(self)), pszObjectID, pValues, ppResults);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceProperties_Delete(self: *const T, pszObjectID: ?[*:0]const u16, pKeys: ?*IPortableDeviceKeyCollection) HRESULT {
                return @as(*const IPortableDeviceProperties.VTable, @ptrCast(self.vtable)).Delete(@as(*const IPortableDeviceProperties, @ptrCast(self)), pszObjectID, pKeys);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceProperties_Cancel(self: *const T) HRESULT {
                return @as(*const IPortableDeviceProperties.VTable, @ptrCast(self.vtable)).Cancel(@as(*const IPortableDeviceProperties, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IPortableDeviceResources_Value = Guid.initString("fd8878ac-d841-4d17-891c-e6829cdb6934");
pub const IID_IPortableDeviceResources = &IID_IPortableDeviceResources_Value;
pub const IPortableDeviceResources = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetSupportedResources: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceResources,
                pszObjectID: ?[*:0]const u16,
                ppKeys: ?*?*IPortableDeviceKeyCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceResources,
                pszObjectID: ?[*:0]const u16,
                ppKeys: ?*?*IPortableDeviceKeyCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetResourceAttributes: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceResources,
                pszObjectID: ?[*:0]const u16,
                Key: ?*const PROPERTYKEY,
                ppResourceAttributes: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceResources,
                pszObjectID: ?[*:0]const u16,
                Key: ?*const PROPERTYKEY,
                ppResourceAttributes: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetStream: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceResources,
                pszObjectID: ?[*:0]const u16,
                Key: ?*const PROPERTYKEY,
                dwMode: u32,
                pdwOptimalBufferSize: ?*u32,
                ppStream: ?*?*IStream,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceResources,
                pszObjectID: ?[*:0]const u16,
                Key: ?*const PROPERTYKEY,
                dwMode: u32,
                pdwOptimalBufferSize: ?*u32,
                ppStream: ?*?*IStream,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Delete: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceResources,
                pszObjectID: ?[*:0]const u16,
                pKeys: ?*IPortableDeviceKeyCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceResources,
                pszObjectID: ?[*:0]const u16,
                pKeys: ?*IPortableDeviceKeyCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Cancel: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceResources,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceResources,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        CreateResource: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceResources,
                pResourceAttributes: ?*IPortableDeviceValues,
                ppData: ?*?*IStream,
                pdwOptimalWriteBufferSize: ?*u32,
                ppszCookie: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceResources,
                pResourceAttributes: ?*IPortableDeviceValues,
                ppData: ?*?*IStream,
                pdwOptimalWriteBufferSize: ?*u32,
                ppszCookie: ?*?PWSTR,
            ) 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 IPortableDeviceResources_GetSupportedResources(self: *const T, pszObjectID: ?[*:0]const u16, ppKeys: ?*?*IPortableDeviceKeyCollection) HRESULT {
                return @as(*const IPortableDeviceResources.VTable, @ptrCast(self.vtable)).GetSupportedResources(@as(*const IPortableDeviceResources, @ptrCast(self)), pszObjectID, ppKeys);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceResources_GetResourceAttributes(self: *const T, pszObjectID: ?[*:0]const u16, Key: ?*const PROPERTYKEY, ppResourceAttributes: ?*?*IPortableDeviceValues) HRESULT {
                return @as(*const IPortableDeviceResources.VTable, @ptrCast(self.vtable)).GetResourceAttributes(@as(*const IPortableDeviceResources, @ptrCast(self)), pszObjectID, Key, ppResourceAttributes);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceResources_GetStream(self: *const T, pszObjectID: ?[*:0]const u16, Key: ?*const PROPERTYKEY, dwMode: u32, pdwOptimalBufferSize: ?*u32, ppStream: ?*?*IStream) HRESULT {
                return @as(*const IPortableDeviceResources.VTable, @ptrCast(self.vtable)).GetStream(@as(*const IPortableDeviceResources, @ptrCast(self)), pszObjectID, Key, dwMode, pdwOptimalBufferSize, ppStream);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceResources_Delete(self: *const T, pszObjectID: ?[*:0]const u16, pKeys: ?*IPortableDeviceKeyCollection) HRESULT {
                return @as(*const IPortableDeviceResources.VTable, @ptrCast(self.vtable)).Delete(@as(*const IPortableDeviceResources, @ptrCast(self)), pszObjectID, pKeys);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceResources_Cancel(self: *const T) HRESULT {
                return @as(*const IPortableDeviceResources.VTable, @ptrCast(self.vtable)).Cancel(@as(*const IPortableDeviceResources, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceResources_CreateResource(self: *const T, pResourceAttributes: ?*IPortableDeviceValues, ppData: ?*?*IStream, pdwOptimalWriteBufferSize: ?*u32, ppszCookie: ?*?PWSTR) HRESULT {
                return @as(*const IPortableDeviceResources.VTable, @ptrCast(self.vtable)).CreateResource(@as(*const IPortableDeviceResources, @ptrCast(self)), pResourceAttributes, ppData, pdwOptimalWriteBufferSize, ppszCookie);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IPortableDeviceCapabilities_Value = Guid.initString("2c8c6dbf-e3dc-4061-becc-8542e810d126");
pub const IID_IPortableDeviceCapabilities = &IID_IPortableDeviceCapabilities_Value;
pub const IPortableDeviceCapabilities = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetSupportedCommands: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceCapabilities,
                ppCommands: ?*?*IPortableDeviceKeyCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceCapabilities,
                ppCommands: ?*?*IPortableDeviceKeyCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetCommandOptions: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceCapabilities,
                Command: ?*const PROPERTYKEY,
                ppOptions: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceCapabilities,
                Command: ?*const PROPERTYKEY,
                ppOptions: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetFunctionalCategories: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceCapabilities,
                ppCategories: ?*?*IPortableDevicePropVariantCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceCapabilities,
                ppCategories: ?*?*IPortableDevicePropVariantCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetFunctionalObjects: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceCapabilities,
                Category: ?*const Guid,
                ppObjectIDs: ?*?*IPortableDevicePropVariantCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceCapabilities,
                Category: ?*const Guid,
                ppObjectIDs: ?*?*IPortableDevicePropVariantCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetSupportedContentTypes: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceCapabilities,
                Category: ?*const Guid,
                ppContentTypes: ?*?*IPortableDevicePropVariantCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceCapabilities,
                Category: ?*const Guid,
                ppContentTypes: ?*?*IPortableDevicePropVariantCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetSupportedFormats: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceCapabilities,
                ContentType: ?*const Guid,
                ppFormats: ?*?*IPortableDevicePropVariantCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceCapabilities,
                ContentType: ?*const Guid,
                ppFormats: ?*?*IPortableDevicePropVariantCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetSupportedFormatProperties: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceCapabilities,
                Format: ?*const Guid,
                ppKeys: ?*?*IPortableDeviceKeyCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceCapabilities,
                Format: ?*const Guid,
                ppKeys: ?*?*IPortableDeviceKeyCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetFixedPropertyAttributes: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceCapabilities,
                Format: ?*const Guid,
                Key: ?*const PROPERTYKEY,
                ppAttributes: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceCapabilities,
                Format: ?*const Guid,
                Key: ?*const PROPERTYKEY,
                ppAttributes: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Cancel: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceCapabilities,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceCapabilities,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetSupportedEvents: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceCapabilities,
                ppEvents: ?*?*IPortableDevicePropVariantCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceCapabilities,
                ppEvents: ?*?*IPortableDevicePropVariantCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetEventOptions: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceCapabilities,
                Event: ?*const Guid,
                ppOptions: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceCapabilities,
                Event: ?*const Guid,
                ppOptions: ?*?*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 IPortableDeviceCapabilities_GetSupportedCommands(self: *const T, ppCommands: ?*?*IPortableDeviceKeyCollection) HRESULT {
                return @as(*const IPortableDeviceCapabilities.VTable, @ptrCast(self.vtable)).GetSupportedCommands(@as(*const IPortableDeviceCapabilities, @ptrCast(self)), ppCommands);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceCapabilities_GetCommandOptions(self: *const T, Command: ?*const PROPERTYKEY, ppOptions: ?*?*IPortableDeviceValues) HRESULT {
                return @as(*const IPortableDeviceCapabilities.VTable, @ptrCast(self.vtable)).GetCommandOptions(@as(*const IPortableDeviceCapabilities, @ptrCast(self)), Command, ppOptions);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceCapabilities_GetFunctionalCategories(self: *const T, ppCategories: ?*?*IPortableDevicePropVariantCollection) HRESULT {
                return @as(*const IPortableDeviceCapabilities.VTable, @ptrCast(self.vtable)).GetFunctionalCategories(@as(*const IPortableDeviceCapabilities, @ptrCast(self)), ppCategories);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceCapabilities_GetFunctionalObjects(self: *const T, Category: ?*const Guid, ppObjectIDs: ?*?*IPortableDevicePropVariantCollection) HRESULT {
                return @as(*const IPortableDeviceCapabilities.VTable, @ptrCast(self.vtable)).GetFunctionalObjects(@as(*const IPortableDeviceCapabilities, @ptrCast(self)), Category, ppObjectIDs);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceCapabilities_GetSupportedContentTypes(self: *const T, Category: ?*const Guid, ppContentTypes: ?*?*IPortableDevicePropVariantCollection) HRESULT {
                return @as(*const IPortableDeviceCapabilities.VTable, @ptrCast(self.vtable)).GetSupportedContentTypes(@as(*const IPortableDeviceCapabilities, @ptrCast(self)), Category, ppContentTypes);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceCapabilities_GetSupportedFormats(self: *const T, ContentType: ?*const Guid, ppFormats: ?*?*IPortableDevicePropVariantCollection) HRESULT {
                return @as(*const IPortableDeviceCapabilities.VTable, @ptrCast(self.vtable)).GetSupportedFormats(@as(*const IPortableDeviceCapabilities, @ptrCast(self)), ContentType, ppFormats);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceCapabilities_GetSupportedFormatProperties(self: *const T, Format: ?*const Guid, ppKeys: ?*?*IPortableDeviceKeyCollection) HRESULT {
                return @as(*const IPortableDeviceCapabilities.VTable, @ptrCast(self.vtable)).GetSupportedFormatProperties(@as(*const IPortableDeviceCapabilities, @ptrCast(self)), Format, ppKeys);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceCapabilities_GetFixedPropertyAttributes(self: *const T, Format: ?*const Guid, Key: ?*const PROPERTYKEY, ppAttributes: ?*?*IPortableDeviceValues) HRESULT {
                return @as(*const IPortableDeviceCapabilities.VTable, @ptrCast(self.vtable)).GetFixedPropertyAttributes(@as(*const IPortableDeviceCapabilities, @ptrCast(self)), Format, Key, ppAttributes);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceCapabilities_Cancel(self: *const T) HRESULT {
                return @as(*const IPortableDeviceCapabilities.VTable, @ptrCast(self.vtable)).Cancel(@as(*const IPortableDeviceCapabilities, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceCapabilities_GetSupportedEvents(self: *const T, ppEvents: ?*?*IPortableDevicePropVariantCollection) HRESULT {
                return @as(*const IPortableDeviceCapabilities.VTable, @ptrCast(self.vtable)).GetSupportedEvents(@as(*const IPortableDeviceCapabilities, @ptrCast(self)), ppEvents);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceCapabilities_GetEventOptions(self: *const T, Event: ?*const Guid, ppOptions: ?*?*IPortableDeviceValues) HRESULT {
                return @as(*const IPortableDeviceCapabilities.VTable, @ptrCast(self.vtable)).GetEventOptions(@as(*const IPortableDeviceCapabilities, @ptrCast(self)), Event, ppOptions);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IPortableDeviceEventCallback_Value = Guid.initString("a8792a31-f385-493c-a893-40f64eb45f6e");
pub const IID_IPortableDeviceEventCallback = &IID_IPortableDeviceEventCallback_Value;
pub const IPortableDeviceEventCallback = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        OnEvent: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceEventCallback,
                pEventParameters: ?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceEventCallback,
                pEventParameters: ?*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 IPortableDeviceEventCallback_OnEvent(self: *const T, pEventParameters: ?*IPortableDeviceValues) HRESULT {
                return @as(*const IPortableDeviceEventCallback.VTable, @ptrCast(self.vtable)).OnEvent(@as(*const IPortableDeviceEventCallback, @ptrCast(self)), pEventParameters);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IPortableDeviceDataStream_Value = Guid.initString("88e04db3-1012-4d64-9996-f703a950d3f4");
pub const IID_IPortableDeviceDataStream = &IID_IPortableDeviceDataStream_Value;
pub const IPortableDeviceDataStream = extern struct {
    pub const VTable = extern struct {
        base: IStream.VTable,
        GetObjectID: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceDataStream,
                ppszObjectID: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceDataStream,
                ppszObjectID: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Cancel: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceDataStream,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceDataStream,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IStream.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceDataStream_GetObjectID(self: *const T, ppszObjectID: ?*?PWSTR) HRESULT {
                return @as(*const IPortableDeviceDataStream.VTable, @ptrCast(self.vtable)).GetObjectID(@as(*const IPortableDeviceDataStream, @ptrCast(self)), ppszObjectID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceDataStream_Cancel(self: *const T) HRESULT {
                return @as(*const IPortableDeviceDataStream.VTable, @ptrCast(self.vtable)).Cancel(@as(*const IPortableDeviceDataStream, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows8.0'
const IID_IPortableDeviceUnitsStream_Value = Guid.initString("5e98025f-bfc4-47a2-9a5f-bc900a507c67");
pub const IID_IPortableDeviceUnitsStream = &IID_IPortableDeviceUnitsStream_Value;
pub const IPortableDeviceUnitsStream = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        SeekInUnits: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceUnitsStream,
                dlibMove: LARGE_INTEGER,
                units: WPD_STREAM_UNITS,
                dwOrigin: u32,
                plibNewPosition: ?*ULARGE_INTEGER,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceUnitsStream,
                dlibMove: LARGE_INTEGER,
                units: WPD_STREAM_UNITS,
                dwOrigin: u32,
                plibNewPosition: ?*ULARGE_INTEGER,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Cancel: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceUnitsStream,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceUnitsStream,
            ) 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 IPortableDeviceUnitsStream_SeekInUnits(self: *const T, dlibMove: LARGE_INTEGER, units: WPD_STREAM_UNITS, dwOrigin: u32, plibNewPosition: ?*ULARGE_INTEGER) HRESULT {
                return @as(*const IPortableDeviceUnitsStream.VTable, @ptrCast(self.vtable)).SeekInUnits(@as(*const IPortableDeviceUnitsStream, @ptrCast(self)), dlibMove, units, dwOrigin, plibNewPosition);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceUnitsStream_Cancel(self: *const T) HRESULT {
                return @as(*const IPortableDeviceUnitsStream.VTable, @ptrCast(self.vtable)).Cancel(@as(*const IPortableDeviceUnitsStream, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IPortableDevicePropertiesBulk_Value = Guid.initString("482b05c0-4056-44ed-9e0f-5e23b009da93");
pub const IID_IPortableDevicePropertiesBulk = &IID_IPortableDevicePropertiesBulk_Value;
pub const IPortableDevicePropertiesBulk = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        QueueGetValuesByObjectList: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDevicePropertiesBulk,
                pObjectIDs: ?*IPortableDevicePropVariantCollection,
                pKeys: ?*IPortableDeviceKeyCollection,
                pCallback: ?*IPortableDevicePropertiesBulkCallback,
                pContext: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDevicePropertiesBulk,
                pObjectIDs: ?*IPortableDevicePropVariantCollection,
                pKeys: ?*IPortableDeviceKeyCollection,
                pCallback: ?*IPortableDevicePropertiesBulkCallback,
                pContext: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        QueueGetValuesByObjectFormat: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDevicePropertiesBulk,
                pguidObjectFormat: ?*const Guid,
                pszParentObjectID: ?[*:0]const u16,
                dwDepth: u32,
                pKeys: ?*IPortableDeviceKeyCollection,
                pCallback: ?*IPortableDevicePropertiesBulkCallback,
                pContext: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDevicePropertiesBulk,
                pguidObjectFormat: ?*const Guid,
                pszParentObjectID: ?[*:0]const u16,
                dwDepth: u32,
                pKeys: ?*IPortableDeviceKeyCollection,
                pCallback: ?*IPortableDevicePropertiesBulkCallback,
                pContext: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        QueueSetValuesByObjectList: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDevicePropertiesBulk,
                pObjectValues: ?*IPortableDeviceValuesCollection,
                pCallback: ?*IPortableDevicePropertiesBulkCallback,
                pContext: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDevicePropertiesBulk,
                pObjectValues: ?*IPortableDeviceValuesCollection,
                pCallback: ?*IPortableDevicePropertiesBulkCallback,
                pContext: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Start: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDevicePropertiesBulk,
                pContext: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDevicePropertiesBulk,
                pContext: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Cancel: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDevicePropertiesBulk,
                pContext: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDevicePropertiesBulk,
                pContext: ?*const 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 IPortableDevicePropertiesBulk_QueueGetValuesByObjectList(self: *const T, pObjectIDs: ?*IPortableDevicePropVariantCollection, pKeys: ?*IPortableDeviceKeyCollection, pCallback: ?*IPortableDevicePropertiesBulkCallback, pContext: ?*Guid) HRESULT {
                return @as(*const IPortableDevicePropertiesBulk.VTable, @ptrCast(self.vtable)).QueueGetValuesByObjectList(@as(*const IPortableDevicePropertiesBulk, @ptrCast(self)), pObjectIDs, pKeys, pCallback, pContext);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDevicePropertiesBulk_QueueGetValuesByObjectFormat(self: *const T, pguidObjectFormat: ?*const Guid, pszParentObjectID: ?[*:0]const u16, dwDepth: u32, pKeys: ?*IPortableDeviceKeyCollection, pCallback: ?*IPortableDevicePropertiesBulkCallback, pContext: ?*Guid) HRESULT {
                return @as(*const IPortableDevicePropertiesBulk.VTable, @ptrCast(self.vtable)).QueueGetValuesByObjectFormat(@as(*const IPortableDevicePropertiesBulk, @ptrCast(self)), pguidObjectFormat, pszParentObjectID, dwDepth, pKeys, pCallback, pContext);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDevicePropertiesBulk_QueueSetValuesByObjectList(self: *const T, pObjectValues: ?*IPortableDeviceValuesCollection, pCallback: ?*IPortableDevicePropertiesBulkCallback, pContext: ?*Guid) HRESULT {
                return @as(*const IPortableDevicePropertiesBulk.VTable, @ptrCast(self.vtable)).QueueSetValuesByObjectList(@as(*const IPortableDevicePropertiesBulk, @ptrCast(self)), pObjectValues, pCallback, pContext);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDevicePropertiesBulk_Start(self: *const T, pContext: ?*const Guid) HRESULT {
                return @as(*const IPortableDevicePropertiesBulk.VTable, @ptrCast(self.vtable)).Start(@as(*const IPortableDevicePropertiesBulk, @ptrCast(self)), pContext);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDevicePropertiesBulk_Cancel(self: *const T, pContext: ?*const Guid) HRESULT {
                return @as(*const IPortableDevicePropertiesBulk.VTable, @ptrCast(self.vtable)).Cancel(@as(*const IPortableDevicePropertiesBulk, @ptrCast(self)), pContext);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IPortableDevicePropertiesBulkCallback_Value = Guid.initString("9deacb80-11e8-40e3-a9f3-f557986a7845");
pub const IID_IPortableDevicePropertiesBulkCallback = &IID_IPortableDevicePropertiesBulkCallback_Value;
pub const IPortableDevicePropertiesBulkCallback = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        OnStart: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDevicePropertiesBulkCallback,
                pContext: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDevicePropertiesBulkCallback,
                pContext: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnProgress: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDevicePropertiesBulkCallback,
                pContext: ?*const Guid,
                pResults: ?*IPortableDeviceValuesCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDevicePropertiesBulkCallback,
                pContext: ?*const Guid,
                pResults: ?*IPortableDeviceValuesCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnEnd: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDevicePropertiesBulkCallback,
                pContext: ?*const Guid,
                hrStatus: HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDevicePropertiesBulkCallback,
                pContext: ?*const Guid,
                hrStatus: HRESULT,
            ) 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 IPortableDevicePropertiesBulkCallback_OnStart(self: *const T, pContext: ?*const Guid) HRESULT {
                return @as(*const IPortableDevicePropertiesBulkCallback.VTable, @ptrCast(self.vtable)).OnStart(@as(*const IPortableDevicePropertiesBulkCallback, @ptrCast(self)), pContext);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDevicePropertiesBulkCallback_OnProgress(self: *const T, pContext: ?*const Guid, pResults: ?*IPortableDeviceValuesCollection) HRESULT {
                return @as(*const IPortableDevicePropertiesBulkCallback.VTable, @ptrCast(self.vtable)).OnProgress(@as(*const IPortableDevicePropertiesBulkCallback, @ptrCast(self)), pContext, pResults);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDevicePropertiesBulkCallback_OnEnd(self: *const T, pContext: ?*const Guid, hrStatus: HRESULT) HRESULT {
                return @as(*const IPortableDevicePropertiesBulkCallback.VTable, @ptrCast(self.vtable)).OnEnd(@as(*const IPortableDevicePropertiesBulkCallback, @ptrCast(self)), pContext, hrStatus);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.1'
const IID_IPortableDeviceServiceManager_Value = Guid.initString("a8abc4e9-a84a-47a9-80b3-c5d9b172a961");
pub const IID_IPortableDeviceServiceManager = &IID_IPortableDeviceServiceManager_Value;
pub const IPortableDeviceServiceManager = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetDeviceServices: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceServiceManager,
                pszPnPDeviceID: ?[*:0]const u16,
                guidServiceCategory: ?*const Guid,
                pServices: ?*?PWSTR,
                pcServices: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceServiceManager,
                pszPnPDeviceID: ?[*:0]const u16,
                guidServiceCategory: ?*const Guid,
                pServices: ?*?PWSTR,
                pcServices: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetDeviceForService: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceServiceManager,
                pszPnPServiceID: ?[*:0]const u16,
                ppszPnPDeviceID: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceServiceManager,
                pszPnPServiceID: ?[*:0]const u16,
                ppszPnPDeviceID: ?*?PWSTR,
            ) 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 IPortableDeviceServiceManager_GetDeviceServices(self: *const T, pszPnPDeviceID: ?[*:0]const u16, guidServiceCategory: ?*const Guid, pServices: ?*?PWSTR, pcServices: ?*u32) HRESULT {
                return @as(*const IPortableDeviceServiceManager.VTable, @ptrCast(self.vtable)).GetDeviceServices(@as(*const IPortableDeviceServiceManager, @ptrCast(self)), pszPnPDeviceID, guidServiceCategory, pServices, pcServices);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceServiceManager_GetDeviceForService(self: *const T, pszPnPServiceID: ?[*:0]const u16, ppszPnPDeviceID: ?*?PWSTR) HRESULT {
                return @as(*const IPortableDeviceServiceManager.VTable, @ptrCast(self.vtable)).GetDeviceForService(@as(*const IPortableDeviceServiceManager, @ptrCast(self)), pszPnPServiceID, ppszPnPDeviceID);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.1'
const IID_IPortableDeviceService_Value = Guid.initString("d3bd3a44-d7b5-40a9-98b7-2fa4d01dec08");
pub const IID_IPortableDeviceService = &IID_IPortableDeviceService_Value;
pub const IPortableDeviceService = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Open: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceService,
                pszPnPServiceID: ?[*:0]const u16,
                pClientInfo: ?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceService,
                pszPnPServiceID: ?[*:0]const u16,
                pClientInfo: ?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Capabilities: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceService,
                ppCapabilities: ?*?*IPortableDeviceServiceCapabilities,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceService,
                ppCapabilities: ?*?*IPortableDeviceServiceCapabilities,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Content: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceService,
                ppContent: ?*?*IPortableDeviceContent2,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceService,
                ppContent: ?*?*IPortableDeviceContent2,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Methods: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceService,
                ppMethods: ?*?*IPortableDeviceServiceMethods,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceService,
                ppMethods: ?*?*IPortableDeviceServiceMethods,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Cancel: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceService,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceService,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Close: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceService,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceService,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetServiceObjectID: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceService,
                ppszServiceObjectID: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceService,
                ppszServiceObjectID: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetPnPServiceID: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceService,
                ppszPnPServiceID: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceService,
                ppszPnPServiceID: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Advise: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceService,
                dwFlags: u32,
                pCallback: ?*IPortableDeviceEventCallback,
                pParameters: ?*IPortableDeviceValues,
                ppszCookie: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceService,
                dwFlags: u32,
                pCallback: ?*IPortableDeviceEventCallback,
                pParameters: ?*IPortableDeviceValues,
                ppszCookie: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Unadvise: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceService,
                pszCookie: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceService,
                pszCookie: ?[*:0]const u16,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SendCommand: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceService,
                dwFlags: u32,
                pParameters: ?*IPortableDeviceValues,
                ppResults: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceService,
                dwFlags: u32,
                pParameters: ?*IPortableDeviceValues,
                ppResults: ?*?*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 IPortableDeviceService_Open(self: *const T, pszPnPServiceID: ?[*:0]const u16, pClientInfo: ?*IPortableDeviceValues) HRESULT {
                return @as(*const IPortableDeviceService.VTable, @ptrCast(self.vtable)).Open(@as(*const IPortableDeviceService, @ptrCast(self)), pszPnPServiceID, pClientInfo);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceService_Capabilities(self: *const T, ppCapabilities: ?*?*IPortableDeviceServiceCapabilities) HRESULT {
                return @as(*const IPortableDeviceService.VTable, @ptrCast(self.vtable)).Capabilities(@as(*const IPortableDeviceService, @ptrCast(self)), ppCapabilities);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceService_Content(self: *const T, ppContent: ?*?*IPortableDeviceContent2) HRESULT {
                return @as(*const IPortableDeviceService.VTable, @ptrCast(self.vtable)).Content(@as(*const IPortableDeviceService, @ptrCast(self)), ppContent);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceService_Methods(self: *const T, ppMethods: ?*?*IPortableDeviceServiceMethods) HRESULT {
                return @as(*const IPortableDeviceService.VTable, @ptrCast(self.vtable)).Methods(@as(*const IPortableDeviceService, @ptrCast(self)), ppMethods);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceService_Cancel(self: *const T) HRESULT {
                return @as(*const IPortableDeviceService.VTable, @ptrCast(self.vtable)).Cancel(@as(*const IPortableDeviceService, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceService_Close(self: *const T) HRESULT {
                return @as(*const IPortableDeviceService.VTable, @ptrCast(self.vtable)).Close(@as(*const IPortableDeviceService, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceService_GetServiceObjectID(self: *const T, ppszServiceObjectID: ?*?PWSTR) HRESULT {
                return @as(*const IPortableDeviceService.VTable, @ptrCast(self.vtable)).GetServiceObjectID(@as(*const IPortableDeviceService, @ptrCast(self)), ppszServiceObjectID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceService_GetPnPServiceID(self: *const T, ppszPnPServiceID: ?*?PWSTR) HRESULT {
                return @as(*const IPortableDeviceService.VTable, @ptrCast(self.vtable)).GetPnPServiceID(@as(*const IPortableDeviceService, @ptrCast(self)), ppszPnPServiceID);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceService_Advise(self: *const T, dwFlags: u32, pCallback: ?*IPortableDeviceEventCallback, pParameters: ?*IPortableDeviceValues, ppszCookie: ?*?PWSTR) HRESULT {
                return @as(*const IPortableDeviceService.VTable, @ptrCast(self.vtable)).Advise(@as(*const IPortableDeviceService, @ptrCast(self)), dwFlags, pCallback, pParameters, ppszCookie);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceService_Unadvise(self: *const T, pszCookie: ?[*:0]const u16) HRESULT {
                return @as(*const IPortableDeviceService.VTable, @ptrCast(self.vtable)).Unadvise(@as(*const IPortableDeviceService, @ptrCast(self)), pszCookie);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceService_SendCommand(self: *const T, dwFlags: u32, pParameters: ?*IPortableDeviceValues, ppResults: ?*?*IPortableDeviceValues) HRESULT {
                return @as(*const IPortableDeviceService.VTable, @ptrCast(self.vtable)).SendCommand(@as(*const IPortableDeviceService, @ptrCast(self)), dwFlags, pParameters, ppResults);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.1'
const IID_IPortableDeviceServiceCapabilities_Value = Guid.initString("24dbd89d-413e-43e0-bd5b-197f3c56c886");
pub const IID_IPortableDeviceServiceCapabilities = &IID_IPortableDeviceServiceCapabilities_Value;
pub const IPortableDeviceServiceCapabilities = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetSupportedMethods: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceServiceCapabilities,
                ppMethods: ?*?*IPortableDevicePropVariantCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceServiceCapabilities,
                ppMethods: ?*?*IPortableDevicePropVariantCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetSupportedMethodsByFormat: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceServiceCapabilities,
                Format: ?*const Guid,
                ppMethods: ?*?*IPortableDevicePropVariantCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceServiceCapabilities,
                Format: ?*const Guid,
                ppMethods: ?*?*IPortableDevicePropVariantCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetMethodAttributes: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceServiceCapabilities,
                Method: ?*const Guid,
                ppAttributes: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceServiceCapabilities,
                Method: ?*const Guid,
                ppAttributes: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetMethodParameterAttributes: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceServiceCapabilities,
                Method: ?*const Guid,
                Parameter: ?*const PROPERTYKEY,
                ppAttributes: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceServiceCapabilities,
                Method: ?*const Guid,
                Parameter: ?*const PROPERTYKEY,
                ppAttributes: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetSupportedFormats: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceServiceCapabilities,
                ppFormats: ?*?*IPortableDevicePropVariantCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceServiceCapabilities,
                ppFormats: ?*?*IPortableDevicePropVariantCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetFormatAttributes: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceServiceCapabilities,
                Format: ?*const Guid,
                ppAttributes: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceServiceCapabilities,
                Format: ?*const Guid,
                ppAttributes: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetSupportedFormatProperties: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceServiceCapabilities,
                Format: ?*const Guid,
                ppKeys: ?*?*IPortableDeviceKeyCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceServiceCapabilities,
                Format: ?*const Guid,
                ppKeys: ?*?*IPortableDeviceKeyCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetFormatPropertyAttributes: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceServiceCapabilities,
                Format: ?*const Guid,
                Property: ?*const PROPERTYKEY,
                ppAttributes: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceServiceCapabilities,
                Format: ?*const Guid,
                Property: ?*const PROPERTYKEY,
                ppAttributes: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetSupportedEvents: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceServiceCapabilities,
                ppEvents: ?*?*IPortableDevicePropVariantCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceServiceCapabilities,
                ppEvents: ?*?*IPortableDevicePropVariantCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetEventAttributes: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceServiceCapabilities,
                Event: ?*const Guid,
                ppAttributes: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceServiceCapabilities,
                Event: ?*const Guid,
                ppAttributes: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetEventParameterAttributes: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceServiceCapabilities,
                Event: ?*const Guid,
                Parameter: ?*const PROPERTYKEY,
                ppAttributes: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceServiceCapabilities,
                Event: ?*const Guid,
                Parameter: ?*const PROPERTYKEY,
                ppAttributes: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetInheritedServices: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceServiceCapabilities,
                dwInheritanceType: u32,
                ppServices: ?*?*IPortableDevicePropVariantCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceServiceCapabilities,
                dwInheritanceType: u32,
                ppServices: ?*?*IPortableDevicePropVariantCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetFormatRenderingProfiles: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceServiceCapabilities,
                Format: ?*const Guid,
                ppRenderingProfiles: ?*?*IPortableDeviceValuesCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceServiceCapabilities,
                Format: ?*const Guid,
                ppRenderingProfiles: ?*?*IPortableDeviceValuesCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetSupportedCommands: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceServiceCapabilities,
                ppCommands: ?*?*IPortableDeviceKeyCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceServiceCapabilities,
                ppCommands: ?*?*IPortableDeviceKeyCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetCommandOptions: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceServiceCapabilities,
                Command: ?*const PROPERTYKEY,
                ppOptions: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceServiceCapabilities,
                Command: ?*const PROPERTYKEY,
                ppOptions: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Cancel: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceServiceCapabilities,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceServiceCapabilities,
            ) 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 IPortableDeviceServiceCapabilities_GetSupportedMethods(self: *const T, ppMethods: ?*?*IPortableDevicePropVariantCollection) HRESULT {
                return @as(*const IPortableDeviceServiceCapabilities.VTable, @ptrCast(self.vtable)).GetSupportedMethods(@as(*const IPortableDeviceServiceCapabilities, @ptrCast(self)), ppMethods);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceServiceCapabilities_GetSupportedMethodsByFormat(self: *const T, Format: ?*const Guid, ppMethods: ?*?*IPortableDevicePropVariantCollection) HRESULT {
                return @as(*const IPortableDeviceServiceCapabilities.VTable, @ptrCast(self.vtable)).GetSupportedMethodsByFormat(@as(*const IPortableDeviceServiceCapabilities, @ptrCast(self)), Format, ppMethods);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceServiceCapabilities_GetMethodAttributes(self: *const T, Method: ?*const Guid, ppAttributes: ?*?*IPortableDeviceValues) HRESULT {
                return @as(*const IPortableDeviceServiceCapabilities.VTable, @ptrCast(self.vtable)).GetMethodAttributes(@as(*const IPortableDeviceServiceCapabilities, @ptrCast(self)), Method, ppAttributes);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceServiceCapabilities_GetMethodParameterAttributes(self: *const T, Method: ?*const Guid, Parameter: ?*const PROPERTYKEY, ppAttributes: ?*?*IPortableDeviceValues) HRESULT {
                return @as(*const IPortableDeviceServiceCapabilities.VTable, @ptrCast(self.vtable)).GetMethodParameterAttributes(@as(*const IPortableDeviceServiceCapabilities, @ptrCast(self)), Method, Parameter, ppAttributes);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceServiceCapabilities_GetSupportedFormats(self: *const T, ppFormats: ?*?*IPortableDevicePropVariantCollection) HRESULT {
                return @as(*const IPortableDeviceServiceCapabilities.VTable, @ptrCast(self.vtable)).GetSupportedFormats(@as(*const IPortableDeviceServiceCapabilities, @ptrCast(self)), ppFormats);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceServiceCapabilities_GetFormatAttributes(self: *const T, Format: ?*const Guid, ppAttributes: ?*?*IPortableDeviceValues) HRESULT {
                return @as(*const IPortableDeviceServiceCapabilities.VTable, @ptrCast(self.vtable)).GetFormatAttributes(@as(*const IPortableDeviceServiceCapabilities, @ptrCast(self)), Format, ppAttributes);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceServiceCapabilities_GetSupportedFormatProperties(self: *const T, Format: ?*const Guid, ppKeys: ?*?*IPortableDeviceKeyCollection) HRESULT {
                return @as(*const IPortableDeviceServiceCapabilities.VTable, @ptrCast(self.vtable)).GetSupportedFormatProperties(@as(*const IPortableDeviceServiceCapabilities, @ptrCast(self)), Format, ppKeys);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceServiceCapabilities_GetFormatPropertyAttributes(self: *const T, Format: ?*const Guid, Property: ?*const PROPERTYKEY, ppAttributes: ?*?*IPortableDeviceValues) HRESULT {
                return @as(*const IPortableDeviceServiceCapabilities.VTable, @ptrCast(self.vtable)).GetFormatPropertyAttributes(@as(*const IPortableDeviceServiceCapabilities, @ptrCast(self)), Format, Property, ppAttributes);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceServiceCapabilities_GetSupportedEvents(self: *const T, ppEvents: ?*?*IPortableDevicePropVariantCollection) HRESULT {
                return @as(*const IPortableDeviceServiceCapabilities.VTable, @ptrCast(self.vtable)).GetSupportedEvents(@as(*const IPortableDeviceServiceCapabilities, @ptrCast(self)), ppEvents);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceServiceCapabilities_GetEventAttributes(self: *const T, Event: ?*const Guid, ppAttributes: ?*?*IPortableDeviceValues) HRESULT {
                return @as(*const IPortableDeviceServiceCapabilities.VTable, @ptrCast(self.vtable)).GetEventAttributes(@as(*const IPortableDeviceServiceCapabilities, @ptrCast(self)), Event, ppAttributes);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceServiceCapabilities_GetEventParameterAttributes(self: *const T, Event: ?*const Guid, Parameter: ?*const PROPERTYKEY, ppAttributes: ?*?*IPortableDeviceValues) HRESULT {
                return @as(*const IPortableDeviceServiceCapabilities.VTable, @ptrCast(self.vtable)).GetEventParameterAttributes(@as(*const IPortableDeviceServiceCapabilities, @ptrCast(self)), Event, Parameter, ppAttributes);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceServiceCapabilities_GetInheritedServices(self: *const T, dwInheritanceType: u32, ppServices: ?*?*IPortableDevicePropVariantCollection) HRESULT {
                return @as(*const IPortableDeviceServiceCapabilities.VTable, @ptrCast(self.vtable)).GetInheritedServices(@as(*const IPortableDeviceServiceCapabilities, @ptrCast(self)), dwInheritanceType, ppServices);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceServiceCapabilities_GetFormatRenderingProfiles(self: *const T, Format: ?*const Guid, ppRenderingProfiles: ?*?*IPortableDeviceValuesCollection) HRESULT {
                return @as(*const IPortableDeviceServiceCapabilities.VTable, @ptrCast(self.vtable)).GetFormatRenderingProfiles(@as(*const IPortableDeviceServiceCapabilities, @ptrCast(self)), Format, ppRenderingProfiles);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceServiceCapabilities_GetSupportedCommands(self: *const T, ppCommands: ?*?*IPortableDeviceKeyCollection) HRESULT {
                return @as(*const IPortableDeviceServiceCapabilities.VTable, @ptrCast(self.vtable)).GetSupportedCommands(@as(*const IPortableDeviceServiceCapabilities, @ptrCast(self)), ppCommands);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceServiceCapabilities_GetCommandOptions(self: *const T, Command: ?*const PROPERTYKEY, ppOptions: ?*?*IPortableDeviceValues) HRESULT {
                return @as(*const IPortableDeviceServiceCapabilities.VTable, @ptrCast(self.vtable)).GetCommandOptions(@as(*const IPortableDeviceServiceCapabilities, @ptrCast(self)), Command, ppOptions);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceServiceCapabilities_Cancel(self: *const T) HRESULT {
                return @as(*const IPortableDeviceServiceCapabilities.VTable, @ptrCast(self.vtable)).Cancel(@as(*const IPortableDeviceServiceCapabilities, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.1'
const IID_IPortableDeviceServiceMethods_Value = Guid.initString("e20333c9-fd34-412d-a381-cc6f2d820df7");
pub const IID_IPortableDeviceServiceMethods = &IID_IPortableDeviceServiceMethods_Value;
pub const IPortableDeviceServiceMethods = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Invoke: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceServiceMethods,
                Method: ?*const Guid,
                pParameters: ?*IPortableDeviceValues,
                ppResults: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceServiceMethods,
                Method: ?*const Guid,
                pParameters: ?*IPortableDeviceValues,
                ppResults: ?*?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        InvokeAsync: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceServiceMethods,
                Method: ?*const Guid,
                pParameters: ?*IPortableDeviceValues,
                pCallback: ?*IPortableDeviceServiceMethodCallback,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceServiceMethods,
                Method: ?*const Guid,
                pParameters: ?*IPortableDeviceValues,
                pCallback: ?*IPortableDeviceServiceMethodCallback,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Cancel: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceServiceMethods,
                pCallback: ?*IPortableDeviceServiceMethodCallback,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceServiceMethods,
                pCallback: ?*IPortableDeviceServiceMethodCallback,
            ) 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 IPortableDeviceServiceMethods_Invoke(self: *const T, Method: ?*const Guid, pParameters: ?*IPortableDeviceValues, ppResults: ?*?*IPortableDeviceValues) HRESULT {
                return @as(*const IPortableDeviceServiceMethods.VTable, @ptrCast(self.vtable)).Invoke(@as(*const IPortableDeviceServiceMethods, @ptrCast(self)), Method, pParameters, ppResults);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceServiceMethods_InvokeAsync(self: *const T, Method: ?*const Guid, pParameters: ?*IPortableDeviceValues, pCallback: ?*IPortableDeviceServiceMethodCallback) HRESULT {
                return @as(*const IPortableDeviceServiceMethods.VTable, @ptrCast(self.vtable)).InvokeAsync(@as(*const IPortableDeviceServiceMethods, @ptrCast(self)), Method, pParameters, pCallback);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceServiceMethods_Cancel(self: *const T, pCallback: ?*IPortableDeviceServiceMethodCallback) HRESULT {
                return @as(*const IPortableDeviceServiceMethods.VTable, @ptrCast(self.vtable)).Cancel(@as(*const IPortableDeviceServiceMethods, @ptrCast(self)), pCallback);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.1'
const IID_IPortableDeviceServiceMethodCallback_Value = Guid.initString("c424233c-afce-4828-a756-7ed7a2350083");
pub const IID_IPortableDeviceServiceMethodCallback = &IID_IPortableDeviceServiceMethodCallback_Value;
pub const IPortableDeviceServiceMethodCallback = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        OnComplete: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceServiceMethodCallback,
                hrStatus: HRESULT,
                pResults: ?*IPortableDeviceValues,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceServiceMethodCallback,
                hrStatus: HRESULT,
                pResults: ?*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 IPortableDeviceServiceMethodCallback_OnComplete(self: *const T, hrStatus: HRESULT, pResults: ?*IPortableDeviceValues) HRESULT {
                return @as(*const IPortableDeviceServiceMethodCallback.VTable, @ptrCast(self.vtable)).OnComplete(@as(*const IPortableDeviceServiceMethodCallback, @ptrCast(self)), hrStatus, pResults);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IPortableDeviceServiceActivation_Value = Guid.initString("e56b0534-d9b9-425c-9b99-75f97cb3d7c8");
pub const IID_IPortableDeviceServiceActivation = &IID_IPortableDeviceServiceActivation_Value;
pub const IPortableDeviceServiceActivation = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        OpenAsync: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceServiceActivation,
                pszPnPServiceID: ?[*:0]const u16,
                pClientInfo: ?*IPortableDeviceValues,
                pCallback: ?*IPortableDeviceServiceOpenCallback,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceServiceActivation,
                pszPnPServiceID: ?[*:0]const u16,
                pClientInfo: ?*IPortableDeviceValues,
                pCallback: ?*IPortableDeviceServiceOpenCallback,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        CancelOpenAsync: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceServiceActivation,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceServiceActivation,
            ) 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 IPortableDeviceServiceActivation_OpenAsync(self: *const T, pszPnPServiceID: ?[*:0]const u16, pClientInfo: ?*IPortableDeviceValues, pCallback: ?*IPortableDeviceServiceOpenCallback) HRESULT {
                return @as(*const IPortableDeviceServiceActivation.VTable, @ptrCast(self.vtable)).OpenAsync(@as(*const IPortableDeviceServiceActivation, @ptrCast(self)), pszPnPServiceID, pClientInfo, pCallback);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceServiceActivation_CancelOpenAsync(self: *const T) HRESULT {
                return @as(*const IPortableDeviceServiceActivation.VTable, @ptrCast(self.vtable)).CancelOpenAsync(@as(*const IPortableDeviceServiceActivation, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IPortableDeviceServiceOpenCallback_Value = Guid.initString("bced49c8-8efe-41ed-960b-61313abd47a9");
pub const IID_IPortableDeviceServiceOpenCallback = &IID_IPortableDeviceServiceOpenCallback_Value;
pub const IPortableDeviceServiceOpenCallback = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        OnComplete: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceServiceOpenCallback,
                hrStatus: HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceServiceOpenCallback,
                hrStatus: HRESULT,
            ) 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 IPortableDeviceServiceOpenCallback_OnComplete(self: *const T, hrStatus: HRESULT) HRESULT {
                return @as(*const IPortableDeviceServiceOpenCallback.VTable, @ptrCast(self.vtable)).OnComplete(@as(*const IPortableDeviceServiceOpenCallback, @ptrCast(self)), hrStatus);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.1'
const IID_IPortableDeviceDispatchFactory_Value = Guid.initString("5e1eafc3-e3d7-4132-96fa-759c0f9d1e0f");
pub const IID_IPortableDeviceDispatchFactory = &IID_IPortableDeviceDispatchFactory_Value;
pub const IPortableDeviceDispatchFactory = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetDeviceDispatch: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceDispatchFactory,
                pszPnPDeviceID: ?[*:0]const u16,
                ppDeviceDispatch: ?*?*IDispatch,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceDispatchFactory,
                pszPnPDeviceID: ?[*:0]const u16,
                ppDeviceDispatch: ?*?*IDispatch,
            ) 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 IPortableDeviceDispatchFactory_GetDeviceDispatch(self: *const T, pszPnPDeviceID: ?[*:0]const u16, ppDeviceDispatch: ?*?*IDispatch) HRESULT {
                return @as(*const IPortableDeviceDispatchFactory.VTable, @ptrCast(self.vtable)).GetDeviceDispatch(@as(*const IPortableDeviceDispatchFactory, @ptrCast(self)), pszPnPDeviceID, ppDeviceDispatch);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows8.0'
const IID_IPortableDeviceWebControl_Value = Guid.initString("94fc7953-5ca1-483a-8aee-df52e7747d00");
pub const IID_IPortableDeviceWebControl = &IID_IPortableDeviceWebControl_Value;
pub const IPortableDeviceWebControl = extern struct {
    pub const VTable = extern struct {
        base: IDispatch.VTable,
        GetDeviceFromId: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceWebControl,
                deviceId: ?BSTR,
                ppDevice: ?*?*IDispatch,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceWebControl,
                deviceId: ?BSTR,
                ppDevice: ?*?*IDispatch,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetDeviceFromIdAsync: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceWebControl,
                deviceId: ?BSTR,
                pCompletionHandler: ?*IDispatch,
                pErrorHandler: ?*IDispatch,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceWebControl,
                deviceId: ?BSTR,
                pCompletionHandler: ?*IDispatch,
                pErrorHandler: ?*IDispatch,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDispatch.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceWebControl_GetDeviceFromId(self: *const T, deviceId: ?BSTR, ppDevice: ?*?*IDispatch) HRESULT {
                return @as(*const IPortableDeviceWebControl.VTable, @ptrCast(self.vtable)).GetDeviceFromId(@as(*const IPortableDeviceWebControl, @ptrCast(self)), deviceId, ppDevice);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceWebControl_GetDeviceFromIdAsync(self: *const T, deviceId: ?BSTR, pCompletionHandler: ?*IDispatch, pErrorHandler: ?*IDispatch) HRESULT {
                return @as(*const IPortableDeviceWebControl.VTable, @ptrCast(self.vtable)).GetDeviceFromIdAsync(@as(*const IPortableDeviceWebControl, @ptrCast(self)), deviceId, pCompletionHandler, pErrorHandler);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const CLSID_EnumBthMtpConnectors_Value = Guid.initString("a1570149-e645-4f43-8b0d-409b061db2fc");
pub const CLSID_EnumBthMtpConnectors = &CLSID_EnumBthMtpConnectors_Value;

const IID_IEnumPortableDeviceConnectors_Value = Guid.initString("bfdef549-9247-454f-bd82-06fe80853faa");
pub const IID_IEnumPortableDeviceConnectors = &IID_IEnumPortableDeviceConnectors_Value;
pub const IEnumPortableDeviceConnectors = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Next: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IEnumPortableDeviceConnectors,
                cRequested: u32,
                pConnectors: [*]?*IPortableDeviceConnector,
                pcFetched: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IEnumPortableDeviceConnectors,
                cRequested: u32,
                pConnectors: [*]?*IPortableDeviceConnector,
                pcFetched: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Skip: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IEnumPortableDeviceConnectors,
                cConnectors: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IEnumPortableDeviceConnectors,
                cConnectors: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Reset: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IEnumPortableDeviceConnectors,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IEnumPortableDeviceConnectors,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Clone: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IEnumPortableDeviceConnectors,
                ppEnum: ?*?*IEnumPortableDeviceConnectors,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IEnumPortableDeviceConnectors,
                ppEnum: ?*?*IEnumPortableDeviceConnectors,
            ) 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 IEnumPortableDeviceConnectors_Next(self: *const T, cRequested: u32, pConnectors: [*]?*IPortableDeviceConnector, pcFetched: ?*u32) HRESULT {
                return @as(*const IEnumPortableDeviceConnectors.VTable, @ptrCast(self.vtable)).Next(@as(*const IEnumPortableDeviceConnectors, @ptrCast(self)), cRequested, pConnectors, pcFetched);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IEnumPortableDeviceConnectors_Skip(self: *const T, cConnectors: u32) HRESULT {
                return @as(*const IEnumPortableDeviceConnectors.VTable, @ptrCast(self.vtable)).Skip(@as(*const IEnumPortableDeviceConnectors, @ptrCast(self)), cConnectors);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IEnumPortableDeviceConnectors_Reset(self: *const T) HRESULT {
                return @as(*const IEnumPortableDeviceConnectors.VTable, @ptrCast(self.vtable)).Reset(@as(*const IEnumPortableDeviceConnectors, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IEnumPortableDeviceConnectors_Clone(self: *const T, ppEnum: ?*?*IEnumPortableDeviceConnectors) HRESULT {
                return @as(*const IEnumPortableDeviceConnectors.VTable, @ptrCast(self.vtable)).Clone(@as(*const IEnumPortableDeviceConnectors, @ptrCast(self)), ppEnum);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

// TODO: this type is limited to platform 'windows6.1'
const IID_IPortableDeviceConnector_Value = Guid.initString("625e2df8-6392-4cf0-9ad1-3cfa5f17775c");
pub const IID_IPortableDeviceConnector = &IID_IPortableDeviceConnector_Value;
pub const IPortableDeviceConnector = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Connect: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceConnector,
                pCallback: ?*IConnectionRequestCallback,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceConnector,
                pCallback: ?*IConnectionRequestCallback,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Disconnect: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceConnector,
                pCallback: ?*IConnectionRequestCallback,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceConnector,
                pCallback: ?*IConnectionRequestCallback,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Cancel: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceConnector,
                pCallback: ?*IConnectionRequestCallback,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceConnector,
                pCallback: ?*IConnectionRequestCallback,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetProperty: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceConnector,
                pPropertyKey: ?*const DEVPROPKEY,
                pPropertyType: ?*u32,
                ppData: [*]?*u8,
                pcbData: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceConnector,
                pPropertyKey: ?*const DEVPROPKEY,
                pPropertyType: ?*u32,
                ppData: [*]?*u8,
                pcbData: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetProperty: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceConnector,
                pPropertyKey: ?*const DEVPROPKEY,
                PropertyType: u32,
                pData: [*:0]const u8,
                cbData: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceConnector,
                pPropertyKey: ?*const DEVPROPKEY,
                PropertyType: u32,
                pData: [*:0]const u8,
                cbData: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetPnPID: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IPortableDeviceConnector,
                ppwszPnPID: ?*?PWSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IPortableDeviceConnector,
                ppwszPnPID: ?*?PWSTR,
            ) 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 IPortableDeviceConnector_Connect(self: *const T, pCallback: ?*IConnectionRequestCallback) HRESULT {
                return @as(*const IPortableDeviceConnector.VTable, @ptrCast(self.vtable)).Connect(@as(*const IPortableDeviceConnector, @ptrCast(self)), pCallback);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceConnector_Disconnect(self: *const T, pCallback: ?*IConnectionRequestCallback) HRESULT {
                return @as(*const IPortableDeviceConnector.VTable, @ptrCast(self.vtable)).Disconnect(@as(*const IPortableDeviceConnector, @ptrCast(self)), pCallback);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceConnector_Cancel(self: *const T, pCallback: ?*IConnectionRequestCallback) HRESULT {
                return @as(*const IPortableDeviceConnector.VTable, @ptrCast(self.vtable)).Cancel(@as(*const IPortableDeviceConnector, @ptrCast(self)), pCallback);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceConnector_GetProperty(self: *const T, pPropertyKey: ?*const DEVPROPKEY, pPropertyType: ?*u32, ppData: [*]?*u8, pcbData: ?*u32) HRESULT {
                return @as(*const IPortableDeviceConnector.VTable, @ptrCast(self.vtable)).GetProperty(@as(*const IPortableDeviceConnector, @ptrCast(self)), pPropertyKey, pPropertyType, ppData, pcbData);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceConnector_SetProperty(self: *const T, pPropertyKey: ?*const DEVPROPKEY, PropertyType: u32, pData: [*:0]const u8, cbData: u32) HRESULT {
                return @as(*const IPortableDeviceConnector.VTable, @ptrCast(self.vtable)).SetProperty(@as(*const IPortableDeviceConnector, @ptrCast(self)), pPropertyKey, PropertyType, pData, cbData);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IPortableDeviceConnector_GetPnPID(self: *const T, ppwszPnPID: ?*?PWSTR) HRESULT {
                return @as(*const IPortableDeviceConnector.VTable, @ptrCast(self.vtable)).GetPnPID(@as(*const IPortableDeviceConnector, @ptrCast(self)), ppwszPnPID);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IConnectionRequestCallback_Value = Guid.initString("272c9ae0-7161-4ae0-91bd-9f448ee9c427");
pub const IID_IConnectionRequestCallback = &IID_IConnectionRequestCallback_Value;
pub const IConnectionRequestCallback = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        OnComplete: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IConnectionRequestCallback,
                hrStatus: HRESULT,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IConnectionRequestCallback,
                hrStatus: HRESULT,
            ) 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 IConnectionRequestCallback_OnComplete(self: *const T, hrStatus: HRESULT) HRESULT {
                return @as(*const IConnectionRequestCallback.VTable, @ptrCast(self.vtable)).OnComplete(@as(*const IConnectionRequestCallback, @ptrCast(self)), hrStatus);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

pub const DEVICE_RADIO_STATE = enum(i32) {
    RADIO_ON = 0,
    SW_RADIO_OFF = 1,
    HW_RADIO_OFF = 2,
    SW_HW_RADIO_OFF = 3,
    HW_RADIO_ON_UNCONTROLLABLE = 4,
    RADIO_INVALID = 5,
    HW_RADIO_OFF_UNCONTROLLABLE = 6,
    // RADIO_MAX = 6, this enum value conflicts with HW_RADIO_OFF_UNCONTROLLABLE
};
pub const DRS_RADIO_ON = DEVICE_RADIO_STATE.RADIO_ON;
pub const DRS_SW_RADIO_OFF = DEVICE_RADIO_STATE.SW_RADIO_OFF;
pub const DRS_HW_RADIO_OFF = DEVICE_RADIO_STATE.HW_RADIO_OFF;
pub const DRS_SW_HW_RADIO_OFF = DEVICE_RADIO_STATE.SW_HW_RADIO_OFF;
pub const DRS_HW_RADIO_ON_UNCONTROLLABLE = DEVICE_RADIO_STATE.HW_RADIO_ON_UNCONTROLLABLE;
pub const DRS_RADIO_INVALID = DEVICE_RADIO_STATE.RADIO_INVALID;
pub const DRS_HW_RADIO_OFF_UNCONTROLLABLE = DEVICE_RADIO_STATE.HW_RADIO_OFF_UNCONTROLLABLE;
pub const DRS_RADIO_MAX = DEVICE_RADIO_STATE.HW_RADIO_OFF_UNCONTROLLABLE;

pub const SYSTEM_RADIO_STATE = enum(i32) {
    ENABLED = 0,
    DISABLED = 1,
};
pub const SRS_RADIO_ENABLED = SYSTEM_RADIO_STATE.ENABLED;
pub const SRS_RADIO_DISABLED = SYSTEM_RADIO_STATE.DISABLED;

const IID_IMediaRadioManager_Value = Guid.initString("6cfdcab5-fc47-42a5-9241-074b58830e73");
pub const IID_IMediaRadioManager = &IID_IMediaRadioManager_Value;
pub const IMediaRadioManager = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetRadioInstances: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IMediaRadioManager,
                ppCollection: ?*?*IRadioInstanceCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IMediaRadioManager,
                ppCollection: ?*?*IRadioInstanceCollection,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnSystemRadioStateChange: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IMediaRadioManager,
                sysRadioState: SYSTEM_RADIO_STATE,
                uTimeoutSec: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IMediaRadioManager,
                sysRadioState: SYSTEM_RADIO_STATE,
                uTimeoutSec: 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 IMediaRadioManager_GetRadioInstances(self: *const T, ppCollection: ?*?*IRadioInstanceCollection) HRESULT {
                return @as(*const IMediaRadioManager.VTable, @ptrCast(self.vtable)).GetRadioInstances(@as(*const IMediaRadioManager, @ptrCast(self)), ppCollection);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IMediaRadioManager_OnSystemRadioStateChange(self: *const T, sysRadioState: SYSTEM_RADIO_STATE, uTimeoutSec: u32) HRESULT {
                return @as(*const IMediaRadioManager.VTable, @ptrCast(self.vtable)).OnSystemRadioStateChange(@as(*const IMediaRadioManager, @ptrCast(self)), sysRadioState, uTimeoutSec);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IRadioInstanceCollection_Value = Guid.initString("e5791fae-5665-4e0c-95be-5fde31644185");
pub const IID_IRadioInstanceCollection = &IID_IRadioInstanceCollection_Value;
pub const IRadioInstanceCollection = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetCount: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRadioInstanceCollection,
                pcInstance: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRadioInstanceCollection,
                pcInstance: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetAt: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRadioInstanceCollection,
                uIndex: u32,
                ppRadioInstance: ?*?*IRadioInstance,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRadioInstanceCollection,
                uIndex: u32,
                ppRadioInstance: ?*?*IRadioInstance,
            ) 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 IRadioInstanceCollection_GetCount(self: *const T, pcInstance: ?*u32) HRESULT {
                return @as(*const IRadioInstanceCollection.VTable, @ptrCast(self.vtable)).GetCount(@as(*const IRadioInstanceCollection, @ptrCast(self)), pcInstance);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRadioInstanceCollection_GetAt(self: *const T, uIndex: u32, ppRadioInstance: ?*?*IRadioInstance) HRESULT {
                return @as(*const IRadioInstanceCollection.VTable, @ptrCast(self.vtable)).GetAt(@as(*const IRadioInstanceCollection, @ptrCast(self)), uIndex, ppRadioInstance);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IRadioInstance_Value = Guid.initString("70aa1c9e-f2b4-4c61-86d3-6b9fb75fd1a2");
pub const IID_IRadioInstance = &IID_IRadioInstance_Value;
pub const IRadioInstance = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetRadioManagerSignature: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRadioInstance,
                pguidSignature: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRadioInstance,
                pguidSignature: ?*Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetInstanceSignature: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRadioInstance,
                pbstrId: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRadioInstance,
                pbstrId: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetFriendlyName: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRadioInstance,
                lcid: u32,
                pbstrName: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRadioInstance,
                lcid: u32,
                pbstrName: ?*?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetRadioState: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRadioInstance,
                pRadioState: ?*DEVICE_RADIO_STATE,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRadioInstance,
                pRadioState: ?*DEVICE_RADIO_STATE,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetRadioState: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRadioInstance,
                radioState: DEVICE_RADIO_STATE,
                uTimeoutSec: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IRadioInstance,
                radioState: DEVICE_RADIO_STATE,
                uTimeoutSec: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        IsMultiComm: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRadioInstance,
            ) callconv(@import("std").os.windows.WINAPI) BOOL,
            else => *const fn (
                self: *const IRadioInstance,
            ) callconv(@import("std").os.windows.WINAPI) BOOL,
        },
        IsAssociatingDevice: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IRadioInstance,
            ) callconv(@import("std").os.windows.WINAPI) BOOL,
            else => *const fn (
                self: *const IRadioInstance,
            ) callconv(@import("std").os.windows.WINAPI) BOOL,
        },
    };
    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 IRadioInstance_GetRadioManagerSignature(self: *const T, pguidSignature: ?*Guid) HRESULT {
                return @as(*const IRadioInstance.VTable, @ptrCast(self.vtable)).GetRadioManagerSignature(@as(*const IRadioInstance, @ptrCast(self)), pguidSignature);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRadioInstance_GetInstanceSignature(self: *const T, pbstrId: ?*?BSTR) HRESULT {
                return @as(*const IRadioInstance.VTable, @ptrCast(self.vtable)).GetInstanceSignature(@as(*const IRadioInstance, @ptrCast(self)), pbstrId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRadioInstance_GetFriendlyName(self: *const T, lcid: u32, pbstrName: ?*?BSTR) HRESULT {
                return @as(*const IRadioInstance.VTable, @ptrCast(self.vtable)).GetFriendlyName(@as(*const IRadioInstance, @ptrCast(self)), lcid, pbstrName);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRadioInstance_GetRadioState(self: *const T, pRadioState: ?*DEVICE_RADIO_STATE) HRESULT {
                return @as(*const IRadioInstance.VTable, @ptrCast(self.vtable)).GetRadioState(@as(*const IRadioInstance, @ptrCast(self)), pRadioState);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRadioInstance_SetRadioState(self: *const T, radioState: DEVICE_RADIO_STATE, uTimeoutSec: u32) HRESULT {
                return @as(*const IRadioInstance.VTable, @ptrCast(self.vtable)).SetRadioState(@as(*const IRadioInstance, @ptrCast(self)), radioState, uTimeoutSec);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRadioInstance_IsMultiComm(self: *const T) BOOL {
                return @as(*const IRadioInstance.VTable, @ptrCast(self.vtable)).IsMultiComm(@as(*const IRadioInstance, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IRadioInstance_IsAssociatingDevice(self: *const T) BOOL {
                return @as(*const IRadioInstance.VTable, @ptrCast(self.vtable)).IsAssociatingDevice(@as(*const IRadioInstance, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IMediaRadioManagerNotifySink_Value = Guid.initString("89d81f5f-c147-49ed-a11c-77b20c31e7c9");
pub const IID_IMediaRadioManagerNotifySink = &IID_IMediaRadioManagerNotifySink_Value;
pub const IMediaRadioManagerNotifySink = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        OnInstanceAdd: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IMediaRadioManagerNotifySink,
                pRadioInstance: ?*IRadioInstance,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IMediaRadioManagerNotifySink,
                pRadioInstance: ?*IRadioInstance,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnInstanceRemove: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IMediaRadioManagerNotifySink,
                bstrRadioInstanceId: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IMediaRadioManagerNotifySink,
                bstrRadioInstanceId: ?BSTR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        OnInstanceRadioChange: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IMediaRadioManagerNotifySink,
                bstrRadioInstanceId: ?BSTR,
                radioState: DEVICE_RADIO_STATE,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IMediaRadioManagerNotifySink,
                bstrRadioInstanceId: ?BSTR,
                radioState: DEVICE_RADIO_STATE,
            ) 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 IMediaRadioManagerNotifySink_OnInstanceAdd(self: *const T, pRadioInstance: ?*IRadioInstance) HRESULT {
                return @as(*const IMediaRadioManagerNotifySink.VTable, @ptrCast(self.vtable)).OnInstanceAdd(@as(*const IMediaRadioManagerNotifySink, @ptrCast(self)), pRadioInstance);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IMediaRadioManagerNotifySink_OnInstanceRemove(self: *const T, bstrRadioInstanceId: ?BSTR) HRESULT {
                return @as(*const IMediaRadioManagerNotifySink.VTable, @ptrCast(self.vtable)).OnInstanceRemove(@as(*const IMediaRadioManagerNotifySink, @ptrCast(self)), bstrRadioInstanceId);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IMediaRadioManagerNotifySink_OnInstanceRadioChange(self: *const T, bstrRadioInstanceId: ?BSTR, radioState: DEVICE_RADIO_STATE) HRESULT {
                return @as(*const IMediaRadioManagerNotifySink.VTable, @ptrCast(self.vtable)).OnInstanceRadioChange(@as(*const IMediaRadioManagerNotifySink, @ptrCast(self)), bstrRadioInstanceId, radioState);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

//--------------------------------------------------------------------------------
// Section: Functions (1)
//--------------------------------------------------------------------------------
pub extern "dmprocessxmlfiltered" fn DMProcessConfigXMLFiltered(
    pszXmlIn: ?[*:0]const u16,
    rgszAllowedCspNodes: [*]?PWSTR,
    dwNumAllowedCspNodes: u32,
    pbstrXmlOut: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

//--------------------------------------------------------------------------------
// 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 BSTR = @import("../foundation.zig").BSTR;
const DEVPROPKEY = @import("../devices/properties.zig").DEVPROPKEY;
const HRESULT = @import("../foundation.zig").HRESULT;
const IDispatch = @import("../system/com.zig").IDispatch;
const IPropertyStore = @import("../ui/shell/properties_system.zig").IPropertyStore;
const IStream = @import("../system/com.zig").IStream;
const IUnknown = @import("../system/com.zig").IUnknown;
const LARGE_INTEGER = @import("../foundation.zig").LARGE_INTEGER;
const PROPERTYKEY = @import("../ui/shell/properties_system.zig").PROPERTYKEY;
const PROPVARIANT = @import("../system/com/structured_storage.zig").PROPVARIANT;
const PWSTR = @import("../foundation.zig").PWSTR;
const ULARGE_INTEGER = @import("../foundation.zig").ULARGE_INTEGER;

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);
        }
    }
}
