Adding upstream version 1.64.0+dfsg1.upstream/1.64.0+dfsg1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

51 files changed, 4771 insertions, 0 deletions

diff --git a/vendor/windows-sys/src/Windows/Devices/Adc/Provider/mod.rs b/vendor/windows-sys/src/Windows/Devices/Adc/Provider/mod.rs
new file mode 100644
index 000000000..ead7c47f2
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/Adc/Provider/mod.rs
@@ -0,0 +1,15 @@
+pub type IAdcControllerProvider = *mut ::core::ffi::c_void;
+pub type IAdcProvider = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Adc_Provider\"`*"]
+#[repr(transparent)]
+pub struct ProviderAdcChannelMode(pub i32);
+impl ProviderAdcChannelMode {
+    pub const SingleEnded: Self = Self(0i32);
+    pub const Differential: Self = Self(1i32);
+}
+impl ::core::marker::Copy for ProviderAdcChannelMode {}
+impl ::core::clone::Clone for ProviderAdcChannelMode {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/vendor/windows-sys/src/Windows/Devices/Adc/mod.rs b/vendor/windows-sys/src/Windows/Devices/Adc/mod.rs
new file mode 100644
index 000000000..1605154e1
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/Adc/mod.rs
@@ -0,0 +1,17 @@
+#[cfg(feature = "Devices_Adc_Provider")]
+pub mod Provider;
+pub type AdcChannel = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Adc\"`*"]
+#[repr(transparent)]
+pub struct AdcChannelMode(pub i32);
+impl AdcChannelMode {
+    pub const SingleEnded: Self = Self(0i32);
+    pub const Differential: Self = Self(1i32);
+}
+impl ::core::marker::Copy for AdcChannelMode {}
+impl ::core::clone::Clone for AdcChannelMode {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type AdcController = *mut ::core::ffi::c_void;
diff --git a/vendor/windows-sys/src/Windows/Devices/AllJoyn/mod.rs b/vendor/windows-sys/src/Windows/Devices/AllJoyn/mod.rs
new file mode 100644
index 000000000..787ce1a1e
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/AllJoyn/mod.rs
@@ -0,0 +1,104 @@
+pub type AllJoynAboutData = *mut ::core::ffi::c_void;
+pub type AllJoynAboutDataView = *mut ::core::ffi::c_void;
+pub type AllJoynAcceptSessionJoinerEventArgs = *mut ::core::ffi::c_void;
+pub type AllJoynAuthenticationCompleteEventArgs = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_AllJoyn\"`, `\"deprecated\"`*"]
+#[cfg(feature = "deprecated")]
+#[repr(transparent)]
+pub struct AllJoynAuthenticationMechanism(pub i32);
+#[cfg(feature = "deprecated")]
+impl AllJoynAuthenticationMechanism {
+    pub const None: Self = Self(0i32);
+    pub const SrpAnonymous: Self = Self(1i32);
+    pub const SrpLogon: Self = Self(2i32);
+    pub const EcdheNull: Self = Self(3i32);
+    pub const EcdhePsk: Self = Self(4i32);
+    pub const EcdheEcdsa: Self = Self(5i32);
+    pub const EcdheSpeke: Self = Self(6i32);
+}
+#[cfg(feature = "deprecated")]
+impl ::core::marker::Copy for AllJoynAuthenticationMechanism {}
+#[cfg(feature = "deprecated")]
+impl ::core::clone::Clone for AllJoynAuthenticationMechanism {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type AllJoynBusAttachment = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_AllJoyn\"`, `\"deprecated\"`*"]
+#[cfg(feature = "deprecated")]
+#[repr(transparent)]
+pub struct AllJoynBusAttachmentState(pub i32);
+#[cfg(feature = "deprecated")]
+impl AllJoynBusAttachmentState {
+    pub const Disconnected: Self = Self(0i32);
+    pub const Connecting: Self = Self(1i32);
+    pub const Connected: Self = Self(2i32);
+    pub const Disconnecting: Self = Self(3i32);
+}
+#[cfg(feature = "deprecated")]
+impl ::core::marker::Copy for AllJoynBusAttachmentState {}
+#[cfg(feature = "deprecated")]
+impl ::core::clone::Clone for AllJoynBusAttachmentState {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type AllJoynBusAttachmentStateChangedEventArgs = *mut ::core::ffi::c_void;
+pub type AllJoynBusObject = *mut ::core::ffi::c_void;
+pub type AllJoynBusObjectStoppedEventArgs = *mut ::core::ffi::c_void;
+pub type AllJoynCredentials = *mut ::core::ffi::c_void;
+pub type AllJoynCredentialsRequestedEventArgs = *mut ::core::ffi::c_void;
+pub type AllJoynCredentialsVerificationRequestedEventArgs = *mut ::core::ffi::c_void;
+pub type AllJoynMessageInfo = *mut ::core::ffi::c_void;
+pub type AllJoynProducerStoppedEventArgs = *mut ::core::ffi::c_void;
+pub type AllJoynServiceInfo = *mut ::core::ffi::c_void;
+pub type AllJoynServiceInfoRemovedEventArgs = *mut ::core::ffi::c_void;
+pub type AllJoynSession = *mut ::core::ffi::c_void;
+pub type AllJoynSessionJoinedEventArgs = *mut ::core::ffi::c_void;
+pub type AllJoynSessionLostEventArgs = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_AllJoyn\"`, `\"deprecated\"`*"]
+#[cfg(feature = "deprecated")]
+#[repr(transparent)]
+pub struct AllJoynSessionLostReason(pub i32);
+#[cfg(feature = "deprecated")]
+impl AllJoynSessionLostReason {
+    pub const None: Self = Self(0i32);
+    pub const ProducerLeftSession: Self = Self(1i32);
+    pub const ProducerClosedAbruptly: Self = Self(2i32);
+    pub const RemovedByProducer: Self = Self(3i32);
+    pub const LinkTimeout: Self = Self(4i32);
+    pub const Other: Self = Self(5i32);
+}
+#[cfg(feature = "deprecated")]
+impl ::core::marker::Copy for AllJoynSessionLostReason {}
+#[cfg(feature = "deprecated")]
+impl ::core::clone::Clone for AllJoynSessionLostReason {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type AllJoynSessionMemberAddedEventArgs = *mut ::core::ffi::c_void;
+pub type AllJoynSessionMemberRemovedEventArgs = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_AllJoyn\"`, `\"deprecated\"`*"]
+#[cfg(feature = "deprecated")]
+#[repr(transparent)]
+pub struct AllJoynTrafficType(pub i32);
+#[cfg(feature = "deprecated")]
+impl AllJoynTrafficType {
+    pub const Unknown: Self = Self(0i32);
+    pub const Messages: Self = Self(1i32);
+    pub const RawUnreliable: Self = Self(2i32);
+    pub const RawReliable: Self = Self(4i32);
+}
+#[cfg(feature = "deprecated")]
+impl ::core::marker::Copy for AllJoynTrafficType {}
+#[cfg(feature = "deprecated")]
+impl ::core::clone::Clone for AllJoynTrafficType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type AllJoynWatcherStoppedEventArgs = *mut ::core::ffi::c_void;
+pub type IAllJoynAcceptSessionJoiner = *mut ::core::ffi::c_void;
+pub type IAllJoynProducer = *mut ::core::ffi::c_void;
diff --git a/vendor/windows-sys/src/Windows/Devices/Background/mod.rs b/vendor/windows-sys/src/Windows/Devices/Background/mod.rs
new file mode 100644
index 000000000..28b68c6d9
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/Background/mod.rs
@@ -0,0 +1,2 @@
+pub type DeviceServicingDetails = *mut ::core::ffi::c_void;
+pub type DeviceUseDetails = *mut ::core::ffi::c_void;
diff --git a/vendor/windows-sys/src/Windows/Devices/Bluetooth/Advertisement/mod.rs b/vendor/windows-sys/src/Windows/Devices/Bluetooth/Advertisement/mod.rs
new file mode 100644
index 000000000..2ff2e0d07
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/Bluetooth/Advertisement/mod.rs
@@ -0,0 +1,91 @@
+pub type BluetoothLEAdvertisement = *mut ::core::ffi::c_void;
+pub type BluetoothLEAdvertisementBytePattern = *mut ::core::ffi::c_void;
+pub type BluetoothLEAdvertisementDataSection = *mut ::core::ffi::c_void;
+pub type BluetoothLEAdvertisementFilter = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Bluetooth_Advertisement\"`*"]
+#[repr(transparent)]
+pub struct BluetoothLEAdvertisementFlags(pub u32);
+impl BluetoothLEAdvertisementFlags {
+    pub const None: Self = Self(0u32);
+    pub const LimitedDiscoverableMode: Self = Self(1u32);
+    pub const GeneralDiscoverableMode: Self = Self(2u32);
+    pub const ClassicNotSupported: Self = Self(4u32);
+    pub const DualModeControllerCapable: Self = Self(8u32);
+    pub const DualModeHostCapable: Self = Self(16u32);
+}
+impl ::core::marker::Copy for BluetoothLEAdvertisementFlags {}
+impl ::core::clone::Clone for BluetoothLEAdvertisementFlags {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type BluetoothLEAdvertisementPublisher = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Bluetooth_Advertisement\"`*"]
+#[repr(transparent)]
+pub struct BluetoothLEAdvertisementPublisherStatus(pub i32);
+impl BluetoothLEAdvertisementPublisherStatus {
+    pub const Created: Self = Self(0i32);
+    pub const Waiting: Self = Self(1i32);
+    pub const Started: Self = Self(2i32);
+    pub const Stopping: Self = Self(3i32);
+    pub const Stopped: Self = Self(4i32);
+    pub const Aborted: Self = Self(5i32);
+}
+impl ::core::marker::Copy for BluetoothLEAdvertisementPublisherStatus {}
+impl ::core::clone::Clone for BluetoothLEAdvertisementPublisherStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type BluetoothLEAdvertisementPublisherStatusChangedEventArgs = *mut ::core::ffi::c_void;
+pub type BluetoothLEAdvertisementReceivedEventArgs = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Bluetooth_Advertisement\"`*"]
+#[repr(transparent)]
+pub struct BluetoothLEAdvertisementType(pub i32);
+impl BluetoothLEAdvertisementType {
+    pub const ConnectableUndirected: Self = Self(0i32);
+    pub const ConnectableDirected: Self = Self(1i32);
+    pub const ScannableUndirected: Self = Self(2i32);
+    pub const NonConnectableUndirected: Self = Self(3i32);
+    pub const ScanResponse: Self = Self(4i32);
+    pub const Extended: Self = Self(5i32);
+}
+impl ::core::marker::Copy for BluetoothLEAdvertisementType {}
+impl ::core::clone::Clone for BluetoothLEAdvertisementType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type BluetoothLEAdvertisementWatcher = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Bluetooth_Advertisement\"`*"]
+#[repr(transparent)]
+pub struct BluetoothLEAdvertisementWatcherStatus(pub i32);
+impl BluetoothLEAdvertisementWatcherStatus {
+    pub const Created: Self = Self(0i32);
+    pub const Started: Self = Self(1i32);
+    pub const Stopping: Self = Self(2i32);
+    pub const Stopped: Self = Self(3i32);
+    pub const Aborted: Self = Self(4i32);
+}
+impl ::core::marker::Copy for BluetoothLEAdvertisementWatcherStatus {}
+impl ::core::clone::Clone for BluetoothLEAdvertisementWatcherStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type BluetoothLEAdvertisementWatcherStoppedEventArgs = *mut ::core::ffi::c_void;
+pub type BluetoothLEManufacturerData = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Bluetooth_Advertisement\"`*"]
+#[repr(transparent)]
+pub struct BluetoothLEScanningMode(pub i32);
+impl BluetoothLEScanningMode {
+    pub const Passive: Self = Self(0i32);
+    pub const Active: Self = Self(1i32);
+    pub const None: Self = Self(2i32);
+}
+impl ::core::marker::Copy for BluetoothLEScanningMode {}
+impl ::core::clone::Clone for BluetoothLEScanningMode {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/vendor/windows-sys/src/Windows/Devices/Bluetooth/Background/mod.rs b/vendor/windows-sys/src/Windows/Devices/Bluetooth/Background/mod.rs
new file mode 100644
index 000000000..4257d3eff
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/Bluetooth/Background/mod.rs
@@ -0,0 +1,22 @@
+#[doc = "*Required features: `\"Devices_Bluetooth_Background\"`*"]
+#[repr(transparent)]
+pub struct BluetoothEventTriggeringMode(pub i32);
+impl BluetoothEventTriggeringMode {
+    pub const Serial: Self = Self(0i32);
+    pub const Batch: Self = Self(1i32);
+    pub const KeepLatest: Self = Self(2i32);
+}
+impl ::core::marker::Copy for BluetoothEventTriggeringMode {}
+impl ::core::clone::Clone for BluetoothEventTriggeringMode {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type BluetoothLEAdvertisementPublisherTriggerDetails = *mut ::core::ffi::c_void;
+pub type BluetoothLEAdvertisementWatcherTriggerDetails = *mut ::core::ffi::c_void;
+pub type GattCharacteristicNotificationTriggerDetails = *mut ::core::ffi::c_void;
+pub type GattServiceProviderConnection = *mut ::core::ffi::c_void;
+pub type GattServiceProviderTriggerDetails = *mut ::core::ffi::c_void;
+pub type RfcommConnectionTriggerDetails = *mut ::core::ffi::c_void;
+pub type RfcommInboundConnectionInformation = *mut ::core::ffi::c_void;
+pub type RfcommOutboundConnectionInformation = *mut ::core::ffi::c_void;
diff --git a/vendor/windows-sys/src/Windows/Devices/Bluetooth/GenericAttributeProfile/mod.rs b/vendor/windows-sys/src/Windows/Devices/Bluetooth/GenericAttributeProfile/mod.rs
new file mode 100644
index 000000000..3cfcb0b60
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/Bluetooth/GenericAttributeProfile/mod.rs
@@ -0,0 +1,186 @@
+pub type GattCharacteristic = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Bluetooth_GenericAttributeProfile\"`*"]
+#[repr(transparent)]
+pub struct GattCharacteristicProperties(pub u32);
+impl GattCharacteristicProperties {
+    pub const None: Self = Self(0u32);
+    pub const Broadcast: Self = Self(1u32);
+    pub const Read: Self = Self(2u32);
+    pub const WriteWithoutResponse: Self = Self(4u32);
+    pub const Write: Self = Self(8u32);
+    pub const Notify: Self = Self(16u32);
+    pub const Indicate: Self = Self(32u32);
+    pub const AuthenticatedSignedWrites: Self = Self(64u32);
+    pub const ExtendedProperties: Self = Self(128u32);
+    pub const ReliableWrites: Self = Self(256u32);
+    pub const WritableAuxiliaries: Self = Self(512u32);
+}
+impl ::core::marker::Copy for GattCharacteristicProperties {}
+impl ::core::clone::Clone for GattCharacteristicProperties {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type GattCharacteristicsResult = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Bluetooth_GenericAttributeProfile\"`*"]
+#[repr(transparent)]
+pub struct GattClientCharacteristicConfigurationDescriptorValue(pub i32);
+impl GattClientCharacteristicConfigurationDescriptorValue {
+    pub const None: Self = Self(0i32);
+    pub const Notify: Self = Self(1i32);
+    pub const Indicate: Self = Self(2i32);
+}
+impl ::core::marker::Copy for GattClientCharacteristicConfigurationDescriptorValue {}
+impl ::core::clone::Clone for GattClientCharacteristicConfigurationDescriptorValue {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type GattClientNotificationResult = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Bluetooth_GenericAttributeProfile\"`*"]
+#[repr(transparent)]
+pub struct GattCommunicationStatus(pub i32);
+impl GattCommunicationStatus {
+    pub const Success: Self = Self(0i32);
+    pub const Unreachable: Self = Self(1i32);
+    pub const ProtocolError: Self = Self(2i32);
+    pub const AccessDenied: Self = Self(3i32);
+}
+impl ::core::marker::Copy for GattCommunicationStatus {}
+impl ::core::clone::Clone for GattCommunicationStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type GattDescriptor = *mut ::core::ffi::c_void;
+pub type GattDescriptorsResult = *mut ::core::ffi::c_void;
+pub type GattDeviceService = *mut ::core::ffi::c_void;
+pub type GattDeviceServicesResult = *mut ::core::ffi::c_void;
+pub type GattLocalCharacteristic = *mut ::core::ffi::c_void;
+pub type GattLocalCharacteristicParameters = *mut ::core::ffi::c_void;
+pub type GattLocalCharacteristicResult = *mut ::core::ffi::c_void;
+pub type GattLocalDescriptor = *mut ::core::ffi::c_void;
+pub type GattLocalDescriptorParameters = *mut ::core::ffi::c_void;
+pub type GattLocalDescriptorResult = *mut ::core::ffi::c_void;
+pub type GattLocalService = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Bluetooth_GenericAttributeProfile\"`*"]
+#[repr(transparent)]
+pub struct GattOpenStatus(pub i32);
+impl GattOpenStatus {
+    pub const Unspecified: Self = Self(0i32);
+    pub const Success: Self = Self(1i32);
+    pub const AlreadyOpened: Self = Self(2i32);
+    pub const NotFound: Self = Self(3i32);
+    pub const SharingViolation: Self = Self(4i32);
+    pub const AccessDenied: Self = Self(5i32);
+}
+impl ::core::marker::Copy for GattOpenStatus {}
+impl ::core::clone::Clone for GattOpenStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type GattPresentationFormat = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Bluetooth_GenericAttributeProfile\"`*"]
+#[repr(transparent)]
+pub struct GattProtectionLevel(pub i32);
+impl GattProtectionLevel {
+    pub const Plain: Self = Self(0i32);
+    pub const AuthenticationRequired: Self = Self(1i32);
+    pub const EncryptionRequired: Self = Self(2i32);
+    pub const EncryptionAndAuthenticationRequired: Self = Self(3i32);
+}
+impl ::core::marker::Copy for GattProtectionLevel {}
+impl ::core::clone::Clone for GattProtectionLevel {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type GattReadClientCharacteristicConfigurationDescriptorResult = *mut ::core::ffi::c_void;
+pub type GattReadRequest = *mut ::core::ffi::c_void;
+pub type GattReadRequestedEventArgs = *mut ::core::ffi::c_void;
+pub type GattReadResult = *mut ::core::ffi::c_void;
+pub type GattReliableWriteTransaction = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Bluetooth_GenericAttributeProfile\"`*"]
+#[repr(transparent)]
+pub struct GattRequestState(pub i32);
+impl GattRequestState {
+    pub const Pending: Self = Self(0i32);
+    pub const Completed: Self = Self(1i32);
+    pub const Canceled: Self = Self(2i32);
+}
+impl ::core::marker::Copy for GattRequestState {}
+impl ::core::clone::Clone for GattRequestState {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type GattRequestStateChangedEventArgs = *mut ::core::ffi::c_void;
+pub type GattServiceProvider = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Bluetooth_GenericAttributeProfile\"`*"]
+#[repr(transparent)]
+pub struct GattServiceProviderAdvertisementStatus(pub i32);
+impl GattServiceProviderAdvertisementStatus {
+    pub const Created: Self = Self(0i32);
+    pub const Stopped: Self = Self(1i32);
+    pub const Started: Self = Self(2i32);
+    pub const Aborted: Self = Self(3i32);
+    pub const StartedWithoutAllAdvertisementData: Self = Self(4i32);
+}
+impl ::core::marker::Copy for GattServiceProviderAdvertisementStatus {}
+impl ::core::clone::Clone for GattServiceProviderAdvertisementStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type GattServiceProviderAdvertisementStatusChangedEventArgs = *mut ::core::ffi::c_void;
+pub type GattServiceProviderAdvertisingParameters = *mut ::core::ffi::c_void;
+pub type GattServiceProviderResult = *mut ::core::ffi::c_void;
+pub type GattSession = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Bluetooth_GenericAttributeProfile\"`*"]
+#[repr(transparent)]
+pub struct GattSessionStatus(pub i32);
+impl GattSessionStatus {
+    pub const Closed: Self = Self(0i32);
+    pub const Active: Self = Self(1i32);
+}
+impl ::core::marker::Copy for GattSessionStatus {}
+impl ::core::clone::Clone for GattSessionStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type GattSessionStatusChangedEventArgs = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Bluetooth_GenericAttributeProfile\"`*"]
+#[repr(transparent)]
+pub struct GattSharingMode(pub i32);
+impl GattSharingMode {
+    pub const Unspecified: Self = Self(0i32);
+    pub const Exclusive: Self = Self(1i32);
+    pub const SharedReadOnly: Self = Self(2i32);
+    pub const SharedReadAndWrite: Self = Self(3i32);
+}
+impl ::core::marker::Copy for GattSharingMode {}
+impl ::core::clone::Clone for GattSharingMode {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type GattSubscribedClient = *mut ::core::ffi::c_void;
+pub type GattValueChangedEventArgs = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Bluetooth_GenericAttributeProfile\"`*"]
+#[repr(transparent)]
+pub struct GattWriteOption(pub i32);
+impl GattWriteOption {
+    pub const WriteWithResponse: Self = Self(0i32);
+    pub const WriteWithoutResponse: Self = Self(1i32);
+}
+impl ::core::marker::Copy for GattWriteOption {}
+impl ::core::clone::Clone for GattWriteOption {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type GattWriteRequest = *mut ::core::ffi::c_void;
+pub type GattWriteRequestedEventArgs = *mut ::core::ffi::c_void;
+pub type GattWriteResult = *mut ::core::ffi::c_void;
diff --git a/vendor/windows-sys/src/Windows/Devices/Bluetooth/Rfcomm/mod.rs b/vendor/windows-sys/src/Windows/Devices/Bluetooth/Rfcomm/mod.rs
new file mode 100644
index 000000000..4c560533c
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/Bluetooth/Rfcomm/mod.rs
@@ -0,0 +1,4 @@
+pub type RfcommDeviceService = *mut ::core::ffi::c_void;
+pub type RfcommDeviceServicesResult = *mut ::core::ffi::c_void;
+pub type RfcommServiceId = *mut ::core::ffi::c_void;
+pub type RfcommServiceProvider = *mut ::core::ffi::c_void;
diff --git a/vendor/windows-sys/src/Windows/Devices/Bluetooth/mod.rs b/vendor/windows-sys/src/Windows/Devices/Bluetooth/mod.rs
new file mode 100644
index 000000000..3b438045a
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/Bluetooth/mod.rs
@@ -0,0 +1,220 @@
+#[cfg(feature = "Devices_Bluetooth_Advertisement")]
+pub mod Advertisement;
+#[cfg(feature = "Devices_Bluetooth_Background")]
+pub mod Background;
+#[cfg(feature = "Devices_Bluetooth_GenericAttributeProfile")]
+pub mod GenericAttributeProfile;
+#[cfg(feature = "Devices_Bluetooth_Rfcomm")]
+pub mod Rfcomm;
+pub type BluetoothAdapter = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Bluetooth\"`*"]
+#[repr(transparent)]
+pub struct BluetoothAddressType(pub i32);
+impl BluetoothAddressType {
+    pub const Public: Self = Self(0i32);
+    pub const Random: Self = Self(1i32);
+    pub const Unspecified: Self = Self(2i32);
+}
+impl ::core::marker::Copy for BluetoothAddressType {}
+impl ::core::clone::Clone for BluetoothAddressType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Bluetooth\"`*"]
+#[repr(transparent)]
+pub struct BluetoothCacheMode(pub i32);
+impl BluetoothCacheMode {
+    pub const Cached: Self = Self(0i32);
+    pub const Uncached: Self = Self(1i32);
+}
+impl ::core::marker::Copy for BluetoothCacheMode {}
+impl ::core::clone::Clone for BluetoothCacheMode {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type BluetoothClassOfDevice = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Bluetooth\"`*"]
+#[repr(transparent)]
+pub struct BluetoothConnectionStatus(pub i32);
+impl BluetoothConnectionStatus {
+    pub const Disconnected: Self = Self(0i32);
+    pub const Connected: Self = Self(1i32);
+}
+impl ::core::marker::Copy for BluetoothConnectionStatus {}
+impl ::core::clone::Clone for BluetoothConnectionStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type BluetoothDevice = *mut ::core::ffi::c_void;
+pub type BluetoothDeviceId = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Bluetooth\"`*"]
+#[repr(transparent)]
+pub struct BluetoothError(pub i32);
+impl BluetoothError {
+    pub const Success: Self = Self(0i32);
+    pub const RadioNotAvailable: Self = Self(1i32);
+    pub const ResourceInUse: Self = Self(2i32);
+    pub const DeviceNotConnected: Self = Self(3i32);
+    pub const OtherError: Self = Self(4i32);
+    pub const DisabledByPolicy: Self = Self(5i32);
+    pub const NotSupported: Self = Self(6i32);
+    pub const DisabledByUser: Self = Self(7i32);
+    pub const ConsentRequired: Self = Self(8i32);
+    pub const TransportNotSupported: Self = Self(9i32);
+}
+impl ::core::marker::Copy for BluetoothError {}
+impl ::core::clone::Clone for BluetoothError {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type BluetoothLEAppearance = *mut ::core::ffi::c_void;
+pub type BluetoothLEConnectionParameters = *mut ::core::ffi::c_void;
+pub type BluetoothLEConnectionPhy = *mut ::core::ffi::c_void;
+pub type BluetoothLEConnectionPhyInfo = *mut ::core::ffi::c_void;
+pub type BluetoothLEDevice = *mut ::core::ffi::c_void;
+pub type BluetoothLEPreferredConnectionParameters = *mut ::core::ffi::c_void;
+pub type BluetoothLEPreferredConnectionParametersRequest = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Bluetooth\"`*"]
+#[repr(transparent)]
+pub struct BluetoothLEPreferredConnectionParametersRequestStatus(pub i32);
+impl BluetoothLEPreferredConnectionParametersRequestStatus {
+    pub const Unspecified: Self = Self(0i32);
+    pub const Success: Self = Self(1i32);
+    pub const DeviceNotAvailable: Self = Self(2i32);
+    pub const AccessDenied: Self = Self(3i32);
+}
+impl ::core::marker::Copy for BluetoothLEPreferredConnectionParametersRequestStatus {}
+impl ::core::clone::Clone for BluetoothLEPreferredConnectionParametersRequestStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Bluetooth\"`*"]
+#[repr(transparent)]
+pub struct BluetoothMajorClass(pub i32);
+impl BluetoothMajorClass {
+    pub const Miscellaneous: Self = Self(0i32);
+    pub const Computer: Self = Self(1i32);
+    pub const Phone: Self = Self(2i32);
+    pub const NetworkAccessPoint: Self = Self(3i32);
+    pub const AudioVideo: Self = Self(4i32);
+    pub const Peripheral: Self = Self(5i32);
+    pub const Imaging: Self = Self(6i32);
+    pub const Wearable: Self = Self(7i32);
+    pub const Toy: Self = Self(8i32);
+    pub const Health: Self = Self(9i32);
+}
+impl ::core::marker::Copy for BluetoothMajorClass {}
+impl ::core::clone::Clone for BluetoothMajorClass {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Bluetooth\"`*"]
+#[repr(transparent)]
+pub struct BluetoothMinorClass(pub i32);
+impl BluetoothMinorClass {
+    pub const Uncategorized: Self = Self(0i32);
+    pub const ComputerDesktop: Self = Self(1i32);
+    pub const ComputerServer: Self = Self(2i32);
+    pub const ComputerLaptop: Self = Self(3i32);
+    pub const ComputerHandheld: Self = Self(4i32);
+    pub const ComputerPalmSize: Self = Self(5i32);
+    pub const ComputerWearable: Self = Self(6i32);
+    pub const ComputerTablet: Self = Self(7i32);
+    pub const PhoneCellular: Self = Self(1i32);
+    pub const PhoneCordless: Self = Self(2i32);
+    pub const PhoneSmartPhone: Self = Self(3i32);
+    pub const PhoneWired: Self = Self(4i32);
+    pub const PhoneIsdn: Self = Self(5i32);
+    pub const NetworkFullyAvailable: Self = Self(0i32);
+    pub const NetworkUsed01To17Percent: Self = Self(8i32);
+    pub const NetworkUsed17To33Percent: Self = Self(16i32);
+    pub const NetworkUsed33To50Percent: Self = Self(24i32);
+    pub const NetworkUsed50To67Percent: Self = Self(32i32);
+    pub const NetworkUsed67To83Percent: Self = Self(40i32);
+    pub const NetworkUsed83To99Percent: Self = Self(48i32);
+    pub const NetworkNoServiceAvailable: Self = Self(56i32);
+    pub const AudioVideoWearableHeadset: Self = Self(1i32);
+    pub const AudioVideoHandsFree: Self = Self(2i32);
+    pub const AudioVideoMicrophone: Self = Self(4i32);
+    pub const AudioVideoLoudspeaker: Self = Self(5i32);
+    pub const AudioVideoHeadphones: Self = Self(6i32);
+    pub const AudioVideoPortableAudio: Self = Self(7i32);
+    pub const AudioVideoCarAudio: Self = Self(8i32);
+    pub const AudioVideoSetTopBox: Self = Self(9i32);
+    pub const AudioVideoHifiAudioDevice: Self = Self(10i32);
+    pub const AudioVideoVcr: Self = Self(11i32);
+    pub const AudioVideoVideoCamera: Self = Self(12i32);
+    pub const AudioVideoCamcorder: Self = Self(13i32);
+    pub const AudioVideoVideoMonitor: Self = Self(14i32);
+    pub const AudioVideoVideoDisplayAndLoudspeaker: Self = Self(15i32);
+    pub const AudioVideoVideoConferencing: Self = Self(16i32);
+    pub const AudioVideoGamingOrToy: Self = Self(18i32);
+    pub const PeripheralJoystick: Self = Self(1i32);
+    pub const PeripheralGamepad: Self = Self(2i32);
+    pub const PeripheralRemoteControl: Self = Self(3i32);
+    pub const PeripheralSensing: Self = Self(4i32);
+    pub const PeripheralDigitizerTablet: Self = Self(5i32);
+    pub const PeripheralCardReader: Self = Self(6i32);
+    pub const PeripheralDigitalPen: Self = Self(7i32);
+    pub const PeripheralHandheldScanner: Self = Self(8i32);
+    pub const PeripheralHandheldGesture: Self = Self(9i32);
+    pub const WearableWristwatch: Self = Self(1i32);
+    pub const WearablePager: Self = Self(2i32);
+    pub const WearableJacket: Self = Self(3i32);
+    pub const WearableHelmet: Self = Self(4i32);
+    pub const WearableGlasses: Self = Self(5i32);
+    pub const ToyRobot: Self = Self(1i32);
+    pub const ToyVehicle: Self = Self(2i32);
+    pub const ToyDoll: Self = Self(3i32);
+    pub const ToyController: Self = Self(4i32);
+    pub const ToyGame: Self = Self(5i32);
+    pub const HealthBloodPressureMonitor: Self = Self(1i32);
+    pub const HealthThermometer: Self = Self(2i32);
+    pub const HealthWeighingScale: Self = Self(3i32);
+    pub const HealthGlucoseMeter: Self = Self(4i32);
+    pub const HealthPulseOximeter: Self = Self(5i32);
+    pub const HealthHeartRateMonitor: Self = Self(6i32);
+    pub const HealthHealthDataDisplay: Self = Self(7i32);
+    pub const HealthStepCounter: Self = Self(8i32);
+    pub const HealthBodyCompositionAnalyzer: Self = Self(9i32);
+    pub const HealthPeakFlowMonitor: Self = Self(10i32);
+    pub const HealthMedicationMonitor: Self = Self(11i32);
+    pub const HealthKneeProsthesis: Self = Self(12i32);
+    pub const HealthAnkleProsthesis: Self = Self(13i32);
+    pub const HealthGenericHealthManager: Self = Self(14i32);
+    pub const HealthPersonalMobilityDevice: Self = Self(15i32);
+}
+impl ::core::marker::Copy for BluetoothMinorClass {}
+impl ::core::clone::Clone for BluetoothMinorClass {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Bluetooth\"`*"]
+#[repr(transparent)]
+pub struct BluetoothServiceCapabilities(pub u32);
+impl BluetoothServiceCapabilities {
+    pub const None: Self = Self(0u32);
+    pub const LimitedDiscoverableMode: Self = Self(1u32);
+    pub const PositioningService: Self = Self(8u32);
+    pub const NetworkingService: Self = Self(16u32);
+    pub const RenderingService: Self = Self(32u32);
+    pub const CapturingService: Self = Self(64u32);
+    pub const ObjectTransferService: Self = Self(128u32);
+    pub const AudioService: Self = Self(256u32);
+    pub const TelephoneService: Self = Self(512u32);
+    pub const InformationService: Self = Self(1024u32);
+}
+impl ::core::marker::Copy for BluetoothServiceCapabilities {}
+impl ::core::clone::Clone for BluetoothServiceCapabilities {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type BluetoothSignalStrengthFilter = *mut ::core::ffi::c_void;
diff --git a/vendor/windows-sys/src/Windows/Devices/Custom/mod.rs b/vendor/windows-sys/src/Windows/Devices/Custom/mod.rs
new file mode 100644
index 000000000..396ae4905
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/Custom/mod.rs
@@ -0,0 +1,60 @@
+pub type CustomDevice = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Custom\"`*"]
+#[repr(transparent)]
+pub struct DeviceAccessMode(pub i32);
+impl DeviceAccessMode {
+    pub const Read: Self = Self(0i32);
+    pub const Write: Self = Self(1i32);
+    pub const ReadWrite: Self = Self(2i32);
+}
+impl ::core::marker::Copy for DeviceAccessMode {}
+impl ::core::clone::Clone for DeviceAccessMode {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Custom\"`*"]
+#[repr(transparent)]
+pub struct DeviceSharingMode(pub i32);
+impl DeviceSharingMode {
+    pub const Shared: Self = Self(0i32);
+    pub const Exclusive: Self = Self(1i32);
+}
+impl ::core::marker::Copy for DeviceSharingMode {}
+impl ::core::clone::Clone for DeviceSharingMode {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type IIOControlCode = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Custom\"`*"]
+#[repr(transparent)]
+pub struct IOControlAccessMode(pub i32);
+impl IOControlAccessMode {
+    pub const Any: Self = Self(0i32);
+    pub const Read: Self = Self(1i32);
+    pub const Write: Self = Self(2i32);
+    pub const ReadWrite: Self = Self(3i32);
+}
+impl ::core::marker::Copy for IOControlAccessMode {}
+impl ::core::clone::Clone for IOControlAccessMode {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Custom\"`*"]
+#[repr(transparent)]
+pub struct IOControlBufferingMethod(pub i32);
+impl IOControlBufferingMethod {
+    pub const Buffered: Self = Self(0i32);
+    pub const DirectInput: Self = Self(1i32);
+    pub const DirectOutput: Self = Self(2i32);
+    pub const Neither: Self = Self(3i32);
+}
+impl ::core::marker::Copy for IOControlBufferingMethod {}
+impl ::core::clone::Clone for IOControlBufferingMethod {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type IOControlCode = *mut ::core::ffi::c_void;
diff --git a/vendor/windows-sys/src/Windows/Devices/Display/Core/mod.rs b/vendor/windows-sys/src/Windows/Devices/Display/Core/mod.rs
new file mode 100644
index 000000000..e06d92364
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/Display/Core/mod.rs
@@ -0,0 +1,340 @@
+pub type DisplayAdapter = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Display_Core\"`*"]
+#[repr(transparent)]
+pub struct DisplayBitsPerChannel(pub u32);
+impl DisplayBitsPerChannel {
+    pub const None: Self = Self(0u32);
+    pub const Bpc6: Self = Self(1u32);
+    pub const Bpc8: Self = Self(2u32);
+    pub const Bpc10: Self = Self(4u32);
+    pub const Bpc12: Self = Self(8u32);
+    pub const Bpc14: Self = Self(16u32);
+    pub const Bpc16: Self = Self(32u32);
+}
+impl ::core::marker::Copy for DisplayBitsPerChannel {}
+impl ::core::clone::Clone for DisplayBitsPerChannel {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type DisplayDevice = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Display_Core\"`*"]
+#[repr(transparent)]
+pub struct DisplayDeviceCapability(pub i32);
+impl DisplayDeviceCapability {
+    pub const FlipOverride: Self = Self(0i32);
+}
+impl ::core::marker::Copy for DisplayDeviceCapability {}
+impl ::core::clone::Clone for DisplayDeviceCapability {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type DisplayFence = *mut ::core::ffi::c_void;
+pub type DisplayManager = *mut ::core::ffi::c_void;
+pub type DisplayManagerChangedEventArgs = *mut ::core::ffi::c_void;
+pub type DisplayManagerDisabledEventArgs = *mut ::core::ffi::c_void;
+pub type DisplayManagerEnabledEventArgs = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Display_Core\"`*"]
+#[repr(transparent)]
+pub struct DisplayManagerOptions(pub u32);
+impl DisplayManagerOptions {
+    pub const None: Self = Self(0u32);
+    pub const EnforceSourceOwnership: Self = Self(1u32);
+    pub const VirtualRefreshRateAware: Self = Self(2u32);
+}
+impl ::core::marker::Copy for DisplayManagerOptions {}
+impl ::core::clone::Clone for DisplayManagerOptions {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type DisplayManagerPathsFailedOrInvalidatedEventArgs = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Display_Core\"`*"]
+#[repr(transparent)]
+pub struct DisplayManagerResult(pub i32);
+impl DisplayManagerResult {
+    pub const Success: Self = Self(0i32);
+    pub const UnknownFailure: Self = Self(1i32);
+    pub const TargetAccessDenied: Self = Self(2i32);
+    pub const TargetStale: Self = Self(3i32);
+    pub const RemoteSessionNotSupported: Self = Self(4i32);
+}
+impl ::core::marker::Copy for DisplayManagerResult {}
+impl ::core::clone::Clone for DisplayManagerResult {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type DisplayManagerResultWithState = *mut ::core::ffi::c_void;
+pub type DisplayModeInfo = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Display_Core\"`*"]
+#[repr(transparent)]
+pub struct DisplayModeQueryOptions(pub u32);
+impl DisplayModeQueryOptions {
+    pub const None: Self = Self(0u32);
+    pub const OnlyPreferredResolution: Self = Self(1u32);
+}
+impl ::core::marker::Copy for DisplayModeQueryOptions {}
+impl ::core::clone::Clone for DisplayModeQueryOptions {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type DisplayPath = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Display_Core\"`*"]
+#[repr(transparent)]
+pub struct DisplayPathScaling(pub i32);
+impl DisplayPathScaling {
+    pub const Identity: Self = Self(0i32);
+    pub const Centered: Self = Self(1i32);
+    pub const Stretched: Self = Self(2i32);
+    pub const AspectRatioStretched: Self = Self(3i32);
+    pub const Custom: Self = Self(4i32);
+    pub const DriverPreferred: Self = Self(5i32);
+}
+impl ::core::marker::Copy for DisplayPathScaling {}
+impl ::core::clone::Clone for DisplayPathScaling {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Display_Core\"`*"]
+#[repr(transparent)]
+pub struct DisplayPathStatus(pub i32);
+impl DisplayPathStatus {
+    pub const Unknown: Self = Self(0i32);
+    pub const Succeeded: Self = Self(1i32);
+    pub const Pending: Self = Self(2i32);
+    pub const Failed: Self = Self(3i32);
+    pub const FailedAsync: Self = Self(4i32);
+    pub const InvalidatedAsync: Self = Self(5i32);
+}
+impl ::core::marker::Copy for DisplayPathStatus {}
+impl ::core::clone::Clone for DisplayPathStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Display_Core\"`*"]
+#[repr(transparent)]
+pub struct DisplayPresentStatus(pub i32);
+impl DisplayPresentStatus {
+    pub const Success: Self = Self(0i32);
+    pub const SourceStatusPreventedPresent: Self = Self(1i32);
+    pub const ScanoutInvalid: Self = Self(2i32);
+    pub const SourceInvalid: Self = Self(3i32);
+    pub const DeviceInvalid: Self = Self(4i32);
+    pub const UnknownFailure: Self = Self(5i32);
+}
+impl ::core::marker::Copy for DisplayPresentStatus {}
+impl ::core::clone::Clone for DisplayPresentStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(C)]
+#[doc = "*Required features: `\"Devices_Display_Core\"`, `\"Foundation_Numerics\"`*"]
+#[cfg(feature = "Foundation_Numerics")]
+pub struct DisplayPresentationRate {
+    pub VerticalSyncRate: super::super::super::Foundation::Numerics::Rational,
+    pub VerticalSyncsPerPresentation: i32,
+}
+#[cfg(feature = "Foundation_Numerics")]
+impl ::core::marker::Copy for DisplayPresentationRate {}
+#[cfg(feature = "Foundation_Numerics")]
+impl ::core::clone::Clone for DisplayPresentationRate {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type DisplayPrimaryDescription = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Display_Core\"`*"]
+#[repr(transparent)]
+pub struct DisplayRotation(pub i32);
+impl DisplayRotation {
+    pub const None: Self = Self(0i32);
+    pub const Clockwise90Degrees: Self = Self(1i32);
+    pub const Clockwise180Degrees: Self = Self(2i32);
+    pub const Clockwise270Degrees: Self = Self(3i32);
+}
+impl ::core::marker::Copy for DisplayRotation {}
+impl ::core::clone::Clone for DisplayRotation {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type DisplayScanout = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Display_Core\"`*"]
+#[repr(transparent)]
+pub struct DisplayScanoutOptions(pub u32);
+impl DisplayScanoutOptions {
+    pub const None: Self = Self(0u32);
+    pub const AllowTearing: Self = Self(2u32);
+}
+impl ::core::marker::Copy for DisplayScanoutOptions {}
+impl ::core::clone::Clone for DisplayScanoutOptions {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type DisplaySource = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Display_Core\"`*"]
+#[repr(transparent)]
+pub struct DisplaySourceStatus(pub i32);
+impl DisplaySourceStatus {
+    pub const Active: Self = Self(0i32);
+    pub const PoweredOff: Self = Self(1i32);
+    pub const Invalid: Self = Self(2i32);
+    pub const OwnedByAnotherDevice: Self = Self(3i32);
+    pub const Unowned: Self = Self(4i32);
+}
+impl ::core::marker::Copy for DisplaySourceStatus {}
+impl ::core::clone::Clone for DisplaySourceStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type DisplayState = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Display_Core\"`*"]
+#[repr(transparent)]
+pub struct DisplayStateApplyOptions(pub u32);
+impl DisplayStateApplyOptions {
+    pub const None: Self = Self(0u32);
+    pub const FailIfStateChanged: Self = Self(1u32);
+    pub const ForceReapply: Self = Self(2u32);
+    pub const ForceModeEnumeration: Self = Self(4u32);
+}
+impl ::core::marker::Copy for DisplayStateApplyOptions {}
+impl ::core::clone::Clone for DisplayStateApplyOptions {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Display_Core\"`*"]
+#[repr(transparent)]
+pub struct DisplayStateFunctionalizeOptions(pub u32);
+impl DisplayStateFunctionalizeOptions {
+    pub const None: Self = Self(0u32);
+    pub const FailIfStateChanged: Self = Self(1u32);
+    pub const ValidateTopologyOnly: Self = Self(2u32);
+}
+impl ::core::marker::Copy for DisplayStateFunctionalizeOptions {}
+impl ::core::clone::Clone for DisplayStateFunctionalizeOptions {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type DisplayStateOperationResult = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Display_Core\"`*"]
+#[repr(transparent)]
+pub struct DisplayStateOperationStatus(pub i32);
+impl DisplayStateOperationStatus {
+    pub const Success: Self = Self(0i32);
+    pub const PartialFailure: Self = Self(1i32);
+    pub const UnknownFailure: Self = Self(2i32);
+    pub const TargetOwnershipLost: Self = Self(3i32);
+    pub const SystemStateChanged: Self = Self(4i32);
+    pub const TooManyPathsForAdapter: Self = Self(5i32);
+    pub const ModesNotSupported: Self = Self(6i32);
+    pub const RemoteSessionNotSupported: Self = Self(7i32);
+}
+impl ::core::marker::Copy for DisplayStateOperationStatus {}
+impl ::core::clone::Clone for DisplayStateOperationStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type DisplaySurface = *mut ::core::ffi::c_void;
+pub type DisplayTarget = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Display_Core\"`*"]
+#[repr(transparent)]
+pub struct DisplayTargetPersistence(pub i32);
+impl DisplayTargetPersistence {
+    pub const None: Self = Self(0i32);
+    pub const BootPersisted: Self = Self(1i32);
+    pub const TemporaryPersisted: Self = Self(2i32);
+    pub const PathPersisted: Self = Self(3i32);
+}
+impl ::core::marker::Copy for DisplayTargetPersistence {}
+impl ::core::clone::Clone for DisplayTargetPersistence {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type DisplayTask = *mut ::core::ffi::c_void;
+pub type DisplayTaskPool = *mut ::core::ffi::c_void;
+pub type DisplayTaskResult = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Display_Core\"`*"]
+#[repr(transparent)]
+pub struct DisplayTaskSignalKind(pub i32);
+impl DisplayTaskSignalKind {
+    pub const OnPresentFlipAway: Self = Self(0i32);
+    pub const OnPresentFlipTo: Self = Self(1i32);
+}
+impl ::core::marker::Copy for DisplayTaskSignalKind {}
+impl ::core::clone::Clone for DisplayTaskSignalKind {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type DisplayView = *mut ::core::ffi::c_void;
+pub type DisplayWireFormat = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Display_Core\"`*"]
+#[repr(transparent)]
+pub struct DisplayWireFormatColorSpace(pub i32);
+impl DisplayWireFormatColorSpace {
+    pub const BT709: Self = Self(0i32);
+    pub const BT2020: Self = Self(1i32);
+    pub const ProfileDefinedWideColorGamut: Self = Self(2i32);
+}
+impl ::core::marker::Copy for DisplayWireFormatColorSpace {}
+impl ::core::clone::Clone for DisplayWireFormatColorSpace {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Display_Core\"`*"]
+#[repr(transparent)]
+pub struct DisplayWireFormatEotf(pub i32);
+impl DisplayWireFormatEotf {
+    pub const Sdr: Self = Self(0i32);
+    pub const HdrSmpte2084: Self = Self(1i32);
+}
+impl ::core::marker::Copy for DisplayWireFormatEotf {}
+impl ::core::clone::Clone for DisplayWireFormatEotf {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Display_Core\"`*"]
+#[repr(transparent)]
+pub struct DisplayWireFormatHdrMetadata(pub i32);
+impl DisplayWireFormatHdrMetadata {
+    pub const None: Self = Self(0i32);
+    pub const Hdr10: Self = Self(1i32);
+    pub const Hdr10Plus: Self = Self(2i32);
+    pub const DolbyVisionLowLatency: Self = Self(3i32);
+}
+impl ::core::marker::Copy for DisplayWireFormatHdrMetadata {}
+impl ::core::clone::Clone for DisplayWireFormatHdrMetadata {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Display_Core\"`*"]
+#[repr(transparent)]
+pub struct DisplayWireFormatPixelEncoding(pub i32);
+impl DisplayWireFormatPixelEncoding {
+    pub const Rgb444: Self = Self(0i32);
+    pub const Ycc444: Self = Self(1i32);
+    pub const Ycc422: Self = Self(2i32);
+    pub const Ycc420: Self = Self(3i32);
+    pub const Intensity: Self = Self(4i32);
+}
+impl ::core::marker::Copy for DisplayWireFormatPixelEncoding {}
+impl ::core::clone::Clone for DisplayWireFormatPixelEncoding {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/vendor/windows-sys/src/Windows/Devices/Display/mod.rs b/vendor/windows-sys/src/Windows/Devices/Display/mod.rs
new file mode 100644
index 000000000..dddd5fbe8
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/Display/mod.rs
@@ -0,0 +1,64 @@
+#[cfg(feature = "Devices_Display_Core")]
+pub mod Core;
+pub type DisplayMonitor = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Display\"`*"]
+#[repr(transparent)]
+pub struct DisplayMonitorConnectionKind(pub i32);
+impl DisplayMonitorConnectionKind {
+    pub const Internal: Self = Self(0i32);
+    pub const Wired: Self = Self(1i32);
+    pub const Wireless: Self = Self(2i32);
+    pub const Virtual: Self = Self(3i32);
+}
+impl ::core::marker::Copy for DisplayMonitorConnectionKind {}
+impl ::core::clone::Clone for DisplayMonitorConnectionKind {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Display\"`*"]
+#[repr(transparent)]
+pub struct DisplayMonitorDescriptorKind(pub i32);
+impl DisplayMonitorDescriptorKind {
+    pub const Edid: Self = Self(0i32);
+    pub const DisplayId: Self = Self(1i32);
+}
+impl ::core::marker::Copy for DisplayMonitorDescriptorKind {}
+impl ::core::clone::Clone for DisplayMonitorDescriptorKind {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Display\"`*"]
+#[repr(transparent)]
+pub struct DisplayMonitorPhysicalConnectorKind(pub i32);
+impl DisplayMonitorPhysicalConnectorKind {
+    pub const Unknown: Self = Self(0i32);
+    pub const HD15: Self = Self(1i32);
+    pub const AnalogTV: Self = Self(2i32);
+    pub const Dvi: Self = Self(3i32);
+    pub const Hdmi: Self = Self(4i32);
+    pub const Lvds: Self = Self(5i32);
+    pub const Sdi: Self = Self(6i32);
+    pub const DisplayPort: Self = Self(7i32);
+}
+impl ::core::marker::Copy for DisplayMonitorPhysicalConnectorKind {}
+impl ::core::clone::Clone for DisplayMonitorPhysicalConnectorKind {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Display\"`*"]
+#[repr(transparent)]
+pub struct DisplayMonitorUsageKind(pub i32);
+impl DisplayMonitorUsageKind {
+    pub const Standard: Self = Self(0i32);
+    pub const HeadMounted: Self = Self(1i32);
+    pub const SpecialPurpose: Self = Self(2i32);
+}
+impl ::core::marker::Copy for DisplayMonitorUsageKind {}
+impl ::core::clone::Clone for DisplayMonitorUsageKind {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/vendor/windows-sys/src/Windows/Devices/Enumeration/Pnp/mod.rs b/vendor/windows-sys/src/Windows/Devices/Enumeration/Pnp/mod.rs
new file mode 100644
index 000000000..fb3930e47
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/Enumeration/Pnp/mod.rs
@@ -0,0 +1,24 @@
+pub type PnpObject = *mut ::core::ffi::c_void;
+pub type PnpObjectCollection = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Enumeration_Pnp\"`*"]
+#[repr(transparent)]
+pub struct PnpObjectType(pub i32);
+impl PnpObjectType {
+    pub const Unknown: Self = Self(0i32);
+    pub const DeviceInterface: Self = Self(1i32);
+    pub const DeviceContainer: Self = Self(2i32);
+    pub const Device: Self = Self(3i32);
+    pub const DeviceInterfaceClass: Self = Self(4i32);
+    pub const AssociationEndpoint: Self = Self(5i32);
+    pub const AssociationEndpointContainer: Self = Self(6i32);
+    pub const AssociationEndpointService: Self = Self(7i32);
+    pub const DevicePanel: Self = Self(8i32);
+}
+impl ::core::marker::Copy for PnpObjectType {}
+impl ::core::clone::Clone for PnpObjectType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type PnpObjectUpdate = *mut ::core::ffi::c_void;
+pub type PnpObjectWatcher = *mut ::core::ffi::c_void;
diff --git a/vendor/windows-sys/src/Windows/Devices/Enumeration/mod.rs b/vendor/windows-sys/src/Windows/Devices/Enumeration/mod.rs
new file mode 100644
index 000000000..fb33aa418
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/Enumeration/mod.rs
@@ -0,0 +1,220 @@
+#[cfg(feature = "Devices_Enumeration_Pnp")]
+pub mod Pnp;
+pub type DeviceAccessChangedEventArgs = *mut ::core::ffi::c_void;
+pub type DeviceAccessInformation = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Enumeration\"`*"]
+#[repr(transparent)]
+pub struct DeviceAccessStatus(pub i32);
+impl DeviceAccessStatus {
+    pub const Unspecified: Self = Self(0i32);
+    pub const Allowed: Self = Self(1i32);
+    pub const DeniedByUser: Self = Self(2i32);
+    pub const DeniedBySystem: Self = Self(3i32);
+}
+impl ::core::marker::Copy for DeviceAccessStatus {}
+impl ::core::clone::Clone for DeviceAccessStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Enumeration\"`*"]
+#[repr(transparent)]
+pub struct DeviceClass(pub i32);
+impl DeviceClass {
+    pub const All: Self = Self(0i32);
+    pub const AudioCapture: Self = Self(1i32);
+    pub const AudioRender: Self = Self(2i32);
+    pub const PortableStorageDevice: Self = Self(3i32);
+    pub const VideoCapture: Self = Self(4i32);
+    pub const ImageScanner: Self = Self(5i32);
+    pub const Location: Self = Self(6i32);
+}
+impl ::core::marker::Copy for DeviceClass {}
+impl ::core::clone::Clone for DeviceClass {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type DeviceConnectionChangeTriggerDetails = *mut ::core::ffi::c_void;
+pub type DeviceDisconnectButtonClickedEventArgs = *mut ::core::ffi::c_void;
+pub type DeviceInformation = *mut ::core::ffi::c_void;
+pub type DeviceInformationCollection = *mut ::core::ffi::c_void;
+pub type DeviceInformationCustomPairing = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Enumeration\"`*"]
+#[repr(transparent)]
+pub struct DeviceInformationKind(pub i32);
+impl DeviceInformationKind {
+    pub const Unknown: Self = Self(0i32);
+    pub const DeviceInterface: Self = Self(1i32);
+    pub const DeviceContainer: Self = Self(2i32);
+    pub const Device: Self = Self(3i32);
+    pub const DeviceInterfaceClass: Self = Self(4i32);
+    pub const AssociationEndpoint: Self = Self(5i32);
+    pub const AssociationEndpointContainer: Self = Self(6i32);
+    pub const AssociationEndpointService: Self = Self(7i32);
+    pub const DevicePanel: Self = Self(8i32);
+}
+impl ::core::marker::Copy for DeviceInformationKind {}
+impl ::core::clone::Clone for DeviceInformationKind {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type DeviceInformationPairing = *mut ::core::ffi::c_void;
+pub type DeviceInformationUpdate = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Enumeration\"`*"]
+#[repr(transparent)]
+pub struct DevicePairingKinds(pub u32);
+impl DevicePairingKinds {
+    pub const None: Self = Self(0u32);
+    pub const ConfirmOnly: Self = Self(1u32);
+    pub const DisplayPin: Self = Self(2u32);
+    pub const ProvidePin: Self = Self(4u32);
+    pub const ConfirmPinMatch: Self = Self(8u32);
+    pub const ProvidePasswordCredential: Self = Self(16u32);
+}
+impl ::core::marker::Copy for DevicePairingKinds {}
+impl ::core::clone::Clone for DevicePairingKinds {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Enumeration\"`*"]
+#[repr(transparent)]
+pub struct DevicePairingProtectionLevel(pub i32);
+impl DevicePairingProtectionLevel {
+    pub const Default: Self = Self(0i32);
+    pub const None: Self = Self(1i32);
+    pub const Encryption: Self = Self(2i32);
+    pub const EncryptionAndAuthentication: Self = Self(3i32);
+}
+impl ::core::marker::Copy for DevicePairingProtectionLevel {}
+impl ::core::clone::Clone for DevicePairingProtectionLevel {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type DevicePairingRequestedEventArgs = *mut ::core::ffi::c_void;
+pub type DevicePairingResult = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Enumeration\"`*"]
+#[repr(transparent)]
+pub struct DevicePairingResultStatus(pub i32);
+impl DevicePairingResultStatus {
+    pub const Paired: Self = Self(0i32);
+    pub const NotReadyToPair: Self = Self(1i32);
+    pub const NotPaired: Self = Self(2i32);
+    pub const AlreadyPaired: Self = Self(3i32);
+    pub const ConnectionRejected: Self = Self(4i32);
+    pub const TooManyConnections: Self = Self(5i32);
+    pub const HardwareFailure: Self = Self(6i32);
+    pub const AuthenticationTimeout: Self = Self(7i32);
+    pub const AuthenticationNotAllowed: Self = Self(8i32);
+    pub const AuthenticationFailure: Self = Self(9i32);
+    pub const NoSupportedProfiles: Self = Self(10i32);
+    pub const ProtectionLevelCouldNotBeMet: Self = Self(11i32);
+    pub const AccessDenied: Self = Self(12i32);
+    pub const InvalidCeremonyData: Self = Self(13i32);
+    pub const PairingCanceled: Self = Self(14i32);
+    pub const OperationAlreadyInProgress: Self = Self(15i32);
+    pub const RequiredHandlerNotRegistered: Self = Self(16i32);
+    pub const RejectedByHandler: Self = Self(17i32);
+    pub const RemoteDeviceHasAssociation: Self = Self(18i32);
+    pub const Failed: Self = Self(19i32);
+}
+impl ::core::marker::Copy for DevicePairingResultStatus {}
+impl ::core::clone::Clone for DevicePairingResultStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type DevicePicker = *mut ::core::ffi::c_void;
+pub type DevicePickerAppearance = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Enumeration\"`*"]
+#[repr(transparent)]
+pub struct DevicePickerDisplayStatusOptions(pub u32);
+impl DevicePickerDisplayStatusOptions {
+    pub const None: Self = Self(0u32);
+    pub const ShowProgress: Self = Self(1u32);
+    pub const ShowDisconnectButton: Self = Self(2u32);
+    pub const ShowRetryButton: Self = Self(4u32);
+}
+impl ::core::marker::Copy for DevicePickerDisplayStatusOptions {}
+impl ::core::clone::Clone for DevicePickerDisplayStatusOptions {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type DevicePickerFilter = *mut ::core::ffi::c_void;
+pub type DeviceSelectedEventArgs = *mut ::core::ffi::c_void;
+pub type DeviceThumbnail = *mut ::core::ffi::c_void;
+pub type DeviceUnpairingResult = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Enumeration\"`*"]
+#[repr(transparent)]
+pub struct DeviceUnpairingResultStatus(pub i32);
+impl DeviceUnpairingResultStatus {
+    pub const Unpaired: Self = Self(0i32);
+    pub const AlreadyUnpaired: Self = Self(1i32);
+    pub const OperationAlreadyInProgress: Self = Self(2i32);
+    pub const AccessDenied: Self = Self(3i32);
+    pub const Failed: Self = Self(4i32);
+}
+impl ::core::marker::Copy for DeviceUnpairingResultStatus {}
+impl ::core::clone::Clone for DeviceUnpairingResultStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type DeviceWatcher = *mut ::core::ffi::c_void;
+pub type DeviceWatcherEvent = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Enumeration\"`*"]
+#[repr(transparent)]
+pub struct DeviceWatcherEventKind(pub i32);
+impl DeviceWatcherEventKind {
+    pub const Add: Self = Self(0i32);
+    pub const Update: Self = Self(1i32);
+    pub const Remove: Self = Self(2i32);
+}
+impl ::core::marker::Copy for DeviceWatcherEventKind {}
+impl ::core::clone::Clone for DeviceWatcherEventKind {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Enumeration\"`*"]
+#[repr(transparent)]
+pub struct DeviceWatcherStatus(pub i32);
+impl DeviceWatcherStatus {
+    pub const Created: Self = Self(0i32);
+    pub const Started: Self = Self(1i32);
+    pub const EnumerationCompleted: Self = Self(2i32);
+    pub const Stopping: Self = Self(3i32);
+    pub const Stopped: Self = Self(4i32);
+    pub const Aborted: Self = Self(5i32);
+}
+impl ::core::marker::Copy for DeviceWatcherStatus {}
+impl ::core::clone::Clone for DeviceWatcherStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type DeviceWatcherTriggerDetails = *mut ::core::ffi::c_void;
+pub type EnclosureLocation = *mut ::core::ffi::c_void;
+pub type IDevicePairingSettings = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Enumeration\"`*"]
+#[repr(transparent)]
+pub struct Panel(pub i32);
+impl Panel {
+    pub const Unknown: Self = Self(0i32);
+    pub const Front: Self = Self(1i32);
+    pub const Back: Self = Self(2i32);
+    pub const Top: Self = Self(3i32);
+    pub const Bottom: Self = Self(4i32);
+    pub const Left: Self = Self(5i32);
+    pub const Right: Self = Self(6i32);
+}
+impl ::core::marker::Copy for Panel {}
+impl ::core::clone::Clone for Panel {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/vendor/windows-sys/src/Windows/Devices/Geolocation/Geofencing/mod.rs b/vendor/windows-sys/src/Windows/Devices/Geolocation/Geofencing/mod.rs
new file mode 100644
index 000000000..2fbbee5c5
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/Geolocation/Geofencing/mod.rs
@@ -0,0 +1,63 @@
+pub type Geofence = *mut ::core::ffi::c_void;
+pub type GeofenceMonitor = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Geolocation_Geofencing\"`*"]
+#[repr(transparent)]
+pub struct GeofenceMonitorStatus(pub i32);
+impl GeofenceMonitorStatus {
+    pub const Ready: Self = Self(0i32);
+    pub const Initializing: Self = Self(1i32);
+    pub const NoData: Self = Self(2i32);
+    pub const Disabled: Self = Self(3i32);
+    pub const NotInitialized: Self = Self(4i32);
+    pub const NotAvailable: Self = Self(5i32);
+}
+impl ::core::marker::Copy for GeofenceMonitorStatus {}
+impl ::core::clone::Clone for GeofenceMonitorStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Geolocation_Geofencing\"`*"]
+#[repr(transparent)]
+pub struct GeofenceRemovalReason(pub i32);
+impl GeofenceRemovalReason {
+    pub const Used: Self = Self(0i32);
+    pub const Expired: Self = Self(1i32);
+}
+impl ::core::marker::Copy for GeofenceRemovalReason {}
+impl ::core::clone::Clone for GeofenceRemovalReason {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Geolocation_Geofencing\"`*"]
+#[repr(transparent)]
+pub struct GeofenceState(pub u32);
+impl GeofenceState {
+    pub const None: Self = Self(0u32);
+    pub const Entered: Self = Self(1u32);
+    pub const Exited: Self = Self(2u32);
+    pub const Removed: Self = Self(4u32);
+}
+impl ::core::marker::Copy for GeofenceState {}
+impl ::core::clone::Clone for GeofenceState {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type GeofenceStateChangeReport = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Geolocation_Geofencing\"`*"]
+#[repr(transparent)]
+pub struct MonitoredGeofenceStates(pub u32);
+impl MonitoredGeofenceStates {
+    pub const None: Self = Self(0u32);
+    pub const Entered: Self = Self(1u32);
+    pub const Exited: Self = Self(2u32);
+    pub const Removed: Self = Self(4u32);
+}
+impl ::core::marker::Copy for MonitoredGeofenceStates {}
+impl ::core::clone::Clone for MonitoredGeofenceStates {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/vendor/windows-sys/src/Windows/Devices/Geolocation/mod.rs b/vendor/windows-sys/src/Windows/Devices/Geolocation/mod.rs
new file mode 100644
index 000000000..f09c27f38
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/Geolocation/mod.rs
@@ -0,0 +1,153 @@
+#[cfg(feature = "Devices_Geolocation_Geofencing")]
+pub mod Geofencing;
+#[doc = "*Required features: `\"Devices_Geolocation\"`*"]
+#[repr(transparent)]
+pub struct AltitudeReferenceSystem(pub i32);
+impl AltitudeReferenceSystem {
+    pub const Unspecified: Self = Self(0i32);
+    pub const Terrain: Self = Self(1i32);
+    pub const Ellipsoid: Self = Self(2i32);
+    pub const Geoid: Self = Self(3i32);
+    pub const Surface: Self = Self(4i32);
+}
+impl ::core::marker::Copy for AltitudeReferenceSystem {}
+impl ::core::clone::Clone for AltitudeReferenceSystem {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(C)]
+#[doc = "*Required features: `\"Devices_Geolocation\"`*"]
+pub struct BasicGeoposition {
+    pub Latitude: f64,
+    pub Longitude: f64,
+    pub Altitude: f64,
+}
+impl ::core::marker::Copy for BasicGeoposition {}
+impl ::core::clone::Clone for BasicGeoposition {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type CivicAddress = *mut ::core::ffi::c_void;
+pub type GeoboundingBox = *mut ::core::ffi::c_void;
+pub type Geocircle = *mut ::core::ffi::c_void;
+pub type Geocoordinate = *mut ::core::ffi::c_void;
+pub type GeocoordinateSatelliteData = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Geolocation\"`*"]
+#[repr(transparent)]
+pub struct GeolocationAccessStatus(pub i32);
+impl GeolocationAccessStatus {
+    pub const Unspecified: Self = Self(0i32);
+    pub const Allowed: Self = Self(1i32);
+    pub const Denied: Self = Self(2i32);
+}
+impl ::core::marker::Copy for GeolocationAccessStatus {}
+impl ::core::clone::Clone for GeolocationAccessStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type Geolocator = *mut ::core::ffi::c_void;
+pub type Geopath = *mut ::core::ffi::c_void;
+pub type Geopoint = *mut ::core::ffi::c_void;
+pub type Geoposition = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Geolocation\"`*"]
+#[repr(transparent)]
+pub struct GeoshapeType(pub i32);
+impl GeoshapeType {
+    pub const Geopoint: Self = Self(0i32);
+    pub const Geocircle: Self = Self(1i32);
+    pub const Geopath: Self = Self(2i32);
+    pub const GeoboundingBox: Self = Self(3i32);
+}
+impl ::core::marker::Copy for GeoshapeType {}
+impl ::core::clone::Clone for GeoshapeType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type Geovisit = *mut ::core::ffi::c_void;
+pub type GeovisitMonitor = *mut ::core::ffi::c_void;
+pub type GeovisitStateChangedEventArgs = *mut ::core::ffi::c_void;
+pub type GeovisitTriggerDetails = *mut ::core::ffi::c_void;
+pub type IGeoshape = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Geolocation\"`*"]
+#[repr(transparent)]
+pub struct PositionAccuracy(pub i32);
+impl PositionAccuracy {
+    pub const Default: Self = Self(0i32);
+    pub const High: Self = Self(1i32);
+}
+impl ::core::marker::Copy for PositionAccuracy {}
+impl ::core::clone::Clone for PositionAccuracy {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type PositionChangedEventArgs = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Geolocation\"`*"]
+#[repr(transparent)]
+pub struct PositionSource(pub i32);
+impl PositionSource {
+    pub const Cellular: Self = Self(0i32);
+    pub const Satellite: Self = Self(1i32);
+    pub const WiFi: Self = Self(2i32);
+    pub const IPAddress: Self = Self(3i32);
+    pub const Unknown: Self = Self(4i32);
+    pub const Default: Self = Self(5i32);
+    pub const Obfuscated: Self = Self(6i32);
+}
+impl ::core::marker::Copy for PositionSource {}
+impl ::core::clone::Clone for PositionSource {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Geolocation\"`*"]
+#[repr(transparent)]
+pub struct PositionStatus(pub i32);
+impl PositionStatus {
+    pub const Ready: Self = Self(0i32);
+    pub const Initializing: Self = Self(1i32);
+    pub const NoData: Self = Self(2i32);
+    pub const Disabled: Self = Self(3i32);
+    pub const NotInitialized: Self = Self(4i32);
+    pub const NotAvailable: Self = Self(5i32);
+}
+impl ::core::marker::Copy for PositionStatus {}
+impl ::core::clone::Clone for PositionStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type StatusChangedEventArgs = *mut ::core::ffi::c_void;
+pub type VenueData = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Geolocation\"`*"]
+#[repr(transparent)]
+pub struct VisitMonitoringScope(pub i32);
+impl VisitMonitoringScope {
+    pub const Venue: Self = Self(0i32);
+    pub const City: Self = Self(1i32);
+}
+impl ::core::marker::Copy for VisitMonitoringScope {}
+impl ::core::clone::Clone for VisitMonitoringScope {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Geolocation\"`*"]
+#[repr(transparent)]
+pub struct VisitStateChange(pub i32);
+impl VisitStateChange {
+    pub const TrackingLost: Self = Self(0i32);
+    pub const Arrived: Self = Self(1i32);
+    pub const Departed: Self = Self(2i32);
+    pub const OtherMovement: Self = Self(3i32);
+}
+impl ::core::marker::Copy for VisitStateChange {}
+impl ::core::clone::Clone for VisitStateChange {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/vendor/windows-sys/src/Windows/Devices/Gpio/Provider/mod.rs b/vendor/windows-sys/src/Windows/Devices/Gpio/Provider/mod.rs
new file mode 100644
index 000000000..b30442ad6
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/Gpio/Provider/mod.rs
@@ -0,0 +1,62 @@
+pub type GpioPinProviderValueChangedEventArgs = *mut ::core::ffi::c_void;
+pub type IGpioControllerProvider = *mut ::core::ffi::c_void;
+pub type IGpioPinProvider = *mut ::core::ffi::c_void;
+pub type IGpioProvider = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Gpio_Provider\"`*"]
+#[repr(transparent)]
+pub struct ProviderGpioPinDriveMode(pub i32);
+impl ProviderGpioPinDriveMode {
+    pub const Input: Self = Self(0i32);
+    pub const Output: Self = Self(1i32);
+    pub const InputPullUp: Self = Self(2i32);
+    pub const InputPullDown: Self = Self(3i32);
+    pub const OutputOpenDrain: Self = Self(4i32);
+    pub const OutputOpenDrainPullUp: Self = Self(5i32);
+    pub const OutputOpenSource: Self = Self(6i32);
+    pub const OutputOpenSourcePullDown: Self = Self(7i32);
+}
+impl ::core::marker::Copy for ProviderGpioPinDriveMode {}
+impl ::core::clone::Clone for ProviderGpioPinDriveMode {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Gpio_Provider\"`*"]
+#[repr(transparent)]
+pub struct ProviderGpioPinEdge(pub i32);
+impl ProviderGpioPinEdge {
+    pub const FallingEdge: Self = Self(0i32);
+    pub const RisingEdge: Self = Self(1i32);
+}
+impl ::core::marker::Copy for ProviderGpioPinEdge {}
+impl ::core::clone::Clone for ProviderGpioPinEdge {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Gpio_Provider\"`*"]
+#[repr(transparent)]
+pub struct ProviderGpioPinValue(pub i32);
+impl ProviderGpioPinValue {
+    pub const Low: Self = Self(0i32);
+    pub const High: Self = Self(1i32);
+}
+impl ::core::marker::Copy for ProviderGpioPinValue {}
+impl ::core::clone::Clone for ProviderGpioPinValue {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Gpio_Provider\"`*"]
+#[repr(transparent)]
+pub struct ProviderGpioSharingMode(pub i32);
+impl ProviderGpioSharingMode {
+    pub const Exclusive: Self = Self(0i32);
+    pub const SharedReadOnly: Self = Self(1i32);
+}
+impl ::core::marker::Copy for ProviderGpioSharingMode {}
+impl ::core::clone::Clone for ProviderGpioSharingMode {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/vendor/windows-sys/src/Windows/Devices/Gpio/mod.rs b/vendor/windows-sys/src/Windows/Devices/Gpio/mod.rs
new file mode 100644
index 000000000..ff04d80a4
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/Gpio/mod.rs
@@ -0,0 +1,125 @@
+#[cfg(feature = "Devices_Gpio_Provider")]
+pub mod Provider;
+#[repr(C)]
+#[doc = "*Required features: `\"Devices_Gpio\"`, `\"Foundation\"`*"]
+#[cfg(feature = "Foundation")]
+pub struct GpioChangeCount {
+    pub Count: u64,
+    pub RelativeTime: super::super::Foundation::TimeSpan,
+}
+#[cfg(feature = "Foundation")]
+impl ::core::marker::Copy for GpioChangeCount {}
+#[cfg(feature = "Foundation")]
+impl ::core::clone::Clone for GpioChangeCount {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type GpioChangeCounter = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Gpio\"`*"]
+#[repr(transparent)]
+pub struct GpioChangePolarity(pub i32);
+impl GpioChangePolarity {
+    pub const Falling: Self = Self(0i32);
+    pub const Rising: Self = Self(1i32);
+    pub const Both: Self = Self(2i32);
+}
+impl ::core::marker::Copy for GpioChangePolarity {}
+impl ::core::clone::Clone for GpioChangePolarity {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type GpioChangeReader = *mut ::core::ffi::c_void;
+#[repr(C)]
+#[doc = "*Required features: `\"Devices_Gpio\"`, `\"Foundation\"`*"]
+#[cfg(feature = "Foundation")]
+pub struct GpioChangeRecord {
+    pub RelativeTime: super::super::Foundation::TimeSpan,
+    pub Edge: GpioPinEdge,
+}
+#[cfg(feature = "Foundation")]
+impl ::core::marker::Copy for GpioChangeRecord {}
+#[cfg(feature = "Foundation")]
+impl ::core::clone::Clone for GpioChangeRecord {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type GpioController = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Gpio\"`*"]
+#[repr(transparent)]
+pub struct GpioOpenStatus(pub i32);
+impl GpioOpenStatus {
+    pub const PinOpened: Self = Self(0i32);
+    pub const PinUnavailable: Self = Self(1i32);
+    pub const SharingViolation: Self = Self(2i32);
+    pub const MuxingConflict: Self = Self(3i32);
+    pub const UnknownError: Self = Self(4i32);
+}
+impl ::core::marker::Copy for GpioOpenStatus {}
+impl ::core::clone::Clone for GpioOpenStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type GpioPin = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Gpio\"`*"]
+#[repr(transparent)]
+pub struct GpioPinDriveMode(pub i32);
+impl GpioPinDriveMode {
+    pub const Input: Self = Self(0i32);
+    pub const Output: Self = Self(1i32);
+    pub const InputPullUp: Self = Self(2i32);
+    pub const InputPullDown: Self = Self(3i32);
+    pub const OutputOpenDrain: Self = Self(4i32);
+    pub const OutputOpenDrainPullUp: Self = Self(5i32);
+    pub const OutputOpenSource: Self = Self(6i32);
+    pub const OutputOpenSourcePullDown: Self = Self(7i32);
+}
+impl ::core::marker::Copy for GpioPinDriveMode {}
+impl ::core::clone::Clone for GpioPinDriveMode {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Gpio\"`*"]
+#[repr(transparent)]
+pub struct GpioPinEdge(pub i32);
+impl GpioPinEdge {
+    pub const FallingEdge: Self = Self(0i32);
+    pub const RisingEdge: Self = Self(1i32);
+}
+impl ::core::marker::Copy for GpioPinEdge {}
+impl ::core::clone::Clone for GpioPinEdge {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Gpio\"`*"]
+#[repr(transparent)]
+pub struct GpioPinValue(pub i32);
+impl GpioPinValue {
+    pub const Low: Self = Self(0i32);
+    pub const High: Self = Self(1i32);
+}
+impl ::core::marker::Copy for GpioPinValue {}
+impl ::core::clone::Clone for GpioPinValue {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type GpioPinValueChangedEventArgs = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Gpio\"`*"]
+#[repr(transparent)]
+pub struct GpioSharingMode(pub i32);
+impl GpioSharingMode {
+    pub const Exclusive: Self = Self(0i32);
+    pub const SharedReadOnly: Self = Self(1i32);
+}
+impl ::core::marker::Copy for GpioSharingMode {}
+impl ::core::clone::Clone for GpioSharingMode {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/vendor/windows-sys/src/Windows/Devices/Haptics/mod.rs b/vendor/windows-sys/src/Windows/Devices/Haptics/mod.rs
new file mode 100644
index 000000000..08e492732
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/Haptics/mod.rs
@@ -0,0 +1,18 @@
+pub type SimpleHapticsController = *mut ::core::ffi::c_void;
+pub type SimpleHapticsControllerFeedback = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Haptics\"`*"]
+#[repr(transparent)]
+pub struct VibrationAccessStatus(pub i32);
+impl VibrationAccessStatus {
+    pub const Allowed: Self = Self(0i32);
+    pub const DeniedByUser: Self = Self(1i32);
+    pub const DeniedBySystem: Self = Self(2i32);
+    pub const DeniedByEnergySaver: Self = Self(3i32);
+}
+impl ::core::marker::Copy for VibrationAccessStatus {}
+impl ::core::clone::Clone for VibrationAccessStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type VibrationDevice = *mut ::core::ffi::c_void;
diff --git a/vendor/windows-sys/src/Windows/Devices/HumanInterfaceDevice/mod.rs b/vendor/windows-sys/src/Windows/Devices/HumanInterfaceDevice/mod.rs
new file mode 100644
index 000000000..8379747fd
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/HumanInterfaceDevice/mod.rs
@@ -0,0 +1,43 @@
+pub type HidBooleanControl = *mut ::core::ffi::c_void;
+pub type HidBooleanControlDescription = *mut ::core::ffi::c_void;
+pub type HidCollection = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_HumanInterfaceDevice\"`*"]
+#[repr(transparent)]
+pub struct HidCollectionType(pub i32);
+impl HidCollectionType {
+    pub const Physical: Self = Self(0i32);
+    pub const Application: Self = Self(1i32);
+    pub const Logical: Self = Self(2i32);
+    pub const Report: Self = Self(3i32);
+    pub const NamedArray: Self = Self(4i32);
+    pub const UsageSwitch: Self = Self(5i32);
+    pub const UsageModifier: Self = Self(6i32);
+    pub const Other: Self = Self(7i32);
+}
+impl ::core::marker::Copy for HidCollectionType {}
+impl ::core::clone::Clone for HidCollectionType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type HidDevice = *mut ::core::ffi::c_void;
+pub type HidFeatureReport = *mut ::core::ffi::c_void;
+pub type HidInputReport = *mut ::core::ffi::c_void;
+pub type HidInputReportReceivedEventArgs = *mut ::core::ffi::c_void;
+pub type HidNumericControl = *mut ::core::ffi::c_void;
+pub type HidNumericControlDescription = *mut ::core::ffi::c_void;
+pub type HidOutputReport = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_HumanInterfaceDevice\"`*"]
+#[repr(transparent)]
+pub struct HidReportType(pub i32);
+impl HidReportType {
+    pub const Input: Self = Self(0i32);
+    pub const Output: Self = Self(1i32);
+    pub const Feature: Self = Self(2i32);
+}
+impl ::core::marker::Copy for HidReportType {}
+impl ::core::clone::Clone for HidReportType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/vendor/windows-sys/src/Windows/Devices/I2c/Provider/mod.rs b/vendor/windows-sys/src/Windows/Devices/I2c/Provider/mod.rs
new file mode 100644
index 000000000..21a47ea6a
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/I2c/Provider/mod.rs
@@ -0,0 +1,56 @@
+pub type II2cControllerProvider = *mut ::core::ffi::c_void;
+pub type II2cDeviceProvider = *mut ::core::ffi::c_void;
+pub type II2cProvider = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_I2c_Provider\"`*"]
+#[repr(transparent)]
+pub struct ProviderI2cBusSpeed(pub i32);
+impl ProviderI2cBusSpeed {
+    pub const StandardMode: Self = Self(0i32);
+    pub const FastMode: Self = Self(1i32);
+}
+impl ::core::marker::Copy for ProviderI2cBusSpeed {}
+impl ::core::clone::Clone for ProviderI2cBusSpeed {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type ProviderI2cConnectionSettings = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_I2c_Provider\"`*"]
+#[repr(transparent)]
+pub struct ProviderI2cSharingMode(pub i32);
+impl ProviderI2cSharingMode {
+    pub const Exclusive: Self = Self(0i32);
+    pub const Shared: Self = Self(1i32);
+}
+impl ::core::marker::Copy for ProviderI2cSharingMode {}
+impl ::core::clone::Clone for ProviderI2cSharingMode {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(C)]
+#[doc = "*Required features: `\"Devices_I2c_Provider\"`*"]
+pub struct ProviderI2cTransferResult {
+    pub Status: ProviderI2cTransferStatus,
+    pub BytesTransferred: u32,
+}
+impl ::core::marker::Copy for ProviderI2cTransferResult {}
+impl ::core::clone::Clone for ProviderI2cTransferResult {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_I2c_Provider\"`*"]
+#[repr(transparent)]
+pub struct ProviderI2cTransferStatus(pub i32);
+impl ProviderI2cTransferStatus {
+    pub const FullTransfer: Self = Self(0i32);
+    pub const PartialTransfer: Self = Self(1i32);
+    pub const SlaveAddressNotAcknowledged: Self = Self(2i32);
+}
+impl ::core::marker::Copy for ProviderI2cTransferStatus {}
+impl ::core::clone::Clone for ProviderI2cTransferStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/vendor/windows-sys/src/Windows/Devices/I2c/mod.rs b/vendor/windows-sys/src/Windows/Devices/I2c/mod.rs
new file mode 100644
index 000000000..59e6a9cbf
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/I2c/mod.rs
@@ -0,0 +1,60 @@
+#[cfg(feature = "Devices_I2c_Provider")]
+pub mod Provider;
+#[doc = "*Required features: `\"Devices_I2c\"`*"]
+#[repr(transparent)]
+pub struct I2cBusSpeed(pub i32);
+impl I2cBusSpeed {
+    pub const StandardMode: Self = Self(0i32);
+    pub const FastMode: Self = Self(1i32);
+}
+impl ::core::marker::Copy for I2cBusSpeed {}
+impl ::core::clone::Clone for I2cBusSpeed {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type I2cConnectionSettings = *mut ::core::ffi::c_void;
+pub type I2cController = *mut ::core::ffi::c_void;
+pub type I2cDevice = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_I2c\"`*"]
+#[repr(transparent)]
+pub struct I2cSharingMode(pub i32);
+impl I2cSharingMode {
+    pub const Exclusive: Self = Self(0i32);
+    pub const Shared: Self = Self(1i32);
+}
+impl ::core::marker::Copy for I2cSharingMode {}
+impl ::core::clone::Clone for I2cSharingMode {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(C)]
+#[doc = "*Required features: `\"Devices_I2c\"`*"]
+pub struct I2cTransferResult {
+    pub Status: I2cTransferStatus,
+    pub BytesTransferred: u32,
+}
+impl ::core::marker::Copy for I2cTransferResult {}
+impl ::core::clone::Clone for I2cTransferResult {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_I2c\"`*"]
+#[repr(transparent)]
+pub struct I2cTransferStatus(pub i32);
+impl I2cTransferStatus {
+    pub const FullTransfer: Self = Self(0i32);
+    pub const PartialTransfer: Self = Self(1i32);
+    pub const SlaveAddressNotAcknowledged: Self = Self(2i32);
+    pub const ClockStretchTimeout: Self = Self(3i32);
+    pub const UnknownError: Self = Self(4i32);
+}
+impl ::core::marker::Copy for I2cTransferStatus {}
+impl ::core::clone::Clone for I2cTransferStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type II2cDeviceStatics = *mut ::core::ffi::c_void;
diff --git a/vendor/windows-sys/src/Windows/Devices/Input/Preview/mod.rs b/vendor/windows-sys/src/Windows/Devices/Input/Preview/mod.rs
new file mode 100644
index 000000000..019d98d91
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/Input/Preview/mod.rs
@@ -0,0 +1,26 @@
+#[doc = "*Required features: `\"Devices_Input_Preview\"`*"]
+#[repr(transparent)]
+pub struct GazeDeviceConfigurationStatePreview(pub i32);
+impl GazeDeviceConfigurationStatePreview {
+    pub const Unknown: Self = Self(0i32);
+    pub const Ready: Self = Self(1i32);
+    pub const Configuring: Self = Self(2i32);
+    pub const ScreenSetupNeeded: Self = Self(3i32);
+    pub const UserCalibrationNeeded: Self = Self(4i32);
+}
+impl ::core::marker::Copy for GazeDeviceConfigurationStatePreview {}
+impl ::core::clone::Clone for GazeDeviceConfigurationStatePreview {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type GazeDevicePreview = *mut ::core::ffi::c_void;
+pub type GazeDeviceWatcherAddedPreviewEventArgs = *mut ::core::ffi::c_void;
+pub type GazeDeviceWatcherPreview = *mut ::core::ffi::c_void;
+pub type GazeDeviceWatcherRemovedPreviewEventArgs = *mut ::core::ffi::c_void;
+pub type GazeDeviceWatcherUpdatedPreviewEventArgs = *mut ::core::ffi::c_void;
+pub type GazeEnteredPreviewEventArgs = *mut ::core::ffi::c_void;
+pub type GazeExitedPreviewEventArgs = *mut ::core::ffi::c_void;
+pub type GazeInputSourcePreview = *mut ::core::ffi::c_void;
+pub type GazeMovedPreviewEventArgs = *mut ::core::ffi::c_void;
+pub type GazePointPreview = *mut ::core::ffi::c_void;
diff --git a/vendor/windows-sys/src/Windows/Devices/Input/mod.rs b/vendor/windows-sys/src/Windows/Devices/Input/mod.rs
new file mode 100644
index 000000000..6112a9af5
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/Input/mod.rs
@@ -0,0 +1,60 @@
+#[cfg(feature = "Devices_Input_Preview")]
+pub mod Preview;
+pub type KeyboardCapabilities = *mut ::core::ffi::c_void;
+pub type MouseCapabilities = *mut ::core::ffi::c_void;
+#[repr(C)]
+#[doc = "*Required features: `\"Devices_Input\"`*"]
+pub struct MouseDelta {
+    pub X: i32,
+    pub Y: i32,
+}
+impl ::core::marker::Copy for MouseDelta {}
+impl ::core::clone::Clone for MouseDelta {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type MouseDevice = *mut ::core::ffi::c_void;
+pub type MouseEventArgs = *mut ::core::ffi::c_void;
+pub type PenButtonListener = *mut ::core::ffi::c_void;
+pub type PenDevice = *mut ::core::ffi::c_void;
+pub type PenDockListener = *mut ::core::ffi::c_void;
+pub type PenDockedEventArgs = *mut ::core::ffi::c_void;
+pub type PenTailButtonClickedEventArgs = *mut ::core::ffi::c_void;
+pub type PenTailButtonDoubleClickedEventArgs = *mut ::core::ffi::c_void;
+pub type PenTailButtonLongPressedEventArgs = *mut ::core::ffi::c_void;
+pub type PenUndockedEventArgs = *mut ::core::ffi::c_void;
+pub type PointerDevice = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Input\"`*"]
+#[repr(transparent)]
+pub struct PointerDeviceType(pub i32);
+impl PointerDeviceType {
+    pub const Touch: Self = Self(0i32);
+    pub const Pen: Self = Self(1i32);
+    pub const Mouse: Self = Self(2i32);
+}
+impl ::core::marker::Copy for PointerDeviceType {}
+impl ::core::clone::Clone for PointerDeviceType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(C)]
+#[doc = "*Required features: `\"Devices_Input\"`*"]
+pub struct PointerDeviceUsage {
+    pub UsagePage: u32,
+    pub Usage: u32,
+    pub MinLogical: i32,
+    pub MaxLogical: i32,
+    pub MinPhysical: i32,
+    pub MaxPhysical: i32,
+    pub Unit: u32,
+    pub PhysicalMultiplier: f32,
+}
+impl ::core::marker::Copy for PointerDeviceUsage {}
+impl ::core::clone::Clone for PointerDeviceUsage {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type TouchCapabilities = *mut ::core::ffi::c_void;
diff --git a/vendor/windows-sys/src/Windows/Devices/Lights/Effects/mod.rs b/vendor/windows-sys/src/Windows/Devices/Lights/Effects/mod.rs
new file mode 100644
index 000000000..9993408f7
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/Lights/Effects/mod.rs
@@ -0,0 +1,48 @@
+pub type ILampArrayEffect = *mut ::core::ffi::c_void;
+pub type LampArrayBitmapEffect = *mut ::core::ffi::c_void;
+pub type LampArrayBitmapRequestedEventArgs = *mut ::core::ffi::c_void;
+pub type LampArrayBlinkEffect = *mut ::core::ffi::c_void;
+pub type LampArrayColorRampEffect = *mut ::core::ffi::c_void;
+pub type LampArrayCustomEffect = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Lights_Effects\"`*"]
+#[repr(transparent)]
+pub struct LampArrayEffectCompletionBehavior(pub i32);
+impl LampArrayEffectCompletionBehavior {
+    pub const ClearState: Self = Self(0i32);
+    pub const KeepState: Self = Self(1i32);
+}
+impl ::core::marker::Copy for LampArrayEffectCompletionBehavior {}
+impl ::core::clone::Clone for LampArrayEffectCompletionBehavior {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type LampArrayEffectPlaylist = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Lights_Effects\"`*"]
+#[repr(transparent)]
+pub struct LampArrayEffectStartMode(pub i32);
+impl LampArrayEffectStartMode {
+    pub const Sequential: Self = Self(0i32);
+    pub const Simultaneous: Self = Self(1i32);
+}
+impl ::core::marker::Copy for LampArrayEffectStartMode {}
+impl ::core::clone::Clone for LampArrayEffectStartMode {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Lights_Effects\"`*"]
+#[repr(transparent)]
+pub struct LampArrayRepetitionMode(pub i32);
+impl LampArrayRepetitionMode {
+    pub const Occurrences: Self = Self(0i32);
+    pub const Forever: Self = Self(1i32);
+}
+impl ::core::marker::Copy for LampArrayRepetitionMode {}
+impl ::core::clone::Clone for LampArrayRepetitionMode {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type LampArraySolidEffect = *mut ::core::ffi::c_void;
+pub type LampArrayUpdateRequestedEventArgs = *mut ::core::ffi::c_void;
diff --git a/vendor/windows-sys/src/Windows/Devices/Lights/mod.rs b/vendor/windows-sys/src/Windows/Devices/Lights/mod.rs
new file mode 100644
index 000000000..443d2eb75
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/Lights/mod.rs
@@ -0,0 +1,46 @@
+#[cfg(feature = "Devices_Lights_Effects")]
+pub mod Effects;
+pub type Lamp = *mut ::core::ffi::c_void;
+pub type LampArray = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Lights\"`*"]
+#[repr(transparent)]
+pub struct LampArrayKind(pub i32);
+impl LampArrayKind {
+    pub const Undefined: Self = Self(0i32);
+    pub const Keyboard: Self = Self(1i32);
+    pub const Mouse: Self = Self(2i32);
+    pub const GameController: Self = Self(3i32);
+    pub const Peripheral: Self = Self(4i32);
+    pub const Scene: Self = Self(5i32);
+    pub const Notification: Self = Self(6i32);
+    pub const Chassis: Self = Self(7i32);
+    pub const Wearable: Self = Self(8i32);
+    pub const Furniture: Self = Self(9i32);
+    pub const Art: Self = Self(10i32);
+}
+impl ::core::marker::Copy for LampArrayKind {}
+impl ::core::clone::Clone for LampArrayKind {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type LampAvailabilityChangedEventArgs = *mut ::core::ffi::c_void;
+pub type LampInfo = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Lights\"`*"]
+#[repr(transparent)]
+pub struct LampPurposes(pub u32);
+impl LampPurposes {
+    pub const Undefined: Self = Self(0u32);
+    pub const Control: Self = Self(1u32);
+    pub const Accent: Self = Self(2u32);
+    pub const Branding: Self = Self(4u32);
+    pub const Status: Self = Self(8u32);
+    pub const Illumination: Self = Self(16u32);
+    pub const Presentation: Self = Self(32u32);
+}
+impl ::core::marker::Copy for LampPurposes {}
+impl ::core::clone::Clone for LampPurposes {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/vendor/windows-sys/src/Windows/Devices/Midi/mod.rs b/vendor/windows-sys/src/Windows/Devices/Midi/mod.rs
new file mode 100644
index 000000000..0a655ede7
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/Midi/mod.rs
@@ -0,0 +1,55 @@
+pub type IMidiMessage = *mut ::core::ffi::c_void;
+pub type IMidiOutPort = *mut ::core::ffi::c_void;
+pub type MidiActiveSensingMessage = *mut ::core::ffi::c_void;
+pub type MidiChannelPressureMessage = *mut ::core::ffi::c_void;
+pub type MidiContinueMessage = *mut ::core::ffi::c_void;
+pub type MidiControlChangeMessage = *mut ::core::ffi::c_void;
+pub type MidiInPort = *mut ::core::ffi::c_void;
+pub type MidiMessageReceivedEventArgs = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Midi\"`*"]
+#[repr(transparent)]
+pub struct MidiMessageType(pub i32);
+impl MidiMessageType {
+    pub const None: Self = Self(0i32);
+    pub const NoteOff: Self = Self(128i32);
+    pub const NoteOn: Self = Self(144i32);
+    pub const PolyphonicKeyPressure: Self = Self(160i32);
+    pub const ControlChange: Self = Self(176i32);
+    pub const ProgramChange: Self = Self(192i32);
+    pub const ChannelPressure: Self = Self(208i32);
+    pub const PitchBendChange: Self = Self(224i32);
+    pub const SystemExclusive: Self = Self(240i32);
+    pub const MidiTimeCode: Self = Self(241i32);
+    pub const SongPositionPointer: Self = Self(242i32);
+    pub const SongSelect: Self = Self(243i32);
+    pub const TuneRequest: Self = Self(246i32);
+    pub const EndSystemExclusive: Self = Self(247i32);
+    pub const TimingClock: Self = Self(248i32);
+    pub const Start: Self = Self(250i32);
+    pub const Continue: Self = Self(251i32);
+    pub const Stop: Self = Self(252i32);
+    pub const ActiveSensing: Self = Self(254i32);
+    pub const SystemReset: Self = Self(255i32);
+}
+impl ::core::marker::Copy for MidiMessageType {}
+impl ::core::clone::Clone for MidiMessageType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type MidiNoteOffMessage = *mut ::core::ffi::c_void;
+pub type MidiNoteOnMessage = *mut ::core::ffi::c_void;
+pub type MidiOutPort = *mut ::core::ffi::c_void;
+pub type MidiPitchBendChangeMessage = *mut ::core::ffi::c_void;
+pub type MidiPolyphonicKeyPressureMessage = *mut ::core::ffi::c_void;
+pub type MidiProgramChangeMessage = *mut ::core::ffi::c_void;
+pub type MidiSongPositionPointerMessage = *mut ::core::ffi::c_void;
+pub type MidiSongSelectMessage = *mut ::core::ffi::c_void;
+pub type MidiStartMessage = *mut ::core::ffi::c_void;
+pub type MidiStopMessage = *mut ::core::ffi::c_void;
+pub type MidiSynthesizer = *mut ::core::ffi::c_void;
+pub type MidiSystemExclusiveMessage = *mut ::core::ffi::c_void;
+pub type MidiSystemResetMessage = *mut ::core::ffi::c_void;
+pub type MidiTimeCodeMessage = *mut ::core::ffi::c_void;
+pub type MidiTimingClockMessage = *mut ::core::ffi::c_void;
+pub type MidiTuneRequestMessage = *mut ::core::ffi::c_void;
diff --git a/vendor/windows-sys/src/Windows/Devices/Perception/Provider/mod.rs b/vendor/windows-sys/src/Windows/Devices/Perception/Provider/mod.rs
new file mode 100644
index 000000000..5eab7c411
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/Perception/Provider/mod.rs
@@ -0,0 +1,12 @@
+pub type IPerceptionFrameProvider = *mut ::core::ffi::c_void;
+pub type IPerceptionFrameProviderManager = *mut ::core::ffi::c_void;
+pub type PerceptionControlGroup = *mut ::core::ffi::c_void;
+pub type PerceptionCorrelation = *mut ::core::ffi::c_void;
+pub type PerceptionCorrelationGroup = *mut ::core::ffi::c_void;
+pub type PerceptionFaceAuthenticationGroup = *mut ::core::ffi::c_void;
+pub type PerceptionFrame = *mut ::core::ffi::c_void;
+pub type PerceptionFrameProviderInfo = *mut ::core::ffi::c_void;
+pub type PerceptionPropertyChangeRequest = *mut ::core::ffi::c_void;
+pub type PerceptionStartFaceAuthenticationHandler = *mut ::core::ffi::c_void;
+pub type PerceptionStopFaceAuthenticationHandler = *mut ::core::ffi::c_void;
+pub type PerceptionVideoFrameAllocator = *mut ::core::ffi::c_void;
diff --git a/vendor/windows-sys/src/Windows/Devices/Perception/mod.rs b/vendor/windows-sys/src/Windows/Devices/Perception/mod.rs
new file mode 100644
index 000000000..6e62053f5
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/Perception/mod.rs
@@ -0,0 +1,69 @@
+#[cfg(feature = "Devices_Perception_Provider")]
+pub mod Provider;
+pub type PerceptionColorFrame = *mut ::core::ffi::c_void;
+pub type PerceptionColorFrameArrivedEventArgs = *mut ::core::ffi::c_void;
+pub type PerceptionColorFrameReader = *mut ::core::ffi::c_void;
+pub type PerceptionColorFrameSource = *mut ::core::ffi::c_void;
+pub type PerceptionColorFrameSourceAddedEventArgs = *mut ::core::ffi::c_void;
+pub type PerceptionColorFrameSourceRemovedEventArgs = *mut ::core::ffi::c_void;
+pub type PerceptionColorFrameSourceWatcher = *mut ::core::ffi::c_void;
+pub type PerceptionControlSession = *mut ::core::ffi::c_void;
+pub type PerceptionDepthCorrelatedCameraIntrinsics = *mut ::core::ffi::c_void;
+pub type PerceptionDepthCorrelatedCoordinateMapper = *mut ::core::ffi::c_void;
+pub type PerceptionDepthFrame = *mut ::core::ffi::c_void;
+pub type PerceptionDepthFrameArrivedEventArgs = *mut ::core::ffi::c_void;
+pub type PerceptionDepthFrameReader = *mut ::core::ffi::c_void;
+pub type PerceptionDepthFrameSource = *mut ::core::ffi::c_void;
+pub type PerceptionDepthFrameSourceAddedEventArgs = *mut ::core::ffi::c_void;
+pub type PerceptionDepthFrameSourceRemovedEventArgs = *mut ::core::ffi::c_void;
+pub type PerceptionDepthFrameSourceWatcher = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Perception\"`, `\"deprecated\"`*"]
+#[cfg(feature = "deprecated")]
+#[repr(transparent)]
+pub struct PerceptionFrameSourceAccessStatus(pub i32);
+#[cfg(feature = "deprecated")]
+impl PerceptionFrameSourceAccessStatus {
+    pub const Unspecified: Self = Self(0i32);
+    pub const Allowed: Self = Self(1i32);
+    pub const DeniedByUser: Self = Self(2i32);
+    pub const DeniedBySystem: Self = Self(3i32);
+}
+#[cfg(feature = "deprecated")]
+impl ::core::marker::Copy for PerceptionFrameSourceAccessStatus {}
+#[cfg(feature = "deprecated")]
+impl ::core::clone::Clone for PerceptionFrameSourceAccessStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type PerceptionFrameSourcePropertiesChangedEventArgs = *mut ::core::ffi::c_void;
+pub type PerceptionFrameSourcePropertyChangeResult = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Perception\"`, `\"deprecated\"`*"]
+#[cfg(feature = "deprecated")]
+#[repr(transparent)]
+pub struct PerceptionFrameSourcePropertyChangeStatus(pub i32);
+#[cfg(feature = "deprecated")]
+impl PerceptionFrameSourcePropertyChangeStatus {
+    pub const Unknown: Self = Self(0i32);
+    pub const Accepted: Self = Self(1i32);
+    pub const LostControl: Self = Self(2i32);
+    pub const PropertyNotSupported: Self = Self(3i32);
+    pub const PropertyReadOnly: Self = Self(4i32);
+    pub const ValueOutOfRange: Self = Self(5i32);
+}
+#[cfg(feature = "deprecated")]
+impl ::core::marker::Copy for PerceptionFrameSourcePropertyChangeStatus {}
+#[cfg(feature = "deprecated")]
+impl ::core::clone::Clone for PerceptionFrameSourcePropertyChangeStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type PerceptionInfraredFrame = *mut ::core::ffi::c_void;
+pub type PerceptionInfraredFrameArrivedEventArgs = *mut ::core::ffi::c_void;
+pub type PerceptionInfraredFrameReader = *mut ::core::ffi::c_void;
+pub type PerceptionInfraredFrameSource = *mut ::core::ffi::c_void;
+pub type PerceptionInfraredFrameSourceAddedEventArgs = *mut ::core::ffi::c_void;
+pub type PerceptionInfraredFrameSourceRemovedEventArgs = *mut ::core::ffi::c_void;
+pub type PerceptionInfraredFrameSourceWatcher = *mut ::core::ffi::c_void;
+pub type PerceptionVideoProfile = *mut ::core::ffi::c_void;
diff --git a/vendor/windows-sys/src/Windows/Devices/PointOfService/Provider/mod.rs b/vendor/windows-sys/src/Windows/Devices/PointOfService/Provider/mod.rs
new file mode 100644
index 000000000..aa05422ba
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/PointOfService/Provider/mod.rs
@@ -0,0 +1,35 @@
+pub type BarcodeScannerDisableScannerRequest = *mut ::core::ffi::c_void;
+pub type BarcodeScannerDisableScannerRequestEventArgs = *mut ::core::ffi::c_void;
+pub type BarcodeScannerEnableScannerRequest = *mut ::core::ffi::c_void;
+pub type BarcodeScannerEnableScannerRequestEventArgs = *mut ::core::ffi::c_void;
+pub type BarcodeScannerFrameReader = *mut ::core::ffi::c_void;
+pub type BarcodeScannerFrameReaderFrameArrivedEventArgs = *mut ::core::ffi::c_void;
+pub type BarcodeScannerGetSymbologyAttributesRequest = *mut ::core::ffi::c_void;
+pub type BarcodeScannerGetSymbologyAttributesRequestEventArgs = *mut ::core::ffi::c_void;
+pub type BarcodeScannerHideVideoPreviewRequest = *mut ::core::ffi::c_void;
+pub type BarcodeScannerHideVideoPreviewRequestEventArgs = *mut ::core::ffi::c_void;
+pub type BarcodeScannerProviderConnection = *mut ::core::ffi::c_void;
+pub type BarcodeScannerProviderTriggerDetails = *mut ::core::ffi::c_void;
+pub type BarcodeScannerSetActiveSymbologiesRequest = *mut ::core::ffi::c_void;
+pub type BarcodeScannerSetActiveSymbologiesRequestEventArgs = *mut ::core::ffi::c_void;
+pub type BarcodeScannerSetSymbologyAttributesRequest = *mut ::core::ffi::c_void;
+pub type BarcodeScannerSetSymbologyAttributesRequestEventArgs = *mut ::core::ffi::c_void;
+pub type BarcodeScannerStartSoftwareTriggerRequest = *mut ::core::ffi::c_void;
+pub type BarcodeScannerStartSoftwareTriggerRequestEventArgs = *mut ::core::ffi::c_void;
+pub type BarcodeScannerStopSoftwareTriggerRequest = *mut ::core::ffi::c_void;
+pub type BarcodeScannerStopSoftwareTriggerRequestEventArgs = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_PointOfService_Provider\"`*"]
+#[repr(transparent)]
+pub struct BarcodeScannerTriggerState(pub i32);
+impl BarcodeScannerTriggerState {
+    pub const Released: Self = Self(0i32);
+    pub const Pressed: Self = Self(1i32);
+}
+impl ::core::marker::Copy for BarcodeScannerTriggerState {}
+impl ::core::clone::Clone for BarcodeScannerTriggerState {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type BarcodeScannerVideoFrame = *mut ::core::ffi::c_void;
+pub type BarcodeSymbologyAttributesBuilder = *mut ::core::ffi::c_void;
diff --git a/vendor/windows-sys/src/Windows/Devices/PointOfService/mod.rs b/vendor/windows-sys/src/Windows/Devices/PointOfService/mod.rs
new file mode 100644
index 000000000..ce011e190
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/PointOfService/mod.rs
@@ -0,0 +1,654 @@
+#[cfg(feature = "Devices_PointOfService_Provider")]
+pub mod Provider;
+pub type BarcodeScanner = *mut ::core::ffi::c_void;
+pub type BarcodeScannerCapabilities = *mut ::core::ffi::c_void;
+pub type BarcodeScannerDataReceivedEventArgs = *mut ::core::ffi::c_void;
+pub type BarcodeScannerErrorOccurredEventArgs = *mut ::core::ffi::c_void;
+pub type BarcodeScannerImagePreviewReceivedEventArgs = *mut ::core::ffi::c_void;
+pub type BarcodeScannerReport = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_PointOfService\"`*"]
+#[repr(transparent)]
+pub struct BarcodeScannerStatus(pub i32);
+impl BarcodeScannerStatus {
+    pub const Online: Self = Self(0i32);
+    pub const Off: Self = Self(1i32);
+    pub const Offline: Self = Self(2i32);
+    pub const OffOrOffline: Self = Self(3i32);
+    pub const Extended: Self = Self(4i32);
+}
+impl ::core::marker::Copy for BarcodeScannerStatus {}
+impl ::core::clone::Clone for BarcodeScannerStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type BarcodeScannerStatusUpdatedEventArgs = *mut ::core::ffi::c_void;
+pub type BarcodeSymbologyAttributes = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_PointOfService\"`*"]
+#[repr(transparent)]
+pub struct BarcodeSymbologyDecodeLengthKind(pub i32);
+impl BarcodeSymbologyDecodeLengthKind {
+    pub const AnyLength: Self = Self(0i32);
+    pub const Discrete: Self = Self(1i32);
+    pub const Range: Self = Self(2i32);
+}
+impl ::core::marker::Copy for BarcodeSymbologyDecodeLengthKind {}
+impl ::core::clone::Clone for BarcodeSymbologyDecodeLengthKind {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type CashDrawer = *mut ::core::ffi::c_void;
+pub type CashDrawerCapabilities = *mut ::core::ffi::c_void;
+pub type CashDrawerCloseAlarm = *mut ::core::ffi::c_void;
+pub type CashDrawerClosedEventArgs = *mut ::core::ffi::c_void;
+pub type CashDrawerEventSource = *mut ::core::ffi::c_void;
+pub type CashDrawerOpenedEventArgs = *mut ::core::ffi::c_void;
+pub type CashDrawerStatus = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_PointOfService\"`*"]
+#[repr(transparent)]
+pub struct CashDrawerStatusKind(pub i32);
+impl CashDrawerStatusKind {
+    pub const Online: Self = Self(0i32);
+    pub const Off: Self = Self(1i32);
+    pub const Offline: Self = Self(2i32);
+    pub const OffOrOffline: Self = Self(3i32);
+    pub const Extended: Self = Self(4i32);
+}
+impl ::core::marker::Copy for CashDrawerStatusKind {}
+impl ::core::clone::Clone for CashDrawerStatusKind {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type CashDrawerStatusUpdatedEventArgs = *mut ::core::ffi::c_void;
+pub type ClaimedBarcodeScanner = *mut ::core::ffi::c_void;
+pub type ClaimedBarcodeScannerClosedEventArgs = *mut ::core::ffi::c_void;
+pub type ClaimedCashDrawer = *mut ::core::ffi::c_void;
+pub type ClaimedCashDrawerClosedEventArgs = *mut ::core::ffi::c_void;
+pub type ClaimedJournalPrinter = *mut ::core::ffi::c_void;
+pub type ClaimedLineDisplay = *mut ::core::ffi::c_void;
+pub type ClaimedLineDisplayClosedEventArgs = *mut ::core::ffi::c_void;
+pub type ClaimedMagneticStripeReader = *mut ::core::ffi::c_void;
+pub type ClaimedMagneticStripeReaderClosedEventArgs = *mut ::core::ffi::c_void;
+pub type ClaimedPosPrinter = *mut ::core::ffi::c_void;
+pub type ClaimedPosPrinterClosedEventArgs = *mut ::core::ffi::c_void;
+pub type ClaimedReceiptPrinter = *mut ::core::ffi::c_void;
+pub type ClaimedSlipPrinter = *mut ::core::ffi::c_void;
+pub type ICashDrawerEventSourceEventArgs = *mut ::core::ffi::c_void;
+pub type ICommonClaimedPosPrinterStation = *mut ::core::ffi::c_void;
+pub type ICommonPosPrintStationCapabilities = *mut ::core::ffi::c_void;
+pub type ICommonReceiptSlipCapabilities = *mut ::core::ffi::c_void;
+pub type IPosPrinterJob = *mut ::core::ffi::c_void;
+pub type IReceiptOrSlipJob = *mut ::core::ffi::c_void;
+pub type JournalPrintJob = *mut ::core::ffi::c_void;
+pub type JournalPrinterCapabilities = *mut ::core::ffi::c_void;
+pub type LineDisplay = *mut ::core::ffi::c_void;
+pub type LineDisplayAttributes = *mut ::core::ffi::c_void;
+pub type LineDisplayCapabilities = *mut ::core::ffi::c_void;
+pub type LineDisplayCursor = *mut ::core::ffi::c_void;
+pub type LineDisplayCursorAttributes = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_PointOfService\"`*"]
+#[repr(transparent)]
+pub struct LineDisplayCursorType(pub i32);
+impl LineDisplayCursorType {
+    pub const None: Self = Self(0i32);
+    pub const Block: Self = Self(1i32);
+    pub const HalfBlock: Self = Self(2i32);
+    pub const Underline: Self = Self(3i32);
+    pub const Reverse: Self = Self(4i32);
+    pub const Other: Self = Self(5i32);
+}
+impl ::core::marker::Copy for LineDisplayCursorType {}
+impl ::core::clone::Clone for LineDisplayCursorType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type LineDisplayCustomGlyphs = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_PointOfService\"`*"]
+#[repr(transparent)]
+pub struct LineDisplayDescriptorState(pub i32);
+impl LineDisplayDescriptorState {
+    pub const Off: Self = Self(0i32);
+    pub const On: Self = Self(1i32);
+    pub const Blink: Self = Self(2i32);
+}
+impl ::core::marker::Copy for LineDisplayDescriptorState {}
+impl ::core::clone::Clone for LineDisplayDescriptorState {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_PointOfService\"`*"]
+#[repr(transparent)]
+pub struct LineDisplayHorizontalAlignment(pub i32);
+impl LineDisplayHorizontalAlignment {
+    pub const Left: Self = Self(0i32);
+    pub const Center: Self = Self(1i32);
+    pub const Right: Self = Self(2i32);
+}
+impl ::core::marker::Copy for LineDisplayHorizontalAlignment {}
+impl ::core::clone::Clone for LineDisplayHorizontalAlignment {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type LineDisplayMarquee = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_PointOfService\"`*"]
+#[repr(transparent)]
+pub struct LineDisplayMarqueeFormat(pub i32);
+impl LineDisplayMarqueeFormat {
+    pub const None: Self = Self(0i32);
+    pub const Walk: Self = Self(1i32);
+    pub const Place: Self = Self(2i32);
+}
+impl ::core::marker::Copy for LineDisplayMarqueeFormat {}
+impl ::core::clone::Clone for LineDisplayMarqueeFormat {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_PointOfService\"`*"]
+#[repr(transparent)]
+pub struct LineDisplayPowerStatus(pub i32);
+impl LineDisplayPowerStatus {
+    pub const Unknown: Self = Self(0i32);
+    pub const Online: Self = Self(1i32);
+    pub const Off: Self = Self(2i32);
+    pub const Offline: Self = Self(3i32);
+    pub const OffOrOffline: Self = Self(4i32);
+}
+impl ::core::marker::Copy for LineDisplayPowerStatus {}
+impl ::core::clone::Clone for LineDisplayPowerStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_PointOfService\"`*"]
+#[repr(transparent)]
+pub struct LineDisplayScrollDirection(pub i32);
+impl LineDisplayScrollDirection {
+    pub const Up: Self = Self(0i32);
+    pub const Down: Self = Self(1i32);
+    pub const Left: Self = Self(2i32);
+    pub const Right: Self = Self(3i32);
+}
+impl ::core::marker::Copy for LineDisplayScrollDirection {}
+impl ::core::clone::Clone for LineDisplayScrollDirection {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type LineDisplayStatisticsCategorySelector = *mut ::core::ffi::c_void;
+pub type LineDisplayStatusUpdatedEventArgs = *mut ::core::ffi::c_void;
+pub type LineDisplayStoredBitmap = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_PointOfService\"`*"]
+#[repr(transparent)]
+pub struct LineDisplayTextAttribute(pub i32);
+impl LineDisplayTextAttribute {
+    pub const Normal: Self = Self(0i32);
+    pub const Blink: Self = Self(1i32);
+    pub const Reverse: Self = Self(2i32);
+    pub const ReverseBlink: Self = Self(3i32);
+}
+impl ::core::marker::Copy for LineDisplayTextAttribute {}
+impl ::core::clone::Clone for LineDisplayTextAttribute {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_PointOfService\"`*"]
+#[repr(transparent)]
+pub struct LineDisplayTextAttributeGranularity(pub i32);
+impl LineDisplayTextAttributeGranularity {
+    pub const NotSupported: Self = Self(0i32);
+    pub const EntireDisplay: Self = Self(1i32);
+    pub const PerCharacter: Self = Self(2i32);
+}
+impl ::core::marker::Copy for LineDisplayTextAttributeGranularity {}
+impl ::core::clone::Clone for LineDisplayTextAttributeGranularity {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_PointOfService\"`*"]
+#[repr(transparent)]
+pub struct LineDisplayVerticalAlignment(pub i32);
+impl LineDisplayVerticalAlignment {
+    pub const Top: Self = Self(0i32);
+    pub const Center: Self = Self(1i32);
+    pub const Bottom: Self = Self(2i32);
+}
+impl ::core::marker::Copy for LineDisplayVerticalAlignment {}
+impl ::core::clone::Clone for LineDisplayVerticalAlignment {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type LineDisplayWindow = *mut ::core::ffi::c_void;
+pub type MagneticStripeReader = *mut ::core::ffi::c_void;
+pub type MagneticStripeReaderAamvaCardDataReceivedEventArgs = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_PointOfService\"`*"]
+#[repr(transparent)]
+pub struct MagneticStripeReaderAuthenticationLevel(pub i32);
+impl MagneticStripeReaderAuthenticationLevel {
+    pub const NotSupported: Self = Self(0i32);
+    pub const Optional: Self = Self(1i32);
+    pub const Required: Self = Self(2i32);
+}
+impl ::core::marker::Copy for MagneticStripeReaderAuthenticationLevel {}
+impl ::core::clone::Clone for MagneticStripeReaderAuthenticationLevel {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_PointOfService\"`*"]
+#[repr(transparent)]
+pub struct MagneticStripeReaderAuthenticationProtocol(pub i32);
+impl MagneticStripeReaderAuthenticationProtocol {
+    pub const None: Self = Self(0i32);
+    pub const ChallengeResponse: Self = Self(1i32);
+}
+impl ::core::marker::Copy for MagneticStripeReaderAuthenticationProtocol {}
+impl ::core::clone::Clone for MagneticStripeReaderAuthenticationProtocol {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type MagneticStripeReaderBankCardDataReceivedEventArgs = *mut ::core::ffi::c_void;
+pub type MagneticStripeReaderCapabilities = *mut ::core::ffi::c_void;
+pub type MagneticStripeReaderErrorOccurredEventArgs = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_PointOfService\"`*"]
+#[repr(transparent)]
+pub struct MagneticStripeReaderErrorReportingType(pub i32);
+impl MagneticStripeReaderErrorReportingType {
+    pub const CardLevel: Self = Self(0i32);
+    pub const TrackLevel: Self = Self(1i32);
+}
+impl ::core::marker::Copy for MagneticStripeReaderErrorReportingType {}
+impl ::core::clone::Clone for MagneticStripeReaderErrorReportingType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type MagneticStripeReaderReport = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_PointOfService\"`*"]
+#[repr(transparent)]
+pub struct MagneticStripeReaderStatus(pub i32);
+impl MagneticStripeReaderStatus {
+    pub const Unauthenticated: Self = Self(0i32);
+    pub const Authenticated: Self = Self(1i32);
+    pub const Extended: Self = Self(2i32);
+}
+impl ::core::marker::Copy for MagneticStripeReaderStatus {}
+impl ::core::clone::Clone for MagneticStripeReaderStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type MagneticStripeReaderStatusUpdatedEventArgs = *mut ::core::ffi::c_void;
+pub type MagneticStripeReaderTrackData = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_PointOfService\"`*"]
+#[repr(transparent)]
+pub struct MagneticStripeReaderTrackErrorType(pub i32);
+impl MagneticStripeReaderTrackErrorType {
+    pub const None: Self = Self(0i32);
+    pub const StartSentinelError: Self = Self(1i32);
+    pub const EndSentinelError: Self = Self(2i32);
+    pub const ParityError: Self = Self(3i32);
+    pub const LrcError: Self = Self(4i32);
+    pub const Unknown: Self = Self(-1i32);
+}
+impl ::core::marker::Copy for MagneticStripeReaderTrackErrorType {}
+impl ::core::clone::Clone for MagneticStripeReaderTrackErrorType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_PointOfService\"`*"]
+#[repr(transparent)]
+pub struct MagneticStripeReaderTrackIds(pub i32);
+impl MagneticStripeReaderTrackIds {
+    pub const None: Self = Self(0i32);
+    pub const Track1: Self = Self(1i32);
+    pub const Track2: Self = Self(2i32);
+    pub const Track3: Self = Self(4i32);
+    pub const Track4: Self = Self(8i32);
+}
+impl ::core::marker::Copy for MagneticStripeReaderTrackIds {}
+impl ::core::clone::Clone for MagneticStripeReaderTrackIds {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type MagneticStripeReaderVendorSpecificCardDataReceivedEventArgs = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_PointOfService\"`*"]
+#[repr(transparent)]
+pub struct PosConnectionTypes(pub u32);
+impl PosConnectionTypes {
+    pub const Local: Self = Self(1u32);
+    pub const IP: Self = Self(2u32);
+    pub const Bluetooth: Self = Self(4u32);
+    pub const All: Self = Self(4294967295u32);
+}
+impl ::core::marker::Copy for PosConnectionTypes {}
+impl ::core::clone::Clone for PosConnectionTypes {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type PosPrinter = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_PointOfService\"`*"]
+#[repr(transparent)]
+pub struct PosPrinterAlignment(pub i32);
+impl PosPrinterAlignment {
+    pub const Left: Self = Self(0i32);
+    pub const Center: Self = Self(1i32);
+    pub const Right: Self = Self(2i32);
+}
+impl ::core::marker::Copy for PosPrinterAlignment {}
+impl ::core::clone::Clone for PosPrinterAlignment {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_PointOfService\"`*"]
+#[repr(transparent)]
+pub struct PosPrinterBarcodeTextPosition(pub i32);
+impl PosPrinterBarcodeTextPosition {
+    pub const None: Self = Self(0i32);
+    pub const Above: Self = Self(1i32);
+    pub const Below: Self = Self(2i32);
+}
+impl ::core::marker::Copy for PosPrinterBarcodeTextPosition {}
+impl ::core::clone::Clone for PosPrinterBarcodeTextPosition {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type PosPrinterCapabilities = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_PointOfService\"`*"]
+#[repr(transparent)]
+pub struct PosPrinterCartridgeSensors(pub u32);
+impl PosPrinterCartridgeSensors {
+    pub const None: Self = Self(0u32);
+    pub const Removed: Self = Self(1u32);
+    pub const Empty: Self = Self(2u32);
+    pub const HeadCleaning: Self = Self(4u32);
+    pub const NearEnd: Self = Self(8u32);
+}
+impl ::core::marker::Copy for PosPrinterCartridgeSensors {}
+impl ::core::clone::Clone for PosPrinterCartridgeSensors {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_PointOfService\"`*"]
+#[repr(transparent)]
+pub struct PosPrinterColorCapabilities(pub u32);
+impl PosPrinterColorCapabilities {
+    pub const None: Self = Self(0u32);
+    pub const Primary: Self = Self(1u32);
+    pub const Custom1: Self = Self(2u32);
+    pub const Custom2: Self = Self(4u32);
+    pub const Custom3: Self = Self(8u32);
+    pub const Custom4: Self = Self(16u32);
+    pub const Custom5: Self = Self(32u32);
+    pub const Custom6: Self = Self(64u32);
+    pub const Cyan: Self = Self(128u32);
+    pub const Magenta: Self = Self(256u32);
+    pub const Yellow: Self = Self(512u32);
+    pub const Full: Self = Self(1024u32);
+}
+impl ::core::marker::Copy for PosPrinterColorCapabilities {}
+impl ::core::clone::Clone for PosPrinterColorCapabilities {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_PointOfService\"`*"]
+#[repr(transparent)]
+pub struct PosPrinterColorCartridge(pub i32);
+impl PosPrinterColorCartridge {
+    pub const Unknown: Self = Self(0i32);
+    pub const Primary: Self = Self(1i32);
+    pub const Custom1: Self = Self(2i32);
+    pub const Custom2: Self = Self(3i32);
+    pub const Custom3: Self = Self(4i32);
+    pub const Custom4: Self = Self(5i32);
+    pub const Custom5: Self = Self(6i32);
+    pub const Custom6: Self = Self(7i32);
+    pub const Cyan: Self = Self(8i32);
+    pub const Magenta: Self = Self(9i32);
+    pub const Yellow: Self = Self(10i32);
+}
+impl ::core::marker::Copy for PosPrinterColorCartridge {}
+impl ::core::clone::Clone for PosPrinterColorCartridge {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type PosPrinterFontProperty = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_PointOfService\"`*"]
+#[repr(transparent)]
+pub struct PosPrinterLineDirection(pub i32);
+impl PosPrinterLineDirection {
+    pub const Horizontal: Self = Self(0i32);
+    pub const Vertical: Self = Self(1i32);
+}
+impl ::core::marker::Copy for PosPrinterLineDirection {}
+impl ::core::clone::Clone for PosPrinterLineDirection {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_PointOfService\"`*"]
+#[repr(transparent)]
+pub struct PosPrinterLineStyle(pub i32);
+impl PosPrinterLineStyle {
+    pub const SingleSolid: Self = Self(0i32);
+    pub const DoubleSolid: Self = Self(1i32);
+    pub const Broken: Self = Self(2i32);
+    pub const Chain: Self = Self(3i32);
+}
+impl ::core::marker::Copy for PosPrinterLineStyle {}
+impl ::core::clone::Clone for PosPrinterLineStyle {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_PointOfService\"`*"]
+#[repr(transparent)]
+pub struct PosPrinterMapMode(pub i32);
+impl PosPrinterMapMode {
+    pub const Dots: Self = Self(0i32);
+    pub const Twips: Self = Self(1i32);
+    pub const English: Self = Self(2i32);
+    pub const Metric: Self = Self(3i32);
+}
+impl ::core::marker::Copy for PosPrinterMapMode {}
+impl ::core::clone::Clone for PosPrinterMapMode {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_PointOfService\"`*"]
+#[repr(transparent)]
+pub struct PosPrinterMarkFeedCapabilities(pub u32);
+impl PosPrinterMarkFeedCapabilities {
+    pub const None: Self = Self(0u32);
+    pub const ToTakeUp: Self = Self(1u32);
+    pub const ToCutter: Self = Self(2u32);
+    pub const ToCurrentTopOfForm: Self = Self(4u32);
+    pub const ToNextTopOfForm: Self = Self(8u32);
+}
+impl ::core::marker::Copy for PosPrinterMarkFeedCapabilities {}
+impl ::core::clone::Clone for PosPrinterMarkFeedCapabilities {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_PointOfService\"`*"]
+#[repr(transparent)]
+pub struct PosPrinterMarkFeedKind(pub i32);
+impl PosPrinterMarkFeedKind {
+    pub const ToTakeUp: Self = Self(0i32);
+    pub const ToCutter: Self = Self(1i32);
+    pub const ToCurrentTopOfForm: Self = Self(2i32);
+    pub const ToNextTopOfForm: Self = Self(3i32);
+}
+impl ::core::marker::Copy for PosPrinterMarkFeedKind {}
+impl ::core::clone::Clone for PosPrinterMarkFeedKind {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type PosPrinterPrintOptions = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_PointOfService\"`*"]
+#[repr(transparent)]
+pub struct PosPrinterPrintSide(pub i32);
+impl PosPrinterPrintSide {
+    pub const Unknown: Self = Self(0i32);
+    pub const Side1: Self = Self(1i32);
+    pub const Side2: Self = Self(2i32);
+}
+impl ::core::marker::Copy for PosPrinterPrintSide {}
+impl ::core::clone::Clone for PosPrinterPrintSide {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type PosPrinterReleaseDeviceRequestedEventArgs = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_PointOfService\"`*"]
+#[repr(transparent)]
+pub struct PosPrinterRotation(pub i32);
+impl PosPrinterRotation {
+    pub const Normal: Self = Self(0i32);
+    pub const Right90: Self = Self(1i32);
+    pub const Left90: Self = Self(2i32);
+    pub const Rotate180: Self = Self(3i32);
+}
+impl ::core::marker::Copy for PosPrinterRotation {}
+impl ::core::clone::Clone for PosPrinterRotation {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_PointOfService\"`*"]
+#[repr(transparent)]
+pub struct PosPrinterRuledLineCapabilities(pub u32);
+impl PosPrinterRuledLineCapabilities {
+    pub const None: Self = Self(0u32);
+    pub const Horizontal: Self = Self(1u32);
+    pub const Vertical: Self = Self(2u32);
+}
+impl ::core::marker::Copy for PosPrinterRuledLineCapabilities {}
+impl ::core::clone::Clone for PosPrinterRuledLineCapabilities {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type PosPrinterStatus = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_PointOfService\"`*"]
+#[repr(transparent)]
+pub struct PosPrinterStatusKind(pub i32);
+impl PosPrinterStatusKind {
+    pub const Online: Self = Self(0i32);
+    pub const Off: Self = Self(1i32);
+    pub const Offline: Self = Self(2i32);
+    pub const OffOrOffline: Self = Self(3i32);
+    pub const Extended: Self = Self(4i32);
+}
+impl ::core::marker::Copy for PosPrinterStatusKind {}
+impl ::core::clone::Clone for PosPrinterStatusKind {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type PosPrinterStatusUpdatedEventArgs = *mut ::core::ffi::c_void;
+pub type ReceiptPrintJob = *mut ::core::ffi::c_void;
+pub type ReceiptPrinterCapabilities = *mut ::core::ffi::c_void;
+#[repr(C)]
+#[doc = "*Required features: `\"Devices_PointOfService\"`*"]
+pub struct SizeUInt32 {
+    pub Width: u32,
+    pub Height: u32,
+}
+impl ::core::marker::Copy for SizeUInt32 {}
+impl ::core::clone::Clone for SizeUInt32 {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type SlipPrintJob = *mut ::core::ffi::c_void;
+pub type SlipPrinterCapabilities = *mut ::core::ffi::c_void;
+pub type UnifiedPosErrorData = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_PointOfService\"`*"]
+#[repr(transparent)]
+pub struct UnifiedPosErrorReason(pub i32);
+impl UnifiedPosErrorReason {
+    pub const UnknownErrorReason: Self = Self(0i32);
+    pub const NoService: Self = Self(1i32);
+    pub const Disabled: Self = Self(2i32);
+    pub const Illegal: Self = Self(3i32);
+    pub const NoHardware: Self = Self(4i32);
+    pub const Closed: Self = Self(5i32);
+    pub const Offline: Self = Self(6i32);
+    pub const Failure: Self = Self(7i32);
+    pub const Timeout: Self = Self(8i32);
+    pub const Busy: Self = Self(9i32);
+    pub const Extended: Self = Self(10i32);
+}
+impl ::core::marker::Copy for UnifiedPosErrorReason {}
+impl ::core::clone::Clone for UnifiedPosErrorReason {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_PointOfService\"`*"]
+#[repr(transparent)]
+pub struct UnifiedPosErrorSeverity(pub i32);
+impl UnifiedPosErrorSeverity {
+    pub const UnknownErrorSeverity: Self = Self(0i32);
+    pub const Warning: Self = Self(1i32);
+    pub const Recoverable: Self = Self(2i32);
+    pub const Unrecoverable: Self = Self(3i32);
+    pub const AssistanceRequired: Self = Self(4i32);
+    pub const Fatal: Self = Self(5i32);
+}
+impl ::core::marker::Copy for UnifiedPosErrorSeverity {}
+impl ::core::clone::Clone for UnifiedPosErrorSeverity {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_PointOfService\"`*"]
+#[repr(transparent)]
+pub struct UnifiedPosHealthCheckLevel(pub i32);
+impl UnifiedPosHealthCheckLevel {
+    pub const UnknownHealthCheckLevel: Self = Self(0i32);
+    pub const POSInternal: Self = Self(1i32);
+    pub const External: Self = Self(2i32);
+    pub const Interactive: Self = Self(3i32);
+}
+impl ::core::marker::Copy for UnifiedPosHealthCheckLevel {}
+impl ::core::clone::Clone for UnifiedPosHealthCheckLevel {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_PointOfService\"`*"]
+#[repr(transparent)]
+pub struct UnifiedPosPowerReportingType(pub i32);
+impl UnifiedPosPowerReportingType {
+    pub const UnknownPowerReportingType: Self = Self(0i32);
+    pub const Standard: Self = Self(1i32);
+    pub const Advanced: Self = Self(2i32);
+}
+impl ::core::marker::Copy for UnifiedPosPowerReportingType {}
+impl ::core::clone::Clone for UnifiedPosPowerReportingType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/vendor/windows-sys/src/Windows/Devices/Portable/mod.rs b/vendor/windows-sys/src/Windows/Devices/Portable/mod.rs
new file mode 100644
index 000000000..b5653857d
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/Portable/mod.rs
@@ -0,0 +1,18 @@
+#[doc = "*Required features: `\"Devices_Portable\"`*"]
+#[repr(transparent)]
+pub struct ServiceDeviceType(pub i32);
+impl ServiceDeviceType {
+    pub const CalendarService: Self = Self(0i32);
+    pub const ContactsService: Self = Self(1i32);
+    pub const DeviceStatusService: Self = Self(2i32);
+    pub const NotesService: Self = Self(3i32);
+    pub const RingtonesService: Self = Self(4i32);
+    pub const SmsService: Self = Self(5i32);
+    pub const TasksService: Self = Self(6i32);
+}
+impl ::core::marker::Copy for ServiceDeviceType {}
+impl ::core::clone::Clone for ServiceDeviceType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/vendor/windows-sys/src/Windows/Devices/Power/mod.rs b/vendor/windows-sys/src/Windows/Devices/Power/mod.rs
new file mode 100644
index 000000000..3cc4b60f5
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/Power/mod.rs
@@ -0,0 +1,2 @@
+pub type Battery = *mut ::core::ffi::c_void;
+pub type BatteryReport = *mut ::core::ffi::c_void;
diff --git a/vendor/windows-sys/src/Windows/Devices/Printers/Extensions/mod.rs b/vendor/windows-sys/src/Windows/Devices/Printers/Extensions/mod.rs
new file mode 100644
index 000000000..28509aa6e
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/Printers/Extensions/mod.rs
@@ -0,0 +1,42 @@
+pub type Print3DWorkflow = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Printers_Extensions\"`*"]
+#[repr(transparent)]
+pub struct Print3DWorkflowDetail(pub i32);
+impl Print3DWorkflowDetail {
+    pub const Unknown: Self = Self(0i32);
+    pub const ModelExceedsPrintBed: Self = Self(1i32);
+    pub const UploadFailed: Self = Self(2i32);
+    pub const InvalidMaterialSelection: Self = Self(3i32);
+    pub const InvalidModel: Self = Self(4i32);
+    pub const ModelNotManifold: Self = Self(5i32);
+    pub const InvalidPrintTicket: Self = Self(6i32);
+}
+impl ::core::marker::Copy for Print3DWorkflowDetail {}
+impl ::core::clone::Clone for Print3DWorkflowDetail {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type Print3DWorkflowPrintRequestedEventArgs = *mut ::core::ffi::c_void;
+pub type Print3DWorkflowPrinterChangedEventArgs = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Printers_Extensions\"`*"]
+#[repr(transparent)]
+pub struct Print3DWorkflowStatus(pub i32);
+impl Print3DWorkflowStatus {
+    pub const Abandoned: Self = Self(0i32);
+    pub const Canceled: Self = Self(1i32);
+    pub const Failed: Self = Self(2i32);
+    pub const Slicing: Self = Self(3i32);
+    pub const Submitted: Self = Self(4i32);
+}
+impl ::core::marker::Copy for Print3DWorkflowStatus {}
+impl ::core::clone::Clone for Print3DWorkflowStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type PrintNotificationEventDetails = *mut ::core::ffi::c_void;
+pub type PrintTaskConfiguration = *mut ::core::ffi::c_void;
+pub type PrintTaskConfigurationSaveRequest = *mut ::core::ffi::c_void;
+pub type PrintTaskConfigurationSaveRequestedDeferral = *mut ::core::ffi::c_void;
+pub type PrintTaskConfigurationSaveRequestedEventArgs = *mut ::core::ffi::c_void;
diff --git a/vendor/windows-sys/src/Windows/Devices/Printers/mod.rs b/vendor/windows-sys/src/Windows/Devices/Printers/mod.rs
new file mode 100644
index 000000000..04db5d4d0
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/Printers/mod.rs
@@ -0,0 +1,72 @@
+#[cfg(feature = "Devices_Printers_Extensions")]
+pub mod Extensions;
+pub type IppAttributeError = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Printers\"`*"]
+#[repr(transparent)]
+pub struct IppAttributeErrorReason(pub i32);
+impl IppAttributeErrorReason {
+    pub const RequestEntityTooLarge: Self = Self(0i32);
+    pub const AttributeNotSupported: Self = Self(1i32);
+    pub const AttributeValuesNotSupported: Self = Self(2i32);
+    pub const AttributeNotSettable: Self = Self(3i32);
+    pub const ConflictingAttributes: Self = Self(4i32);
+}
+impl ::core::marker::Copy for IppAttributeErrorReason {}
+impl ::core::clone::Clone for IppAttributeErrorReason {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type IppAttributeValue = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Printers\"`*"]
+#[repr(transparent)]
+pub struct IppAttributeValueKind(pub i32);
+impl IppAttributeValueKind {
+    pub const Unsupported: Self = Self(0i32);
+    pub const Unknown: Self = Self(1i32);
+    pub const NoValue: Self = Self(2i32);
+    pub const Integer: Self = Self(3i32);
+    pub const Boolean: Self = Self(4i32);
+    pub const Enum: Self = Self(5i32);
+    pub const OctetString: Self = Self(6i32);
+    pub const DateTime: Self = Self(7i32);
+    pub const Resolution: Self = Self(8i32);
+    pub const RangeOfInteger: Self = Self(9i32);
+    pub const Collection: Self = Self(10i32);
+    pub const TextWithLanguage: Self = Self(11i32);
+    pub const NameWithLanguage: Self = Self(12i32);
+    pub const TextWithoutLanguage: Self = Self(13i32);
+    pub const NameWithoutLanguage: Self = Self(14i32);
+    pub const Keyword: Self = Self(15i32);
+    pub const Uri: Self = Self(16i32);
+    pub const UriSchema: Self = Self(17i32);
+    pub const Charset: Self = Self(18i32);
+    pub const NaturalLanguage: Self = Self(19i32);
+    pub const MimeMediaType: Self = Self(20i32);
+}
+impl ::core::marker::Copy for IppAttributeValueKind {}
+impl ::core::clone::Clone for IppAttributeValueKind {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type IppIntegerRange = *mut ::core::ffi::c_void;
+pub type IppPrintDevice = *mut ::core::ffi::c_void;
+pub type IppResolution = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Printers\"`*"]
+#[repr(transparent)]
+pub struct IppResolutionUnit(pub i32);
+impl IppResolutionUnit {
+    pub const DotsPerInch: Self = Self(0i32);
+    pub const DotsPerCentimeter: Self = Self(1i32);
+}
+impl ::core::marker::Copy for IppResolutionUnit {}
+impl ::core::clone::Clone for IppResolutionUnit {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type IppSetAttributesResult = *mut ::core::ffi::c_void;
+pub type IppTextWithLanguage = *mut ::core::ffi::c_void;
+pub type Print3DDevice = *mut ::core::ffi::c_void;
+pub type PrintSchema = *mut ::core::ffi::c_void;
diff --git a/vendor/windows-sys/src/Windows/Devices/Pwm/Provider/mod.rs b/vendor/windows-sys/src/Windows/Devices/Pwm/Provider/mod.rs
new file mode 100644
index 000000000..be08ef3f5
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/Pwm/Provider/mod.rs
@@ -0,0 +1,2 @@
+pub type IPwmControllerProvider = *mut ::core::ffi::c_void;
+pub type IPwmProvider = *mut ::core::ffi::c_void;
diff --git a/vendor/windows-sys/src/Windows/Devices/Pwm/mod.rs b/vendor/windows-sys/src/Windows/Devices/Pwm/mod.rs
new file mode 100644
index 000000000..0465e2496
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/Pwm/mod.rs
@@ -0,0 +1,17 @@
+#[cfg(feature = "Devices_Pwm_Provider")]
+pub mod Provider;
+pub type PwmController = *mut ::core::ffi::c_void;
+pub type PwmPin = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Pwm\"`*"]
+#[repr(transparent)]
+pub struct PwmPulsePolarity(pub i32);
+impl PwmPulsePolarity {
+    pub const ActiveHigh: Self = Self(0i32);
+    pub const ActiveLow: Self = Self(1i32);
+}
+impl ::core::marker::Copy for PwmPulsePolarity {}
+impl ::core::clone::Clone for PwmPulsePolarity {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/vendor/windows-sys/src/Windows/Devices/Radios/mod.rs b/vendor/windows-sys/src/Windows/Devices/Radios/mod.rs
new file mode 100644
index 000000000..dcc70cabb
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/Radios/mod.rs
@@ -0,0 +1,47 @@
+pub type Radio = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Radios\"`*"]
+#[repr(transparent)]
+pub struct RadioAccessStatus(pub i32);
+impl RadioAccessStatus {
+    pub const Unspecified: Self = Self(0i32);
+    pub const Allowed: Self = Self(1i32);
+    pub const DeniedByUser: Self = Self(2i32);
+    pub const DeniedBySystem: Self = Self(3i32);
+}
+impl ::core::marker::Copy for RadioAccessStatus {}
+impl ::core::clone::Clone for RadioAccessStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Radios\"`*"]
+#[repr(transparent)]
+pub struct RadioKind(pub i32);
+impl RadioKind {
+    pub const Other: Self = Self(0i32);
+    pub const WiFi: Self = Self(1i32);
+    pub const MobileBroadband: Self = Self(2i32);
+    pub const Bluetooth: Self = Self(3i32);
+    pub const FM: Self = Self(4i32);
+}
+impl ::core::marker::Copy for RadioKind {}
+impl ::core::clone::Clone for RadioKind {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Radios\"`*"]
+#[repr(transparent)]
+pub struct RadioState(pub i32);
+impl RadioState {
+    pub const Unknown: Self = Self(0i32);
+    pub const On: Self = Self(1i32);
+    pub const Off: Self = Self(2i32);
+    pub const Disabled: Self = Self(3i32);
+}
+impl ::core::marker::Copy for RadioState {}
+impl ::core::clone::Clone for RadioState {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/vendor/windows-sys/src/Windows/Devices/Scanners/mod.rs b/vendor/windows-sys/src/Windows/Devices/Scanners/mod.rs
new file mode 100644
index 000000000..e8087d7b3
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/Scanners/mod.rs
@@ -0,0 +1,82 @@
+pub type IImageScannerFormatConfiguration = *mut ::core::ffi::c_void;
+pub type IImageScannerSourceConfiguration = *mut ::core::ffi::c_void;
+pub type ImageScanner = *mut ::core::ffi::c_void;
+pub type ImageScannerAutoConfiguration = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Scanners\"`*"]
+#[repr(transparent)]
+pub struct ImageScannerAutoCroppingMode(pub i32);
+impl ImageScannerAutoCroppingMode {
+    pub const Disabled: Self = Self(0i32);
+    pub const SingleRegion: Self = Self(1i32);
+    pub const MultipleRegion: Self = Self(2i32);
+}
+impl ::core::marker::Copy for ImageScannerAutoCroppingMode {}
+impl ::core::clone::Clone for ImageScannerAutoCroppingMode {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Scanners\"`*"]
+#[repr(transparent)]
+pub struct ImageScannerColorMode(pub i32);
+impl ImageScannerColorMode {
+    pub const Color: Self = Self(0i32);
+    pub const Grayscale: Self = Self(1i32);
+    pub const Monochrome: Self = Self(2i32);
+    pub const AutoColor: Self = Self(3i32);
+}
+impl ::core::marker::Copy for ImageScannerColorMode {}
+impl ::core::clone::Clone for ImageScannerColorMode {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type ImageScannerFeederConfiguration = *mut ::core::ffi::c_void;
+pub type ImageScannerFlatbedConfiguration = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Scanners\"`*"]
+#[repr(transparent)]
+pub struct ImageScannerFormat(pub i32);
+impl ImageScannerFormat {
+    pub const Jpeg: Self = Self(0i32);
+    pub const Png: Self = Self(1i32);
+    pub const DeviceIndependentBitmap: Self = Self(2i32);
+    pub const Tiff: Self = Self(3i32);
+    pub const Xps: Self = Self(4i32);
+    pub const OpenXps: Self = Self(5i32);
+    pub const Pdf: Self = Self(6i32);
+}
+impl ::core::marker::Copy for ImageScannerFormat {}
+impl ::core::clone::Clone for ImageScannerFormat {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type ImageScannerPreviewResult = *mut ::core::ffi::c_void;
+#[repr(C)]
+#[doc = "*Required features: `\"Devices_Scanners\"`*"]
+pub struct ImageScannerResolution {
+    pub DpiX: f32,
+    pub DpiY: f32,
+}
+impl ::core::marker::Copy for ImageScannerResolution {}
+impl ::core::clone::Clone for ImageScannerResolution {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type ImageScannerScanResult = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Scanners\"`*"]
+#[repr(transparent)]
+pub struct ImageScannerScanSource(pub i32);
+impl ImageScannerScanSource {
+    pub const Default: Self = Self(0i32);
+    pub const Flatbed: Self = Self(1i32);
+    pub const Feeder: Self = Self(2i32);
+    pub const AutoConfigured: Self = Self(3i32);
+}
+impl ::core::marker::Copy for ImageScannerScanSource {}
+impl ::core::clone::Clone for ImageScannerScanSource {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/vendor/windows-sys/src/Windows/Devices/Sensors/Custom/mod.rs b/vendor/windows-sys/src/Windows/Devices/Sensors/Custom/mod.rs
new file mode 100644
index 000000000..38b77878d
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/Sensors/Custom/mod.rs
@@ -0,0 +1,3 @@
+pub type CustomSensor = *mut ::core::ffi::c_void;
+pub type CustomSensorReading = *mut ::core::ffi::c_void;
+pub type CustomSensorReadingChangedEventArgs = *mut ::core::ffi::c_void;
diff --git a/vendor/windows-sys/src/Windows/Devices/Sensors/mod.rs b/vendor/windows-sys/src/Windows/Devices/Sensors/mod.rs
new file mode 100644
index 000000000..8b66a0e10
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/Sensors/mod.rs
@@ -0,0 +1,203 @@
+#[cfg(feature = "Devices_Sensors_Custom")]
+pub mod Custom;
+pub type Accelerometer = *mut ::core::ffi::c_void;
+pub type AccelerometerDataThreshold = *mut ::core::ffi::c_void;
+pub type AccelerometerReading = *mut ::core::ffi::c_void;
+pub type AccelerometerReadingChangedEventArgs = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Sensors\"`*"]
+#[repr(transparent)]
+pub struct AccelerometerReadingType(pub i32);
+impl AccelerometerReadingType {
+    pub const Standard: Self = Self(0i32);
+    pub const Linear: Self = Self(1i32);
+    pub const Gravity: Self = Self(2i32);
+}
+impl ::core::marker::Copy for AccelerometerReadingType {}
+impl ::core::clone::Clone for AccelerometerReadingType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type AccelerometerShakenEventArgs = *mut ::core::ffi::c_void;
+pub type ActivitySensor = *mut ::core::ffi::c_void;
+pub type ActivitySensorReading = *mut ::core::ffi::c_void;
+pub type ActivitySensorReadingChangeReport = *mut ::core::ffi::c_void;
+pub type ActivitySensorReadingChangedEventArgs = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Sensors\"`*"]
+#[repr(transparent)]
+pub struct ActivitySensorReadingConfidence(pub i32);
+impl ActivitySensorReadingConfidence {
+    pub const High: Self = Self(0i32);
+    pub const Low: Self = Self(1i32);
+}
+impl ::core::marker::Copy for ActivitySensorReadingConfidence {}
+impl ::core::clone::Clone for ActivitySensorReadingConfidence {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type ActivitySensorTriggerDetails = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Sensors\"`*"]
+#[repr(transparent)]
+pub struct ActivityType(pub i32);
+impl ActivityType {
+    pub const Unknown: Self = Self(0i32);
+    pub const Idle: Self = Self(1i32);
+    pub const Stationary: Self = Self(2i32);
+    pub const Fidgeting: Self = Self(3i32);
+    pub const Walking: Self = Self(4i32);
+    pub const Running: Self = Self(5i32);
+    pub const InVehicle: Self = Self(6i32);
+    pub const Biking: Self = Self(7i32);
+}
+impl ::core::marker::Copy for ActivityType {}
+impl ::core::clone::Clone for ActivityType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type Altimeter = *mut ::core::ffi::c_void;
+pub type AltimeterReading = *mut ::core::ffi::c_void;
+pub type AltimeterReadingChangedEventArgs = *mut ::core::ffi::c_void;
+pub type Barometer = *mut ::core::ffi::c_void;
+pub type BarometerDataThreshold = *mut ::core::ffi::c_void;
+pub type BarometerReading = *mut ::core::ffi::c_void;
+pub type BarometerReadingChangedEventArgs = *mut ::core::ffi::c_void;
+pub type Compass = *mut ::core::ffi::c_void;
+pub type CompassDataThreshold = *mut ::core::ffi::c_void;
+pub type CompassReading = *mut ::core::ffi::c_void;
+pub type CompassReadingChangedEventArgs = *mut ::core::ffi::c_void;
+pub type Gyrometer = *mut ::core::ffi::c_void;
+pub type GyrometerDataThreshold = *mut ::core::ffi::c_void;
+pub type GyrometerReading = *mut ::core::ffi::c_void;
+pub type GyrometerReadingChangedEventArgs = *mut ::core::ffi::c_void;
+pub type HingeAngleReading = *mut ::core::ffi::c_void;
+pub type HingeAngleSensor = *mut ::core::ffi::c_void;
+pub type HingeAngleSensorReadingChangedEventArgs = *mut ::core::ffi::c_void;
+pub type ISensorDataThreshold = *mut ::core::ffi::c_void;
+pub type Inclinometer = *mut ::core::ffi::c_void;
+pub type InclinometerDataThreshold = *mut ::core::ffi::c_void;
+pub type InclinometerReading = *mut ::core::ffi::c_void;
+pub type InclinometerReadingChangedEventArgs = *mut ::core::ffi::c_void;
+pub type LightSensor = *mut ::core::ffi::c_void;
+pub type LightSensorDataThreshold = *mut ::core::ffi::c_void;
+pub type LightSensorReading = *mut ::core::ffi::c_void;
+pub type LightSensorReadingChangedEventArgs = *mut ::core::ffi::c_void;
+pub type Magnetometer = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Sensors\"`*"]
+#[repr(transparent)]
+pub struct MagnetometerAccuracy(pub i32);
+impl MagnetometerAccuracy {
+    pub const Unknown: Self = Self(0i32);
+    pub const Unreliable: Self = Self(1i32);
+    pub const Approximate: Self = Self(2i32);
+    pub const High: Self = Self(3i32);
+}
+impl ::core::marker::Copy for MagnetometerAccuracy {}
+impl ::core::clone::Clone for MagnetometerAccuracy {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type MagnetometerDataThreshold = *mut ::core::ffi::c_void;
+pub type MagnetometerReading = *mut ::core::ffi::c_void;
+pub type MagnetometerReadingChangedEventArgs = *mut ::core::ffi::c_void;
+pub type OrientationSensor = *mut ::core::ffi::c_void;
+pub type OrientationSensorReading = *mut ::core::ffi::c_void;
+pub type OrientationSensorReadingChangedEventArgs = *mut ::core::ffi::c_void;
+pub type Pedometer = *mut ::core::ffi::c_void;
+pub type PedometerDataThreshold = *mut ::core::ffi::c_void;
+pub type PedometerReading = *mut ::core::ffi::c_void;
+pub type PedometerReadingChangedEventArgs = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Sensors\"`*"]
+#[repr(transparent)]
+pub struct PedometerStepKind(pub i32);
+impl PedometerStepKind {
+    pub const Unknown: Self = Self(0i32);
+    pub const Walking: Self = Self(1i32);
+    pub const Running: Self = Self(2i32);
+}
+impl ::core::marker::Copy for PedometerStepKind {}
+impl ::core::clone::Clone for PedometerStepKind {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type ProximitySensor = *mut ::core::ffi::c_void;
+pub type ProximitySensorDataThreshold = *mut ::core::ffi::c_void;
+pub type ProximitySensorDisplayOnOffController = *mut ::core::ffi::c_void;
+pub type ProximitySensorReading = *mut ::core::ffi::c_void;
+pub type ProximitySensorReadingChangedEventArgs = *mut ::core::ffi::c_void;
+pub type SensorDataThresholdTriggerDetails = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Sensors\"`*"]
+#[repr(transparent)]
+pub struct SensorOptimizationGoal(pub i32);
+impl SensorOptimizationGoal {
+    pub const Precision: Self = Self(0i32);
+    pub const PowerEfficiency: Self = Self(1i32);
+}
+impl ::core::marker::Copy for SensorOptimizationGoal {}
+impl ::core::clone::Clone for SensorOptimizationGoal {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type SensorQuaternion = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Sensors\"`*"]
+#[repr(transparent)]
+pub struct SensorReadingType(pub i32);
+impl SensorReadingType {
+    pub const Absolute: Self = Self(0i32);
+    pub const Relative: Self = Self(1i32);
+}
+impl ::core::marker::Copy for SensorReadingType {}
+impl ::core::clone::Clone for SensorReadingType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type SensorRotationMatrix = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Sensors\"`*"]
+#[repr(transparent)]
+pub struct SensorType(pub i32);
+impl SensorType {
+    pub const Accelerometer: Self = Self(0i32);
+    pub const ActivitySensor: Self = Self(1i32);
+    pub const Barometer: Self = Self(2i32);
+    pub const Compass: Self = Self(3i32);
+    pub const CustomSensor: Self = Self(4i32);
+    pub const Gyroscope: Self = Self(5i32);
+    pub const ProximitySensor: Self = Self(6i32);
+    pub const Inclinometer: Self = Self(7i32);
+    pub const LightSensor: Self = Self(8i32);
+    pub const OrientationSensor: Self = Self(9i32);
+    pub const Pedometer: Self = Self(10i32);
+    pub const RelativeInclinometer: Self = Self(11i32);
+    pub const RelativeOrientationSensor: Self = Self(12i32);
+    pub const SimpleOrientationSensor: Self = Self(13i32);
+}
+impl ::core::marker::Copy for SensorType {}
+impl ::core::clone::Clone for SensorType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Sensors\"`*"]
+#[repr(transparent)]
+pub struct SimpleOrientation(pub i32);
+impl SimpleOrientation {
+    pub const NotRotated: Self = Self(0i32);
+    pub const Rotated90DegreesCounterclockwise: Self = Self(1i32);
+    pub const Rotated180DegreesCounterclockwise: Self = Self(2i32);
+    pub const Rotated270DegreesCounterclockwise: Self = Self(3i32);
+    pub const Faceup: Self = Self(4i32);
+    pub const Facedown: Self = Self(5i32);
+}
+impl ::core::marker::Copy for SimpleOrientation {}
+impl ::core::clone::Clone for SimpleOrientation {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type SimpleOrientationSensor = *mut ::core::ffi::c_void;
+pub type SimpleOrientationSensorOrientationChangedEventArgs = *mut ::core::ffi::c_void;
diff --git a/vendor/windows-sys/src/Windows/Devices/SerialCommunication/mod.rs b/vendor/windows-sys/src/Windows/Devices/SerialCommunication/mod.rs
new file mode 100644
index 000000000..be0061a9a
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/SerialCommunication/mod.rs
@@ -0,0 +1,80 @@
+pub type ErrorReceivedEventArgs = *mut ::core::ffi::c_void;
+pub type PinChangedEventArgs = *mut ::core::ffi::c_void;
+pub type SerialDevice = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_SerialCommunication\"`*"]
+#[repr(transparent)]
+pub struct SerialError(pub i32);
+impl SerialError {
+    pub const Frame: Self = Self(0i32);
+    pub const BufferOverrun: Self = Self(1i32);
+    pub const ReceiveFull: Self = Self(2i32);
+    pub const ReceiveParity: Self = Self(3i32);
+    pub const TransmitFull: Self = Self(4i32);
+}
+impl ::core::marker::Copy for SerialError {}
+impl ::core::clone::Clone for SerialError {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_SerialCommunication\"`*"]
+#[repr(transparent)]
+pub struct SerialHandshake(pub i32);
+impl SerialHandshake {
+    pub const None: Self = Self(0i32);
+    pub const RequestToSend: Self = Self(1i32);
+    pub const XOnXOff: Self = Self(2i32);
+    pub const RequestToSendXOnXOff: Self = Self(3i32);
+}
+impl ::core::marker::Copy for SerialHandshake {}
+impl ::core::clone::Clone for SerialHandshake {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_SerialCommunication\"`*"]
+#[repr(transparent)]
+pub struct SerialParity(pub i32);
+impl SerialParity {
+    pub const None: Self = Self(0i32);
+    pub const Odd: Self = Self(1i32);
+    pub const Even: Self = Self(2i32);
+    pub const Mark: Self = Self(3i32);
+    pub const Space: Self = Self(4i32);
+}
+impl ::core::marker::Copy for SerialParity {}
+impl ::core::clone::Clone for SerialParity {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_SerialCommunication\"`*"]
+#[repr(transparent)]
+pub struct SerialPinChange(pub i32);
+impl SerialPinChange {
+    pub const BreakSignal: Self = Self(0i32);
+    pub const CarrierDetect: Self = Self(1i32);
+    pub const ClearToSend: Self = Self(2i32);
+    pub const DataSetReady: Self = Self(3i32);
+    pub const RingIndicator: Self = Self(4i32);
+}
+impl ::core::marker::Copy for SerialPinChange {}
+impl ::core::clone::Clone for SerialPinChange {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_SerialCommunication\"`*"]
+#[repr(transparent)]
+pub struct SerialStopBitCount(pub i32);
+impl SerialStopBitCount {
+    pub const One: Self = Self(0i32);
+    pub const OnePointFive: Self = Self(1i32);
+    pub const Two: Self = Self(2i32);
+}
+impl ::core::marker::Copy for SerialStopBitCount {}
+impl ::core::clone::Clone for SerialStopBitCount {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/vendor/windows-sys/src/Windows/Devices/SmartCards/mod.rs b/vendor/windows-sys/src/Windows/Devices/SmartCards/mod.rs
new file mode 100644
index 000000000..abb373a4c
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/SmartCards/mod.rs
@@ -0,0 +1,403 @@
+pub type CardAddedEventArgs = *mut ::core::ffi::c_void;
+pub type CardRemovedEventArgs = *mut ::core::ffi::c_void;
+pub type SmartCard = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_SmartCards\"`*"]
+#[repr(transparent)]
+pub struct SmartCardActivationPolicyChangeResult(pub i32);
+impl SmartCardActivationPolicyChangeResult {
+    pub const Denied: Self = Self(0i32);
+    pub const Allowed: Self = Self(1i32);
+}
+impl ::core::marker::Copy for SmartCardActivationPolicyChangeResult {}
+impl ::core::clone::Clone for SmartCardActivationPolicyChangeResult {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type SmartCardAppletIdGroup = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_SmartCards\"`*"]
+#[repr(transparent)]
+pub struct SmartCardAppletIdGroupActivationPolicy(pub i32);
+impl SmartCardAppletIdGroupActivationPolicy {
+    pub const Disabled: Self = Self(0i32);
+    pub const ForegroundOverride: Self = Self(1i32);
+    pub const Enabled: Self = Self(2i32);
+}
+impl ::core::marker::Copy for SmartCardAppletIdGroupActivationPolicy {}
+impl ::core::clone::Clone for SmartCardAppletIdGroupActivationPolicy {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type SmartCardAppletIdGroupRegistration = *mut ::core::ffi::c_void;
+pub type SmartCardAutomaticResponseApdu = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_SmartCards\"`*"]
+#[repr(transparent)]
+pub struct SmartCardAutomaticResponseStatus(pub i32);
+impl SmartCardAutomaticResponseStatus {
+    pub const None: Self = Self(0i32);
+    pub const Success: Self = Self(1i32);
+    pub const UnknownError: Self = Self(2i32);
+}
+impl ::core::marker::Copy for SmartCardAutomaticResponseStatus {}
+impl ::core::clone::Clone for SmartCardAutomaticResponseStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type SmartCardChallengeContext = *mut ::core::ffi::c_void;
+pub type SmartCardConnection = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_SmartCards\"`*"]
+#[repr(transparent)]
+pub struct SmartCardCryptogramAlgorithm(pub i32);
+impl SmartCardCryptogramAlgorithm {
+    pub const None: Self = Self(0i32);
+    pub const CbcMac: Self = Self(1i32);
+    pub const Cvc3Umd: Self = Self(2i32);
+    pub const DecimalizedMsd: Self = Self(3i32);
+    pub const Cvc3MD: Self = Self(4i32);
+    pub const Sha1: Self = Self(5i32);
+    pub const SignedDynamicApplicationData: Self = Self(6i32);
+    pub const RsaPkcs1: Self = Self(7i32);
+    pub const Sha256Hmac: Self = Self(8i32);
+}
+impl ::core::marker::Copy for SmartCardCryptogramAlgorithm {}
+impl ::core::clone::Clone for SmartCardCryptogramAlgorithm {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type SmartCardCryptogramGenerator = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_SmartCards\"`*"]
+#[repr(transparent)]
+pub struct SmartCardCryptogramGeneratorOperationStatus(pub i32);
+impl SmartCardCryptogramGeneratorOperationStatus {
+    pub const Success: Self = Self(0i32);
+    pub const AuthorizationFailed: Self = Self(1i32);
+    pub const AuthorizationCanceled: Self = Self(2i32);
+    pub const AuthorizationRequired: Self = Self(3i32);
+    pub const CryptogramMaterialPackageStorageKeyExists: Self = Self(4i32);
+    pub const NoCryptogramMaterialPackageStorageKey: Self = Self(5i32);
+    pub const NoCryptogramMaterialPackage: Self = Self(6i32);
+    pub const UnsupportedCryptogramMaterialPackage: Self = Self(7i32);
+    pub const UnknownCryptogramMaterialName: Self = Self(8i32);
+    pub const InvalidCryptogramMaterialUsage: Self = Self(9i32);
+    pub const ApduResponseNotSent: Self = Self(10i32);
+    pub const OtherError: Self = Self(11i32);
+    pub const ValidationFailed: Self = Self(12i32);
+    pub const NotSupported: Self = Self(13i32);
+}
+impl ::core::marker::Copy for SmartCardCryptogramGeneratorOperationStatus {}
+impl ::core::clone::Clone for SmartCardCryptogramGeneratorOperationStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type SmartCardCryptogramGetAllCryptogramMaterialCharacteristicsResult = *mut ::core::ffi::c_void;
+pub type SmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult = *mut ::core::ffi::c_void;
+pub type SmartCardCryptogramGetAllCryptogramStorageKeyCharacteristicsResult = *mut ::core::ffi::c_void;
+pub type SmartCardCryptogramMaterialCharacteristics = *mut ::core::ffi::c_void;
+pub type SmartCardCryptogramMaterialPackageCharacteristics = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_SmartCards\"`*"]
+#[repr(transparent)]
+pub struct SmartCardCryptogramMaterialPackageConfirmationResponseFormat(pub i32);
+impl SmartCardCryptogramMaterialPackageConfirmationResponseFormat {
+    pub const None: Self = Self(0i32);
+    pub const VisaHmac: Self = Self(1i32);
+}
+impl ::core::marker::Copy for SmartCardCryptogramMaterialPackageConfirmationResponseFormat {}
+impl ::core::clone::Clone for SmartCardCryptogramMaterialPackageConfirmationResponseFormat {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_SmartCards\"`*"]
+#[repr(transparent)]
+pub struct SmartCardCryptogramMaterialPackageFormat(pub i32);
+impl SmartCardCryptogramMaterialPackageFormat {
+    pub const None: Self = Self(0i32);
+    pub const JweRsaPki: Self = Self(1i32);
+}
+impl ::core::marker::Copy for SmartCardCryptogramMaterialPackageFormat {}
+impl ::core::clone::Clone for SmartCardCryptogramMaterialPackageFormat {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type SmartCardCryptogramMaterialPossessionProof = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_SmartCards\"`*"]
+#[repr(transparent)]
+pub struct SmartCardCryptogramMaterialProtectionMethod(pub i32);
+impl SmartCardCryptogramMaterialProtectionMethod {
+    pub const None: Self = Self(0i32);
+    pub const WhiteBoxing: Self = Self(1i32);
+}
+impl ::core::marker::Copy for SmartCardCryptogramMaterialProtectionMethod {}
+impl ::core::clone::Clone for SmartCardCryptogramMaterialProtectionMethod {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_SmartCards\"`*"]
+#[repr(transparent)]
+pub struct SmartCardCryptogramMaterialType(pub i32);
+impl SmartCardCryptogramMaterialType {
+    pub const None: Self = Self(0i32);
+    pub const StaticDataAuthentication: Self = Self(1i32);
+    pub const TripleDes112: Self = Self(2i32);
+    pub const Aes: Self = Self(3i32);
+    pub const RsaPkcs1: Self = Self(4i32);
+}
+impl ::core::marker::Copy for SmartCardCryptogramMaterialType {}
+impl ::core::clone::Clone for SmartCardCryptogramMaterialType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_SmartCards\"`*"]
+#[repr(transparent)]
+pub struct SmartCardCryptogramPlacementOptions(pub u32);
+impl SmartCardCryptogramPlacementOptions {
+    pub const None: Self = Self(0u32);
+    pub const UnitsAreInNibbles: Self = Self(1u32);
+    pub const ChainOutput: Self = Self(2u32);
+}
+impl ::core::marker::Copy for SmartCardCryptogramPlacementOptions {}
+impl ::core::clone::Clone for SmartCardCryptogramPlacementOptions {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type SmartCardCryptogramPlacementStep = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_SmartCards\"`*"]
+#[repr(transparent)]
+pub struct SmartCardCryptogramStorageKeyAlgorithm(pub i32);
+impl SmartCardCryptogramStorageKeyAlgorithm {
+    pub const None: Self = Self(0i32);
+    pub const Rsa2048: Self = Self(1i32);
+}
+impl ::core::marker::Copy for SmartCardCryptogramStorageKeyAlgorithm {}
+impl ::core::clone::Clone for SmartCardCryptogramStorageKeyAlgorithm {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_SmartCards\"`*"]
+#[repr(transparent)]
+pub struct SmartCardCryptogramStorageKeyCapabilities(pub u32);
+impl SmartCardCryptogramStorageKeyCapabilities {
+    pub const None: Self = Self(0u32);
+    pub const HardwareProtection: Self = Self(1u32);
+    pub const UnlockPrompt: Self = Self(2u32);
+}
+impl ::core::marker::Copy for SmartCardCryptogramStorageKeyCapabilities {}
+impl ::core::clone::Clone for SmartCardCryptogramStorageKeyCapabilities {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type SmartCardCryptogramStorageKeyCharacteristics = *mut ::core::ffi::c_void;
+pub type SmartCardCryptogramStorageKeyInfo = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_SmartCards\"`*"]
+#[repr(transparent)]
+pub struct SmartCardCryptographicKeyAttestationStatus(pub i32);
+impl SmartCardCryptographicKeyAttestationStatus {
+    pub const NoAttestation: Self = Self(0i32);
+    pub const SoftwareKeyWithoutTpm: Self = Self(1i32);
+    pub const SoftwareKeyWithTpm: Self = Self(2i32);
+    pub const TpmKeyUnknownAttestationStatus: Self = Self(3i32);
+    pub const TpmKeyWithoutAttestationCapability: Self = Self(4i32);
+    pub const TpmKeyWithTemporaryAttestationFailure: Self = Self(5i32);
+    pub const TpmKeyWithLongTermAttestationFailure: Self = Self(6i32);
+    pub const TpmKeyWithAttestation: Self = Self(7i32);
+}
+impl ::core::marker::Copy for SmartCardCryptographicKeyAttestationStatus {}
+impl ::core::clone::Clone for SmartCardCryptographicKeyAttestationStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_SmartCards\"`*"]
+#[repr(transparent)]
+pub struct SmartCardEmulationCategory(pub i32);
+impl SmartCardEmulationCategory {
+    pub const Other: Self = Self(0i32);
+    pub const Payment: Self = Self(1i32);
+}
+impl ::core::marker::Copy for SmartCardEmulationCategory {}
+impl ::core::clone::Clone for SmartCardEmulationCategory {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_SmartCards\"`*"]
+#[repr(transparent)]
+pub struct SmartCardEmulationType(pub i32);
+impl SmartCardEmulationType {
+    pub const Host: Self = Self(0i32);
+    pub const Uicc: Self = Self(1i32);
+    pub const EmbeddedSE: Self = Self(2i32);
+}
+impl ::core::marker::Copy for SmartCardEmulationType {}
+impl ::core::clone::Clone for SmartCardEmulationType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type SmartCardEmulator = *mut ::core::ffi::c_void;
+pub type SmartCardEmulatorApduReceivedEventArgs = *mut ::core::ffi::c_void;
+pub type SmartCardEmulatorConnectionDeactivatedEventArgs = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_SmartCards\"`*"]
+#[repr(transparent)]
+pub struct SmartCardEmulatorConnectionDeactivatedReason(pub i32);
+impl SmartCardEmulatorConnectionDeactivatedReason {
+    pub const ConnectionLost: Self = Self(0i32);
+    pub const ConnectionRedirected: Self = Self(1i32);
+}
+impl ::core::marker::Copy for SmartCardEmulatorConnectionDeactivatedReason {}
+impl ::core::clone::Clone for SmartCardEmulatorConnectionDeactivatedReason {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type SmartCardEmulatorConnectionProperties = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_SmartCards\"`*"]
+#[repr(transparent)]
+pub struct SmartCardEmulatorConnectionSource(pub i32);
+impl SmartCardEmulatorConnectionSource {
+    pub const Unknown: Self = Self(0i32);
+    pub const NfcReader: Self = Self(1i32);
+}
+impl ::core::marker::Copy for SmartCardEmulatorConnectionSource {}
+impl ::core::clone::Clone for SmartCardEmulatorConnectionSource {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_SmartCards\"`*"]
+#[repr(transparent)]
+pub struct SmartCardEmulatorEnablementPolicy(pub i32);
+impl SmartCardEmulatorEnablementPolicy {
+    pub const Never: Self = Self(0i32);
+    pub const Always: Self = Self(1i32);
+    pub const ScreenOn: Self = Self(2i32);
+    pub const ScreenUnlocked: Self = Self(3i32);
+}
+impl ::core::marker::Copy for SmartCardEmulatorEnablementPolicy {}
+impl ::core::clone::Clone for SmartCardEmulatorEnablementPolicy {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_SmartCards\"`*"]
+#[repr(transparent)]
+pub struct SmartCardLaunchBehavior(pub i32);
+impl SmartCardLaunchBehavior {
+    pub const Default: Self = Self(0i32);
+    pub const AboveLock: Self = Self(1i32);
+}
+impl ::core::marker::Copy for SmartCardLaunchBehavior {}
+impl ::core::clone::Clone for SmartCardLaunchBehavior {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_SmartCards\"`*"]
+#[repr(transparent)]
+pub struct SmartCardPinCharacterPolicyOption(pub i32);
+impl SmartCardPinCharacterPolicyOption {
+    pub const Allow: Self = Self(0i32);
+    pub const RequireAtLeastOne: Self = Self(1i32);
+    pub const Disallow: Self = Self(2i32);
+}
+impl ::core::marker::Copy for SmartCardPinCharacterPolicyOption {}
+impl ::core::clone::Clone for SmartCardPinCharacterPolicyOption {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type SmartCardPinPolicy = *mut ::core::ffi::c_void;
+pub type SmartCardPinResetDeferral = *mut ::core::ffi::c_void;
+pub type SmartCardPinResetHandler = *mut ::core::ffi::c_void;
+pub type SmartCardPinResetRequest = *mut ::core::ffi::c_void;
+pub type SmartCardProvisioning = *mut ::core::ffi::c_void;
+pub type SmartCardReader = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_SmartCards\"`*"]
+#[repr(transparent)]
+pub struct SmartCardReaderKind(pub i32);
+impl SmartCardReaderKind {
+    pub const Any: Self = Self(0i32);
+    pub const Generic: Self = Self(1i32);
+    pub const Tpm: Self = Self(2i32);
+    pub const Nfc: Self = Self(3i32);
+    pub const Uicc: Self = Self(4i32);
+    pub const EmbeddedSE: Self = Self(5i32);
+}
+impl ::core::marker::Copy for SmartCardReaderKind {}
+impl ::core::clone::Clone for SmartCardReaderKind {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_SmartCards\"`*"]
+#[repr(transparent)]
+pub struct SmartCardReaderStatus(pub i32);
+impl SmartCardReaderStatus {
+    pub const Disconnected: Self = Self(0i32);
+    pub const Ready: Self = Self(1i32);
+    pub const Exclusive: Self = Self(2i32);
+}
+impl ::core::marker::Copy for SmartCardReaderStatus {}
+impl ::core::clone::Clone for SmartCardReaderStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_SmartCards\"`*"]
+#[repr(transparent)]
+pub struct SmartCardStatus(pub i32);
+impl SmartCardStatus {
+    pub const Disconnected: Self = Self(0i32);
+    pub const Ready: Self = Self(1i32);
+    pub const Shared: Self = Self(2i32);
+    pub const Exclusive: Self = Self(3i32);
+    pub const Unresponsive: Self = Self(4i32);
+}
+impl ::core::marker::Copy for SmartCardStatus {}
+impl ::core::clone::Clone for SmartCardStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type SmartCardTriggerDetails = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_SmartCards\"`*"]
+#[repr(transparent)]
+pub struct SmartCardTriggerType(pub i32);
+impl SmartCardTriggerType {
+    pub const EmulatorTransaction: Self = Self(0i32);
+    pub const EmulatorNearFieldEntry: Self = Self(1i32);
+    pub const EmulatorNearFieldExit: Self = Self(2i32);
+    pub const EmulatorHostApplicationActivated: Self = Self(3i32);
+    pub const EmulatorAppletIdGroupRegistrationChanged: Self = Self(4i32);
+    pub const ReaderCardAdded: Self = Self(5i32);
+}
+impl ::core::marker::Copy for SmartCardTriggerType {}
+impl ::core::clone::Clone for SmartCardTriggerType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_SmartCards\"`*"]
+#[repr(transparent)]
+pub struct SmartCardUnlockPromptingBehavior(pub i32);
+impl SmartCardUnlockPromptingBehavior {
+    pub const AllowUnlockPrompt: Self = Self(0i32);
+    pub const RequireUnlockPrompt: Self = Self(1i32);
+    pub const PreventUnlockPrompt: Self = Self(2i32);
+}
+impl ::core::marker::Copy for SmartCardUnlockPromptingBehavior {}
+impl ::core::clone::Clone for SmartCardUnlockPromptingBehavior {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/vendor/windows-sys/src/Windows/Devices/Sms/mod.rs b/vendor/windows-sys/src/Windows/Devices/Sms/mod.rs
new file mode 100644
index 000000000..de851ea32
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/Sms/mod.rs
@@ -0,0 +1,251 @@
+#[doc = "*Required features: `\"Devices_Sms\"`*"]
+#[repr(transparent)]
+pub struct CellularClass(pub i32);
+impl CellularClass {
+    pub const None: Self = Self(0i32);
+    pub const Gsm: Self = Self(1i32);
+    pub const Cdma: Self = Self(2i32);
+}
+impl ::core::marker::Copy for CellularClass {}
+impl ::core::clone::Clone for CellularClass {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type DeleteSmsMessageOperation = *mut ::core::ffi::c_void;
+pub type DeleteSmsMessagesOperation = *mut ::core::ffi::c_void;
+pub type GetSmsDeviceOperation = *mut ::core::ffi::c_void;
+pub type GetSmsMessageOperation = *mut ::core::ffi::c_void;
+pub type GetSmsMessagesOperation = *mut ::core::ffi::c_void;
+pub type ISmsBinaryMessage = *mut ::core::ffi::c_void;
+pub type ISmsDevice = *mut ::core::ffi::c_void;
+pub type ISmsMessage = *mut ::core::ffi::c_void;
+pub type ISmsMessageBase = *mut ::core::ffi::c_void;
+pub type ISmsTextMessage = *mut ::core::ffi::c_void;
+pub type SendSmsMessageOperation = *mut ::core::ffi::c_void;
+pub type SmsAppMessage = *mut ::core::ffi::c_void;
+pub type SmsBinaryMessage = *mut ::core::ffi::c_void;
+pub type SmsBroadcastMessage = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Sms\"`*"]
+#[repr(transparent)]
+pub struct SmsBroadcastType(pub i32);
+impl SmsBroadcastType {
+    pub const Other: Self = Self(0i32);
+    pub const CmasPresidential: Self = Self(1i32);
+    pub const CmasExtreme: Self = Self(2i32);
+    pub const CmasSevere: Self = Self(3i32);
+    pub const CmasAmber: Self = Self(4i32);
+    pub const CmasTest: Self = Self(5i32);
+    pub const EUAlert1: Self = Self(6i32);
+    pub const EUAlert2: Self = Self(7i32);
+    pub const EUAlert3: Self = Self(8i32);
+    pub const EUAlertAmber: Self = Self(9i32);
+    pub const EUAlertInfo: Self = Self(10i32);
+    pub const EtwsEarthquake: Self = Self(11i32);
+    pub const EtwsTsunami: Self = Self(12i32);
+    pub const EtwsTsunamiAndEarthquake: Self = Self(13i32);
+    pub const LatAlertLocal: Self = Self(14i32);
+}
+impl ::core::marker::Copy for SmsBroadcastType {}
+impl ::core::clone::Clone for SmsBroadcastType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Sms\"`*"]
+#[repr(transparent)]
+pub struct SmsDataFormat(pub i32);
+impl SmsDataFormat {
+    pub const Unknown: Self = Self(0i32);
+    pub const CdmaSubmit: Self = Self(1i32);
+    pub const GsmSubmit: Self = Self(2i32);
+    pub const CdmaDeliver: Self = Self(3i32);
+    pub const GsmDeliver: Self = Self(4i32);
+}
+impl ::core::marker::Copy for SmsDataFormat {}
+impl ::core::clone::Clone for SmsDataFormat {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type SmsDevice = *mut ::core::ffi::c_void;
+pub type SmsDevice2 = *mut ::core::ffi::c_void;
+pub type SmsDeviceMessageStore = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Sms\"`*"]
+#[repr(transparent)]
+pub struct SmsDeviceStatus(pub i32);
+impl SmsDeviceStatus {
+    pub const Off: Self = Self(0i32);
+    pub const Ready: Self = Self(1i32);
+    pub const SimNotInserted: Self = Self(2i32);
+    pub const BadSim: Self = Self(3i32);
+    pub const DeviceFailure: Self = Self(4i32);
+    pub const SubscriptionNotActivated: Self = Self(5i32);
+    pub const DeviceLocked: Self = Self(6i32);
+    pub const DeviceBlocked: Self = Self(7i32);
+}
+impl ::core::marker::Copy for SmsDeviceStatus {}
+impl ::core::clone::Clone for SmsDeviceStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type SmsDeviceStatusChangedEventHandler = *mut ::core::ffi::c_void;
+#[repr(C)]
+#[doc = "*Required features: `\"Devices_Sms\"`*"]
+pub struct SmsEncodedLength {
+    pub SegmentCount: u32,
+    pub CharacterCountLastSegment: u32,
+    pub CharactersPerSegment: u32,
+    pub ByteCountLastSegment: u32,
+    pub BytesPerSegment: u32,
+}
+impl ::core::marker::Copy for SmsEncodedLength {}
+impl ::core::clone::Clone for SmsEncodedLength {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Sms\"`*"]
+#[repr(transparent)]
+pub struct SmsEncoding(pub i32);
+impl SmsEncoding {
+    pub const Unknown: Self = Self(0i32);
+    pub const Optimal: Self = Self(1i32);
+    pub const SevenBitAscii: Self = Self(2i32);
+    pub const Unicode: Self = Self(3i32);
+    pub const GsmSevenBit: Self = Self(4i32);
+    pub const EightBit: Self = Self(5i32);
+    pub const Latin: Self = Self(6i32);
+    pub const Korean: Self = Self(7i32);
+    pub const IA5: Self = Self(8i32);
+    pub const ShiftJis: Self = Self(9i32);
+    pub const LatinHebrew: Self = Self(10i32);
+}
+impl ::core::marker::Copy for SmsEncoding {}
+impl ::core::clone::Clone for SmsEncoding {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Sms\"`*"]
+#[repr(transparent)]
+pub struct SmsFilterActionType(pub i32);
+impl SmsFilterActionType {
+    pub const AcceptImmediately: Self = Self(0i32);
+    pub const Drop: Self = Self(1i32);
+    pub const Peek: Self = Self(2i32);
+    pub const Accept: Self = Self(3i32);
+}
+impl ::core::marker::Copy for SmsFilterActionType {}
+impl ::core::clone::Clone for SmsFilterActionType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type SmsFilterRule = *mut ::core::ffi::c_void;
+pub type SmsFilterRules = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Sms\"`*"]
+#[repr(transparent)]
+pub struct SmsGeographicalScope(pub i32);
+impl SmsGeographicalScope {
+    pub const None: Self = Self(0i32);
+    pub const CellWithImmediateDisplay: Self = Self(1i32);
+    pub const LocationArea: Self = Self(2i32);
+    pub const Plmn: Self = Self(3i32);
+    pub const Cell: Self = Self(4i32);
+}
+impl ::core::marker::Copy for SmsGeographicalScope {}
+impl ::core::clone::Clone for SmsGeographicalScope {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Sms\"`*"]
+#[repr(transparent)]
+pub struct SmsMessageClass(pub i32);
+impl SmsMessageClass {
+    pub const None: Self = Self(0i32);
+    pub const Class0: Self = Self(1i32);
+    pub const Class1: Self = Self(2i32);
+    pub const Class2: Self = Self(3i32);
+    pub const Class3: Self = Self(4i32);
+}
+impl ::core::marker::Copy for SmsMessageClass {}
+impl ::core::clone::Clone for SmsMessageClass {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Sms\"`, `\"deprecated\"`*"]
+#[cfg(feature = "deprecated")]
+#[repr(transparent)]
+pub struct SmsMessageFilter(pub i32);
+#[cfg(feature = "deprecated")]
+impl SmsMessageFilter {
+    pub const All: Self = Self(0i32);
+    pub const Unread: Self = Self(1i32);
+    pub const Read: Self = Self(2i32);
+    pub const Sent: Self = Self(3i32);
+    pub const Draft: Self = Self(4i32);
+}
+#[cfg(feature = "deprecated")]
+impl ::core::marker::Copy for SmsMessageFilter {}
+#[cfg(feature = "deprecated")]
+impl ::core::clone::Clone for SmsMessageFilter {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type SmsMessageReceivedEventArgs = *mut ::core::ffi::c_void;
+pub type SmsMessageReceivedEventHandler = *mut ::core::ffi::c_void;
+pub type SmsMessageReceivedTriggerDetails = *mut ::core::ffi::c_void;
+pub type SmsMessageRegistration = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Sms\"`*"]
+#[repr(transparent)]
+pub struct SmsMessageType(pub i32);
+impl SmsMessageType {
+    pub const Binary: Self = Self(0i32);
+    pub const Text: Self = Self(1i32);
+    pub const Wap: Self = Self(2i32);
+    pub const App: Self = Self(3i32);
+    pub const Broadcast: Self = Self(4i32);
+    pub const Voicemail: Self = Self(5i32);
+    pub const Status: Self = Self(6i32);
+}
+impl ::core::marker::Copy for SmsMessageType {}
+impl ::core::clone::Clone for SmsMessageType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Sms\"`*"]
+#[repr(transparent)]
+pub struct SmsModemErrorCode(pub i32);
+impl SmsModemErrorCode {
+    pub const Other: Self = Self(0i32);
+    pub const MessagingNetworkError: Self = Self(1i32);
+    pub const SmsOperationNotSupportedByDevice: Self = Self(2i32);
+    pub const SmsServiceNotSupportedByNetwork: Self = Self(3i32);
+    pub const DeviceFailure: Self = Self(4i32);
+    pub const MessageNotEncodedProperly: Self = Self(5i32);
+    pub const MessageTooLarge: Self = Self(6i32);
+    pub const DeviceNotReady: Self = Self(7i32);
+    pub const NetworkNotReady: Self = Self(8i32);
+    pub const InvalidSmscAddress: Self = Self(9i32);
+    pub const NetworkFailure: Self = Self(10i32);
+    pub const FixedDialingNumberRestricted: Self = Self(11i32);
+}
+impl ::core::marker::Copy for SmsModemErrorCode {}
+impl ::core::clone::Clone for SmsModemErrorCode {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type SmsReceivedEventDetails = *mut ::core::ffi::c_void;
+pub type SmsSendMessageResult = *mut ::core::ffi::c_void;
+pub type SmsStatusMessage = *mut ::core::ffi::c_void;
+pub type SmsTextMessage = *mut ::core::ffi::c_void;
+pub type SmsTextMessage2 = *mut ::core::ffi::c_void;
+pub type SmsVoicemailMessage = *mut ::core::ffi::c_void;
+pub type SmsWapMessage = *mut ::core::ffi::c_void;
diff --git a/vendor/windows-sys/src/Windows/Devices/Spi/Provider/mod.rs b/vendor/windows-sys/src/Windows/Devices/Spi/Provider/mod.rs
new file mode 100644
index 000000000..d1d28e99f
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/Spi/Provider/mod.rs
@@ -0,0 +1,32 @@
+pub type ISpiControllerProvider = *mut ::core::ffi::c_void;
+pub type ISpiDeviceProvider = *mut ::core::ffi::c_void;
+pub type ISpiProvider = *mut ::core::ffi::c_void;
+pub type ProviderSpiConnectionSettings = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Spi_Provider\"`*"]
+#[repr(transparent)]
+pub struct ProviderSpiMode(pub i32);
+impl ProviderSpiMode {
+    pub const Mode0: Self = Self(0i32);
+    pub const Mode1: Self = Self(1i32);
+    pub const Mode2: Self = Self(2i32);
+    pub const Mode3: Self = Self(3i32);
+}
+impl ::core::marker::Copy for ProviderSpiMode {}
+impl ::core::clone::Clone for ProviderSpiMode {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Spi_Provider\"`*"]
+#[repr(transparent)]
+pub struct ProviderSpiSharingMode(pub i32);
+impl ProviderSpiSharingMode {
+    pub const Exclusive: Self = Self(0i32);
+    pub const Shared: Self = Self(1i32);
+}
+impl ::core::marker::Copy for ProviderSpiSharingMode {}
+impl ::core::clone::Clone for ProviderSpiSharingMode {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/vendor/windows-sys/src/Windows/Devices/Spi/mod.rs b/vendor/windows-sys/src/Windows/Devices/Spi/mod.rs
new file mode 100644
index 000000000..772c9e75e
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/Spi/mod.rs
@@ -0,0 +1,35 @@
+#[cfg(feature = "Devices_Spi_Provider")]
+pub mod Provider;
+pub type ISpiDeviceStatics = *mut ::core::ffi::c_void;
+pub type SpiBusInfo = *mut ::core::ffi::c_void;
+pub type SpiConnectionSettings = *mut ::core::ffi::c_void;
+pub type SpiController = *mut ::core::ffi::c_void;
+pub type SpiDevice = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Spi\"`*"]
+#[repr(transparent)]
+pub struct SpiMode(pub i32);
+impl SpiMode {
+    pub const Mode0: Self = Self(0i32);
+    pub const Mode1: Self = Self(1i32);
+    pub const Mode2: Self = Self(2i32);
+    pub const Mode3: Self = Self(3i32);
+}
+impl ::core::marker::Copy for SpiMode {}
+impl ::core::clone::Clone for SpiMode {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Spi\"`*"]
+#[repr(transparent)]
+pub struct SpiSharingMode(pub i32);
+impl SpiSharingMode {
+    pub const Exclusive: Self = Self(0i32);
+    pub const Shared: Self = Self(1i32);
+}
+impl ::core::marker::Copy for SpiSharingMode {}
+impl ::core::clone::Clone for SpiSharingMode {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/vendor/windows-sys/src/Windows/Devices/Usb/mod.rs b/vendor/windows-sys/src/Windows/Devices/Usb/mod.rs
new file mode 100644
index 000000000..69b329c09
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/Usb/mod.rs
@@ -0,0 +1,110 @@
+pub type UsbBulkInEndpointDescriptor = *mut ::core::ffi::c_void;
+pub type UsbBulkInPipe = *mut ::core::ffi::c_void;
+pub type UsbBulkOutEndpointDescriptor = *mut ::core::ffi::c_void;
+pub type UsbBulkOutPipe = *mut ::core::ffi::c_void;
+pub type UsbConfiguration = *mut ::core::ffi::c_void;
+pub type UsbConfigurationDescriptor = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Usb\"`*"]
+#[repr(transparent)]
+pub struct UsbControlRecipient(pub i32);
+impl UsbControlRecipient {
+    pub const Device: Self = Self(0i32);
+    pub const SpecifiedInterface: Self = Self(1i32);
+    pub const Endpoint: Self = Self(2i32);
+    pub const Other: Self = Self(3i32);
+    pub const DefaultInterface: Self = Self(4i32);
+}
+impl ::core::marker::Copy for UsbControlRecipient {}
+impl ::core::clone::Clone for UsbControlRecipient {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type UsbControlRequestType = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Usb\"`*"]
+#[repr(transparent)]
+pub struct UsbControlTransferType(pub i32);
+impl UsbControlTransferType {
+    pub const Standard: Self = Self(0i32);
+    pub const Class: Self = Self(1i32);
+    pub const Vendor: Self = Self(2i32);
+}
+impl ::core::marker::Copy for UsbControlTransferType {}
+impl ::core::clone::Clone for UsbControlTransferType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type UsbDescriptor = *mut ::core::ffi::c_void;
+pub type UsbDevice = *mut ::core::ffi::c_void;
+pub type UsbDeviceClass = *mut ::core::ffi::c_void;
+pub type UsbDeviceClasses = *mut ::core::ffi::c_void;
+pub type UsbDeviceDescriptor = *mut ::core::ffi::c_void;
+pub type UsbEndpointDescriptor = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Usb\"`*"]
+#[repr(transparent)]
+pub struct UsbEndpointType(pub i32);
+impl UsbEndpointType {
+    pub const Control: Self = Self(0i32);
+    pub const Isochronous: Self = Self(1i32);
+    pub const Bulk: Self = Self(2i32);
+    pub const Interrupt: Self = Self(3i32);
+}
+impl ::core::marker::Copy for UsbEndpointType {}
+impl ::core::clone::Clone for UsbEndpointType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type UsbInterface = *mut ::core::ffi::c_void;
+pub type UsbInterfaceDescriptor = *mut ::core::ffi::c_void;
+pub type UsbInterfaceSetting = *mut ::core::ffi::c_void;
+pub type UsbInterruptInEndpointDescriptor = *mut ::core::ffi::c_void;
+pub type UsbInterruptInEventArgs = *mut ::core::ffi::c_void;
+pub type UsbInterruptInPipe = *mut ::core::ffi::c_void;
+pub type UsbInterruptOutEndpointDescriptor = *mut ::core::ffi::c_void;
+pub type UsbInterruptOutPipe = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Usb\"`*"]
+#[repr(transparent)]
+pub struct UsbReadOptions(pub u32);
+impl UsbReadOptions {
+    pub const None: Self = Self(0u32);
+    pub const AutoClearStall: Self = Self(1u32);
+    pub const OverrideAutomaticBufferManagement: Self = Self(2u32);
+    pub const IgnoreShortPacket: Self = Self(4u32);
+    pub const AllowPartialReads: Self = Self(8u32);
+}
+impl ::core::marker::Copy for UsbReadOptions {}
+impl ::core::clone::Clone for UsbReadOptions {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type UsbSetupPacket = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_Usb\"`*"]
+#[repr(transparent)]
+pub struct UsbTransferDirection(pub i32);
+impl UsbTransferDirection {
+    pub const Out: Self = Self(0i32);
+    pub const In: Self = Self(1i32);
+}
+impl ::core::marker::Copy for UsbTransferDirection {}
+impl ::core::clone::Clone for UsbTransferDirection {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_Usb\"`*"]
+#[repr(transparent)]
+pub struct UsbWriteOptions(pub u32);
+impl UsbWriteOptions {
+    pub const None: Self = Self(0u32);
+    pub const AutoClearStall: Self = Self(1u32);
+    pub const ShortPacketTerminate: Self = Self(2u32);
+}
+impl ::core::marker::Copy for UsbWriteOptions {}
+impl ::core::clone::Clone for UsbWriteOptions {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/vendor/windows-sys/src/Windows/Devices/WiFi/mod.rs b/vendor/windows-sys/src/Windows/Devices/WiFi/mod.rs
new file mode 100644
index 000000000..1b028e940
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/WiFi/mod.rs
@@ -0,0 +1,132 @@
+#[doc = "*Required features: `\"Devices_WiFi\"`*"]
+#[repr(transparent)]
+pub struct WiFiAccessStatus(pub i32);
+impl WiFiAccessStatus {
+    pub const Unspecified: Self = Self(0i32);
+    pub const Allowed: Self = Self(1i32);
+    pub const DeniedByUser: Self = Self(2i32);
+    pub const DeniedBySystem: Self = Self(3i32);
+}
+impl ::core::marker::Copy for WiFiAccessStatus {}
+impl ::core::clone::Clone for WiFiAccessStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type WiFiAdapter = *mut ::core::ffi::c_void;
+pub type WiFiAvailableNetwork = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_WiFi\"`*"]
+#[repr(transparent)]
+pub struct WiFiConnectionMethod(pub i32);
+impl WiFiConnectionMethod {
+    pub const Default: Self = Self(0i32);
+    pub const WpsPin: Self = Self(1i32);
+    pub const WpsPushButton: Self = Self(2i32);
+}
+impl ::core::marker::Copy for WiFiConnectionMethod {}
+impl ::core::clone::Clone for WiFiConnectionMethod {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type WiFiConnectionResult = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_WiFi\"`*"]
+#[repr(transparent)]
+pub struct WiFiConnectionStatus(pub i32);
+impl WiFiConnectionStatus {
+    pub const UnspecifiedFailure: Self = Self(0i32);
+    pub const Success: Self = Self(1i32);
+    pub const AccessRevoked: Self = Self(2i32);
+    pub const InvalidCredential: Self = Self(3i32);
+    pub const NetworkNotAvailable: Self = Self(4i32);
+    pub const Timeout: Self = Self(5i32);
+    pub const UnsupportedAuthenticationProtocol: Self = Self(6i32);
+}
+impl ::core::marker::Copy for WiFiConnectionStatus {}
+impl ::core::clone::Clone for WiFiConnectionStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_WiFi\"`*"]
+#[repr(transparent)]
+pub struct WiFiNetworkKind(pub i32);
+impl WiFiNetworkKind {
+    pub const Any: Self = Self(0i32);
+    pub const Infrastructure: Self = Self(1i32);
+    pub const Adhoc: Self = Self(2i32);
+}
+impl ::core::marker::Copy for WiFiNetworkKind {}
+impl ::core::clone::Clone for WiFiNetworkKind {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type WiFiNetworkReport = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_WiFi\"`*"]
+#[repr(transparent)]
+pub struct WiFiPhyKind(pub i32);
+impl WiFiPhyKind {
+    pub const Unknown: Self = Self(0i32);
+    pub const Fhss: Self = Self(1i32);
+    pub const Dsss: Self = Self(2i32);
+    pub const IRBaseband: Self = Self(3i32);
+    pub const Ofdm: Self = Self(4i32);
+    pub const Hrdsss: Self = Self(5i32);
+    pub const Erp: Self = Self(6i32);
+    pub const HT: Self = Self(7i32);
+    pub const Vht: Self = Self(8i32);
+    pub const Dmg: Self = Self(9i32);
+    pub const HE: Self = Self(10i32);
+}
+impl ::core::marker::Copy for WiFiPhyKind {}
+impl ::core::clone::Clone for WiFiPhyKind {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_WiFi\"`*"]
+#[repr(transparent)]
+pub struct WiFiReconnectionKind(pub i32);
+impl WiFiReconnectionKind {
+    pub const Automatic: Self = Self(0i32);
+    pub const Manual: Self = Self(1i32);
+}
+impl ::core::marker::Copy for WiFiReconnectionKind {}
+impl ::core::clone::Clone for WiFiReconnectionKind {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type WiFiWpsConfigurationResult = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_WiFi\"`*"]
+#[repr(transparent)]
+pub struct WiFiWpsConfigurationStatus(pub i32);
+impl WiFiWpsConfigurationStatus {
+    pub const UnspecifiedFailure: Self = Self(0i32);
+    pub const Success: Self = Self(1i32);
+    pub const Timeout: Self = Self(2i32);
+}
+impl ::core::marker::Copy for WiFiWpsConfigurationStatus {}
+impl ::core::clone::Clone for WiFiWpsConfigurationStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_WiFi\"`*"]
+#[repr(transparent)]
+pub struct WiFiWpsKind(pub i32);
+impl WiFiWpsKind {
+    pub const Unknown: Self = Self(0i32);
+    pub const Pin: Self = Self(1i32);
+    pub const PushButton: Self = Self(2i32);
+    pub const Nfc: Self = Self(3i32);
+    pub const Ethernet: Self = Self(4i32);
+    pub const Usb: Self = Self(5i32);
+}
+impl ::core::marker::Copy for WiFiWpsKind {}
+impl ::core::clone::Clone for WiFiWpsKind {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/vendor/windows-sys/src/Windows/Devices/WiFiDirect/Services/mod.rs b/vendor/windows-sys/src/Windows/Devices/WiFiDirect/Services/mod.rs
new file mode 100644
index 000000000..ff24e85d3
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/WiFiDirect/Services/mod.rs
@@ -0,0 +1,113 @@
+pub type WiFiDirectService = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_WiFiDirect_Services\"`*"]
+#[repr(transparent)]
+pub struct WiFiDirectServiceAdvertisementStatus(pub i32);
+impl WiFiDirectServiceAdvertisementStatus {
+    pub const Created: Self = Self(0i32);
+    pub const Started: Self = Self(1i32);
+    pub const Stopped: Self = Self(2i32);
+    pub const Aborted: Self = Self(3i32);
+}
+impl ::core::marker::Copy for WiFiDirectServiceAdvertisementStatus {}
+impl ::core::clone::Clone for WiFiDirectServiceAdvertisementStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type WiFiDirectServiceAdvertiser = *mut ::core::ffi::c_void;
+pub type WiFiDirectServiceAutoAcceptSessionConnectedEventArgs = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_WiFiDirect_Services\"`*"]
+#[repr(transparent)]
+pub struct WiFiDirectServiceConfigurationMethod(pub i32);
+impl WiFiDirectServiceConfigurationMethod {
+    pub const Default: Self = Self(0i32);
+    pub const PinDisplay: Self = Self(1i32);
+    pub const PinEntry: Self = Self(2i32);
+}
+impl ::core::marker::Copy for WiFiDirectServiceConfigurationMethod {}
+impl ::core::clone::Clone for WiFiDirectServiceConfigurationMethod {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_WiFiDirect_Services\"`*"]
+#[repr(transparent)]
+pub struct WiFiDirectServiceError(pub i32);
+impl WiFiDirectServiceError {
+    pub const Success: Self = Self(0i32);
+    pub const RadioNotAvailable: Self = Self(1i32);
+    pub const ResourceInUse: Self = Self(2i32);
+    pub const UnsupportedHardware: Self = Self(3i32);
+    pub const NoHardware: Self = Self(4i32);
+}
+impl ::core::marker::Copy for WiFiDirectServiceError {}
+impl ::core::clone::Clone for WiFiDirectServiceError {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_WiFiDirect_Services\"`*"]
+#[repr(transparent)]
+pub struct WiFiDirectServiceIPProtocol(pub i32);
+impl WiFiDirectServiceIPProtocol {
+    pub const Tcp: Self = Self(6i32);
+    pub const Udp: Self = Self(17i32);
+}
+impl ::core::marker::Copy for WiFiDirectServiceIPProtocol {}
+impl ::core::clone::Clone for WiFiDirectServiceIPProtocol {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type WiFiDirectServiceProvisioningInfo = *mut ::core::ffi::c_void;
+pub type WiFiDirectServiceRemotePortAddedEventArgs = *mut ::core::ffi::c_void;
+pub type WiFiDirectServiceSession = *mut ::core::ffi::c_void;
+pub type WiFiDirectServiceSessionDeferredEventArgs = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_WiFiDirect_Services\"`*"]
+#[repr(transparent)]
+pub struct WiFiDirectServiceSessionErrorStatus(pub i32);
+impl WiFiDirectServiceSessionErrorStatus {
+    pub const Ok: Self = Self(0i32);
+    pub const Disassociated: Self = Self(1i32);
+    pub const LocalClose: Self = Self(2i32);
+    pub const RemoteClose: Self = Self(3i32);
+    pub const SystemFailure: Self = Self(4i32);
+    pub const NoResponseFromRemote: Self = Self(5i32);
+}
+impl ::core::marker::Copy for WiFiDirectServiceSessionErrorStatus {}
+impl ::core::clone::Clone for WiFiDirectServiceSessionErrorStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type WiFiDirectServiceSessionRequest = *mut ::core::ffi::c_void;
+pub type WiFiDirectServiceSessionRequestedEventArgs = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_WiFiDirect_Services\"`*"]
+#[repr(transparent)]
+pub struct WiFiDirectServiceSessionStatus(pub i32);
+impl WiFiDirectServiceSessionStatus {
+    pub const Closed: Self = Self(0i32);
+    pub const Initiated: Self = Self(1i32);
+    pub const Requested: Self = Self(2i32);
+    pub const Open: Self = Self(3i32);
+}
+impl ::core::marker::Copy for WiFiDirectServiceSessionStatus {}
+impl ::core::clone::Clone for WiFiDirectServiceSessionStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_WiFiDirect_Services\"`*"]
+#[repr(transparent)]
+pub struct WiFiDirectServiceStatus(pub i32);
+impl WiFiDirectServiceStatus {
+    pub const Available: Self = Self(0i32);
+    pub const Busy: Self = Self(1i32);
+    pub const Custom: Self = Self(2i32);
+}
+impl ::core::marker::Copy for WiFiDirectServiceStatus {}
+impl ::core::clone::Clone for WiFiDirectServiceStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/vendor/windows-sys/src/Windows/Devices/WiFiDirect/mod.rs b/vendor/windows-sys/src/Windows/Devices/WiFiDirect/mod.rs
new file mode 100644
index 000000000..6baf63e15
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/WiFiDirect/mod.rs
@@ -0,0 +1,108 @@
+#[cfg(feature = "Devices_WiFiDirect_Services")]
+pub mod Services;
+pub type WiFiDirectAdvertisement = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_WiFiDirect\"`*"]
+#[repr(transparent)]
+pub struct WiFiDirectAdvertisementListenStateDiscoverability(pub i32);
+impl WiFiDirectAdvertisementListenStateDiscoverability {
+    pub const None: Self = Self(0i32);
+    pub const Normal: Self = Self(1i32);
+    pub const Intensive: Self = Self(2i32);
+}
+impl ::core::marker::Copy for WiFiDirectAdvertisementListenStateDiscoverability {}
+impl ::core::clone::Clone for WiFiDirectAdvertisementListenStateDiscoverability {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type WiFiDirectAdvertisementPublisher = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_WiFiDirect\"`*"]
+#[repr(transparent)]
+pub struct WiFiDirectAdvertisementPublisherStatus(pub i32);
+impl WiFiDirectAdvertisementPublisherStatus {
+    pub const Created: Self = Self(0i32);
+    pub const Started: Self = Self(1i32);
+    pub const Stopped: Self = Self(2i32);
+    pub const Aborted: Self = Self(3i32);
+}
+impl ::core::marker::Copy for WiFiDirectAdvertisementPublisherStatus {}
+impl ::core::clone::Clone for WiFiDirectAdvertisementPublisherStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type WiFiDirectAdvertisementPublisherStatusChangedEventArgs = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_WiFiDirect\"`*"]
+#[repr(transparent)]
+pub struct WiFiDirectConfigurationMethod(pub i32);
+impl WiFiDirectConfigurationMethod {
+    pub const ProvidePin: Self = Self(0i32);
+    pub const DisplayPin: Self = Self(1i32);
+    pub const PushButton: Self = Self(2i32);
+}
+impl ::core::marker::Copy for WiFiDirectConfigurationMethod {}
+impl ::core::clone::Clone for WiFiDirectConfigurationMethod {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type WiFiDirectConnectionListener = *mut ::core::ffi::c_void;
+pub type WiFiDirectConnectionParameters = *mut ::core::ffi::c_void;
+pub type WiFiDirectConnectionRequest = *mut ::core::ffi::c_void;
+pub type WiFiDirectConnectionRequestedEventArgs = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_WiFiDirect\"`*"]
+#[repr(transparent)]
+pub struct WiFiDirectConnectionStatus(pub i32);
+impl WiFiDirectConnectionStatus {
+    pub const Disconnected: Self = Self(0i32);
+    pub const Connected: Self = Self(1i32);
+}
+impl ::core::marker::Copy for WiFiDirectConnectionStatus {}
+impl ::core::clone::Clone for WiFiDirectConnectionStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type WiFiDirectDevice = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_WiFiDirect\"`*"]
+#[repr(transparent)]
+pub struct WiFiDirectDeviceSelectorType(pub i32);
+impl WiFiDirectDeviceSelectorType {
+    pub const DeviceInterface: Self = Self(0i32);
+    pub const AssociationEndpoint: Self = Self(1i32);
+}
+impl ::core::marker::Copy for WiFiDirectDeviceSelectorType {}
+impl ::core::clone::Clone for WiFiDirectDeviceSelectorType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Devices_WiFiDirect\"`*"]
+#[repr(transparent)]
+pub struct WiFiDirectError(pub i32);
+impl WiFiDirectError {
+    pub const Success: Self = Self(0i32);
+    pub const RadioNotAvailable: Self = Self(1i32);
+    pub const ResourceInUse: Self = Self(2i32);
+}
+impl ::core::marker::Copy for WiFiDirectError {}
+impl ::core::clone::Clone for WiFiDirectError {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type WiFiDirectInformationElement = *mut ::core::ffi::c_void;
+pub type WiFiDirectLegacySettings = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Devices_WiFiDirect\"`*"]
+#[repr(transparent)]
+pub struct WiFiDirectPairingProcedure(pub i32);
+impl WiFiDirectPairingProcedure {
+    pub const GroupOwnerNegotiation: Self = Self(0i32);
+    pub const Invitation: Self = Self(1i32);
+}
+impl ::core::marker::Copy for WiFiDirectPairingProcedure {}
+impl ::core::clone::Clone for WiFiDirectPairingProcedure {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/vendor/windows-sys/src/Windows/Devices/mod.rs b/vendor/windows-sys/src/Windows/Devices/mod.rs
new file mode 100644
index 000000000..130d2acc6
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Devices/mod.rs
@@ -0,0 +1,65 @@
+#[cfg(feature = "Devices_Adc")]
+pub mod Adc;
+#[cfg(feature = "Devices_AllJoyn")]
+pub mod AllJoyn;
+#[cfg(feature = "Devices_Background")]
+pub mod Background;
+#[cfg(feature = "Devices_Bluetooth")]
+pub mod Bluetooth;
+#[cfg(feature = "Devices_Custom")]
+pub mod Custom;
+#[cfg(feature = "Devices_Display")]
+pub mod Display;
+#[cfg(feature = "Devices_Enumeration")]
+pub mod Enumeration;
+#[cfg(feature = "Devices_Geolocation")]
+pub mod Geolocation;
+#[cfg(feature = "Devices_Gpio")]
+pub mod Gpio;
+#[cfg(feature = "Devices_Haptics")]
+pub mod Haptics;
+#[cfg(feature = "Devices_HumanInterfaceDevice")]
+pub mod HumanInterfaceDevice;
+#[cfg(feature = "Devices_I2c")]
+pub mod I2c;
+#[cfg(feature = "Devices_Input")]
+pub mod Input;
+#[cfg(feature = "Devices_Lights")]
+pub mod Lights;
+#[cfg(feature = "Devices_Midi")]
+pub mod Midi;
+#[cfg(feature = "Devices_Perception")]
+pub mod Perception;
+#[cfg(feature = "Devices_PointOfService")]
+pub mod PointOfService;
+#[cfg(feature = "Devices_Portable")]
+pub mod Portable;
+#[cfg(feature = "Devices_Power")]
+pub mod Power;
+#[cfg(feature = "Devices_Printers")]
+pub mod Printers;
+#[cfg(feature = "Devices_Pwm")]
+pub mod Pwm;
+#[cfg(feature = "Devices_Radios")]
+pub mod Radios;
+#[cfg(feature = "Devices_Scanners")]
+pub mod Scanners;
+#[cfg(feature = "Devices_Sensors")]
+pub mod Sensors;
+#[cfg(feature = "Devices_SerialCommunication")]
+pub mod SerialCommunication;
+#[cfg(feature = "Devices_SmartCards")]
+pub mod SmartCards;
+#[cfg(feature = "Devices_Sms")]
+pub mod Sms;
+#[cfg(feature = "Devices_Spi")]
+pub mod Spi;
+#[cfg(feature = "Devices_Usb")]
+pub mod Usb;
+#[cfg(feature = "Devices_WiFi")]
+pub mod WiFi;
+#[cfg(feature = "Devices_WiFiDirect")]
+pub mod WiFiDirect;
+pub type ILowLevelDevicesAggregateProvider = *mut ::core::ffi::c_void;
+pub type LowLevelDevicesAggregateProvider = *mut ::core::ffi::c_void;
+pub type LowLevelDevicesController = *mut ::core::ffi::c_void;