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

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

11 files changed, 1905 insertions, 0 deletions

diff --git a/vendor/windows-sys/src/Windows/Networking/BackgroundTransfer/mod.rs b/vendor/windows-sys/src/Windows/Networking/BackgroundTransfer/mod.rs
new file mode 100644
index 000000000..150797ca2
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Networking/BackgroundTransfer/mod.rs
@@ -0,0 +1,121 @@
+#[repr(C)]
+#[doc = "*Required features: `\"Networking_BackgroundTransfer\"`*"]
+pub struct BackgroundDownloadProgress {
+    pub BytesReceived: u64,
+    pub TotalBytesToReceive: u64,
+    pub Status: BackgroundTransferStatus,
+    pub HasResponseChanged: bool,
+    pub HasRestarted: bool,
+}
+impl ::core::marker::Copy for BackgroundDownloadProgress {}
+impl ::core::clone::Clone for BackgroundDownloadProgress {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type BackgroundDownloader = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_BackgroundTransfer\"`*"]
+#[repr(transparent)]
+pub struct BackgroundTransferBehavior(pub i32);
+impl BackgroundTransferBehavior {
+    pub const Parallel: Self = Self(0i32);
+    pub const Serialized: Self = Self(1i32);
+}
+impl ::core::marker::Copy for BackgroundTransferBehavior {}
+impl ::core::clone::Clone for BackgroundTransferBehavior {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type BackgroundTransferCompletionGroup = *mut ::core::ffi::c_void;
+pub type BackgroundTransferCompletionGroupTriggerDetails = *mut ::core::ffi::c_void;
+pub type BackgroundTransferContentPart = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_BackgroundTransfer\"`*"]
+#[repr(transparent)]
+pub struct BackgroundTransferCostPolicy(pub i32);
+impl BackgroundTransferCostPolicy {
+    pub const Default: Self = Self(0i32);
+    pub const UnrestrictedOnly: Self = Self(1i32);
+    pub const Always: Self = Self(2i32);
+}
+impl ::core::marker::Copy for BackgroundTransferCostPolicy {}
+impl ::core::clone::Clone for BackgroundTransferCostPolicy {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(C)]
+#[doc = "*Required features: `\"Networking_BackgroundTransfer\"`*"]
+pub struct BackgroundTransferFileRange {
+    pub Offset: u64,
+    pub Length: u64,
+}
+impl ::core::marker::Copy for BackgroundTransferFileRange {}
+impl ::core::clone::Clone for BackgroundTransferFileRange {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type BackgroundTransferGroup = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_BackgroundTransfer\"`*"]
+#[repr(transparent)]
+pub struct BackgroundTransferPriority(pub i32);
+impl BackgroundTransferPriority {
+    pub const Default: Self = Self(0i32);
+    pub const High: Self = Self(1i32);
+    pub const Low: Self = Self(2i32);
+}
+impl ::core::marker::Copy for BackgroundTransferPriority {}
+impl ::core::clone::Clone for BackgroundTransferPriority {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type BackgroundTransferRangesDownloadedEventArgs = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_BackgroundTransfer\"`*"]
+#[repr(transparent)]
+pub struct BackgroundTransferStatus(pub i32);
+impl BackgroundTransferStatus {
+    pub const Idle: Self = Self(0i32);
+    pub const Running: Self = Self(1i32);
+    pub const PausedByApplication: Self = Self(2i32);
+    pub const PausedCostedNetwork: Self = Self(3i32);
+    pub const PausedNoNetwork: Self = Self(4i32);
+    pub const Completed: Self = Self(5i32);
+    pub const Canceled: Self = Self(6i32);
+    pub const Error: Self = Self(7i32);
+    pub const PausedRecoverableWebErrorStatus: Self = Self(8i32);
+    pub const PausedSystemPolicy: Self = Self(32i32);
+}
+impl ::core::marker::Copy for BackgroundTransferStatus {}
+impl ::core::clone::Clone for BackgroundTransferStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(C)]
+#[doc = "*Required features: `\"Networking_BackgroundTransfer\"`*"]
+pub struct BackgroundUploadProgress {
+    pub BytesReceived: u64,
+    pub BytesSent: u64,
+    pub TotalBytesToReceive: u64,
+    pub TotalBytesToSend: u64,
+    pub Status: BackgroundTransferStatus,
+    pub HasResponseChanged: bool,
+    pub HasRestarted: bool,
+}
+impl ::core::marker::Copy for BackgroundUploadProgress {}
+impl ::core::clone::Clone for BackgroundUploadProgress {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type BackgroundUploader = *mut ::core::ffi::c_void;
+pub type DownloadOperation = *mut ::core::ffi::c_void;
+pub type IBackgroundTransferBase = *mut ::core::ffi::c_void;
+pub type IBackgroundTransferContentPartFactory = *mut ::core::ffi::c_void;
+pub type IBackgroundTransferOperation = *mut ::core::ffi::c_void;
+pub type IBackgroundTransferOperationPriority = *mut ::core::ffi::c_void;
+pub type ResponseInformation = *mut ::core::ffi::c_void;
+pub type UnconstrainedTransferRequestResult = *mut ::core::ffi::c_void;
+pub type UploadOperation = *mut ::core::ffi::c_void;
diff --git a/vendor/windows-sys/src/Windows/Networking/Connectivity/mod.rs b/vendor/windows-sys/src/Windows/Networking/Connectivity/mod.rs
new file mode 100644
index 000000000..875b85190
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Networking/Connectivity/mod.rs
@@ -0,0 +1,276 @@
+pub type AttributedNetworkUsage = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_Connectivity\"`*"]
+#[repr(transparent)]
+pub struct CellularApnAuthenticationType(pub i32);
+impl CellularApnAuthenticationType {
+    pub const None: Self = Self(0i32);
+    pub const Pap: Self = Self(1i32);
+    pub const Chap: Self = Self(2i32);
+    pub const Mschapv2: Self = Self(3i32);
+}
+impl ::core::marker::Copy for CellularApnAuthenticationType {}
+impl ::core::clone::Clone for CellularApnAuthenticationType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type CellularApnContext = *mut ::core::ffi::c_void;
+pub type ConnectionCost = *mut ::core::ffi::c_void;
+pub type ConnectionProfile = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_Connectivity\"`*"]
+#[repr(transparent)]
+pub struct ConnectionProfileDeleteStatus(pub i32);
+impl ConnectionProfileDeleteStatus {
+    pub const Success: Self = Self(0i32);
+    pub const DeniedByUser: Self = Self(1i32);
+    pub const DeniedBySystem: Self = Self(2i32);
+    pub const UnknownError: Self = Self(3i32);
+}
+impl ::core::marker::Copy for ConnectionProfileDeleteStatus {}
+impl ::core::clone::Clone for ConnectionProfileDeleteStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type ConnectionProfileFilter = *mut ::core::ffi::c_void;
+pub type ConnectionSession = *mut ::core::ffi::c_void;
+pub type ConnectivityInterval = *mut ::core::ffi::c_void;
+pub type DataPlanStatus = *mut ::core::ffi::c_void;
+pub type DataPlanUsage = *mut ::core::ffi::c_void;
+pub type DataUsage = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_Connectivity\"`*"]
+#[repr(transparent)]
+pub struct DataUsageGranularity(pub i32);
+impl DataUsageGranularity {
+    pub const PerMinute: Self = Self(0i32);
+    pub const PerHour: Self = Self(1i32);
+    pub const PerDay: Self = Self(2i32);
+    pub const Total: Self = Self(3i32);
+}
+impl ::core::marker::Copy for DataUsageGranularity {}
+impl ::core::clone::Clone for DataUsageGranularity {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Networking_Connectivity\"`*"]
+#[repr(transparent)]
+pub struct DomainConnectivityLevel(pub i32);
+impl DomainConnectivityLevel {
+    pub const None: Self = Self(0i32);
+    pub const Unauthenticated: Self = Self(1i32);
+    pub const Authenticated: Self = Self(2i32);
+}
+impl ::core::marker::Copy for DomainConnectivityLevel {}
+impl ::core::clone::Clone for DomainConnectivityLevel {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type IPInformation = *mut ::core::ffi::c_void;
+pub type LanIdentifier = *mut ::core::ffi::c_void;
+pub type LanIdentifierData = *mut ::core::ffi::c_void;
+pub type NetworkAdapter = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_Connectivity\"`*"]
+#[repr(transparent)]
+pub struct NetworkAuthenticationType(pub i32);
+impl NetworkAuthenticationType {
+    pub const None: Self = Self(0i32);
+    pub const Unknown: Self = Self(1i32);
+    pub const Open80211: Self = Self(2i32);
+    pub const SharedKey80211: Self = Self(3i32);
+    pub const Wpa: Self = Self(4i32);
+    pub const WpaPsk: Self = Self(5i32);
+    pub const WpaNone: Self = Self(6i32);
+    pub const Rsna: Self = Self(7i32);
+    pub const RsnaPsk: Self = Self(8i32);
+    pub const Ihv: Self = Self(9i32);
+    pub const Wpa3: Self = Self(10i32);
+    pub const Wpa3Enterprise192Bits: Self = Self(10i32);
+    pub const Wpa3Sae: Self = Self(11i32);
+    pub const Owe: Self = Self(12i32);
+    pub const Wpa3Enterprise: Self = Self(13i32);
+}
+impl ::core::marker::Copy for NetworkAuthenticationType {}
+impl ::core::clone::Clone for NetworkAuthenticationType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Networking_Connectivity\"`*"]
+#[repr(transparent)]
+pub struct NetworkConnectivityLevel(pub i32);
+impl NetworkConnectivityLevel {
+    pub const None: Self = Self(0i32);
+    pub const LocalAccess: Self = Self(1i32);
+    pub const ConstrainedInternetAccess: Self = Self(2i32);
+    pub const InternetAccess: Self = Self(3i32);
+}
+impl ::core::marker::Copy for NetworkConnectivityLevel {}
+impl ::core::clone::Clone for NetworkConnectivityLevel {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Networking_Connectivity\"`*"]
+#[repr(transparent)]
+pub struct NetworkCostType(pub i32);
+impl NetworkCostType {
+    pub const Unknown: Self = Self(0i32);
+    pub const Unrestricted: Self = Self(1i32);
+    pub const Fixed: Self = Self(2i32);
+    pub const Variable: Self = Self(3i32);
+}
+impl ::core::marker::Copy for NetworkCostType {}
+impl ::core::clone::Clone for NetworkCostType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Networking_Connectivity\"`*"]
+#[repr(transparent)]
+pub struct NetworkEncryptionType(pub i32);
+impl NetworkEncryptionType {
+    pub const None: Self = Self(0i32);
+    pub const Unknown: Self = Self(1i32);
+    pub const Wep: Self = Self(2i32);
+    pub const Wep40: Self = Self(3i32);
+    pub const Wep104: Self = Self(4i32);
+    pub const Tkip: Self = Self(5i32);
+    pub const Ccmp: Self = Self(6i32);
+    pub const WpaUseGroup: Self = Self(7i32);
+    pub const RsnUseGroup: Self = Self(8i32);
+    pub const Ihv: Self = Self(9i32);
+    pub const Gcmp: Self = Self(10i32);
+    pub const Gcmp256: Self = Self(11i32);
+}
+impl ::core::marker::Copy for NetworkEncryptionType {}
+impl ::core::clone::Clone for NetworkEncryptionType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type NetworkItem = *mut ::core::ffi::c_void;
+pub type NetworkSecuritySettings = *mut ::core::ffi::c_void;
+pub type NetworkStateChangeEventDetails = *mut ::core::ffi::c_void;
+pub type NetworkStatusChangedEventHandler = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_Connectivity\"`*"]
+#[repr(transparent)]
+pub struct NetworkTypes(pub u32);
+impl NetworkTypes {
+    pub const None: Self = Self(0u32);
+    pub const Internet: Self = Self(1u32);
+    pub const PrivateNetwork: Self = Self(2u32);
+}
+impl ::core::marker::Copy for NetworkTypes {}
+impl ::core::clone::Clone for NetworkTypes {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type NetworkUsage = *mut ::core::ffi::c_void;
+#[repr(C)]
+#[doc = "*Required features: `\"Networking_Connectivity\"`*"]
+pub struct NetworkUsageStates {
+    pub Roaming: TriStates,
+    pub Shared: TriStates,
+}
+impl ::core::marker::Copy for NetworkUsageStates {}
+impl ::core::clone::Clone for NetworkUsageStates {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type ProviderNetworkUsage = *mut ::core::ffi::c_void;
+pub type ProxyConfiguration = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_Connectivity\"`*"]
+#[repr(transparent)]
+pub struct RoamingStates(pub u32);
+impl RoamingStates {
+    pub const None: Self = Self(0u32);
+    pub const NotRoaming: Self = Self(1u32);
+    pub const Roaming: Self = Self(2u32);
+}
+impl ::core::marker::Copy for RoamingStates {}
+impl ::core::clone::Clone for RoamingStates {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type RoutePolicy = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_Connectivity\"`*"]
+#[repr(transparent)]
+pub struct TriStates(pub i32);
+impl TriStates {
+    pub const DoNotCare: Self = Self(0i32);
+    pub const No: Self = Self(1i32);
+    pub const Yes: Self = Self(2i32);
+}
+impl ::core::marker::Copy for TriStates {}
+impl ::core::clone::Clone for TriStates {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type WlanConnectionProfileDetails = *mut ::core::ffi::c_void;
+pub type WwanConnectionProfileDetails = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_Connectivity\"`*"]
+#[repr(transparent)]
+pub struct WwanDataClass(pub u32);
+impl WwanDataClass {
+    pub const None: Self = Self(0u32);
+    pub const Gprs: Self = Self(1u32);
+    pub const Edge: Self = Self(2u32);
+    pub const Umts: Self = Self(4u32);
+    pub const Hsdpa: Self = Self(8u32);
+    pub const Hsupa: Self = Self(16u32);
+    pub const LteAdvanced: Self = Self(32u32);
+    pub const Cdma1xRtt: Self = Self(65536u32);
+    pub const Cdma1xEvdo: Self = Self(131072u32);
+    pub const Cdma1xEvdoRevA: Self = Self(262144u32);
+    pub const Cdma1xEvdv: Self = Self(524288u32);
+    pub const Cdma3xRtt: Self = Self(1048576u32);
+    pub const Cdma1xEvdoRevB: Self = Self(2097152u32);
+    pub const CdmaUmb: Self = Self(4194304u32);
+    pub const Custom: Self = Self(2147483648u32);
+}
+impl ::core::marker::Copy for WwanDataClass {}
+impl ::core::clone::Clone for WwanDataClass {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Networking_Connectivity\"`*"]
+#[repr(transparent)]
+pub struct WwanNetworkIPKind(pub i32);
+impl WwanNetworkIPKind {
+    pub const None: Self = Self(0i32);
+    pub const Ipv4: Self = Self(1i32);
+    pub const Ipv6: Self = Self(2i32);
+    pub const Ipv4v6: Self = Self(3i32);
+    pub const Ipv4v6v4Xlat: Self = Self(4i32);
+}
+impl ::core::marker::Copy for WwanNetworkIPKind {}
+impl ::core::clone::Clone for WwanNetworkIPKind {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Networking_Connectivity\"`*"]
+#[repr(transparent)]
+pub struct WwanNetworkRegistrationState(pub i32);
+impl WwanNetworkRegistrationState {
+    pub const None: Self = Self(0i32);
+    pub const Deregistered: Self = Self(1i32);
+    pub const Searching: Self = Self(2i32);
+    pub const Home: Self = Self(3i32);
+    pub const Roaming: Self = Self(4i32);
+    pub const Partner: Self = Self(5i32);
+    pub const Denied: Self = Self(6i32);
+}
+impl ::core::marker::Copy for WwanNetworkRegistrationState {}
+impl ::core::clone::Clone for WwanNetworkRegistrationState {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/vendor/windows-sys/src/Windows/Networking/NetworkOperators/mod.rs b/vendor/windows-sys/src/Windows/Networking/NetworkOperators/mod.rs
new file mode 100644
index 000000000..647a5c273
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Networking/NetworkOperators/mod.rs
@@ -0,0 +1,664 @@
+#[doc = "*Required features: `\"Networking_NetworkOperators\"`*"]
+#[repr(transparent)]
+pub struct DataClasses(pub u32);
+impl DataClasses {
+    pub const None: Self = Self(0u32);
+    pub const Gprs: Self = Self(1u32);
+    pub const Edge: Self = Self(2u32);
+    pub const Umts: Self = Self(4u32);
+    pub const Hsdpa: Self = Self(8u32);
+    pub const Hsupa: Self = Self(16u32);
+    pub const LteAdvanced: Self = Self(32u32);
+    pub const NewRadioNonStandalone: Self = Self(64u32);
+    pub const NewRadioStandalone: Self = Self(128u32);
+    pub const Cdma1xRtt: Self = Self(65536u32);
+    pub const Cdma1xEvdo: Self = Self(131072u32);
+    pub const Cdma1xEvdoRevA: Self = Self(262144u32);
+    pub const Cdma1xEvdv: Self = Self(524288u32);
+    pub const Cdma3xRtt: Self = Self(1048576u32);
+    pub const Cdma1xEvdoRevB: Self = Self(2097152u32);
+    pub const CdmaUmb: Self = Self(4194304u32);
+    pub const Custom: Self = Self(2147483648u32);
+}
+impl ::core::marker::Copy for DataClasses {}
+impl ::core::clone::Clone for DataClasses {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type ESim = *mut ::core::ffi::c_void;
+pub type ESimAddedEventArgs = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_NetworkOperators\"`*"]
+#[repr(transparent)]
+pub struct ESimAuthenticationPreference(pub i32);
+impl ESimAuthenticationPreference {
+    pub const OnEntry: Self = Self(0i32);
+    pub const OnAction: Self = Self(1i32);
+    pub const Never: Self = Self(2i32);
+}
+impl ::core::marker::Copy for ESimAuthenticationPreference {}
+impl ::core::clone::Clone for ESimAuthenticationPreference {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type ESimDiscoverEvent = *mut ::core::ffi::c_void;
+pub type ESimDiscoverResult = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_NetworkOperators\"`*"]
+#[repr(transparent)]
+pub struct ESimDiscoverResultKind(pub i32);
+impl ESimDiscoverResultKind {
+    pub const None: Self = Self(0i32);
+    pub const Events: Self = Self(1i32);
+    pub const ProfileMetadata: Self = Self(2i32);
+}
+impl ::core::marker::Copy for ESimDiscoverResultKind {}
+impl ::core::clone::Clone for ESimDiscoverResultKind {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type ESimDownloadProfileMetadataResult = *mut ::core::ffi::c_void;
+pub type ESimOperationResult = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_NetworkOperators\"`*"]
+#[repr(transparent)]
+pub struct ESimOperationStatus(pub i32);
+impl ESimOperationStatus {
+    pub const Success: Self = Self(0i32);
+    pub const NotAuthorized: Self = Self(1i32);
+    pub const NotFound: Self = Self(2i32);
+    pub const PolicyViolation: Self = Self(3i32);
+    pub const InsufficientSpaceOnCard: Self = Self(4i32);
+    pub const ServerFailure: Self = Self(5i32);
+    pub const ServerNotReachable: Self = Self(6i32);
+    pub const TimeoutWaitingForUserConsent: Self = Self(7i32);
+    pub const IncorrectConfirmationCode: Self = Self(8i32);
+    pub const ConfirmationCodeMaxRetriesExceeded: Self = Self(9i32);
+    pub const CardRemoved: Self = Self(10i32);
+    pub const CardBusy: Self = Self(11i32);
+    pub const Other: Self = Self(12i32);
+    pub const CardGeneralFailure: Self = Self(13i32);
+    pub const ConfirmationCodeMissing: Self = Self(14i32);
+    pub const InvalidMatchingId: Self = Self(15i32);
+    pub const NoEligibleProfileForThisDevice: Self = Self(16i32);
+    pub const OperationAborted: Self = Self(17i32);
+    pub const EidMismatch: Self = Self(18i32);
+    pub const ProfileNotAvailableForNewBinding: Self = Self(19i32);
+    pub const ProfileNotReleasedByOperator: Self = Self(20i32);
+    pub const OperationProhibitedByProfileClass: Self = Self(21i32);
+    pub const ProfileNotPresent: Self = Self(22i32);
+    pub const NoCorrespondingRequest: Self = Self(23i32);
+    pub const TimeoutWaitingForResponse: Self = Self(24i32);
+    pub const IccidAlreadyExists: Self = Self(25i32);
+    pub const ProfileProcessingError: Self = Self(26i32);
+    pub const ServerNotTrusted: Self = Self(27i32);
+    pub const ProfileDownloadMaxRetriesExceeded: Self = Self(28i32);
+}
+impl ::core::marker::Copy for ESimOperationStatus {}
+impl ::core::clone::Clone for ESimOperationStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type ESimPolicy = *mut ::core::ffi::c_void;
+pub type ESimProfile = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_NetworkOperators\"`*"]
+#[repr(transparent)]
+pub struct ESimProfileClass(pub i32);
+impl ESimProfileClass {
+    pub const Operational: Self = Self(0i32);
+    pub const Test: Self = Self(1i32);
+    pub const Provisioning: Self = Self(2i32);
+}
+impl ::core::marker::Copy for ESimProfileClass {}
+impl ::core::clone::Clone for ESimProfileClass {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(C)]
+#[doc = "*Required features: `\"Networking_NetworkOperators\"`*"]
+pub struct ESimProfileInstallProgress {
+    pub TotalSizeInBytes: i32,
+    pub InstalledSizeInBytes: i32,
+}
+impl ::core::marker::Copy for ESimProfileInstallProgress {}
+impl ::core::clone::Clone for ESimProfileInstallProgress {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type ESimProfileMetadata = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_NetworkOperators\"`*"]
+#[repr(transparent)]
+pub struct ESimProfileMetadataState(pub i32);
+impl ESimProfileMetadataState {
+    pub const Unknown: Self = Self(0i32);
+    pub const WaitingForInstall: Self = Self(1i32);
+    pub const Downloading: Self = Self(2i32);
+    pub const Installing: Self = Self(3i32);
+    pub const Expired: Self = Self(4i32);
+    pub const RejectingDownload: Self = Self(5i32);
+    pub const NoLongerAvailable: Self = Self(6i32);
+    pub const DeniedByPolicy: Self = Self(7i32);
+}
+impl ::core::marker::Copy for ESimProfileMetadataState {}
+impl ::core::clone::Clone for ESimProfileMetadataState {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type ESimProfilePolicy = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_NetworkOperators\"`*"]
+#[repr(transparent)]
+pub struct ESimProfileState(pub i32);
+impl ESimProfileState {
+    pub const Unknown: Self = Self(0i32);
+    pub const Disabled: Self = Self(1i32);
+    pub const Enabled: Self = Self(2i32);
+    pub const Deleted: Self = Self(3i32);
+}
+impl ::core::marker::Copy for ESimProfileState {}
+impl ::core::clone::Clone for ESimProfileState {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type ESimRemovedEventArgs = *mut ::core::ffi::c_void;
+pub type ESimServiceInfo = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_NetworkOperators\"`*"]
+#[repr(transparent)]
+pub struct ESimState(pub i32);
+impl ESimState {
+    pub const Unknown: Self = Self(0i32);
+    pub const Idle: Self = Self(1i32);
+    pub const Removed: Self = Self(2i32);
+    pub const Busy: Self = Self(3i32);
+}
+impl ::core::marker::Copy for ESimState {}
+impl ::core::clone::Clone for ESimState {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type ESimUpdatedEventArgs = *mut ::core::ffi::c_void;
+pub type ESimWatcher = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_NetworkOperators\"`*"]
+#[repr(transparent)]
+pub struct ESimWatcherStatus(pub i32);
+impl ESimWatcherStatus {
+    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);
+}
+impl ::core::marker::Copy for ESimWatcherStatus {}
+impl ::core::clone::Clone for ESimWatcherStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type HotspotAuthenticationContext = *mut ::core::ffi::c_void;
+pub type HotspotAuthenticationEventDetails = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_NetworkOperators\"`*"]
+#[repr(transparent)]
+pub struct HotspotAuthenticationResponseCode(pub i32);
+impl HotspotAuthenticationResponseCode {
+    pub const NoError: Self = Self(0i32);
+    pub const LoginSucceeded: Self = Self(50i32);
+    pub const LoginFailed: Self = Self(100i32);
+    pub const RadiusServerError: Self = Self(102i32);
+    pub const NetworkAdministratorError: Self = Self(105i32);
+    pub const LoginAborted: Self = Self(151i32);
+    pub const AccessGatewayInternalError: Self = Self(255i32);
+}
+impl ::core::marker::Copy for HotspotAuthenticationResponseCode {}
+impl ::core::clone::Clone for HotspotAuthenticationResponseCode {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type HotspotCredentialsAuthenticationResult = *mut ::core::ffi::c_void;
+pub type MobileBroadbandAccount = *mut ::core::ffi::c_void;
+pub type MobileBroadbandAccountEventArgs = *mut ::core::ffi::c_void;
+pub type MobileBroadbandAccountUpdatedEventArgs = *mut ::core::ffi::c_void;
+pub type MobileBroadbandAccountWatcher = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_NetworkOperators\"`*"]
+#[repr(transparent)]
+pub struct MobileBroadbandAccountWatcherStatus(pub i32);
+impl MobileBroadbandAccountWatcherStatus {
+    pub const Created: Self = Self(0i32);
+    pub const Started: Self = Self(1i32);
+    pub const EnumerationCompleted: Self = Self(2i32);
+    pub const Stopped: Self = Self(3i32);
+    pub const Aborted: Self = Self(4i32);
+}
+impl ::core::marker::Copy for MobileBroadbandAccountWatcherStatus {}
+impl ::core::clone::Clone for MobileBroadbandAccountWatcherStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type MobileBroadbandAntennaSar = *mut ::core::ffi::c_void;
+pub type MobileBroadbandCellCdma = *mut ::core::ffi::c_void;
+pub type MobileBroadbandCellGsm = *mut ::core::ffi::c_void;
+pub type MobileBroadbandCellLte = *mut ::core::ffi::c_void;
+pub type MobileBroadbandCellNR = *mut ::core::ffi::c_void;
+pub type MobileBroadbandCellTdscdma = *mut ::core::ffi::c_void;
+pub type MobileBroadbandCellUmts = *mut ::core::ffi::c_void;
+pub type MobileBroadbandCellsInfo = *mut ::core::ffi::c_void;
+pub type MobileBroadbandCurrentSlotIndexChangedEventArgs = *mut ::core::ffi::c_void;
+pub type MobileBroadbandDeviceInformation = *mut ::core::ffi::c_void;
+pub type MobileBroadbandDeviceService = *mut ::core::ffi::c_void;
+pub type MobileBroadbandDeviceServiceCommandResult = *mut ::core::ffi::c_void;
+pub type MobileBroadbandDeviceServiceCommandSession = *mut ::core::ffi::c_void;
+pub type MobileBroadbandDeviceServiceDataReceivedEventArgs = *mut ::core::ffi::c_void;
+pub type MobileBroadbandDeviceServiceDataSession = *mut ::core::ffi::c_void;
+pub type MobileBroadbandDeviceServiceInformation = *mut ::core::ffi::c_void;
+pub type MobileBroadbandDeviceServiceTriggerDetails = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_NetworkOperators\"`*"]
+#[repr(transparent)]
+pub struct MobileBroadbandDeviceType(pub i32);
+impl MobileBroadbandDeviceType {
+    pub const Unknown: Self = Self(0i32);
+    pub const Embedded: Self = Self(1i32);
+    pub const Removable: Self = Self(2i32);
+    pub const Remote: Self = Self(3i32);
+}
+impl ::core::marker::Copy for MobileBroadbandDeviceType {}
+impl ::core::clone::Clone for MobileBroadbandDeviceType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type MobileBroadbandModem = *mut ::core::ffi::c_void;
+pub type MobileBroadbandModemConfiguration = *mut ::core::ffi::c_void;
+pub type MobileBroadbandModemIsolation = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_NetworkOperators\"`*"]
+#[repr(transparent)]
+pub struct MobileBroadbandModemStatus(pub i32);
+impl MobileBroadbandModemStatus {
+    pub const Success: Self = Self(0i32);
+    pub const OtherFailure: Self = Self(1i32);
+    pub const Busy: Self = Self(2i32);
+    pub const NoDeviceSupport: Self = Self(3i32);
+}
+impl ::core::marker::Copy for MobileBroadbandModemStatus {}
+impl ::core::clone::Clone for MobileBroadbandModemStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type MobileBroadbandNetwork = *mut ::core::ffi::c_void;
+pub type MobileBroadbandNetworkRegistrationStateChange = *mut ::core::ffi::c_void;
+pub type MobileBroadbandNetworkRegistrationStateChangeTriggerDetails = *mut ::core::ffi::c_void;
+pub type MobileBroadbandPco = *mut ::core::ffi::c_void;
+pub type MobileBroadbandPcoDataChangeTriggerDetails = *mut ::core::ffi::c_void;
+pub type MobileBroadbandPin = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_NetworkOperators\"`*"]
+#[repr(transparent)]
+pub struct MobileBroadbandPinFormat(pub i32);
+impl MobileBroadbandPinFormat {
+    pub const Unknown: Self = Self(0i32);
+    pub const Numeric: Self = Self(1i32);
+    pub const Alphanumeric: Self = Self(2i32);
+}
+impl ::core::marker::Copy for MobileBroadbandPinFormat {}
+impl ::core::clone::Clone for MobileBroadbandPinFormat {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Networking_NetworkOperators\"`*"]
+#[repr(transparent)]
+pub struct MobileBroadbandPinLockState(pub i32);
+impl MobileBroadbandPinLockState {
+    pub const Unknown: Self = Self(0i32);
+    pub const Unlocked: Self = Self(1i32);
+    pub const PinRequired: Self = Self(2i32);
+    pub const PinUnblockKeyRequired: Self = Self(3i32);
+}
+impl ::core::marker::Copy for MobileBroadbandPinLockState {}
+impl ::core::clone::Clone for MobileBroadbandPinLockState {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type MobileBroadbandPinLockStateChange = *mut ::core::ffi::c_void;
+pub type MobileBroadbandPinLockStateChangeTriggerDetails = *mut ::core::ffi::c_void;
+pub type MobileBroadbandPinManager = *mut ::core::ffi::c_void;
+pub type MobileBroadbandPinOperationResult = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_NetworkOperators\"`*"]
+#[repr(transparent)]
+pub struct MobileBroadbandPinType(pub i32);
+impl MobileBroadbandPinType {
+    pub const None: Self = Self(0i32);
+    pub const Custom: Self = Self(1i32);
+    pub const Pin1: Self = Self(2i32);
+    pub const Pin2: Self = Self(3i32);
+    pub const SimPin: Self = Self(4i32);
+    pub const FirstSimPin: Self = Self(5i32);
+    pub const NetworkPin: Self = Self(6i32);
+    pub const NetworkSubsetPin: Self = Self(7i32);
+    pub const ServiceProviderPin: Self = Self(8i32);
+    pub const CorporatePin: Self = Self(9i32);
+    pub const SubsidyLock: Self = Self(10i32);
+}
+impl ::core::marker::Copy for MobileBroadbandPinType {}
+impl ::core::clone::Clone for MobileBroadbandPinType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Networking_NetworkOperators\"`*"]
+#[repr(transparent)]
+pub struct MobileBroadbandRadioState(pub i32);
+impl MobileBroadbandRadioState {
+    pub const Off: Self = Self(0i32);
+    pub const On: Self = Self(1i32);
+}
+impl ::core::marker::Copy for MobileBroadbandRadioState {}
+impl ::core::clone::Clone for MobileBroadbandRadioState {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type MobileBroadbandRadioStateChange = *mut ::core::ffi::c_void;
+pub type MobileBroadbandRadioStateChangeTriggerDetails = *mut ::core::ffi::c_void;
+pub type MobileBroadbandSarManager = *mut ::core::ffi::c_void;
+pub type MobileBroadbandSlotInfo = *mut ::core::ffi::c_void;
+pub type MobileBroadbandSlotInfoChangedEventArgs = *mut ::core::ffi::c_void;
+pub type MobileBroadbandSlotManager = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_NetworkOperators\"`*"]
+#[repr(transparent)]
+pub struct MobileBroadbandSlotState(pub i32);
+impl MobileBroadbandSlotState {
+    pub const Unmanaged: Self = Self(0i32);
+    pub const Unknown: Self = Self(1i32);
+    pub const OffEmpty: Self = Self(2i32);
+    pub const Off: Self = Self(3i32);
+    pub const Empty: Self = Self(4i32);
+    pub const NotReady: Self = Self(5i32);
+    pub const Active: Self = Self(6i32);
+    pub const Error: Self = Self(7i32);
+    pub const ActiveEsim: Self = Self(8i32);
+    pub const ActiveEsimNoProfile: Self = Self(9i32);
+}
+impl ::core::marker::Copy for MobileBroadbandSlotState {}
+impl ::core::clone::Clone for MobileBroadbandSlotState {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type MobileBroadbandTransmissionStateChangedEventArgs = *mut ::core::ffi::c_void;
+pub type MobileBroadbandUicc = *mut ::core::ffi::c_void;
+pub type MobileBroadbandUiccApp = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_NetworkOperators\"`*"]
+#[repr(transparent)]
+pub struct MobileBroadbandUiccAppOperationStatus(pub i32);
+impl MobileBroadbandUiccAppOperationStatus {
+    pub const Success: Self = Self(0i32);
+    pub const InvalidUiccFilePath: Self = Self(1i32);
+    pub const AccessConditionNotHeld: Self = Self(2i32);
+    pub const UiccBusy: Self = Self(3i32);
+}
+impl ::core::marker::Copy for MobileBroadbandUiccAppOperationStatus {}
+impl ::core::clone::Clone for MobileBroadbandUiccAppOperationStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type MobileBroadbandUiccAppReadRecordResult = *mut ::core::ffi::c_void;
+pub type MobileBroadbandUiccAppRecordDetailsResult = *mut ::core::ffi::c_void;
+pub type MobileBroadbandUiccAppsResult = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_NetworkOperators\"`*"]
+#[repr(transparent)]
+pub struct NetworkDeviceStatus(pub i32);
+impl NetworkDeviceStatus {
+    pub const DeviceNotReady: Self = Self(0i32);
+    pub const DeviceReady: Self = Self(1i32);
+    pub const SimNotInserted: Self = Self(2i32);
+    pub const BadSim: Self = Self(3i32);
+    pub const DeviceHardwareFailure: Self = Self(4i32);
+    pub const AccountNotActivated: Self = Self(5i32);
+    pub const DeviceLocked: Self = Self(6i32);
+    pub const DeviceBlocked: Self = Self(7i32);
+}
+impl ::core::marker::Copy for NetworkDeviceStatus {}
+impl ::core::clone::Clone for NetworkDeviceStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Networking_NetworkOperators\"`*"]
+#[repr(transparent)]
+pub struct NetworkOperatorDataUsageNotificationKind(pub i32);
+impl NetworkOperatorDataUsageNotificationKind {
+    pub const DataUsageProgress: Self = Self(0i32);
+}
+impl ::core::marker::Copy for NetworkOperatorDataUsageNotificationKind {}
+impl ::core::clone::Clone for NetworkOperatorDataUsageNotificationKind {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type NetworkOperatorDataUsageTriggerDetails = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_NetworkOperators\"`*"]
+#[repr(transparent)]
+pub struct NetworkOperatorEventMessageType(pub i32);
+impl NetworkOperatorEventMessageType {
+    pub const Gsm: Self = Self(0i32);
+    pub const Cdma: Self = Self(1i32);
+    pub const Ussd: Self = Self(2i32);
+    pub const DataPlanThresholdReached: Self = Self(3i32);
+    pub const DataPlanReset: Self = Self(4i32);
+    pub const DataPlanDeleted: Self = Self(5i32);
+    pub const ProfileConnected: Self = Self(6i32);
+    pub const ProfileDisconnected: Self = Self(7i32);
+    pub const RegisteredRoaming: Self = Self(8i32);
+    pub const RegisteredHome: Self = Self(9i32);
+    pub const TetheringEntitlementCheck: Self = Self(10i32);
+    pub const TetheringOperationalStateChanged: Self = Self(11i32);
+    pub const TetheringNumberOfClientsChanged: Self = Self(12i32);
+}
+impl ::core::marker::Copy for NetworkOperatorEventMessageType {}
+impl ::core::clone::Clone for NetworkOperatorEventMessageType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type NetworkOperatorNotificationEventDetails = *mut ::core::ffi::c_void;
+pub type NetworkOperatorTetheringAccessPointConfiguration = *mut ::core::ffi::c_void;
+pub type NetworkOperatorTetheringClient = *mut ::core::ffi::c_void;
+pub type NetworkOperatorTetheringManager = *mut ::core::ffi::c_void;
+pub type NetworkOperatorTetheringOperationResult = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_NetworkOperators\"`*"]
+#[repr(transparent)]
+pub struct NetworkRegistrationState(pub i32);
+impl NetworkRegistrationState {
+    pub const None: Self = Self(0i32);
+    pub const Deregistered: Self = Self(1i32);
+    pub const Searching: Self = Self(2i32);
+    pub const Home: Self = Self(3i32);
+    pub const Roaming: Self = Self(4i32);
+    pub const Partner: Self = Self(5i32);
+    pub const Denied: Self = Self(6i32);
+}
+impl ::core::marker::Copy for NetworkRegistrationState {}
+impl ::core::clone::Clone for NetworkRegistrationState {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Networking_NetworkOperators\"`*"]
+#[repr(transparent)]
+pub struct ProfileMediaType(pub i32);
+impl ProfileMediaType {
+    pub const Wlan: Self = Self(0i32);
+    pub const Wwan: Self = Self(1i32);
+}
+impl ::core::marker::Copy for ProfileMediaType {}
+impl ::core::clone::Clone for ProfileMediaType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(C)]
+#[doc = "*Required features: `\"Networking_NetworkOperators\"`, `\"Foundation\"`*"]
+#[cfg(feature = "Foundation")]
+pub struct ProfileUsage {
+    pub UsageInMegabytes: u32,
+    pub LastSyncTime: super::super::Foundation::DateTime,
+}
+#[cfg(feature = "Foundation")]
+impl ::core::marker::Copy for ProfileUsage {}
+#[cfg(feature = "Foundation")]
+impl ::core::clone::Clone for ProfileUsage {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type ProvisionFromXmlDocumentResults = *mut ::core::ffi::c_void;
+pub type ProvisionedProfile = *mut ::core::ffi::c_void;
+pub type ProvisioningAgent = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_NetworkOperators\"`*"]
+#[repr(transparent)]
+pub struct TetheringCapability(pub i32);
+impl TetheringCapability {
+    pub const Enabled: Self = Self(0i32);
+    pub const DisabledByGroupPolicy: Self = Self(1i32);
+    pub const DisabledByHardwareLimitation: Self = Self(2i32);
+    pub const DisabledByOperator: Self = Self(3i32);
+    pub const DisabledBySku: Self = Self(4i32);
+    pub const DisabledByRequiredAppNotInstalled: Self = Self(5i32);
+    pub const DisabledDueToUnknownCause: Self = Self(6i32);
+    pub const DisabledBySystemCapability: Self = Self(7i32);
+}
+impl ::core::marker::Copy for TetheringCapability {}
+impl ::core::clone::Clone for TetheringCapability {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type TetheringEntitlementCheckTriggerDetails = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_NetworkOperators\"`*"]
+#[repr(transparent)]
+pub struct TetheringOperationStatus(pub i32);
+impl TetheringOperationStatus {
+    pub const Success: Self = Self(0i32);
+    pub const Unknown: Self = Self(1i32);
+    pub const MobileBroadbandDeviceOff: Self = Self(2i32);
+    pub const WiFiDeviceOff: Self = Self(3i32);
+    pub const EntitlementCheckTimeout: Self = Self(4i32);
+    pub const EntitlementCheckFailure: Self = Self(5i32);
+    pub const OperationInProgress: Self = Self(6i32);
+    pub const BluetoothDeviceOff: Self = Self(7i32);
+    pub const NetworkLimitedConnectivity: Self = Self(8i32);
+}
+impl ::core::marker::Copy for TetheringOperationStatus {}
+impl ::core::clone::Clone for TetheringOperationStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Networking_NetworkOperators\"`*"]
+#[repr(transparent)]
+pub struct TetheringOperationalState(pub i32);
+impl TetheringOperationalState {
+    pub const Unknown: Self = Self(0i32);
+    pub const On: Self = Self(1i32);
+    pub const Off: Self = Self(2i32);
+    pub const InTransition: Self = Self(3i32);
+}
+impl ::core::marker::Copy for TetheringOperationalState {}
+impl ::core::clone::Clone for TetheringOperationalState {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Networking_NetworkOperators\"`*"]
+#[repr(transparent)]
+pub struct TetheringWiFiBand(pub i32);
+impl TetheringWiFiBand {
+    pub const Auto: Self = Self(0i32);
+    pub const TwoPointFourGigahertz: Self = Self(1i32);
+    pub const FiveGigahertz: Self = Self(2i32);
+}
+impl ::core::marker::Copy for TetheringWiFiBand {}
+impl ::core::clone::Clone for TetheringWiFiBand {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Networking_NetworkOperators\"`*"]
+#[repr(transparent)]
+pub struct UiccAccessCondition(pub i32);
+impl UiccAccessCondition {
+    pub const AlwaysAllowed: Self = Self(0i32);
+    pub const Pin1: Self = Self(1i32);
+    pub const Pin2: Self = Self(2i32);
+    pub const Pin3: Self = Self(3i32);
+    pub const Pin4: Self = Self(4i32);
+    pub const Administrative5: Self = Self(5i32);
+    pub const Administrative6: Self = Self(6i32);
+    pub const NeverAllowed: Self = Self(7i32);
+}
+impl ::core::marker::Copy for UiccAccessCondition {}
+impl ::core::clone::Clone for UiccAccessCondition {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Networking_NetworkOperators\"`*"]
+#[repr(transparent)]
+pub struct UiccAppKind(pub i32);
+impl UiccAppKind {
+    pub const Unknown: Self = Self(0i32);
+    pub const MF: Self = Self(1i32);
+    pub const MFSim: Self = Self(2i32);
+    pub const MFRuim: Self = Self(3i32);
+    pub const USim: Self = Self(4i32);
+    pub const CSim: Self = Self(5i32);
+    pub const ISim: Self = Self(6i32);
+}
+impl ::core::marker::Copy for UiccAppKind {}
+impl ::core::clone::Clone for UiccAppKind {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Networking_NetworkOperators\"`*"]
+#[repr(transparent)]
+pub struct UiccAppRecordKind(pub i32);
+impl UiccAppRecordKind {
+    pub const Unknown: Self = Self(0i32);
+    pub const Transparent: Self = Self(1i32);
+    pub const RecordOriented: Self = Self(2i32);
+}
+impl ::core::marker::Copy for UiccAppRecordKind {}
+impl ::core::clone::Clone for UiccAppRecordKind {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type UssdMessage = *mut ::core::ffi::c_void;
+pub type UssdReply = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_NetworkOperators\"`*"]
+#[repr(transparent)]
+pub struct UssdResultCode(pub i32);
+impl UssdResultCode {
+    pub const NoActionRequired: Self = Self(0i32);
+    pub const ActionRequired: Self = Self(1i32);
+    pub const Terminated: Self = Self(2i32);
+    pub const OtherLocalClient: Self = Self(3i32);
+    pub const OperationNotSupported: Self = Self(4i32);
+    pub const NetworkTimeout: Self = Self(5i32);
+}
+impl ::core::marker::Copy for UssdResultCode {}
+impl ::core::clone::Clone for UssdResultCode {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type UssdSession = *mut ::core::ffi::c_void;
diff --git a/vendor/windows-sys/src/Windows/Networking/Proximity/mod.rs b/vendor/windows-sys/src/Windows/Networking/Proximity/mod.rs
new file mode 100644
index 000000000..1a15ac9a1
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Networking/Proximity/mod.rs
@@ -0,0 +1,72 @@
+pub type ConnectionRequestedEventArgs = *mut ::core::ffi::c_void;
+pub type DeviceArrivedEventHandler = *mut ::core::ffi::c_void;
+pub type DeviceDepartedEventHandler = *mut ::core::ffi::c_void;
+pub type MessageReceivedHandler = *mut ::core::ffi::c_void;
+pub type MessageTransmittedHandler = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_Proximity\"`*"]
+#[repr(transparent)]
+pub struct PeerDiscoveryTypes(pub u32);
+impl PeerDiscoveryTypes {
+    pub const None: Self = Self(0u32);
+    pub const Browse: Self = Self(1u32);
+    pub const Triggered: Self = Self(2u32);
+}
+impl ::core::marker::Copy for PeerDiscoveryTypes {}
+impl ::core::clone::Clone for PeerDiscoveryTypes {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type PeerInformation = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_Proximity\"`*"]
+#[repr(transparent)]
+pub struct PeerRole(pub i32);
+impl PeerRole {
+    pub const Peer: Self = Self(0i32);
+    pub const Host: Self = Self(1i32);
+    pub const Client: Self = Self(2i32);
+}
+impl ::core::marker::Copy for PeerRole {}
+impl ::core::clone::Clone for PeerRole {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type PeerWatcher = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_Proximity\"`*"]
+#[repr(transparent)]
+pub struct PeerWatcherStatus(pub i32);
+impl PeerWatcherStatus {
+    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 PeerWatcherStatus {}
+impl ::core::clone::Clone for PeerWatcherStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type ProximityDevice = *mut ::core::ffi::c_void;
+pub type ProximityMessage = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_Proximity\"`*"]
+#[repr(transparent)]
+pub struct TriggeredConnectState(pub i32);
+impl TriggeredConnectState {
+    pub const PeerFound: Self = Self(0i32);
+    pub const Listening: Self = Self(1i32);
+    pub const Connecting: Self = Self(2i32);
+    pub const Completed: Self = Self(3i32);
+    pub const Canceled: Self = Self(4i32);
+    pub const Failed: Self = Self(5i32);
+}
+impl ::core::marker::Copy for TriggeredConnectState {}
+impl ::core::clone::Clone for TriggeredConnectState {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type TriggeredConnectionStateChangedEventArgs = *mut ::core::ffi::c_void;
diff --git a/vendor/windows-sys/src/Windows/Networking/PushNotifications/mod.rs b/vendor/windows-sys/src/Windows/Networking/PushNotifications/mod.rs
new file mode 100644
index 000000000..81e9d2d92
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Networking/PushNotifications/mod.rs
@@ -0,0 +1,21 @@
+pub type PushNotificationChannel = *mut ::core::ffi::c_void;
+pub type PushNotificationChannelManagerForUser = *mut ::core::ffi::c_void;
+pub type PushNotificationChannelsRevokedEventArgs = *mut ::core::ffi::c_void;
+pub type PushNotificationReceivedEventArgs = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_PushNotifications\"`*"]
+#[repr(transparent)]
+pub struct PushNotificationType(pub i32);
+impl PushNotificationType {
+    pub const Toast: Self = Self(0i32);
+    pub const Tile: Self = Self(1i32);
+    pub const Badge: Self = Self(2i32);
+    pub const Raw: Self = Self(3i32);
+    pub const TileFlyout: Self = Self(4i32);
+}
+impl ::core::marker::Copy for PushNotificationType {}
+impl ::core::clone::Clone for PushNotificationType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type RawNotification = *mut ::core::ffi::c_void;
diff --git a/vendor/windows-sys/src/Windows/Networking/ServiceDiscovery/Dnssd/mod.rs b/vendor/windows-sys/src/Windows/Networking/ServiceDiscovery/Dnssd/mod.rs
new file mode 100644
index 000000000..b61de34be
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Networking/ServiceDiscovery/Dnssd/mod.rs
@@ -0,0 +1,36 @@
+pub type DnssdRegistrationResult = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_ServiceDiscovery_Dnssd\"`*"]
+#[repr(transparent)]
+pub struct DnssdRegistrationStatus(pub i32);
+impl DnssdRegistrationStatus {
+    pub const Success: Self = Self(0i32);
+    pub const InvalidServiceName: Self = Self(1i32);
+    pub const ServerError: Self = Self(2i32);
+    pub const SecurityError: Self = Self(3i32);
+}
+impl ::core::marker::Copy for DnssdRegistrationStatus {}
+impl ::core::clone::Clone for DnssdRegistrationStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type DnssdServiceInstance = *mut ::core::ffi::c_void;
+pub type DnssdServiceInstanceCollection = *mut ::core::ffi::c_void;
+pub type DnssdServiceWatcher = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_ServiceDiscovery_Dnssd\"`*"]
+#[repr(transparent)]
+pub struct DnssdServiceWatcherStatus(pub i32);
+impl DnssdServiceWatcherStatus {
+    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 DnssdServiceWatcherStatus {}
+impl ::core::clone::Clone for DnssdServiceWatcherStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/vendor/windows-sys/src/Windows/Networking/ServiceDiscovery/mod.rs b/vendor/windows-sys/src/Windows/Networking/ServiceDiscovery/mod.rs
new file mode 100644
index 000000000..fea71d1b1
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Networking/ServiceDiscovery/mod.rs
@@ -0,0 +1,2 @@
+#[cfg(feature = "Networking_ServiceDiscovery_Dnssd")]
+pub mod Dnssd;
diff --git a/vendor/windows-sys/src/Windows/Networking/Sockets/mod.rs b/vendor/windows-sys/src/Windows/Networking/Sockets/mod.rs
new file mode 100644
index 000000000..49d6350e5
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Networking/Sockets/mod.rs
@@ -0,0 +1,273 @@
+#[repr(C)]
+#[doc = "*Required features: `\"Networking_Sockets\"`*"]
+pub struct BandwidthStatistics {
+    pub OutboundBitsPerSecond: u64,
+    pub InboundBitsPerSecond: u64,
+    pub OutboundBitsPerSecondInstability: u64,
+    pub InboundBitsPerSecondInstability: u64,
+    pub OutboundBandwidthPeaked: bool,
+    pub InboundBandwidthPeaked: bool,
+}
+impl ::core::marker::Copy for BandwidthStatistics {}
+impl ::core::clone::Clone for BandwidthStatistics {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type ControlChannelTrigger = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_Sockets\"`*"]
+#[repr(transparent)]
+pub struct ControlChannelTriggerResetReason(pub i32);
+impl ControlChannelTriggerResetReason {
+    pub const FastUserSwitched: Self = Self(0i32);
+    pub const LowPowerExit: Self = Self(1i32);
+    pub const QuietHoursExit: Self = Self(2i32);
+    pub const ApplicationRestart: Self = Self(3i32);
+}
+impl ::core::marker::Copy for ControlChannelTriggerResetReason {}
+impl ::core::clone::Clone for ControlChannelTriggerResetReason {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Networking_Sockets\"`*"]
+#[repr(transparent)]
+pub struct ControlChannelTriggerResourceType(pub i32);
+impl ControlChannelTriggerResourceType {
+    pub const RequestSoftwareSlot: Self = Self(0i32);
+    pub const RequestHardwareSlot: Self = Self(1i32);
+}
+impl ::core::marker::Copy for ControlChannelTriggerResourceType {}
+impl ::core::clone::Clone for ControlChannelTriggerResourceType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Networking_Sockets\"`*"]
+#[repr(transparent)]
+pub struct ControlChannelTriggerStatus(pub i32);
+impl ControlChannelTriggerStatus {
+    pub const HardwareSlotRequested: Self = Self(0i32);
+    pub const SoftwareSlotAllocated: Self = Self(1i32);
+    pub const HardwareSlotAllocated: Self = Self(2i32);
+    pub const PolicyError: Self = Self(3i32);
+    pub const SystemError: Self = Self(4i32);
+    pub const TransportDisconnected: Self = Self(5i32);
+    pub const ServiceUnavailable: Self = Self(6i32);
+}
+impl ::core::marker::Copy for ControlChannelTriggerStatus {}
+impl ::core::clone::Clone for ControlChannelTriggerStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type DatagramSocket = *mut ::core::ffi::c_void;
+pub type DatagramSocketControl = *mut ::core::ffi::c_void;
+pub type DatagramSocketInformation = *mut ::core::ffi::c_void;
+pub type DatagramSocketMessageReceivedEventArgs = *mut ::core::ffi::c_void;
+pub type IControlChannelTriggerEventDetails = *mut ::core::ffi::c_void;
+pub type IControlChannelTriggerResetEventDetails = *mut ::core::ffi::c_void;
+pub type IWebSocket = *mut ::core::ffi::c_void;
+pub type IWebSocketControl = *mut ::core::ffi::c_void;
+pub type IWebSocketControl2 = *mut ::core::ffi::c_void;
+pub type IWebSocketInformation = *mut ::core::ffi::c_void;
+pub type IWebSocketInformation2 = *mut ::core::ffi::c_void;
+pub type MessageWebSocket = *mut ::core::ffi::c_void;
+pub type MessageWebSocketControl = *mut ::core::ffi::c_void;
+pub type MessageWebSocketInformation = *mut ::core::ffi::c_void;
+pub type MessageWebSocketMessageReceivedEventArgs = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_Sockets\"`*"]
+#[repr(transparent)]
+pub struct MessageWebSocketReceiveMode(pub i32);
+impl MessageWebSocketReceiveMode {
+    pub const FullMessage: Self = Self(0i32);
+    pub const PartialMessage: Self = Self(1i32);
+}
+impl ::core::marker::Copy for MessageWebSocketReceiveMode {}
+impl ::core::clone::Clone for MessageWebSocketReceiveMode {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[repr(C)]
+#[doc = "*Required features: `\"Networking_Sockets\"`*"]
+pub struct RoundTripTimeStatistics {
+    pub Variance: u32,
+    pub Max: u32,
+    pub Min: u32,
+    pub Sum: u32,
+}
+impl ::core::marker::Copy for RoundTripTimeStatistics {}
+impl ::core::clone::Clone for RoundTripTimeStatistics {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type ServerMessageWebSocket = *mut ::core::ffi::c_void;
+pub type ServerMessageWebSocketControl = *mut ::core::ffi::c_void;
+pub type ServerMessageWebSocketInformation = *mut ::core::ffi::c_void;
+pub type ServerStreamWebSocket = *mut ::core::ffi::c_void;
+pub type ServerStreamWebSocketInformation = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_Sockets\"`*"]
+#[repr(transparent)]
+pub struct SocketActivityConnectedStandbyAction(pub i32);
+impl SocketActivityConnectedStandbyAction {
+    pub const DoNotWake: Self = Self(0i32);
+    pub const Wake: Self = Self(1i32);
+}
+impl ::core::marker::Copy for SocketActivityConnectedStandbyAction {}
+impl ::core::clone::Clone for SocketActivityConnectedStandbyAction {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type SocketActivityContext = *mut ::core::ffi::c_void;
+pub type SocketActivityInformation = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_Sockets\"`*"]
+#[repr(transparent)]
+pub struct SocketActivityKind(pub i32);
+impl SocketActivityKind {
+    pub const None: Self = Self(0i32);
+    pub const StreamSocketListener: Self = Self(1i32);
+    pub const DatagramSocket: Self = Self(2i32);
+    pub const StreamSocket: Self = Self(3i32);
+}
+impl ::core::marker::Copy for SocketActivityKind {}
+impl ::core::clone::Clone for SocketActivityKind {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type SocketActivityTriggerDetails = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_Sockets\"`*"]
+#[repr(transparent)]
+pub struct SocketActivityTriggerReason(pub i32);
+impl SocketActivityTriggerReason {
+    pub const None: Self = Self(0i32);
+    pub const SocketActivity: Self = Self(1i32);
+    pub const ConnectionAccepted: Self = Self(2i32);
+    pub const KeepAliveTimerExpired: Self = Self(3i32);
+    pub const SocketClosed: Self = Self(4i32);
+}
+impl ::core::marker::Copy for SocketActivityTriggerReason {}
+impl ::core::clone::Clone for SocketActivityTriggerReason {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Networking_Sockets\"`*"]
+#[repr(transparent)]
+pub struct SocketErrorStatus(pub i32);
+impl SocketErrorStatus {
+    pub const Unknown: Self = Self(0i32);
+    pub const OperationAborted: Self = Self(1i32);
+    pub const HttpInvalidServerResponse: Self = Self(2i32);
+    pub const ConnectionTimedOut: Self = Self(3i32);
+    pub const AddressFamilyNotSupported: Self = Self(4i32);
+    pub const SocketTypeNotSupported: Self = Self(5i32);
+    pub const HostNotFound: Self = Self(6i32);
+    pub const NoDataRecordOfRequestedType: Self = Self(7i32);
+    pub const NonAuthoritativeHostNotFound: Self = Self(8i32);
+    pub const ClassTypeNotFound: Self = Self(9i32);
+    pub const AddressAlreadyInUse: Self = Self(10i32);
+    pub const CannotAssignRequestedAddress: Self = Self(11i32);
+    pub const ConnectionRefused: Self = Self(12i32);
+    pub const NetworkIsUnreachable: Self = Self(13i32);
+    pub const UnreachableHost: Self = Self(14i32);
+    pub const NetworkIsDown: Self = Self(15i32);
+    pub const NetworkDroppedConnectionOnReset: Self = Self(16i32);
+    pub const SoftwareCausedConnectionAbort: Self = Self(17i32);
+    pub const ConnectionResetByPeer: Self = Self(18i32);
+    pub const HostIsDown: Self = Self(19i32);
+    pub const NoAddressesFound: Self = Self(20i32);
+    pub const TooManyOpenFiles: Self = Self(21i32);
+    pub const MessageTooLong: Self = Self(22i32);
+    pub const CertificateExpired: Self = Self(23i32);
+    pub const CertificateUntrustedRoot: Self = Self(24i32);
+    pub const CertificateCommonNameIsIncorrect: Self = Self(25i32);
+    pub const CertificateWrongUsage: Self = Self(26i32);
+    pub const CertificateRevoked: Self = Self(27i32);
+    pub const CertificateNoRevocationCheck: Self = Self(28i32);
+    pub const CertificateRevocationServerOffline: Self = Self(29i32);
+    pub const CertificateIsInvalid: Self = Self(30i32);
+}
+impl ::core::marker::Copy for SocketErrorStatus {}
+impl ::core::clone::Clone for SocketErrorStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Networking_Sockets\"`*"]
+#[repr(transparent)]
+pub struct SocketMessageType(pub i32);
+impl SocketMessageType {
+    pub const Binary: Self = Self(0i32);
+    pub const Utf8: Self = Self(1i32);
+}
+impl ::core::marker::Copy for SocketMessageType {}
+impl ::core::clone::Clone for SocketMessageType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Networking_Sockets\"`*"]
+#[repr(transparent)]
+pub struct SocketProtectionLevel(pub i32);
+impl SocketProtectionLevel {
+    pub const PlainSocket: Self = Self(0i32);
+    pub const Ssl: Self = Self(1i32);
+    pub const SslAllowNullEncryption: Self = Self(2i32);
+    pub const BluetoothEncryptionAllowNullAuthentication: Self = Self(3i32);
+    pub const BluetoothEncryptionWithAuthentication: Self = Self(4i32);
+    pub const Ssl3AllowWeakEncryption: Self = Self(5i32);
+    pub const Tls10: Self = Self(6i32);
+    pub const Tls11: Self = Self(7i32);
+    pub const Tls12: Self = Self(8i32);
+    pub const Unspecified: Self = Self(9i32);
+}
+impl ::core::marker::Copy for SocketProtectionLevel {}
+impl ::core::clone::Clone for SocketProtectionLevel {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Networking_Sockets\"`*"]
+#[repr(transparent)]
+pub struct SocketQualityOfService(pub i32);
+impl SocketQualityOfService {
+    pub const Normal: Self = Self(0i32);
+    pub const LowLatency: Self = Self(1i32);
+}
+impl ::core::marker::Copy for SocketQualityOfService {}
+impl ::core::clone::Clone for SocketQualityOfService {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Networking_Sockets\"`*"]
+#[repr(transparent)]
+pub struct SocketSslErrorSeverity(pub i32);
+impl SocketSslErrorSeverity {
+    pub const None: Self = Self(0i32);
+    pub const Ignorable: Self = Self(1i32);
+    pub const Fatal: Self = Self(2i32);
+}
+impl ::core::marker::Copy for SocketSslErrorSeverity {}
+impl ::core::clone::Clone for SocketSslErrorSeverity {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type StreamSocket = *mut ::core::ffi::c_void;
+pub type StreamSocketControl = *mut ::core::ffi::c_void;
+pub type StreamSocketInformation = *mut ::core::ffi::c_void;
+pub type StreamSocketListener = *mut ::core::ffi::c_void;
+pub type StreamSocketListenerConnectionReceivedEventArgs = *mut ::core::ffi::c_void;
+pub type StreamSocketListenerControl = *mut ::core::ffi::c_void;
+pub type StreamSocketListenerInformation = *mut ::core::ffi::c_void;
+pub type StreamWebSocket = *mut ::core::ffi::c_void;
+pub type StreamWebSocketControl = *mut ::core::ffi::c_void;
+pub type StreamWebSocketInformation = *mut ::core::ffi::c_void;
+pub type WebSocketClosedEventArgs = *mut ::core::ffi::c_void;
+pub type WebSocketKeepAlive = *mut ::core::ffi::c_void;
+pub type WebSocketServerCustomValidationRequestedEventArgs = *mut ::core::ffi::c_void;
diff --git a/vendor/windows-sys/src/Windows/Networking/Vpn/mod.rs b/vendor/windows-sys/src/Windows/Networking/Vpn/mod.rs
new file mode 100644
index 000000000..0f3e21cf6
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Networking/Vpn/mod.rs
@@ -0,0 +1,248 @@
+pub type IVpnChannelStatics = *mut ::core::ffi::c_void;
+pub type IVpnCredential = *mut ::core::ffi::c_void;
+pub type IVpnCustomPrompt = *mut ::core::ffi::c_void;
+pub type IVpnCustomPromptElement = *mut ::core::ffi::c_void;
+pub type IVpnDomainNameInfoFactory = *mut ::core::ffi::c_void;
+pub type IVpnInterfaceIdFactory = *mut ::core::ffi::c_void;
+pub type IVpnNamespaceInfoFactory = *mut ::core::ffi::c_void;
+pub type IVpnPacketBufferFactory = *mut ::core::ffi::c_void;
+pub type IVpnPlugIn = *mut ::core::ffi::c_void;
+pub type IVpnProfile = *mut ::core::ffi::c_void;
+pub type IVpnRouteFactory = *mut ::core::ffi::c_void;
+pub type VpnAppId = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_Vpn\"`*"]
+#[repr(transparent)]
+pub struct VpnAppIdType(pub i32);
+impl VpnAppIdType {
+    pub const PackageFamilyName: Self = Self(0i32);
+    pub const FullyQualifiedBinaryName: Self = Self(1i32);
+    pub const FilePath: Self = Self(2i32);
+}
+impl ::core::marker::Copy for VpnAppIdType {}
+impl ::core::clone::Clone for VpnAppIdType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Networking_Vpn\"`*"]
+#[repr(transparent)]
+pub struct VpnAuthenticationMethod(pub i32);
+impl VpnAuthenticationMethod {
+    pub const Mschapv2: Self = Self(0i32);
+    pub const Eap: Self = Self(1i32);
+    pub const Certificate: Self = Self(2i32);
+    pub const PresharedKey: Self = Self(3i32);
+}
+impl ::core::marker::Copy for VpnAuthenticationMethod {}
+impl ::core::clone::Clone for VpnAuthenticationMethod {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type VpnChannel = *mut ::core::ffi::c_void;
+pub type VpnChannelActivityEventArgs = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_Vpn\"`*"]
+#[repr(transparent)]
+pub struct VpnChannelActivityEventType(pub i32);
+impl VpnChannelActivityEventType {
+    pub const Idle: Self = Self(0i32);
+    pub const Active: Self = Self(1i32);
+}
+impl ::core::marker::Copy for VpnChannelActivityEventType {}
+impl ::core::clone::Clone for VpnChannelActivityEventType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type VpnChannelActivityStateChangedArgs = *mut ::core::ffi::c_void;
+pub type VpnChannelConfiguration = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_Vpn\"`*"]
+#[repr(transparent)]
+pub struct VpnChannelRequestCredentialsOptions(pub u32);
+impl VpnChannelRequestCredentialsOptions {
+    pub const None: Self = Self(0u32);
+    pub const Retrying: Self = Self(1u32);
+    pub const UseForSingleSignIn: Self = Self(2u32);
+}
+impl ::core::marker::Copy for VpnChannelRequestCredentialsOptions {}
+impl ::core::clone::Clone for VpnChannelRequestCredentialsOptions {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type VpnCredential = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_Vpn\"`*"]
+#[repr(transparent)]
+pub struct VpnCredentialType(pub i32);
+impl VpnCredentialType {
+    pub const UsernamePassword: Self = Self(0i32);
+    pub const UsernameOtpPin: Self = Self(1i32);
+    pub const UsernamePasswordAndPin: Self = Self(2i32);
+    pub const UsernamePasswordChange: Self = Self(3i32);
+    pub const SmartCard: Self = Self(4i32);
+    pub const ProtectedCertificate: Self = Self(5i32);
+    pub const UnProtectedCertificate: Self = Self(6i32);
+}
+impl ::core::marker::Copy for VpnCredentialType {}
+impl ::core::clone::Clone for VpnCredentialType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type VpnCustomCheckBox = *mut ::core::ffi::c_void;
+pub type VpnCustomComboBox = *mut ::core::ffi::c_void;
+pub type VpnCustomEditBox = *mut ::core::ffi::c_void;
+pub type VpnCustomErrorBox = *mut ::core::ffi::c_void;
+pub type VpnCustomPromptBooleanInput = *mut ::core::ffi::c_void;
+pub type VpnCustomPromptOptionSelector = *mut ::core::ffi::c_void;
+pub type VpnCustomPromptText = *mut ::core::ffi::c_void;
+pub type VpnCustomPromptTextInput = *mut ::core::ffi::c_void;
+pub type VpnCustomTextBox = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_Vpn\"`*"]
+#[repr(transparent)]
+pub struct VpnDataPathType(pub i32);
+impl VpnDataPathType {
+    pub const Send: Self = Self(0i32);
+    pub const Receive: Self = Self(1i32);
+}
+impl ::core::marker::Copy for VpnDataPathType {}
+impl ::core::clone::Clone for VpnDataPathType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type VpnDomainNameAssignment = *mut ::core::ffi::c_void;
+pub type VpnDomainNameInfo = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_Vpn\"`*"]
+#[repr(transparent)]
+pub struct VpnDomainNameType(pub i32);
+impl VpnDomainNameType {
+    pub const Suffix: Self = Self(0i32);
+    pub const FullyQualified: Self = Self(1i32);
+    pub const Reserved: Self = Self(65535i32);
+}
+impl ::core::marker::Copy for VpnDomainNameType {}
+impl ::core::clone::Clone for VpnDomainNameType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type VpnForegroundActivatedEventArgs = *mut ::core::ffi::c_void;
+pub type VpnForegroundActivationOperation = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_Vpn\"`*"]
+#[repr(transparent)]
+pub struct VpnIPProtocol(pub i32);
+impl VpnIPProtocol {
+    pub const None: Self = Self(0i32);
+    pub const Tcp: Self = Self(6i32);
+    pub const Udp: Self = Self(17i32);
+    pub const Icmp: Self = Self(1i32);
+    pub const Ipv6Icmp: Self = Self(58i32);
+    pub const Igmp: Self = Self(2i32);
+    pub const Pgm: Self = Self(113i32);
+}
+impl ::core::marker::Copy for VpnIPProtocol {}
+impl ::core::clone::Clone for VpnIPProtocol {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type VpnInterfaceId = *mut ::core::ffi::c_void;
+pub type VpnManagementAgent = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_Vpn\"`*"]
+#[repr(transparent)]
+pub struct VpnManagementConnectionStatus(pub i32);
+impl VpnManagementConnectionStatus {
+    pub const Disconnected: Self = Self(0i32);
+    pub const Disconnecting: Self = Self(1i32);
+    pub const Connected: Self = Self(2i32);
+    pub const Connecting: Self = Self(3i32);
+}
+impl ::core::marker::Copy for VpnManagementConnectionStatus {}
+impl ::core::clone::Clone for VpnManagementConnectionStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Networking_Vpn\"`*"]
+#[repr(transparent)]
+pub struct VpnManagementErrorStatus(pub i32);
+impl VpnManagementErrorStatus {
+    pub const Ok: Self = Self(0i32);
+    pub const Other: Self = Self(1i32);
+    pub const InvalidXmlSyntax: Self = Self(2i32);
+    pub const ProfileNameTooLong: Self = Self(3i32);
+    pub const ProfileInvalidAppId: Self = Self(4i32);
+    pub const AccessDenied: Self = Self(5i32);
+    pub const CannotFindProfile: Self = Self(6i32);
+    pub const AlreadyDisconnecting: Self = Self(7i32);
+    pub const AlreadyConnected: Self = Self(8i32);
+    pub const GeneralAuthenticationFailure: Self = Self(9i32);
+    pub const EapFailure: Self = Self(10i32);
+    pub const SmartCardFailure: Self = Self(11i32);
+    pub const CertificateFailure: Self = Self(12i32);
+    pub const ServerConfiguration: Self = Self(13i32);
+    pub const NoConnection: Self = Self(14i32);
+    pub const ServerConnection: Self = Self(15i32);
+    pub const UserNamePassword: Self = Self(16i32);
+    pub const DnsNotResolvable: Self = Self(17i32);
+    pub const InvalidIP: Self = Self(18i32);
+}
+impl ::core::marker::Copy for VpnManagementErrorStatus {}
+impl ::core::clone::Clone for VpnManagementErrorStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type VpnNamespaceAssignment = *mut ::core::ffi::c_void;
+pub type VpnNamespaceInfo = *mut ::core::ffi::c_void;
+pub type VpnNativeProfile = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_Vpn\"`*"]
+#[repr(transparent)]
+pub struct VpnNativeProtocolType(pub i32);
+impl VpnNativeProtocolType {
+    pub const Pptp: Self = Self(0i32);
+    pub const L2tp: Self = Self(1i32);
+    pub const IpsecIkev2: Self = Self(2i32);
+}
+impl ::core::marker::Copy for VpnNativeProtocolType {}
+impl ::core::clone::Clone for VpnNativeProtocolType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type VpnPacketBuffer = *mut ::core::ffi::c_void;
+pub type VpnPacketBufferList = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_Vpn\"`*"]
+#[repr(transparent)]
+pub struct VpnPacketBufferStatus(pub i32);
+impl VpnPacketBufferStatus {
+    pub const Ok: Self = Self(0i32);
+    pub const InvalidBufferSize: Self = Self(1i32);
+}
+impl ::core::marker::Copy for VpnPacketBufferStatus {}
+impl ::core::clone::Clone for VpnPacketBufferStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type VpnPickedCredential = *mut ::core::ffi::c_void;
+pub type VpnPlugInProfile = *mut ::core::ffi::c_void;
+pub type VpnRoute = *mut ::core::ffi::c_void;
+pub type VpnRouteAssignment = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_Vpn\"`*"]
+#[repr(transparent)]
+pub struct VpnRoutingPolicyType(pub i32);
+impl VpnRoutingPolicyType {
+    pub const SplitRouting: Self = Self(0i32);
+    pub const ForceAllTrafficOverVpn: Self = Self(1i32);
+}
+impl ::core::marker::Copy for VpnRoutingPolicyType {}
+impl ::core::clone::Clone for VpnRoutingPolicyType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type VpnSystemHealth = *mut ::core::ffi::c_void;
+pub type VpnTrafficFilter = *mut ::core::ffi::c_void;
+pub type VpnTrafficFilterAssignment = *mut ::core::ffi::c_void;
diff --git a/vendor/windows-sys/src/Windows/Networking/XboxLive/mod.rs b/vendor/windows-sys/src/Windows/Networking/XboxLive/mod.rs
new file mode 100644
index 000000000..f0746acb5
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Networking/XboxLive/mod.rs
@@ -0,0 +1,131 @@
+pub type XboxLiveDeviceAddress = *mut ::core::ffi::c_void;
+pub type XboxLiveEndpointPair = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_XboxLive\"`*"]
+#[repr(transparent)]
+pub struct XboxLiveEndpointPairCreationBehaviors(pub u32);
+impl XboxLiveEndpointPairCreationBehaviors {
+    pub const None: Self = Self(0u32);
+    pub const ReevaluatePath: Self = Self(1u32);
+}
+impl ::core::marker::Copy for XboxLiveEndpointPairCreationBehaviors {}
+impl ::core::clone::Clone for XboxLiveEndpointPairCreationBehaviors {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type XboxLiveEndpointPairCreationResult = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_XboxLive\"`*"]
+#[repr(transparent)]
+pub struct XboxLiveEndpointPairCreationStatus(pub i32);
+impl XboxLiveEndpointPairCreationStatus {
+    pub const Succeeded: Self = Self(0i32);
+    pub const NoLocalNetworks: Self = Self(1i32);
+    pub const NoCompatibleNetworkPaths: Self = Self(2i32);
+    pub const LocalSystemNotAuthorized: Self = Self(3i32);
+    pub const Canceled: Self = Self(4i32);
+    pub const TimedOut: Self = Self(5i32);
+    pub const RemoteSystemNotAuthorized: Self = Self(6i32);
+    pub const RefusedDueToConfiguration: Self = Self(7i32);
+    pub const UnexpectedInternalError: Self = Self(8i32);
+}
+impl ::core::marker::Copy for XboxLiveEndpointPairCreationStatus {}
+impl ::core::clone::Clone for XboxLiveEndpointPairCreationStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Networking_XboxLive\"`*"]
+#[repr(transparent)]
+pub struct XboxLiveEndpointPairState(pub i32);
+impl XboxLiveEndpointPairState {
+    pub const Invalid: Self = Self(0i32);
+    pub const CreatingOutbound: Self = Self(1i32);
+    pub const CreatingInbound: Self = Self(2i32);
+    pub const Ready: Self = Self(3i32);
+    pub const DeletingLocally: Self = Self(4i32);
+    pub const RemoteEndpointTerminating: Self = Self(5i32);
+    pub const Deleted: Self = Self(6i32);
+}
+impl ::core::marker::Copy for XboxLiveEndpointPairState {}
+impl ::core::clone::Clone for XboxLiveEndpointPairState {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type XboxLiveEndpointPairStateChangedEventArgs = *mut ::core::ffi::c_void;
+pub type XboxLiveEndpointPairTemplate = *mut ::core::ffi::c_void;
+pub type XboxLiveInboundEndpointPairCreatedEventArgs = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_XboxLive\"`*"]
+#[repr(transparent)]
+pub struct XboxLiveNetworkAccessKind(pub i32);
+impl XboxLiveNetworkAccessKind {
+    pub const Open: Self = Self(0i32);
+    pub const Moderate: Self = Self(1i32);
+    pub const Strict: Self = Self(2i32);
+}
+impl ::core::marker::Copy for XboxLiveNetworkAccessKind {}
+impl ::core::clone::Clone for XboxLiveNetworkAccessKind {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type XboxLiveQualityOfServiceMeasurement = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_XboxLive\"`*"]
+#[repr(transparent)]
+pub struct XboxLiveQualityOfServiceMeasurementStatus(pub i32);
+impl XboxLiveQualityOfServiceMeasurementStatus {
+    pub const NotStarted: Self = Self(0i32);
+    pub const InProgress: Self = Self(1i32);
+    pub const InProgressWithProvisionalResults: Self = Self(2i32);
+    pub const Succeeded: Self = Self(3i32);
+    pub const NoLocalNetworks: Self = Self(4i32);
+    pub const NoCompatibleNetworkPaths: Self = Self(5i32);
+    pub const LocalSystemNotAuthorized: Self = Self(6i32);
+    pub const Canceled: Self = Self(7i32);
+    pub const TimedOut: Self = Self(8i32);
+    pub const RemoteSystemNotAuthorized: Self = Self(9i32);
+    pub const RefusedDueToConfiguration: Self = Self(10i32);
+    pub const UnexpectedInternalError: Self = Self(11i32);
+}
+impl ::core::marker::Copy for XboxLiveQualityOfServiceMeasurementStatus {}
+impl ::core::clone::Clone for XboxLiveQualityOfServiceMeasurementStatus {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Networking_XboxLive\"`*"]
+#[repr(transparent)]
+pub struct XboxLiveQualityOfServiceMetric(pub i32);
+impl XboxLiveQualityOfServiceMetric {
+    pub const AverageLatencyInMilliseconds: Self = Self(0i32);
+    pub const MinLatencyInMilliseconds: Self = Self(1i32);
+    pub const MaxLatencyInMilliseconds: Self = Self(2i32);
+    pub const AverageOutboundBitsPerSecond: Self = Self(3i32);
+    pub const MinOutboundBitsPerSecond: Self = Self(4i32);
+    pub const MaxOutboundBitsPerSecond: Self = Self(5i32);
+    pub const AverageInboundBitsPerSecond: Self = Self(6i32);
+    pub const MinInboundBitsPerSecond: Self = Self(7i32);
+    pub const MaxInboundBitsPerSecond: Self = Self(8i32);
+}
+impl ::core::marker::Copy for XboxLiveQualityOfServiceMetric {}
+impl ::core::clone::Clone for XboxLiveQualityOfServiceMetric {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type XboxLiveQualityOfServiceMetricResult = *mut ::core::ffi::c_void;
+pub type XboxLiveQualityOfServicePrivatePayloadResult = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking_XboxLive\"`*"]
+#[repr(transparent)]
+pub struct XboxLiveSocketKind(pub i32);
+impl XboxLiveSocketKind {
+    pub const None: Self = Self(0i32);
+    pub const Datagram: Self = Self(1i32);
+    pub const Stream: Self = Self(2i32);
+}
+impl ::core::marker::Copy for XboxLiveSocketKind {}
+impl ::core::clone::Clone for XboxLiveSocketKind {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
diff --git a/vendor/windows-sys/src/Windows/Networking/mod.rs b/vendor/windows-sys/src/Windows/Networking/mod.rs
new file mode 100644
index 000000000..ea21157ce
--- /dev/null
+++ b/vendor/windows-sys/src/Windows/Networking/mod.rs
@@ -0,0 +1,61 @@
+#[cfg(feature = "Networking_BackgroundTransfer")]
+pub mod BackgroundTransfer;
+#[cfg(feature = "Networking_Connectivity")]
+pub mod Connectivity;
+#[cfg(feature = "Networking_NetworkOperators")]
+pub mod NetworkOperators;
+#[cfg(feature = "Networking_Proximity")]
+pub mod Proximity;
+#[cfg(feature = "Networking_PushNotifications")]
+pub mod PushNotifications;
+#[cfg(feature = "Networking_ServiceDiscovery")]
+pub mod ServiceDiscovery;
+#[cfg(feature = "Networking_Sockets")]
+pub mod Sockets;
+#[cfg(feature = "Networking_Vpn")]
+pub mod Vpn;
+#[cfg(feature = "Networking_XboxLive")]
+pub mod XboxLive;
+#[doc = "*Required features: `\"Networking\"`*"]
+#[repr(transparent)]
+pub struct DomainNameType(pub i32);
+impl DomainNameType {
+    pub const Suffix: Self = Self(0i32);
+    pub const FullyQualified: Self = Self(1i32);
+}
+impl ::core::marker::Copy for DomainNameType {}
+impl ::core::clone::Clone for DomainNameType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+pub type EndpointPair = *mut ::core::ffi::c_void;
+pub type HostName = *mut ::core::ffi::c_void;
+#[doc = "*Required features: `\"Networking\"`*"]
+#[repr(transparent)]
+pub struct HostNameSortOptions(pub u32);
+impl HostNameSortOptions {
+    pub const None: Self = Self(0u32);
+    pub const OptimizeForLongConnections: Self = Self(2u32);
+}
+impl ::core::marker::Copy for HostNameSortOptions {}
+impl ::core::clone::Clone for HostNameSortOptions {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+#[doc = "*Required features: `\"Networking\"`*"]
+#[repr(transparent)]
+pub struct HostNameType(pub i32);
+impl HostNameType {
+    pub const DomainName: Self = Self(0i32);
+    pub const Ipv4: Self = Self(1i32);
+    pub const Ipv6: Self = Self(2i32);
+    pub const Bluetooth: Self = Self(3i32);
+}
+impl ::core::marker::Copy for HostNameType {}
+impl ::core::clone::Clone for HostNameType {
+    fn clone(&self) -> Self {
+        *self
+    }
+}